← Back to branch summary

~ubuntu-branches/ubuntu/trusty/ffc/trusty

« back to all changes in this revision

Viewing changes to test/unit/symbolics/testmixedsymbols.py

  • Committer: Bazaar Package Importer
  • Author(s): Johannes Ring
  • Date: 2010-02-03 20:22:35 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20100203202235-fe8d0kajuvgy2sqn
Tags: 0.9.0-1
* New upstream release.
* debian/control: Bump Standards-Version (no changes needed).
* Update debian/copyright and debian/copyright_hints.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/unit/symbolics/testmixedsymbols.py
 
1
#!/usr/bin/env python
 
2
 
 
3
__author__ = "Kristian B. Oelgaard (k.b.oelgaard@gmail.com)"
 
4
__date__ = "2010-01-06"
 
5
__copyright__ = "Copyright (C) 2010 Kristian B. Oelgaard"
 
6
__license__  = "GNU GPL version 3 or any later version"
 
7
 
 
8
# Last changed: 2010-02-01
 
9
 
 
10
# Pyhton modules
 
11
import unittest
 
12
import time
 
13
 
 
14
# FFC modules
 
15
from ffc.quadrature.symbolics import *
 
16
from ffc.cpp import format, set_float_formatting
 
17
from ffc.parameters import FFC_PARAMETERS
 
18
set_float_formatting(FFC_PARAMETERS['precision'])
 
19
 
 
20
class TestMixedSymbols(unittest.TestCase):
 
21
 
 
22
    def testMixedSymbols(self):
 
23
 
 
24
        f_0 = format["float"](0)
 
25
        f_2 = format["float"](2)
 
26
        f_3 = format["float"](3)
 
27
        f_4 = format["float"](4)
 
28
        f_6 = format["float"](6)
 
29
 
 
30
        f0 = FloatValue(-2.0)
 
31
        f1 = FloatValue(3.0)
 
32
        f2 = FloatValue(0)
 
33
 
 
34
        s0 = Symbol("x", BASIS)
 
35
        s1 = Symbol("y", GEO)
 
36
        s2 = Symbol("z", GEO)
 
37
 
 
38
        p0 = Product([s0, s1])
 
39
        p1 = Product([f1, s0, s1])
 
40
        p2 = Product([s0, f2, s2])
 
41
        p3 = Product([s0, f0, s1, f1, s2])
 
42
 
 
43
        S0 = Sum([s0, s1])
 
44
        S1 = Sum([s0, s0])
 
45
        S2 = Sum([f0, s0])
 
46
        S3 = Sum([s0, f0, s0])
 
47
 
 
48
        F0 = Fraction(f1, f0)
 
49
        F1 = Fraction(s0, s1)
 
50
        F2 = Fraction(s0, f1)
 
51
        F3 = Fraction(f0, s1)
 
52
 
 
53
        x = 1.2; y = 2.36; z = 6.75;
 
54
        # Mixed products
 
55
        mpp0 = Product([p0, s0])
 
56
        mpp1 = Product([p1, p0])
 
57
        mpp2 = Product([p2, p3])
 
58
        mpp3 = Product([p1, mpp1])
 
59
 
 
60
        mps0 = Product([S0, s0])
 
61
        mps1 = Product([S1, S0])
 
62
        mps2 = Product([S2, S3])
 
63
        mps3 = Product([S1, mps1])
 
64
 
 
65
        mpf0 = Product([F1, s0])
 
66
        mpf1 = Product([F1, F2])
 
67
        mpf2 = Product([F2, F3])
 
68
        mpf3 = Product([F1, mpf1])
 
69
 
 
70
#        print "\nMixed Products"
 
71
#        print "\nmpp0: %s * %s = '%s'" % (p0, s0, mpp0)
 
72
#        print "mpp1: %s * %s = '%s'" % (p1, p0, mpp1)
 
73
#        print "mpp2: %s * %s = '%s'" % (p2, p3, mpp2)
 
