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
|
#include <stdio.h>
#include <assert.h>
#include "tlib.hh"
#include "signals.hh"
#include "sigprint.hh"
#include "ppsig.hh"
#include "simplify.hh"
#include "normalize.hh"
#include "sigorderrules.hh"
#include <map>
#include <list>
#include "mterm.hh"
#include "aterm.hh"
#if 0
static void countAddTerm (map<Tree,Tree>& M, Tree t, bool invflag);
static void incTermCount (map<Tree,int>& M, Tree t, bool invflag);
static Tree buildPowTerm (Tree f, int q);
static Tree simplifyingReorganizingMul(Tree t1, Tree t2);
static Tree reorganizingMul(Tree k, Tree t);
static void factorizeAddTerm(map<Tree,Tree>& M);
#endif
#undef TRACE
/**
* Compute the Add-Normal form of a term t.
* \param t the term to be normalized
* \return the normalized term
*/
Tree normalizeAddTerm(Tree t)
{
#ifdef TRACE
cerr << "START normalizeAddTerm : " << ppsig(t) << endl;
#endif
aterm A(t);
#ifdef TRACE
cerr << "ATERM of " << A << endl;
#endif
mterm D = A.greatestDivisor();
while (D.isNotZero() && D.complexity() > 0) {
#ifdef TRACE
cerr << "*** GREAT DIV : " << D << endl;
#endif
A = A.factorize(D);
D = A.greatestDivisor();
}
Tree r = A.normalizedTree();
#ifdef TRACE
cerr << "ATERM of " << A << " --> " << ppsig(r) << endl;
#endif
return r;
}
/**
* Compute the normal form of a 1-sample delay term s'.
* The normalisation rules are :
* 0' -> 0 /// INACTIVATE dec07 bug recursion
* (k*s)' -> k*s'
* (s/k)' -> s'/k
* \param s the term to be delayed by 1 sample
* \return the normalized term
*/
Tree normalizeDelay1Term(Tree s)
{
return normalizeFixedDelayTerm(s, tree(1));
}
/**
* Compute the normal form of a fixed delay term (s@d).
* The normalisation rules are :
* s@0 -> s
* 0@d -> 0
* (k*s)@d -> k*(s@d)
* (s/k)@d -> (s@d)/k
* (s@n)@m -> s@(n+m)
* Note that the same rules can't be applied to
* + et - becaue the value of the first d samples
* would be wrong. We could also add delays such that
* \param s the term to be delayed
* \param d the value of the delay
* \return the normalized term
*/
Tree normalizeFixedDelayTerm(Tree s, Tree d)
{
Tree x, y, r;
int i;
if (isZero(d) && ! isProj(s, &i, r)) {
return s;
} else if (isZero(s)) {
return s;
} else if (isSigMul(s, x, y)) {
if (getSigOrder(x) < 2) {
return /*simplify*/(sigMul(x,normalizeFixedDelayTerm(y,d)));
} else if (getSigOrder(y) < 2) {
return /*simplify*/(sigMul(y,normalizeFixedDelayTerm(x,d)));
} else {
return sigFixDelay(s,d);
}
} else if (isSigDiv(s, x, y)) {
if (getSigOrder(y) < 2) {
return /*simplify*/(sigDiv(normalizeFixedDelayTerm(x,d),y));
} else {
return sigFixDelay(s,d);
}
} else if (isSigFixDelay(s, x, y)) {
// (x@n)@m = x@(n+m)
// return sigFixDelay(x,tree(tree2int(d)+tree2int(y)));
return normalizeFixedDelayTerm(x,simplify(sigAdd(d,y)));
} else {
return sigFixDelay(s,d);
}
}
|
