# convenience interface for use inside Python
def __init__(self, value):
+ """Given an int, create a Float16 from the bitpattern represented by
+ that int. Otherwise, given some value, create a Float16 by rounding
+ float(value).
+ """
cdef cfloat.ui64_double ud
cdef cfloat.float64_t d
def __mul__(self, Float16 other):
return self.mul(other)
- cpdef Float16 fma(self, Float16 a2, Float16 a3):
- cdef cfloat.float16_t f = cfloat.f16_mulAdd(self._c_float, a2._c_float, a3._c_float)
- return Float16.from_c_float(f)
-
- cpdef Float16 fam(self, Float16 a1, Float16 a2):
+ cpdef Float16 fma(self, Float16 a1, Float16 a2):
cdef cfloat.float16_t f = cfloat.f16_mulAdd(a1._c_float, a2._c_float, self._c_float)
return Float16.from_c_float(f)
self.imul(other)
return self
- cpdef void ifma(self, Float16 a2, Float16 a3):
- self._c_float = cfloat.f16_mulAdd(self._c_float, a2._c_float, a3._c_float)
-
- cpdef void ifam(self, Float16 a1, Float16 a2):
+ cpdef void ifma(self, Float16 a1, Float16 a2):
self._c_float = cfloat.f16_mulAdd(a1._c_float, a2._c_float, self._c_float)
cpdef void idiv(self, Float16 other):
cdef cfloat.float16_t f = cfloat.f16_mul(a1._c_float, a2._c_float)
return Float16.from_c_float(f)
-cpdef Float16 f16_fma(Float16 a1, Float16 a2, Float16 a3):
- cdef cfloat.float16_t f = cfloat.f16_mulAdd(a1._c_float, a2._c_float, a3._c_float)
- return Float16.from_c_float(f)
-
-cpdef Float16 f16_fam(Float16 a3, Float16 a1, Float16 a2):
- cdef cfloat.float16_t f = cfloat.f16_mulAdd(a1._c_float, a2._c_float, a3._c_float)
+cpdef Float16 f16_fma(Float16 acc, Float16 a1, Float16 a2):
+ cdef cfloat.float16_t f = cfloat.f16_mulAdd(a1._c_float, a2._c_float, acc._c_float)
return Float16.from_c_float(f)
cpdef Float16 f16_div(Float16 a1, Float16 a2):
# convenience interface for use inside Python
def __init__(self, value):
+ """Given an int, create a Float32 from the bitpattern represented by
+ that int. Otherwise, given some value, create a Float32 by rounding
+ float(value).
+ """
cdef cfloat.ui64_double ud
cdef cfloat.float64_t d
def __mul__(self, Float32 other):
return self.mul(other)
- cpdef Float32 fma(self, Float32 a2, Float32 a3):
- cdef cfloat.float32_t f = cfloat.f32_mulAdd(self._c_float, a2._c_float, a3._c_float)
- return Float32.from_c_float(f)
-
- cpdef Float32 fam(self, Float32 a1, Float32 a2):
+ cpdef Float32 fma(self, Float32 a1, Float32 a2):
cdef cfloat.float32_t f = cfloat.f32_mulAdd(a1._c_float, a2._c_float, self._c_float)
return Float32.from_c_float(f)
self.imul(other)
return self
- cpdef void ifma(self, Float32 a2, Float32 a3):
- self._c_float = cfloat.f32_mulAdd(self._c_float, a2._c_float, a3._c_float)
-
- cpdef void ifam(self, Float32 a1, Float32 a2):
+ cpdef void ifma(self, Float32 a1, Float32 a2):
self._c_float = cfloat.f32_mulAdd(a1._c_float, a2._c_float, self._c_float)
cpdef void idiv(self, Float32 other):
cdef cfloat.float64_t f = cfloat.f32_to_f64(self._c_float)
return Float64.from_c_float(f)
+########
+# integer conversions
+########
+
+# u/i32 <-> f16
+
+cpdef Float16 i32_to_f16(int32_t value):
+ cdef cfloat.float16_t f = cfloat.i32_to_f16(value)
+ return Float16.from_c_float(f)
+
+cpdef Float16 ui32_to_f16(uint32_t value):
+ cdef cfloat.float16_t f = cfloat.ui32_to_f16(value)
+ return Float16.from_c_float(f)
+
+cpdef uint32_t f16_to_ui32(Float16 a1):
+ cdef uint32_t i = cfloat.f16_to_ui32(a1._c_float,
+ cfloat.softfloat_roundingMode, True)
+ return i
+
+cpdef int32_t f16_to_i32(Float16 a1):
+ cdef int32_t i = cfloat.f16_to_i32(a1._c_float,
+ cfloat.softfloat_roundingMode, True)
+ return i
+
+# u/i32 <-> f32
+
+cpdef Float32 i32_to_f32(int32_t value):
+ cdef cfloat.float32_t f = cfloat.i32_to_f32(value)
+ return Float32.from_c_float(f)
+
+cpdef Float32 ui32_to_f32(uint32_t value):
+ cdef cfloat.float32_t f = cfloat.ui32_to_f32(value)
+ return Float32.from_c_float(f)
+
+cpdef uint32_t f32_to_ui32(Float32 a1):
+ cdef uint32_t i = cfloat.f32_to_ui32(a1._c_float,
+ cfloat.softfloat_roundingMode, True)
+ return i
+
+cpdef int32_t f32_to_i32(Float32 a1):
+ cdef int32_t i = cfloat.f32_to_i32(a1._c_float,
+ cfloat.softfloat_roundingMode, True)
+ return i
+
+# u/i32 <-> f64
+
+cpdef Float64 i32_to_f64(int32_t value):
+ cdef cfloat.float64_t f = cfloat.i32_to_f64(value)
+ return Float64.from_c_float(f)
+
+cpdef Float64 ui32_to_f64(uint32_t value):
+ cdef cfloat.float64_t f = cfloat.ui32_to_f64(value)
+ return Float64.from_c_float(f)
+
+cpdef uint32_t f64_to_ui32(Float64 a1):
+ cdef uint32_t i = cfloat.f64_to_ui32(a1._c_float,
+ cfloat.softfloat_roundingMode, True)
+ return i
+
+cpdef int32_t f64_to_i32(Float64 a1):
+ cdef int32_t i = cfloat.f64_to_i32(a1._c_float,
+ cfloat.softfloat_roundingMode, True)
+ return i
+
+# u/i64 <-> f16
+
+cpdef Float16 i64_to_f16(int64_t value):
+ cdef cfloat.float16_t f = cfloat.i64_to_f16(value)
+ return Float16.from_c_float(f)
+
+cpdef Float16 ui64_to_f16(uint64_t value):
+ cdef cfloat.float16_t f = cfloat.ui64_to_f16(value)
+ return Float16.from_c_float(f)
+
+cpdef uint64_t f16_to_ui64(Float16 a1):
+ cdef uint64_t i = cfloat.f16_to_ui64(a1._c_float,
+ cfloat.softfloat_roundingMode, True)
+ return i
+
+cpdef int64_t f16_to_i64(Float16 a1):
+ cdef int64_t i = cfloat.f16_to_i64(a1._c_float,
+ cfloat.softfloat_roundingMode, True)
+ return i
+
+# u/i64 <-> f32
+
+cpdef Float32 i64_to_f32(int64_t value):
+ cdef cfloat.float32_t f = cfloat.i64_to_f32(value)
+ return Float32.from_c_float(f)
+
+cpdef Float32 ui64_to_f32(uint64_t value):
+ cdef cfloat.float32_t f = cfloat.ui64_to_f32(value)
+ return Float32.from_c_float(f)
+
+cpdef uint32_t f32_to_ui64(Float32 a1):
+ cdef uint32_t i = cfloat.f32_to_ui64(a1._c_float,
+ cfloat.softfloat_roundingMode, True)
+ return i
+
+cpdef int32_t f32_to_i64(Float32 a1):
+ cdef int32_t i = cfloat.f32_to_i64(a1._c_float,
+ cfloat.softfloat_roundingMode, True)
+ return i
+
+# u/i64 <-> f64
+
+cpdef Float64 i64_to_f64(int64_t value):
+ cdef cfloat.float64_t f = cfloat.i64_to_f64(value)
+ return Float64.from_c_float(f)
+
+cpdef Float64 ui64_to_f64(uint64_t value):
+ cdef cfloat.float64_t f = cfloat.ui64_to_f64(value)
+ return Float64.from_c_float(f)
+
+cpdef uint64_t f64_to_ui64(Float64 a1):
+ cdef uint64_t i = cfloat.f64_to_ui64(a1._c_float,
+ cfloat.softfloat_roundingMode, True)
+ return i
+
+cpdef int64_t f64_to_i64(Float64 a1):
+ cdef int64_t i = cfloat.f64_to_i64(a1._c_float,
+ cfloat.softfloat_roundingMode, True)
+ return i
# external, non-method arithmetic
cdef cfloat.float32_t f = cfloat.f32_mul(a1._c_float, a2._c_float)
return Float32.from_c_float(f)
-cpdef Float32 f32_fma(Float32 a1, Float32 a2, Float32 a3):
- cdef cfloat.float32_t f = cfloat.f32_mulAdd(a1._c_float, a2._c_float, a3._c_float)
- return Float32.from_c_float(f)
-
-cpdef Float32 f32_fam(Float32 a3, Float32 a1, Float32 a2):
- cdef cfloat.float32_t f = cfloat.f32_mulAdd(a1._c_float, a2._c_float, a3._c_float)
+cpdef Float32 f32_fma(Float32 acc, Float32 a1, Float32 a2):
+ cdef cfloat.float32_t f = cfloat.f32_mulAdd(a1._c_float, a2._c_float, acc._c_float)
return Float32.from_c_float(f)
cpdef Float32 f32_div(Float32 a1, Float32 a2):
# convenience interface for use inside Python
def __init__(self, value):
+ """Given an int, create a Float64 from the bitpattern represented by
+ that int. Otherwise, given some value, create a Float64 from
+ float(value).
+ """
cdef cfloat.ui64_double ud
cdef cfloat.float64_t d
def __mul__(self, Float64 other):
return self.mul(other)
- cpdef Float64 fma(self, Float64 a2, Float64 a3):
- cdef cfloat.float64_t f = cfloat.f64_mulAdd(self._c_float, a2._c_float, a3._c_float)
- return Float64.from_c_float(f)
-
- cpdef Float64 fam(self, Float64 a1, Float64 a2):
+ cpdef Float64 fma(self, Float64 a1, Float64 a2):
cdef cfloat.float64_t f = cfloat.f64_mulAdd(a1._c_float, a2._c_float, self._c_float)
return Float64.from_c_float(f)
self.imul(other)
return self
- cpdef void ifma(self, Float64 a2, Float64 a3):
- self._c_float = cfloat.f64_mulAdd(self._c_float, a2._c_float, a3._c_float)
-
- cpdef void ifam(self, Float64 a1, Float64 a2):
+ cpdef void ifma(self, Float64 a1, Float64 a2):
self._c_float = cfloat.f64_mulAdd(a1._c_float, a2._c_float, self._c_float)
cpdef void idiv(self, Float64 other):
cdef cfloat.float64_t f = cfloat.f64_mul(a1._c_float, a2._c_float)
return Float64.from_c_float(f)
-cpdef Float64 f64_fma(Float64 a1, Float64 a2, Float64 a3):
- cdef cfloat.float64_t f = cfloat.f64_mulAdd(a1._c_float, a2._c_float, a3._c_float)
- return Float64.from_c_float(f)
-
-cpdef Float64 f64_fam(Float64 a3, Float64 a1, Float64 a2):
- cdef cfloat.float64_t f = cfloat.f64_mulAdd(a1._c_float, a2._c_float, a3._c_float)
+cpdef Float64 f64_fma(Float64 acc, Float64 a1, Float64 a2):
+ cdef cfloat.float64_t f = cfloat.f64_mulAdd(a1._c_float, a2._c_float, acc._c_float)
return Float64.from_c_float(f)
cpdef Float64 f64_div(Float64 a1, Float64 a2):