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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
Testing("Predicates");
Verify(IsFunction(a(b)),True);
Verify(IsFunction(a),False);
Verify(IsList({a,b,c}),True);
Verify(IsList(a),False);
Verify(IsAtom({a,b,c}),False);
Verify(IsAtom(a),True);
Verify(IsAtom(123),True);
Verify(IsNumber(123),True);
Verify(IsNumber(123.123),True);
Verify(IsNumber(a),False);
Verify(IsNumber({a}),False);
Verify(IsInteger(123),True);
Verify(IsInteger(123.123),False);
Verify(IsInteger(a),False);
Verify(IsInteger({a}),False);
Testing("Boolean Operations");
Verify(False And False,False);
Verify(True And False,False);
Verify(False And True,False);
Verify(True And True,True);
Verify(False Or False,False);
Verify(True Or False,True);
Verify(False Or True,True);
Verify(True Or True,True);
Verify(Not(True),False);
Verify(Not(False),True);
Verify(IsEqual(a,b),False);
Verify(IsEqual(a,a),True);
Verify(IsEqual({a,b},{a}),False);
Verify(IsEqual({a,b},{a,b}),True);
Testing("NumberCompares");
Verify(IsLessThan(2,3),True);
Verify(IsLessThan(3,2),False);
Verify(IsGreaterThan(2,3),False);
Verify(IsGreaterThan(3,2),True);
Verify(.1<2,True);
Verify(0.1<2,True);
Verify(.3<2,True);
Verify(.1>2,False);
Verify(0.1>2,False);
Verify(.3>2,False);
Verify(2<.1,False);
Verify(2<0.1,False);
Verify(2<.3,False);
Verify(2>.1,True);
Verify(2>0.1,True);
Verify(2>.3,True);
Testing("comparisons in exponential notation");
// some of these failed
Verify(1e-5 < 1, True);
Verify(1e-5 < 2e-5, True);
Verify(1e-1 < 2e-1, True);
Verify(1e-15 < 2e-15, True);
Verify(1e-5 < 1e-10, False);
Verify(1e-5 < 1e-2, True);
Verify(-1e-5 < 1e-5, True);
Verify(-1e-5 < 1e-6, True);
Verify(1e-5 = 2e-5, False);
Verify(1e-5 = 1e-6, False);
Verify(1e-15 > 0, True);
Verify(1e-5 > 0, True);
Verify(1e-4 > 0, True);
Verify(1e-3 > 0, True);
Verify(1e-2 > 0, True);
Verify(1e-1 > 0, True);
Verify(1e5 > 0, True);
BuiltinPrecisionSet(32);
Verify(1.0000000000000000000000000000111 > 1, True);
Verify(0.999999999999999999999999999992 < 1, True);
BuiltinPrecisionSet(10);
Verify(IsLessThan(-1e-115, 0), True);
Verify(IsLessThan(-1e-15, 0), True);
Verify(IsLessThan(-1e-10, 0), True);
Verify(IsLessThan(-1e-5, 0), True);
Verify(IsLessThan(-1e-1, 0), True);
Testing("Matrix predicates");
Verify(IsHermitian({{0,I},{-I,0}}),True);
Verify(IsHermitian({{0,I},{-I,1}}),True);
Verify(IsHermitian({{0,I},{-2*I,0}}),False);
Verify(IsUnitary({{0,I},{-I,0}}),True);
Verify(IsUnitary({{0,I},{-I,1}}),False);
Verify(IsUnitary({{0,I},{-2*I,0}}),False);
Verify(IsVariable(a),True);
Verify(IsVariable(Sin(a)),False);
Verify(IsVariable(2),False);
Verify(IsVariable(-2),False);
Verify(IsVariable(2.1),False);
Verify(HasExpr(a*b+1,1),True);
Verify(HasExpr(a+Sin(b*c),c),True);
Verify(HasExpr(a*b+1,2),False);
Verify(HasExpr(a*b+f({b,c}),f),False);
Verify(HasExprArith(a*b+1,ToAtom("+")),False);
Verify(HasExprArith(a*b+1,1),True);
Verify(HasExprArith(a+Sin(b*c),c),False);
Verify(HasExprArith(a+Sin(b*c),Sin(b*c)),True);
Verify(HasExprArith(a*b+f({b,c}),c),False);
Verify(HasFunc(a*b+1,*),True);
Verify(HasFunc(a+Sin(b*c),*),True);
Verify(HasFunc(a*b+1,List),False);
Verify(HasFunc(a*b+f({b,c}),List),True);
Verify(HasFuncArith(a*b+1,ToAtom("+")),True);
Verify(HasFuncArith(a+Sin(b*c),*),False);
Verify(HasFuncArith(a+Sin(b*c),Sin),True);
Verify(HasFuncArith(a*b+f({b,c}),List),False);
Verify(IsGaussianInteger(3+4*I),True );
Verify(IsGaussianInteger(5),True);
Verify(IsGaussianInteger(1.1), False );
Verify(IsGaussianPrime(5+2*I),True );
Verify(IsGaussianPrime(13), False );
Verify(IsGaussianPrime(0), False );
Verify(IsGaussianPrime(3.5), False );
Verify(IsGaussianPrime(2+3.1*I), False );
Verify(IsPerfect(2305843008139952128), True );
Verify(IsPerfect(137438691328),True );
Verify(IsPerfect(234325),False );
Testing("IsConstant");
Verify(IsConstant(Pi), True);
Verify(IsConstant(Exp(1)+Sqrt(3)), True);
Verify(IsConstant(x), False);
Verify(IsConstant(Infinity), True);
Verify(IsConstant(-Infinity), True);
Verify(IsConstant(Undefined), True);
Testing("-- IsScalar");
Verify(IsScalar(a),True);
Verify(IsScalar({a}),False);
Testing("-- IsVector");
Verify(IsVector(1),False);
Verify(IsVector(a),False);
Verify(IsVector(Sin(a)+2),False);
Verify(IsVector({}),True);
Verify(IsVector({{}}),False);
Verify(IsVector({1,2,a,4}),True);
Verify(IsVector({1,{2,a},4}),False);
Verify(IsVector({{a,b,c}}),False);
Testing("-- IsVector(IsNumber)");
Verify(IsVector(IsNumber,1),False);
Verify(IsVector(IsNumber,{}),True);
Verify(IsVector(IsNumber,{a,b,c}),False);
Verify(IsVector(IsNumber,{a,2,c}),False);
Verify(IsVector(IsNumber,{2,2.5,4}),True);
Verify(IsVector(IsNumber,{Pi,2,3}),False);
Verify(IsVector(IsNumber,{{1},{2}}),False);
Testing("-- Matrix Predicates");
Testing("---- IsMatrix");
Verify(IsMatrix(1),False);
Verify(IsMatrix({}),False);
Verify(IsMatrix({a,b}),False);
Verify(IsMatrix({{}}),True);
Verify(IsMatrix({{a}}),True);
Verify(IsMatrix({{{a}}}),False);
Verify(IsMatrix({{},a}),False);
Verify(IsMatrix({{a},b}),False);
Verify(IsMatrix({{},{}}),True);
Verify(IsMatrix({{{}},{}}),False);
Verify(IsMatrix({{},{{}}}),False);
Verify(IsMatrix({{a,b},{c}}),False);
Verify(IsMatrix({{a,b},{c,d}}),True);
Verify(IsMatrix({{a,b},{c,{d}}}),False);
Verify(IsMatrix({{{}}}), False);
Verify(IsMatrix({{{a}}}), False);
Verify(IsMatrix({{{{a}}},{{{b}}}}),False);
Testing("---- IsMatrix(IsInteger)");
Verify(IsMatrix(IsInteger,{{a,1}}),False);
Verify(IsMatrix(IsInteger,{{1,2}}),True);
Verify(IsMatrix(IsInteger,{{1,2/3}}),False);
Verify(IsMatrix(IsInteger,{{1,2,3},{4,5,6}}),True);
Verify(IsMatrix(IsInteger,{{1,{2},3},{4,5,6}}),False);
Verify(IsMatrix(IsInteger,{{1,2,3},{4,5}}),False);
Verify(IsMatrix(IsInteger,{{Sin(1),2,3},{4,5,6}}),False);
Verify(IsMatrix(IsInteger,{{Sin(0),2,3},{4,5,6}}),True);
Testing("---- IsSquareMatrix");
Verify(IsSquareMatrix({{}}),False);
Verify(IsSquareMatrix({{a}}),True);
Verify(IsSquareMatrix({{},{}}),False);
Verify(IsSquareMatrix({{a,b}}),False);
Verify(IsSquareMatrix({{a,b},{c,d}}),True);
Verify(IsSquareMatrix({{a,b},{c,d},{e,f}}),False);
Verify(IsSquareMatrix({{a,b,c},{d,e,f},{g,h,i}}),True);
Verify(IsSquareMatrix({{a,b,c},{d,e,f}}),False);
Verify(IsSquareMatrix({{{a,b}},{{c,d}}}), False);
|
