- Banned exZERO(), exONE(), exMINUSHALF() and all this from the interface.
[ginac.git] / ginac / operators.cpp
1 /** @file operators.cpp
2  *
3  *  Implementation of GiNaC's overloaded operators. */
4
5 /*
6  *  GiNaC Copyright (C) 1999 Johannes Gutenberg University Mainz, Germany
7  *
8  *  This program is free software; you can redistribute it and/or modify
9  *  it under the terms of the GNU General Public License as published by
10  *  the Free Software Foundation; either version 2 of the License, or
11  *  (at your option) any later version.
12  *
13  *  This program is distributed in the hope that it will be useful,
14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *  GNU General Public License for more details.
17  *
18  *  You should have received a copy of the GNU General Public License
19  *  along with this program; if not, write to the Free Software
20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  */
22
23 #include <iostream>
24 #include <stdexcept>
25
26 #include "operators.h"
27 #include "basic.h"
28 #include "ex.h"
29 #include "numeric.h"
30 #include "power.h"
31 #include "relational.h"
32 #include "debugmsg.h"
33 #include "utils.h"
34
35 #ifndef NO_GINAC_NAMESPACE
36 namespace GiNaC {
37 #endif // ndef NO_GINAC_NAMESPACE
38
39 // binary arithmetic operators ex with ex
40
41 ex operator+(ex const & lh, ex const & rh)
42 {
43     debugmsg("operator+(ex,ex)",LOGLEVEL_OPERATOR);
44     return lh.exadd(rh);
45 }
46
47 ex operator-(ex const & lh, ex const & rh)
48 {
49     debugmsg("operator-(ex,ex)",LOGLEVEL_OPERATOR);
50     return lh.exadd(rh.exmul(_ex_1()));
51 }
52
53 ex operator*(ex const & lh, ex const & rh)
54 {
55     debugmsg("operator*(ex,ex)",LOGLEVEL_OPERATOR);
56     return lh.exmul(rh);
57 }
58
59 ex operator/(ex const & lh, ex const & rh)
60 {
61     debugmsg("operator*(ex,ex)",LOGLEVEL_OPERATOR);
62     return lh.exmul(power(rh,_ex_1()));
63 }
64
65 ex operator%(ex const & lh, ex const & rh)
66 {
67     debugmsg("operator%(ex,ex)",LOGLEVEL_OPERATOR);
68     return lh.exncmul(rh);
69 }
70
71
72 // binary arithmetic operators numeric with numeric
73
74 numeric operator+(numeric const & lh, numeric const & rh)
75 {
76     debugmsg("operator+(numeric,numeric)",LOGLEVEL_OPERATOR);
77     return lh.add(rh);
78 }
79
80 numeric operator-(numeric const & lh, numeric const & rh)
81 {
82     debugmsg("operator-(numeric,numeric)",LOGLEVEL_OPERATOR);
83     return lh.sub(rh);
84 }
85
86 numeric operator*(numeric const & lh, numeric const & rh)
87 {
88     debugmsg("operator*(numeric,numeric)",LOGLEVEL_OPERATOR);
89     return lh.mul(rh);
90 }
91
92 numeric operator/(numeric const & lh, numeric const & rh)
93 {
94     debugmsg("operator/(numeric,ex)",LOGLEVEL_OPERATOR);
95     return lh.div(rh);
96 }
97
98
99 // binary arithmetic assignment operators with ex
100
101 ex const & operator+=(ex & lh, ex const & rh)
102 {
103     debugmsg("operator+=(ex,ex)",LOGLEVEL_OPERATOR);
104     return (lh=lh+rh);
105 }
106
107 ex const & operator-=(ex & lh, ex const & rh)
108 {
109     debugmsg("operator-=(ex,ex)",LOGLEVEL_OPERATOR);
110     return (lh=lh-rh);
111 }
112
113 ex const & operator*=(ex & lh, ex const & rh)
114 {
115     debugmsg("operator*=(ex,ex)",LOGLEVEL_OPERATOR);
116     return (lh=lh*rh);
117 }
118
119 ex const & operator/=(ex & lh, ex const & rh)
120 {
121     debugmsg("operator/=(ex,ex)",LOGLEVEL_OPERATOR);
122     return (lh=lh/rh);
123 }
124
125 ex const & operator%=(ex & lh, ex const & rh)
126 {
127     debugmsg("operator%=(ex,ex)",LOGLEVEL_OPERATOR);
128     return (lh=lh%rh);
129 }
130
131
132 // binary arithmetic assignment operators with numeric
133
134 numeric const & operator+=(numeric & lh, numeric const & rh)
135 {
136     debugmsg("operator+=(numeric,numeric)",LOGLEVEL_OPERATOR);
137     return (lh=lh.add(rh));
138 }
139
140 numeric const & operator-=(numeric & lh, numeric const & rh)
141 {
142     debugmsg("operator-=(numeric,numeric)",LOGLEVEL_OPERATOR);
143     return (lh=lh.sub(rh));
144 }
145
146 numeric const & operator*=(numeric & lh, numeric const & rh)
147 {
148     debugmsg("operator*=(numeric,numeric)",LOGLEVEL_OPERATOR);
149     return (lh=lh.mul(rh));
150 }
151
152 numeric const & operator/=(numeric & lh, numeric const & rh)
153 {
154     debugmsg("operator/=(numeric,numeric)",LOGLEVEL_OPERATOR);
155     return (lh=lh.div(rh));
156 }
157
158 // unary operators
159
160 ex operator+(ex const & lh)
161 {
162     return lh;
163 }
164
165 ex operator-(ex const & lh)
166 {
167     return lh.exmul(_ex_1());
168 }
169
170 numeric operator+(numeric const & lh)
171 {
172     return lh;
173 }
174
175 numeric operator-(numeric const & lh)
176 {
177     return _num_1()*lh;
178 }
179
180 /** Numeric prefix increment.  Adds 1 and returns incremented number. */
181 numeric& operator++(numeric & rh)
182 {
183     rh = rh+_num1();
184     return rh;
185 }
186
187 /** Numeric prefix decrement.  Subtracts 1 and returns decremented number. */
188 numeric& operator--(numeric & rh)
189 {
190     rh = rh-_num1();
191     return rh;
192 }
193
194 /** Numeric postfix increment.  Returns the number and leaves the original
195  *  incremented by 1. */
196 numeric operator++(numeric & lh, int)
197 {
198     numeric tmp = lh;
199     lh = lh+_num1();
200     return tmp;
201 }
202
203 /** Numeric Postfix decrement.  Returns the number and leaves the original
204  *  decremented by 1. */
205 numeric operator--(numeric & lh, int)
206 {
207     numeric tmp = lh;
208     lh = lh-_num1();
209     return tmp;
210 }
211
212 // binary relational operators ex with ex
213
214 relational operator==(ex const & lh, ex const & rh)
215 {
216     debugmsg("operator==(ex,ex)",LOGLEVEL_OPERATOR);
217     return relational(lh,rh,relational::equal);
218 }
219
220 relational operator!=(ex const & lh, ex const & rh)
221 {
222     debugmsg("operator!=(ex,ex)",LOGLEVEL_OPERATOR);
223     return relational(lh,rh,relational::not_equal);
224 }
225
226 relational operator<(ex const & lh, ex const & rh)
227 {
228     debugmsg("operator<(ex,ex)",LOGLEVEL_OPERATOR);
229     return relational(lh,rh,relational::less);
230 }
231
232 relational operator<=(ex const & lh, ex const & rh)
233 {
234     debugmsg("operator<=(ex,ex)",LOGLEVEL_OPERATOR);
235     return relational(lh,rh,relational::less_or_equal);
236 }
237
238 relational operator>(ex const & lh, ex const & rh)
239 {
240     debugmsg("operator>(ex,ex)",LOGLEVEL_OPERATOR);
241     return relational(lh,rh,relational::greater);
242 }
243
244 relational operator>=(ex const & lh, ex const & rh)
245 {
246     debugmsg("operator>=(ex,ex)",LOGLEVEL_OPERATOR);
247     return relational(lh,rh,relational::greater_or_equal);
248 }
249
250 /*
251
252 // binary relational operators ex with numeric
253
254 relational operator==(ex const & lh, numeric const & rh)
255 {
256     debugmsg("operator==(ex,numeric)",LOGLEVEL_OPERATOR);
257     return relational(lh,rh,relational::equal);
258 }
259
260 relational operator!=(ex const & lh, numeric const & rh)
261 {
262     debugmsg("operator!=(ex,numeric)",LOGLEVEL_OPERATOR);
263     return relational(lh,rh,relational::not_equal);
264 }
265
266 relational operator<(ex const & lh, numeric const & rh)
267 {
268     debugmsg("operator<(ex,numeric)",LOGLEVEL_OPERATOR);
269     return relational(lh,rh,relational::less);
270 }
271
272 relational operator<=(ex const & lh, numeric const & rh)
273 {
274     debugmsg("operator<=(ex,numeric)",LOGLEVEL_OPERATOR);
275     return relational(lh,rh,relational::less_or_equal);
276 }
277
278 relational operator>(ex const & lh, numeric const & rh)
279 {
280     debugmsg("operator>(ex,numeric)",LOGLEVEL_OPERATOR);
281     return relational(lh,rh,relational::greater);
282 }
283
284 relational operator>=(ex const & lh, numeric const & rh)
285 {
286     debugmsg("operator>=(ex,numeric)",LOGLEVEL_OPERATOR);
287     return relational(lh,rh,relational::greater_or_equal);
288 }
289
290 // binary relational operators numeric with ex
291
292 relational operator==(numeric const & lh, ex const & rh)
293 {
294     debugmsg("operator==(numeric,ex)",LOGLEVEL_OPERATOR);
295     return relational(lh,rh,relational::equal);
296 }
297
298 relational operator!=(numeric const & lh, ex const & rh)
299 {
300     debugmsg("operator!=(numeric,ex)",LOGLEVEL_OPERATOR);
301     return relational(lh,rh,relational::not_equal);
302 }
303
304 relational operator<(numeric const & lh, ex const & rh)
305 {
306     debugmsg("operator<(numeric,ex)",LOGLEVEL_OPERATOR);
307     return relational(lh,rh,relational::less);
308 }
309
310 relational operator<=(numeric const & lh, ex const & rh)
311 {
312     debugmsg("operator<=(numeric,ex)",LOGLEVEL_OPERATOR);
313     return relational(lh,rh,relational::less_or_equal);
314 }
315
316 relational operator>(numeric const & lh, ex const & rh)
317 {
318     debugmsg("operator>(numeric,ex)",LOGLEVEL_OPERATOR);
319     return relational(lh,rh,relational::greater);
320 }
321
322 relational operator>=(numeric const & lh, ex const & rh)
323 {
324     debugmsg("operator>=(numeric,ex)",LOGLEVEL_OPERATOR);
325     return relational(lh,rh,relational::greater_or_equal);
326 }
327
328 */
329
330 // input/output stream operators
331
332 ostream & operator<<(ostream & os, ex const & e)
333 {
334     e.print(os);
335     return os;
336 }
337
338 istream & operator>>(istream & is, ex & e)
339 {
340     throw(std::logic_error("input from streams not yet implemented"));
341 }
342
343 #ifndef NO_GINAC_NAMESPACE
344 } // namespace GiNaC
345 #endif // ndef NO_GINAC_NAMESPACE