d503dddbfbe0e0481cac9b995e855aced7b15e24
[Faustine.git] / interpretor / faust-0.9.47mr3 / compiler / documentator / doc_Text.cpp
1 /************************************************************************
2 ************************************************************************
3 FAUST compiler
4 Copyright (C) 2003-2004 GRAME, Centre National de Creation Musicale
5 ---------------------------------------------------------------------
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 ************************************************************************
20 ************************************************************************/
21
22
23
24 #include <stdio.h>
25 #include <string.h>
26 #include "doc_Text.hh"
27 #include "compatibility.hh"
28 #include <string>
29 #include <vector>
30 #include <iostream>
31 #include <sstream>
32 #include <assert.h>
33 #include <cmath>
34 #include <stdlib.h>
35
36 #include "floats.hh"
37
38 #ifndef M_PI
39 #define M_PI 3.14159265358979323846
40 #endif
41
42 #ifndef M_PI_2
43 #define M_PI_2 1.57079632679489661923
44 #endif
45
46 #ifndef M_PI_4
47 #define M_PI_4 0.785398163397448309616
48 #endif
49
50 #ifndef M_E
51 #define M_E 2.71828182845904523536
52 #endif
53
54 extern bool gInternDoubleSwitch;
55 const string symbolicNumber (double n);
56
57
58
59 #if 0
60 /**
61 * Suppress trailing zero in a string representating a floating point number.
62 * example : 1.00000 -> 1.0
63 * example : 1.00000f -> 1.0f
64 */
65
66 static void zdel(char* c)
67 {
68 int l = strlen(c) - 1;
69 bool f = (c[l] == 'f');
70
71 if (f) c[l--] = 0; // remove trailing if any f
72 while ( l>1 && c[l-1] != '.' && c[l] == '0') c[l--] = 0;
73 if (f) c[++l] = 'f'; // restaure trailing f if needed
74 }
75 #endif
76
77 string docT (char* c) { return string(c); }
78 string docT (int n) { char c[64]; snprintf(c, 63, "%d",n); return string(c); }
79 string docT (long n) { char c[64]; snprintf(c, 63, "%ld",n); return string(c); }
80 string docT (double n) { return symbolicNumber(n); }
81
82
83 //
84 //*****************************SYMBOLIC NUMBER REPRESENTATION*******************
85 //
86
87 /**
88 * Compute the smallest float representable
89 * difference epsilon such that 1 != 1+epsilon
90 */
91 float fltEpsilon()
92 {
93 float machEps = 1.0f;
94 do {
95 machEps /= 2.0f;
96 } while ((float)(1.0 + (machEps/2.0)) != 1.0);
97 return machEps;
98 }
99
100
101 /**
102 * Compute the smallest double representable
103 * difference epsilon such that 1 != 1+epsilon
104 */
105 double dblEpsilon()
106 {
107 double machEps = 1.0f;
108 do {
109 machEps /= 2.0f;
110 } while ((1.0 + (machEps/2.0)) != 1.0);
111 return machEps;
112 }
113
114
115 /**
116 * Check if two floating point numbers are (almost) equal
117 * Abs(x-y) < epsilon
118 */
119 static bool AlmostEqual(double A, double B)
120 {
121 double maxRelativeError = 2*dblEpsilon();
122 double maxAbsoluteError = maxRelativeError;
123
124
125 if (fabs(A - B) < maxAbsoluteError)
126 return true;
127 double relativeError;
128 if (fabs(B) > fabs(A))
129 relativeError = fabs((A - B) / B);
130 else
131 relativeError = fabs((A - B) / A);
132 if (relativeError <= maxRelativeError)
133 return true;
134 return false;
135 }
136
137
138 /**
139 * Return true if n>0 is equal to PI^k for some small integer k.
140 * k = log(n)/log(pi) is integer => n = exp(int(k)*log(pi))
141 * The latex representation \pi^{k} is returned in string s
142 */
143 bool isPiPower (double n, string& s)
144 {
145 assert(n>0);
146 stringstream ss (stringstream::out|stringstream::in);
147 int k = floor(log(n)/log(M_PI));
148 if ( AlmostEqual(n, exp(k * log(M_PI))) && (k!=0) && (abs(k)<5.0) ) {
149 ss << "\\pi";
150 if (k!=1) ss << "^{"<< k <<"}";
151 s = ss.str();
152 return true;
153 } else {
154 return false;
155 }
156 }
157
158
159 /**
160 * Return true if n>0 is equal to e^k for some small integer k.
161 * The latex representation e^{k} is returned in string s
162 */
163 bool isExpPower (double n, string& s)
164 {
165 assert(n>0);
166 stringstream ss (stringstream::out|stringstream::in);
167 int k = floor(log(n));
168 if ( AlmostEqual(n, exp(k)) && (k!=0) && (abs(k)<5.0) ) {
169 ss << "e";
170 if (k!=1) ss << "^{"<< k <<"}";
171 s = ss.str();
172 return true;
173 } else {
174 return false;
175 }
176 }
177
178
179 /**
180 * Return true if n>0 is equal to e^k or PI^k for some integer k
181 * The symbolic latex representation is returned in string s
182 */
183 bool isSymbolicPower (double n, string& s)
184 {
185 assert(n>0);
186 if (isPiPower(n,s)) {
187 return true;
188 } else if (isExpPower(n,s)) {
189 return true;
190 } else {
191 return false;
192 }
193 }
194
195
196 /**
197 * Return exp or num.exp, or exp/denom, or num/denom.exp
198 */
199 const string addFraction (int num, int denom, const string& exp)
200 {
201 stringstream ss (stringstream::out|stringstream::in);
202
203 if ((num==1) & (denom==1)) {
204 ss << exp;
205 } else if ((num==1) & (denom!=1)) {
206 ss << "\\frac{"<< exp << "}{" << denom << "}";
207 } else if ((num!=1) & (denom==1)) {
208 ss << num << "*" << exp;
209 } else {
210 ss << "\\frac{"<< num << "}{" << denom << "}*" << exp;
211 }
212 return ss.str();
213 }
214
215
216 /**
217 * Return symbolic or numerical representation of n>0
218 */
219 const string positiveSymbolicNumber (double n)
220 {
221 string s;
222 assert(n>0);
223
224 // Try to find a symbolic representation
225
226 for (int i=1;i<10;i++) {
227 for(int j=1;j<10;j++) {
228 if (isSymbolicPower(i*n/j,s)) {
229 return addFraction(j,i,s);
230 }
231 }
232 }
233
234 // No symbolic representation,
235 // Then numerical representation x.10^k
236
237 char tmp[64];
238 string entree = " * 10^{";
239 char sortie = '}';
240 string::size_type ps;
241
242 snprintf(tmp, 63, "%.15g", n); // Warning: over 15 decimals, results are wrong !!
243 s = tmp;
244 ps = s.find('e');
245
246 if (ps != string::npos) {
247 s.replace(ps, 1, "");
248 s.insert(ps, entree);
249 s += sortie;
250 }
251
252 return s;
253
254 }
255
256
257 /**
258 * Return symbolic or numerical representation of n
259 */
260 const string symbolicNumber (double n)
261 {
262 if (n>0.0) {
263 return positiveSymbolicNumber(n);
264 } else if (n<0.0) {
265 return string("-") + positiveSymbolicNumber(-n);
266 } else {
267 return "0";
268 }
269 }