]> www.ginac.de Git - ginac.git/blob - ginac/constant.cpp
c056a96a1d18b8664319aadefb36ea905547dbcd
[ginac.git] / ginac / constant.cpp
1 /** @file constant.cpp
2  *
3  *  Implementation of GiNaC's constant types and some special constants. */
4
5 /*
6  *  GiNaC Copyright (C) 1999-2001 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 <string>
24 #include <stdexcept>
25
26 #include "constant.h"
27 #include "numeric.h"
28 #include "ex.h"
29 #include "print.h"
30 #include "archive.h"
31 #include "debugmsg.h"
32 #include "utils.h"
33
34 namespace GiNaC {
35
36 GINAC_IMPLEMENT_REGISTERED_CLASS(constant, basic)
37
38 //////////
39 // default ctor, dtor, copy ctor assignment operator and helpers
40 //////////
41
42 // public
43
44 constant::constant() : basic(TINFO_constant), name(""), ef(0), number(0), serial(next_serial++)
45 {
46         debugmsg("constant default ctor",LOGLEVEL_CONSTRUCT);
47 }
48
49 // protected
50
51 /** For use by copy ctor and assignment operator. */
52 void constant::copy(const constant & other)
53 {
54         inherited::copy(other);
55         name = other.name;
56         serial = other.serial;
57         ef = other.ef;
58         if (other.number != 0)
59                 number = new numeric(*other.number);
60         else
61                 number = 0;
62 }
63
64 void constant::destroy(bool call_parent)
65 {
66         delete number;
67         if (call_parent)
68                 inherited::destroy(call_parent);
69 }
70
71 //////////
72 // other ctors
73 //////////
74
75 // public
76
77 constant::constant(const std::string & initname, evalffunctype efun)
78   : basic(TINFO_constant), name(initname), ef(efun), number(0), serial(next_serial++)
79 {
80         debugmsg("constant ctor from string, function",LOGLEVEL_CONSTRUCT);
81         setflag(status_flags::evaluated);
82 }
83
84 constant::constant(const std::string & initname, const numeric & initnumber)
85   : basic(TINFO_constant), name(initname), ef(0), number(new numeric(initnumber)), serial(next_serial++)
86 {
87         debugmsg("constant ctor from string, numeric",LOGLEVEL_CONSTRUCT);
88         setflag(status_flags::evaluated);
89 }
90
91 //////////
92 // archiving
93 //////////
94
95 constant::constant(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst)
96 {
97         debugmsg("constant ctor from archive_node", LOGLEVEL_CONSTRUCT);
98 }
99
100 ex constant::unarchive(const archive_node &n, const lst &sym_lst)
101 {
102         // Find constant by name (!! this is bad: 'twould be better if there
103         // was a list of all global constants that we could search)
104         std::string s;
105         if (n.find_string("name", s)) {
106                 if (s == Pi.name)
107                         return Pi;
108                 else if (s == Catalan.name)
109                         return Catalan;
110                 else if (s == Euler.name)
111                         return Euler;
112                 else
113                         throw (std::runtime_error("unknown constant '" + s + "' in archive"));
114         } else
115                 throw (std::runtime_error("unnamed constant in archive"));
116 }
117
118 void constant::archive(archive_node &n) const
119 {
120         inherited::archive(n);
121         n.add_string("name", name);
122 }
123
124 //////////
125 // functions overriding virtual functions from bases classes
126 //////////
127
128 // public
129
130 void constant::print(const print_context & c, unsigned level) const
131 {
132         debugmsg("constant print", LOGLEVEL_PRINT);
133
134         if (is_of_type(c, print_tree)) {
135                 c.s << std::string(level, ' ') << name << " (" << class_name() << ")"
136                     << std::hex << ", hash=0x" << hashvalue << ", flags=0x" << flags << std::dec
137                     << std::endl;
138         } else if (is_of_type(c, print_latex)) {
139                 if (name=="Pi")
140                         c.s << "\\pi";
141                 else if (name=="Euler")
142                         c.s << "\\gamma_E";
143                 else if (name=="Catalan")
144                         c.s << "G";
145                 else
146                         c.s << "\\mbox{"+name+"}";
147         } else
148                 c.s << name;
149 }
150
151 int constant::degree(const ex & s) const
152 {
153         return is_equal(*s.bp) ? 1 : 0;
154 }
155
156 int constant::ldegree(const ex & s) const
157 {
158         return is_equal(*s.bp) ? 1 : 0;
159 }
160
161 ex constant::coeff(const ex & s, int n) const
162 {
163         if (is_equal(*s.bp))
164                 return n==1 ? _ex1() : _ex0();
165         else
166                 return n==0 ? *this : _ex0();
167 }
168
169 ex constant::evalf(int level) const
170 {
171         if (ef!=0) {
172                 return ef();
173         } else if (number != 0) {
174                 return number->evalf();
175         }
176         return *this;
177 }
178
179 // protected
180
181 /** Implementation of ex::diff() for a constant. It always returns 0.
182  *
183  *  @see ex::diff */
184 ex constant::derivative(const symbol & s) const
185 {
186         return _ex0();
187 }
188
189 int constant::compare_same_type(const basic & other) const
190 {
191         GINAC_ASSERT(is_exactly_of_type(other, constant));
192         // const constant & o=static_cast<constant &>(const_cast<basic &>(other));
193         // return name.compare(o.name);
194         const constant *o = static_cast<const constant *>(&other);
195         if (serial==o->serial) return 0;
196         return serial < o->serial ? -1 : 1;
197 }
198
199 bool constant::is_equal_same_type(const basic & other) const
200 {
201         GINAC_ASSERT(is_exactly_of_type(other, constant));
202         const constant *o = static_cast<const constant *>(&other);
203         return serial==o->serial;
204 }
205
206 unsigned constant::calchash(void) const
207 {
208         hashvalue = golden_ratio_hash(tinfo() ^ serial);
209         // mask out numeric hashes:
210         hashvalue &= 0x7FFFFFFFU;
211         
212         setflag(status_flags::hash_calculated);
213         
214         return hashvalue;
215 }
216
217 //////////
218 // new virtual functions which can be overridden by derived classes
219 //////////
220
221 // none
222
223 //////////
224 // non-virtual functions in this class
225 //////////
226
227 // none
228
229 //////////
230 // static member variables
231 //////////
232
233 unsigned constant::next_serial = 0;
234
235 //////////
236 // global constants
237 //////////
238
239 /**  Pi. (3.14159...)  Diverts straight into CLN for evalf(). */
240 const constant Pi("Pi", PiEvalf);
241
242 /** Euler's constant. (0.57721...)  Sometimes called Euler-Mascheroni constant.
243  *  Diverts straight into CLN for evalf(). */
244 const constant Euler("Euler", EulerEvalf);
245
246 /** Catalan's constant. (0.91597...)  Diverts straight into CLN for evalf(). */
247 const constant Catalan("Catalan", CatalanEvalf);
248
249 } // namespace GiNaC