#[macro_export]
macro_rules! mem_info {
[$msg: expr] => {
{
let (abytes, abuffs, lbytes, lbuffs) = $crate::device_mem_info();
println!("AF Memory: {:?}", $msg);
println!("Allocated [Bytes | Buffers] = [ {} | {} ]", abytes, abuffs);
println!("In Use [Bytes | Buffers] = [ {} | {} ]", lbytes, lbuffs);
}
};
}
#[macro_export]
macro_rules! join_many {
[$dim: expr; $($x:expr),+] => {
{
let mut temp_vec = Vec::new();
$(
temp_vec.push($x);
)*
$crate::join_many($dim, temp_vec)
}
};
}
#[macro_export]
macro_rules! af_print {
[$msg: expr, $x: expr] => {
{
$crate::print_gen(String::from($msg), &$x, Some(4));
}
};
}
#[macro_export]
macro_rules! dim4 {
($dim0:expr) => {
$crate::Dim4::new(&[$dim0, 1, 1, 1])
};
($dim0:expr, $dim1:expr) => {
$crate::Dim4::new(&[$dim0, $dim1, 1, 1])
};
($dim0:expr, $dim1:expr, $dim2:expr) => {
$crate::Dim4::new(&[$dim0, $dim1, $dim2, 1])
};
($dim0:expr, $dim1:expr, $dim2:expr, $dim3:expr) => {
$crate::Dim4::new(&[$dim0, $dim1, $dim2, $dim3])
};
}
#[macro_export]
macro_rules! seq {
() => {
$crate::Seq::<i32>::default()
};
($sty:ty; $start:literal : $end:literal : $step:literal) => {
$crate::Seq::<$sty>::new($start, $end, $step)
};
($start:literal : $end:literal : $step:literal) => {
$crate::Seq::<i32>::new($start, $end, $step)
};
($sty:ty; $start:expr , $end:expr , $step:expr) => {
$crate::Seq::<$sty>::new($start, $end, $step)
};
($start:expr , $end:expr , $step:expr) => {
$crate::Seq::<i32>::new($start, $end, $step)
};
}
#[macro_export]
macro_rules! view {
(@af_max_dims) => {
4
};
( $array_ident:ident ) => {
$array_ident.clone()
};
( $array_ident:ident [ $($start:literal : $end:literal : $step:literal),+ ] ) => {
{
#[allow(non_snake_case)]
let AF_MAX_DIMS: usize = view!(@af_max_dims);
let mut seq_vec = Vec::<$crate::Seq<i32>>::with_capacity(AF_MAX_DIMS);
$(
seq_vec.push($crate::seq!($start:$end:$step));
)*
$crate::index(&$array_ident, &seq_vec)
}
};
(@set_indexer $idim:expr, $idxr:ident, $lterm:expr) => {
{
$idxr.set_index(&$lterm, $idim, None);
}
};
(@set_indexer $idim:expr, $idxr:ident, $hterm:expr, $($tterm:expr),*) => {
{
$idxr.set_index(&$hterm, $idim, None);
view!(@set_indexer $idim + 1, $idxr, $($tterm),*);
}
};
($array_ident:ident [ $($_e:expr),+ ]) => {
{
let mut idxrs = $crate::Indexer::default();
view!(@set_indexer 0, idxrs, $($_e),*);
$crate::index_gen(&$array_ident, idxrs)
}
};
}
#[macro_export]
macro_rules! eval {
( $l:ident [ $($lb:literal : $le:literal : $ls:literal),+ ] =
$r:ident [ $($rb:literal : $re:literal : $rs:literal),+ ]) => {
{
#[allow(non_snake_case)]
let AF_MAX_DIMS: usize = view!(@af_max_dims);
let mut seq_vec = Vec::<$crate::Seq<i32>>::with_capacity(AF_MAX_DIMS);
$(
seq_vec.push($crate::seq!($lb:$le:$ls));
)*
let mut idxrs = $crate::Indexer::default();
for i in 0..seq_vec.len() {
idxrs.set_index(&seq_vec[i], i as u32, None);
}
let eq_rterm = $crate::view!($r[ $($rb:$re:$rs),+ ]);
$crate::assign_gen(&mut $l, &idxrs, &eq_rterm);
}
};
( $l:ident [ $($lb:literal : $le:literal : $ls:literal),+ ] = $r:expr ) => {
{
#[allow(non_snake_case)]
let AF_MAX_DIMS: usize = view!(@af_max_dims);
let mut seq_vec = Vec::<$crate::Seq<i32>>::with_capacity(AF_MAX_DIMS);
$(
seq_vec.push($crate::seq!($lb:$le:$ls));
)*
let mut idxrs = $crate::Indexer::default();
for i in 0..seq_vec.len() {
idxrs.set_index(&seq_vec[i], i as u32, None);
}
$crate::assign_gen(&mut $l, &idxrs, &$r);
}
};
($lhs:ident [ $($lhs_e:expr),+ ] = $rhs:ident [ $($rhs_e:expr),+ ]) => {
{
let eq_rterm = $crate::view!($rhs[ $($rhs_e),+ ]);
let mut idxrs = $crate::Indexer::default();
view!(@set_indexer 0, idxrs, $($lhs_e),*);
$crate::assign_gen(&mut $lhs, &idxrs, &eq_rterm);
}
};
($lhs:ident [ $($lhs_e:expr),+ ] = $rhs:expr) => {
{
let mut idxrs = $crate::Indexer::default();
view!(@set_indexer 0, idxrs, $($lhs_e),*);
$crate::assign_gen(&mut $lhs, &idxrs, &$rhs);
}
};
[$($x:expr),+] => {
{
let mut temp_vec = Vec::new();
$(
temp_vec.push($x);
)*
$crate::eval_multiple(temp_vec)
}
};
}
#[macro_export]
macro_rules! constant {
($value:expr; $($dim:expr),+) => {
$crate::constant($value, $crate::dim4!($($dim),*))
};
}
#[macro_export]
macro_rules! randu {
($($dim:expr),+) => { $crate::randu::<f32>($crate::dim4!($($dim),*)) };
($type:ty; $($dim:expr),+) => { $crate::randu::<$type>($crate::dim4!($($dim),*)) };
}
#[macro_export]
macro_rules! randn {
($($dim:expr),+) => { $crate::randn::<f32>($crate::dim4!($($dim),*)) };
($type:ty; $($dim:expr),+) => { $crate::randn::<$type>($crate::dim4!($($dim),*)) };
}
#[cfg(test)]
mod tests {
use super::super::array::Array;
use super::super::data::constant;
use super::super::device::set_device;
use super::super::index::index;
use super::super::random::randu;
#[test]
fn dim4_construction() {
let dim1d = dim4!(2);
let dim2d = dim4!(2, 3);
let dim3d = dim4!(2, 3, 4);
let dim4d = dim4!(2, 3, 4, 2);
let _dimn = dim4!(dim1d[0], dim2d[1], dim3d[2], dim4d[3]);
}
#[test]
fn seq_construction() {
let default_seq = seq!();
let _range_1_to_10_step_1 = seq!(0:9:1);
let _range_1_to_10_step_1_2 = seq!(f32; 0.0:9.0:1.5);
let _range_from_exprs = seq!(default_seq.begin(), default_seq.end(), default_seq.step());
let _range_from_exprs2 = seq!(f32; default_seq.begin() as f32,
default_seq.end() as f32, default_seq.step() as f32);
}
#[test]
fn seq_view() {
set_device(0);
let mut dim4d = dim4!(5, 3, 2, 1);
dim4d[2] = 1;
let a = randu::<f32>(dim4d);
let seqs = &[seq!(1:3:1), seq!()];
let _sub = index(&a, seqs);
}
#[test]
fn seq_view2() {
set_device(0);
let a = randu::<f32>(dim4!(5, 5));
let _sub = view!(a[1:3:1, 1:1:0]);
}
#[test]
fn view_macro() {
set_device(0);
let dims = dim4!(5, 5, 2, 1);
let a = randu::<f32>(dims);
let b = a.clone();
let c = a.clone();
let d = a.clone();
let e = a.clone();
let _v = view!(a);
let _m = view!(c[1:3:1, 1:3:2]);
let x = seq!(1:3:1);
let y = seq!(1:3:2);
let _u = view!(b[x, y]);
let values: [u32; 3] = [1, 2, 3];
let indices = Array::new(&values, dim4!(3, 1, 1, 1));
let indices2 = Array::new(&values, dim4!(3, 1, 1, 1));
let _w = view!(d[indices, indices2]);
let _z = view!(e[indices, y]);
}
#[test]
fn eval_assign_seq_indexed_array() {
set_device(0);
let dims = dim4!(5, 5);
let mut a = randu::<f32>(dims);
let b = randu::<f32>(dims);
let d0 = seq!(1:2:1);
let d1 = seq!(1:2:1);
let s0 = seq!(1:2:1);
let s1 = seq!(1:2:1);
eval!(a[d0, d1] = b[s0, s1]);
}
#[test]
fn eval_assign_array_to_seqd_array() {
set_device(0);
let mut a = randu::<f32>(dim4!(5, 5));
let b = randu::<f32>(dim4!(2, 2));
eval!(a[1:2:1, 1:2:1] = b);
}
#[test]
fn macro_seq_array_assign() {
set_device(0);
let values: [f32; 3] = [1.0, 2.0, 3.0];
let indices = Array::new(&values, dim4!(3));
let seq4gen = seq!(0:2:1);
let mut a = randu::<f32>(dim4!(5, 3));
let b = constant(2.0 as f32, dim4!(3, 3));
eval!(a[indices, seq4gen] = b);
}
#[test]
fn constant_macro() {
set_device(0);
let _zeros_1d = constant!(0.0f32; 10);
let _zeros_2d = constant!(0.0f64; 5, 5);
let _ones_3d = constant!(1u32; 3, 3, 3);
let _twos_4d = constant!(2u16; 2, 2, 2, 2);
let dim = 10;
let _mix_shape = constant!(42.0f32; dim, 10);
}
#[test]
fn rand_macro() {
set_device(0);
let _ru5x5 = randu!(5, 5);
let _rn5x5 = randn!(5, 5);
let _ruu32_5x5 = randu!(u32; 5, 5);
let _ruu8_5x5 = randu!(u8; 5, 5);
}
}