74
#        print "mpp3: %s * %s = '%s'" % (p1, mpp1, mpp3)
 
75
#        print "\nmps0: %s * %s = '%s'" % (S0, s0, mps0)
 
76
#        print "mps1: %s * %s = '%s'" % (S1, S0, mps1)
 
77
#        print "mps2: %s * %s = '%s'" % (S2, S3, mps2)
 
78
#        print "mps3: %s * %s = '%s'" % (S1, mps1, mps3)
 
79
#        print "\nmpf0: %s * %s = '%s'" % (F1, s0, mpf0)
 
80
#        print "mpf1: %s * %s = '%s'" % (F1, F2, mpf1)
 
81
#        print "mpf2: %s * %s = '%s'" % (F2, F3, mpf2)
 
82
#        print "mpf3: %s * %s = '%s'" % (F1, mpf1, mpf3)
 
83
 
 
84
        self.assertAlmostEqual(eval(str(mpp0)), eval(str(p0))*eval(str(s0)))
 
85
        self.assertAlmostEqual(eval(str(mpp1)), eval(str(p1))*eval(str(p0)))
 
86
        self.assertAlmostEqual(eval(str(mpp2)), eval(str(p2))*eval(str(p3)))
 
87
        self.assertAlmostEqual(eval(str(mpp3)), eval(str(p1))*eval(str(mpp1)))
 
88
 
 
89
        self.assertAlmostEqual(eval(str(mps0)), eval(str(S0))*eval(str(s0)))
 
90
        self.assertAlmostEqual(eval(str(mps1)), eval(str(S1))*eval(str(S0)))
 
91
        self.assertAlmostEqual(eval(str(mps2)), eval(str(S2))*eval(str(S3)))
 
92
        self.assertAlmostEqual(eval(str(mps3)), eval(str(S1))*eval(str(mps1)))
 
93
 
 
94
        self.assertAlmostEqual(eval(str(mpf0)), eval(str(F1))*eval(str(s0)))
 
95
        self.assertAlmostEqual(eval(str(mpf1)), eval(str(F1))*eval(str(F2)))
 
96
        self.assertAlmostEqual(eval(str(mpf2)), eval(str(F2))*eval(str(F3)))
 
97
        self.assertAlmostEqual(eval(str(mpf3)), eval(str(F1))*eval(str(mpf1)))
 
98
 
 
99
        self.assertEqual(mpp0.ops(), 2)
 
100
        self.assertEqual(mpp1.ops(), 4)
 
101
        self.assertEqual(mpp2.ops(), 0)
 
102
        self.assertEqual(mpp3.ops(), 6)
 
103
 
 
104
        self.assertEqual(mps0.ops(), 2)
 
105
        self.assertEqual(mps1.ops(), 3)
 
106
        self.assertEqual(mps2.ops(), 4)
 
107
        self.assertEqual(mps3.ops(), 5)
 
108
 
 
109
        self.assertEqual(mpf0.ops(), 2)
 
110
        self.assertEqual(mpf1.ops(), 3)
 
111
        self.assertEqual(mpf2.ops(), 3)
 
112
        self.assertEqual(mpf3.ops(), 5)
 
113
 
 
114
        self.assertEqual(str(mpp0), 'x*x*y')
 
115
        self.assertEqual(str(mpp1), '%s*x*x*y*y' % f_3)
 
116
        self.assertEqual(str(mpp2), '%s' % f_0)
 
117
        self.assertEqual(str(mpp3), '%s*x*x*x*y*y*y' % format["float"](9))
 
118
        self.assertEqual(str(mps0), 'x*(x + y)')
 
119
        self.assertEqual(str(mps1), '(x + x)*(x + y)')
 
120
#        self.assertEqual(str(mps2), '(x-2)*(x + x-2)')
 
121
        self.assertEqual(str(mps2), '(x + x-%s)*(x-%s)' % (f_2, f_2))
 
122
        self.assertEqual(str(mps3), '(x + x)*(x + x)*(x + y)')
 
123
        self.assertEqual(str(mpf0), 'x*x/y')
 
