openalgebra 0.0.1

Rust linear algebra library for OpenCL
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

use super::af;
use std::ops::*;

use super::{Vector};

macro_rules! arith_func {
    ($type_name: ty, $op_name: ident, $fn_name: ident) => (
        impl<'a> $op_name<&'a $type_name> for &'a Vector {
            type Output = Vector;
            fn $fn_name(self, rhs: &$type_name) -> Self::Output {
                let rhs = Vector::from(rhs);
                Vector::from(af::$fn_name(&self.backend, &rhs.backend, false))
            }
        }

        impl $op_name<$type_name> for Vector {
            type Output = Vector;
            fn $fn_name(self, rhs: $type_name) -> Self::Output {
                let rhs = Vector::from(rhs);
                Vector::from(af::$fn_name(&self.backend, &rhs.backend, false))
            }
        }
    );
}

macro_rules! rem_func {
    ($type_name: ty, $op_name: ident, $fn_name: ident) => (
        impl<'a> $op_name<&'a $type_name> for &'a Vector {
            type Output = Vector;
            fn rem(self, rhs: &$type_name) -> Self::Output {
                let rhs = Vector::from(rhs);
                Vector::from(af::$fn_name(&self.backend, &rhs.backend, false))
            }
        }

        impl $op_name<$type_name> for Vector {
            type Output = Vector;
            fn rem(self, rhs: $type_name) -> Self::Output {
                let rhs = Vector::from(rhs);
                Vector::from(af::$fn_name(&self.backend, &rhs.backend, false))
            }
        }
    );
}

macro_rules! arith_func_type {
    ($type_name: ty) => (
        arith_func!($type_name, Add, add);
        arith_func!($type_name, Sub, sub);
        arith_func!($type_name, Div, div);
        arith_func!($type_name, Mul, mul);
        rem_func!($type_name, Rem, modulo);
    );
}

macro_rules! arith_assign_func {
    ($type_name: ty, $op_name: ident, $fn_name: ident, $base_name: ident) => (
        impl $op_name<$type_name> for Vector {
            fn $fn_name(&mut self, rhs: $type_name) {
                let rhs = Vector::from(rhs);
                *self = Vector::from(af::$base_name(&self.backend, &rhs.backend, false));
            }
        }
    );
}

macro_rules! arith_assign_func_type {
    ($type_name: ty) => (
        arith_assign_func!($type_name, AddAssign, add_assign, add);
        arith_assign_func!($type_name, SubAssign, sub_assign, sub);
        arith_assign_func!($type_name, DivAssign, div_assign, div);
        arith_assign_func!($type_name, MulAssign, mul_assign, mul);
        arith_assign_func!($type_name, RemAssign, rem_assign, rem);
    );
}

macro_rules! generate {
    ($type_name: ty) => (
        arith_func_type!($type_name);
        arith_assign_func_type!($type_name);
    )
}

generate!(Vector);
generate!(f64);

impl Neg for Vector {
    type Output = Vector;
    fn neg(self) -> Self::Output {
        Vector::from(-self.backend)
    }
}