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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
/*
* Copyright (c) 2002-2006 Samit Basu
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
#ifndef __Math_hpp_
#define __Math_hpp_
#include "Array.hpp"
#include <cmath>
/**
* Add the two argument arrays together: $$C_n = A_n + B_n$$.
*/
Array Add(const Array& A, const Array& B);
/**
* Subtract the second array from the first: $$C_n = A_n - B_n$$.
*/
Array Subtract(const Array& A, const Array& B);
/**
* Element-wise multiply of two arrays: $$C_n = A_n B_n$$.
*/
Array DotMultiply(const Array& A, const Array& B);
/**
* Element-wise divide of two arrays: $$C_n = \frac{A_n}{B_n}$$.
*/
Array DotRightDivide(const Array& A, const Array& B);
/**
* Element-wise divide of two arrays: $$C_n = \frac{B_n}{A_n}$$.
*/
Array DotLeftDivide(const Array& A, const Array& B);
/**
* Element-wise compare (lt) of two arrays: $$C_n = A_n < B_n$$.
*/
Array LessThan(const Array& A, const Array& B);
/**
* Element-wise compare (le) of two arrays: $$C_n = A_n \leq B_n$$.
*/
Array LessEquals(const Array& A, const Array& B);
/**
* Element-wise compare (gt) of two arrays: $$C_n = A_n > B_n$$.
*/
Array GreaterThan(const Array& A, const Array& B);
/**
* Element-wise compare (ge) of two arrays: $$C_n = A_n \geq B_n$$.
*/
Array GreaterEquals(const Array& A, const Array& B);
/**
* Element-wise compare (eq) of two arrays: $$C_n = A_n == B_n$$.
*/
Array Equals(const Array& A, const Array& B);
/**
* Element-wise compare (ne) of two arrays: $$C_n = A_n \neq B_n$$.
*/
Array NotEquals(const Array& A, const Array& B);
/**
* Element-wise or of two arrays: $$C_n = A_n \or B_n$$.
*/
Array Or(const Array& A, const Array& B);
/**
* Element-wise and of two arrays: $$C_n = A_n \and B_n$$.
*/
Array And(const Array& A, const Array& B);
/**
* Element-wise not of argument: $$C_n = \not A_n$$.
*/
Array Not(const Array& A);
/**
* Element-wise plus of argument: $$C_n = + A_n$$.
*/
Array Plus(const Array& A);
/**
* Element-wise negate of argument: $$C_n = - A_n$$.
*/
Array Negate(const Array& A);
/**
* Element-wise power: $$C_n = A_n ^ {B_n}$$.
*/
Array DotPower(const Array& A, const Array& B);
/**
* Matrix to matrix power. The calculation performed
* depends on the sizes of the arguments.
* - both are scalars, $$C = A^B$$.
* - $$A$$ is a square matrix, $$B$$ is a scalar,
* $$C = E V^{B} E^{-1}$$, where $$V$$ is the diagonal
* matrix of eigenvalues of $$A$$, and $$E$$ is the
* associated matrix of eigenvectors.
* - $$A$$ is a scalar, $$B$$ is a matrix,
* $$C = E A^{V} E^{-1}$$, where $$V$$ is the diagonal
* matrix of eigenvalues of $$B$$, and $$E$$ is the
* associated matrix of eigenvectors. The quantity
* $$A^{V}$$ is evaluated along the diagonal.
* Throws an exception if
* - both arguments are matrices
* - either of the arguments is more than 2-dimensional
* - any of the arguments are rectangular.
*/
Array Power(const Array& A, const Array& B);
/**
* Matrix multiply of the arguments. For $$m \times n$$ matrix $$A$$,
* and $$n \times k$$ matrix $$B$$, the output matrix $$C$$ is of
* size $$m \times k$$, defined by $$C_{i,j} = \sum_{p=1}^{n} A_{i,p} B_{p,j}$$.
* Throws an exception if the sizes are not conformant.
*/
Array Multiply(const Array& A, const Array& B);
/**
* The right divide operation is related to the left divide operation
* via: B/A = (A'\B')'.
*/
Array RightDivide(const Array& A, const Array& B);
/**
* The left divide operation is equivalent to solving the system of equations
* $$A C = B$$ for the matrix $$C$$, where $$A$$ is of size $$m \times n$$,
* $$B$$ is of size $$m \times k$$, and the output $$C$$ is of size $$n \times k$$.
* Uses the linear equation solver from LAPACK to solve these equations.
* They are effectively solved independently for each column of $$B$$.
*/
Array LeftDivide(const Array& A, const Array& B);
/**
* For scalars $$A$$ and $$B$$, the output is the row vector
* $$[A,A+1,\ldots,A+n]$$, where $$n$$ is the largest integer
* such that $$A+n < B$$.
*/
Array UnitColon(const Array& A, const Array& B);
/**
* For scalars $$A$$, $$B$$ and $$C$$, the output is the row vector
* $$[A,A+B,\ldots,A+nB]$$, where $$n$$ is the largest integer
* such that $$A+nB < C$$.
*/
Array DoubleColon(const Array& A, const Array& B, const Array& C);
void TypeCheck(Array &A, Array &B, bool isDivOrMatrix);
Array InvertMatrix(const Array& A);
#endif
|