124
        self.assertEqual(str(mpf1), 'x/%s*x/y' % f_3)
 
125
        self.assertEqual(str(mpf2), '-%s/y*x/%s' % (f_2, f_3))
 
126
        self.assertEqual(str(mpf3), 'x/%s*x/y*x/y' % f_3)
 
127
 
 
128
 
 
129
        # Mixed sums
 
130
        msp0 = Sum([p0, s0])
 
131
        msp1 = Sum([p1, p0])
 
132
        msp2 = Sum([p2, p3])
 
133
        msp3 = Sum([p1, msp1])
 
134
        msp4 = Sum([f2, f2])
 
135
 
 
136
        mss0 = Sum([S0, s0])
 
137
        mss1 = Sum([S1, S0])
 
138
        mss2 = Sum([S2, S3])
 
139
        mss3 = Sum([S1, mps1])
 
140
 
 
141
        msf0 = Sum([F1, s0])
 
142
        msf1 = Sum([F1, F2])
 
143
        msf2 = Sum([F2, F3])
 
144
        msf3 = Sum([F1, msf1])
 
145
 
 
146
#        print "\nTesting Mixed Sums"
 
147
#        print "\nmsp0: %s + %s = '%s'" % (p0, s0, msp0)
 
148
#        print "msp1: %s + %s = '%s'" % (p1, p0, msp1)
 
149
#        print "msp2: %s + %s = '%s'" % (p2, p3, msp2)
 
150
#        print "msp3: %s + %s = '%s'" % (p1, msp1, msp3)
 
151
#        print "msp4: %s + %s = '%s'" % (f2, f2, msp4)
 
152
#        print "\nmss0: %s + %s = '%s'" % (S0, s0, mss0)
 
153
#        print "mss1: %s + %s = '%s'" % (S1, S0, mss1)
 
154
#        print "mss2: %s + %s = '%s'" % (S2, S3, mss2)
 
155
#        print "mss3: %s + %s = '%s'" % (S1, mss1, mss3)
 
156
#        print "\nmsf0: %s + %s = '%s'" % (F1, s0, msf0)
 
157
#        print "msf1: %s + %s = '%s'" % (F1, F2, msf1)
 
158
#        print "msf2: %s + %s = '%s'" % (F2, F3, msf2)
 
159
#        print "msf3: %s + %s = '%s'" % (F1, msf1, msf3)
 
160
#        print "msf3: %s + %s = '%s'" % (F1, msf1, msf3)
 
161
 
 
162
        self.assertAlmostEqual(eval(str(msp0)), eval(str(p0))+eval(str(s0)))
 
163
        self.assertAlmostEqual(eval(str(msp1)), eval(str(p1))+eval(str(p0)))
 
164
        self.assertAlmostEqual(eval(str(msp2)), eval(str(p2))+eval(str(p3)))
 
165
        self.assertAlmostEqual(eval(str(msp3)), eval(str(p1))+eval(str(msp1)))
 
166
        self.assertEqual(str(msp4), '%s' % f_0)
 
167
 
 
168
        self.assertAlmostEqual(eval(str(mss0)), eval(str(S0))+eval(str(s0)))
 
169
        self.assertAlmostEqual(eval(str(mss1)), eval(str(S1))+eval(str(S0)))
 
170
        self.assertAlmostEqual(eval(str(mss2)), eval(str(S2))+eval(str(S3)))
 
171
        self.assertAlmostEqual(eval(str(mss3)), eval(str(S1))+eval(str(mps1)))
 
172
 
 
173
        self.assertAlmostEqual(eval(str(msf0)), eval(str(F1))+eval(str(s0)))
 
174
        self.assertAlmostEqual(eval(str(msf1)), eval(str(F1))+eval(str(F2)))
 
175
        self.assertAlmostEqual(eval(str(msf2)), eval(str(F2))+eval(str(F3)))
 
176
        self.assertAlmostEqual(eval(str(msf3)), eval(str(F1))+eval(str(msf1)))
 
