Additional changes for f16 type

Author: umar456

src/core/arith.rs

@@ -4,6 +4,8 @@ use super::defines::AfError;
 use super::dim4::Dim4;
 use super::error::HANDLE_ERROR;
 use super::util::{af_array, HasAfEnum, ImplicitPromote, IntegralType};
+
+use half::f16;
 use num::Zero;
 
 use libc::c_int;
@@ -763,6 +765,7 @@ arith_scalar_spec!(Complex<f64>);
 arith_scalar_spec!(Complex<f32>);
 arith_scalar_spec!(f64);
 arith_scalar_spec!(f32);
+arith_scalar_spec!(f16);
 arith_scalar_spec!(u64);
 arith_scalar_spec!(i64);
 arith_scalar_spec!(u32);

src/core/data.rs

@@ -4,6 +4,7 @@ use super::dim4::Dim4;
 use super::error::HANDLE_ERROR;
 use super::util::{af_array, c32, c64, dim_t, u64_t, HasAfEnum};
 
+use half::f16;
 use libc::{c_double, c_int, c_uint};
 use std::option::Option;
 use std::vec::Vec;
@@ -231,6 +232,25 @@ impl ConstGenerator for bool {
     }
 }
 
+impl ConstGenerator for f16 {
+    type OutType = f16;
+
+    fn generate(&self, dims: Dim4) -> Array<Self::OutType> {
+        unsafe {
+            let mut temp: af_array = std::ptr::null_mut();
+            let err_val = af_constant(
+                &mut temp as *mut af_array,
+                f16::to_f64(*self),
+                dims.ndims() as c_uint,
+                dims.get().as_ptr() as *const dim_t,
+                12,
+            );
+            HANDLE_ERROR(AfError::from(err_val));
+            temp.into()
+        }
+    }
+}
+
 macro_rules! cnst {
     ($rust_type:ty, $ffi_type:expr) => {
         impl ConstGenerator for $rust_type {

src/core/num.rs

@@ -1,3 +1,4 @@
+
 pub trait Zero {
     fn zero() -> Self;
 }
@@ -28,6 +29,7 @@ zero_impl!(i64, 0);
 zero_impl!(isize, 0);
 zero_impl!(f32, 0.0);
 zero_impl!(f64, 0.0);
+zero_impl!(half::f16, half::f16::from_f32(0.0));
 
 macro_rules! one_impl {
     ( $t:ident, $o:expr ) => {
@@ -51,3 +53,4 @@ one_impl!(i64, 1);
 one_impl!(isize, 1);
 one_impl!(f32, 1.0);
 one_impl!(f64, 1.0);
+one_impl!(half::f16, half::f16::from_f32(1.0));

src/core/util.rs

@@ -341,7 +341,7 @@ impl HasAfEnum for f16 {
     type AbsOutType = Self;
     type ArgOutType = Self;
     type UnaryOutType = Self;
-    type ComplexOutType = Complex<f16>;
+    type ComplexOutType = Complex<f32>;
     type MeanOutType = Self;
     type AggregateOutType = f32;
     type ProductOutType = f32;
@@ -682,12 +682,18 @@ impl FloatingPoint for f32 {
         true
     }
 }
+impl FloatingPoint for f16 {
+    fn is_real() -> bool {
+        true
+    }
+}
 
 ///Trait qualifier to accept real data(numbers)
 pub trait RealFloating: HasAfEnum {}
 
 impl RealFloating for f64 {}
 impl RealFloating for f32 {}
+impl RealFloating for f16 {}
 
 ///Trait qualifier to accept complex data(numbers)
 pub trait ComplexFloating: HasAfEnum {}
@@ -700,6 +706,7 @@ pub trait RealNumber: HasAfEnum {}
 
 impl RealNumber for f64 {}
 impl RealNumber for f32 {}
+impl RealNumber for f16 {}
 impl RealNumber for i32 {}
 impl RealNumber for u32 {}
 impl RealNumber for i16 {}
@@ -860,6 +867,8 @@ impl Fromf64 for u32  { fn fromf64(value: f64) -> Self { value as Self }}
 #[rustfmt::skip]
 impl Fromf64 for i32  { fn fromf64(value: f64) -> Self { value as Self }}
 #[rustfmt::skip]
+impl Fromf64 for f16  { fn fromf64(value: f64) -> Self { f16::from_f64(value) }}
+#[rustfmt::skip]
 impl Fromf64 for u16  { fn fromf64(value: f64) -> Self { value as Self }}
 #[rustfmt::skip]
 impl Fromf64 for i16  { fn fromf64(value: f64) -> Self { value as Self }}
@@ -877,6 +886,7 @@ impl IndexableType for u64 {}
 impl IndexableType for f32 {}
 impl IndexableType for i32 {}
 impl IndexableType for u32 {}
+impl IndexableType for f16 {}
 impl IndexableType for i16 {}
 impl IndexableType for u16 {}
 impl IndexableType for u8 {}