GeezerVison

Are there non templated versions of random number generators ?

@arrayfire/rust-devel Please check the latest commit, it should cover all the missing gaps now.

I found the need for constant a while ago. But since I don't really need U64_MAX & I64_MAX I approximated it with the following [using conv crate]:

use af;
use conv::{ConvUtil, Saturate};

/// Helper to return a constant value based on type
pub fn constant(dims: Dim4, aftype: DType, val: f32) -> Array {
  match aftype
  {
    DType::F32 => af::constant(val, dims),
    DType::F64 => af::constant(val.approx_as::<f64>().unwrap(), dims),
    DType::C32 => af::constant(Complex::new(val, 0f32)
                                , dims),
    DType::C64 => af::constant(Complex::new(val.approx_as::<f64>().unwrap(), 0f64)
                        , dims),
    DType::B8  => {
      if val > 0f32 {
        af::constant(true, dims)
      }else{
        af::constant(false, dims)
      }
    },
    DType::S32 => af::constant(val.approx_as::<i32>().saturate().unwrap(), dims),
    DType::U32 => af::constant(val.approx_as::<u32>().saturate().unwrap(), dims),
    DType::U8  => af::constant(val.approx_as::<u8>().saturate().unwrap(), dims),
    DType::S64 => af::constant(val.approx_as::<i64>().saturate().unwrap(), dims),
    DType::U64 => af::constant(val.approx_as::<u64>().saturate().unwrap(), dims),
    DType::S16 => af::constant(val.approx_as::<i16>().saturate().unwrap(), dims),
    DType::U16 => af::constant(val.approx_as::<u16>().saturate().unwrap(), dims),
  }
}

@jramapuram I don't like the create_ prefix either, but i couldn't figure out a way to keep both earlier versions of the data generation functions and the new ones with same function names. Even if i mark a function as deprecated, the new function cannot have the same name.

@pavanky @jramapuram Feedback pls, i want to release 3.4.1 of this wrapper this week if possible.

@jramapuram @9prady9

why won't the function shown here work:
#94 (comment)

That version is sacrificing accuracy of u64 and i64 by accepting the constant value as an f32

pub fn constant(dims: Dim4, aftype: DType, val: f32)

I don't think we can do that as a library.

Edited: Added to that, we can't have another function with same name as constant, hence the type suffixes.

@9prady9 accept f64 and have special version called constant_long or something. This is what we do for the C and C++ versions anyway.

I didn't check C++ API, but C API of arrayfire has different functions for u64, i64 and rest of the types.

Edited:

• af_constant_ulong
• af_constant_long
• af_constant_complex and af_constant for test of the types

@9prady9 I wasn't talking about having multiple functions, but about the name (specifically the create_ parts). Will @jramapuram's code causing a conflict?

Yes, we can't have same names.

For him it is working because he had them in different namespace.

Sorry for the delay. Infrequent internet over the winter break. Will review in 2 days.

@arrayfire/rust-devel Awaiting feedback.

Added a simple way to use Enums in comments. Another possible (but have not tested myself) way is to use generics: http://stackoverflow.com/questions/26810793/how-can-i-create-an-is-prime-function-that-is-generic-over-various-integer-types

See solution in that answer as well as comment in accepted answer. Not sure if the generics are robust enough to accept all numeric types yet though.

@jramapuram please check now. Using your suggestion, i have consolidated all the separate create_constant_* functions into a single function constant_t with the suffix _t suggesting that it takes additional type parameter (that's the shortest name i could come up with that is different from constant).

@pavanky please check now. I have renamed all create_* fns to have _t suffix now.

looks good 👍

Looks great!