177
 
 
178
        self.assertEqual(msp0.ops(), 2)
 
179
        self.assertEqual(msp1.ops(), 4)
 
180
        self.assertEqual(msp2.ops(), 3)
 
181
        self.assertEqual(msp3.ops(), 7)
 
182
 
 
183
        self.assertEqual(mss0.ops(), 2)
 
184
        self.assertEqual(mss1.ops(), 3)
 
185
        self.assertEqual(mss2.ops(), 3)
 
186
        self.assertEqual(mss3.ops(), 5)
 
187
 
 
188
        self.assertEqual(msf0.ops(), 2)
 
189
        self.assertEqual(msf1.ops(), 3)
 
190
        self.assertEqual(msf2.ops(), 3)
 
191
        self.assertEqual(msf3.ops(), 5)
 
192
 
 
193
        self.assertEqual(str(msp0), '(x + x*y)')
 
194
        self.assertEqual(str(msp1), '(%s*x*y + x*y)' % f_3)
 
195
        self.assertEqual(str(msp2), '-%s*x*y*z' % f_6)
 
196
        self.assertEqual(str(msp3), '(%s*x*y + %s*x*y + x*y)' % (f_3, f_3))
 
197
        self.assertEqual(str(mss0), '(x + x + y)')
 
198
        self.assertEqual(str(mss1), '(x + x + x + y)')
 
199
        self.assertEqual(str(mss2), '(x + x + x-%s)' % f_4)
 
200
        self.assertEqual(str(mss3), '(x + x + (x + x)*(x + y))')
 
201
        self.assertEqual(str(msf0), '(x + x/y)')
 
202
        self.assertEqual(str(msf1), '(x/%s + x/y)' % f_3)
 
203
        self.assertEqual(str(msf2), '(x/%s-%s/y)' % (f_3, f_2))
 
204
        self.assertEqual(str(msf3), '(x/%s + x/y + x/y)' % f_3)
 
205
 
 
206
 
 
207
        # Mixed fractions
 
208
        mfp0 = Fraction(p0, s0)
 
209
        mfp1 = Fraction(p1, p0)
 
210
        mfp2 = Fraction(p2, p3)
 
211
        mfp3 = Fraction(p1, mfp1)
 
212
 
 
213
        mfs0 = Fraction(S0, s0)
 
214
        mfs1 = Fraction(S1, S0)
 
215
        mfs2 = Fraction(S2, S3)
 
216
        mfs3 = Fraction(S1, mfs1)
 
217
 
 
218
        mff0 = Fraction(F1, s0)
 
219
        mff1 = Fraction(F1, F2)
 
220
        mff2 = Fraction(F2, F3)
 
221
        mff3 = Fraction(F1, mff1)
 
222
 
 
223
#        print "\nTesting Mixed Fractions"
 
224
#        print "\nmfp0: %s / %s = '%s'" % (p0, s0, mfp0)
 
225
#        print "mfp1: %s / %s = '%s'" % (p1, p0, mfp1)
 
226
#        print "mfp2: %s / %s = '%s'" % (p2, p3, mfp2)
 
227
#        print "mfp3: %s / %s = '%s'" % (p1, mfp1, mfp3)
 
228
#        print "\nmfs0: %s / %s = '%s'" % (S0, s0, mfs0)
 
229
#        print "mfs1: %s / %s = '%s'" % (S1, S0, mfs1)
 
230
#        print "mfs2: %s / %s = '%s'" % (S2, S3, mfs2)
 
231
#        print "mfs3: %s / %s = '%s'" % (S1, mfs1, mfs3)
 
232
#        print "\nmff0: %s / %s = '%s'" % (F1, s0, mff0)
 
233
#        print "mff1: %s / %s = '%s'" % (F1, F2, mff1)
 
234
#        print "mff2: %s / %s = '%s'" % (F2, F3, mff2)
 
235
#        print "mff3: %s / %s = '%s'" % (F1, mff1, mff3)
 
236
 
 
237
        self.assertAlmostEqual(eval(str(mfp0)), eval(str(p0))/eval(str(s0)))
 
238
        self.assertAlmostEqual(eval(str(mfp1)), eval(str(p1))/eval(str(p0)))
 
239
        self.assertAlmostEqual(eval(str(mfp2)), eval(str(p2))/eval(str(p3)))
 
240
        self.assertAlmostEqual(eval(str(mfp3)), eval(str(p1))/eval(str(mfp1)))
 
241
 
 
242
        self.assertAlmostEqual(eval(str(mfs0)), eval(str(S0))/eval(str(s0)))
 
243
        self.assertAlmostEqual(eval(str(mfs1)), eval(str(S1))/eval(str(S0)))
 
244
        self.assertAlmostEqual(eval(str(mfs2)), eval(str(S2))/eval(str(S3)))
 
245
        self.assertAlmostEqual(eval(str(mfs3)), eval(str(S1))/eval(str(mfs1)))
 
246
 
 
247
        self.assertAlmostEqual(eval(str(mff0)), eval(str(F1))/eval(str(s0)))
 
248
        self.assertAlmostEqual(eval(str(mff1)), eval(str(F1))/eval(str(F2)))
 
249
        self.assertAlmostEqual(eval(str(mff2)), eval(str(F2))/eval(str(F3)))
 
250
        self.assertAlmostEqual(eval(str(mff3)), eval(str(F1))/eval(str(mff1)))
 
251
 
 
252
        self.assertEqual(mfp0.ops(), 2)
 
253
        self.assertEqual(mfp1.ops(), 4)
 
254
        self.assertEqual(mfp2.ops(), 0)
 
255
        self.assertEqual(mfp3.ops(), 7)
 
256
 
 
257
        self.assertEqual(mfs0.ops(), 2)
 
258
        self.assertEqual(mfs1.ops(), 3)
 
259
        self.assertEqual(mfs2.ops(), 4)
 
260
        self.assertEqual(mfs3.ops(), 5)
 
261
 
 
262
        self.assertEqual(mff0.ops(), 2)
 
263
        self.assertEqual(mff1.ops(), 3)
 
264
        self.assertEqual(mff2.ops(), 3)
 
265
        self.assertEqual(mff3.ops(), 5)
 
266
 
 
267
        self.assertEqual(str(mfp0), 'x*y/x')
 
268
        self.assertEqual(str(mfp1), '%s*x*y/(x*y)' % f_3)
 
269
        self.assertEqual(str(mfp2), '%s' % f_0)
 
270
        self.assertEqual(str(mfp3), '%s*x*y/(%s*x*y/(x*y))' % (f_3, f_3))
 
271
        self.assertEqual(str(mfs0), '(x + y)/x')
 
272
        self.assertEqual(str(mfs1), '(x + x)/(x + y)')
 
273
        self.assertEqual(str(mfs2), '(x-%s)/(x + x-%s)' % (f_2, f_2))
 
274
        self.assertEqual(str(mfs3), '(x + x)/((x + x)/(x + y))')
 
275
        self.assertEqual(str(mff0), '(x/y)/x')
 
276
        self.assertEqual(str(mff1), '(x/y)/(x/%s)' % f_3)
 
277
        self.assertEqual(str(mff2), '(x/%s)/(-%s/y)' % (f_3, f_2))
 
278
        self.assertEqual(str(mff3), '(x/y)/((x/y)/(x/%s))' % f_3)
 
279
 
 
280
        # Use p1 as a base expression for Symbol
 
281
        s3 = Symbol(get_format()["cos"](p1), CONST, p1, 1)
 
282
        self.assertEqual(str(s3), 'std::cos(%s*x*y)' % f_3)
 
283
        self.assertEqual(s3.ops(), 3)
 
284
 
 
285
if __name__ == "__main__":
 
286
 
 
287
    # Run all returned tests
 
288
    runner = unittest.TextTestRunner()
 
289
    runner.run(TestMixedSymbols('testMixedSymbols'))
 
290