"Fossies" - the Fresh Open Source Software Archive

Member "gtybalt-1.3.6/ginac_headers.in/numeric.h" (26 Oct 2020, 11050 Bytes) of package /linux/privat/gtybalt-1.3.6.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "numeric.h" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 1.3.5_vs_1.3.6.

    1 /** @file numeric.h
    2  *
    3  *  Makes the interface to the underlying bignum package available. */
    4 
    5 /*
    6  *  GiNaC Copyright (C) 1999-2020 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
   21  */
   22 
   23 #ifndef GINAC_NUMERIC_H
   24 #define GINAC_NUMERIC_H
   25 
   26 #include "basic.h"
   27 #include "ex.h"
   28 #include "archive.h"
   29 
   30 #include <cln/complex.h>
   31 #include <stdexcept>
   32 #include <vector>
   33 
   34 namespace GiNaC {
   35 
   36 /** Function pointer to implement callbacks in the case 'Digits' gets changed.
   37  *  Main purpose of such callbacks is to adjust look-up tables of certain
   38  *  functions to the new precision. Parameter contains the signed difference
   39  *  between new Digits and old Digits. */
   40 typedef void (* digits_changed_callback)(long);
   41 
   42 /** This class is used to instantiate a global singleton object Digits
   43  *  which behaves just like Maple's Digits.  We need an object rather 
   44  *  than a dumber basic type since as a side-effect we let it change
   45  *  cl_default_float_format when it gets changed.  The only other
   46  *  meaningful thing to do with it is converting it to an unsigned,
   47  *  for temporarily storing its value e.g.  The user must not create an
   48  *  own working object of this class!  Since C++ forces us to make the
   49  *  class definition visible in order to use an object we put in a
   50  *  flag which prevents other objects of that class to be created. */
   51 class _numeric_digits
   52 {
   53 // member functions
   54 public:
   55     _numeric_digits();
   56     _numeric_digits& operator=(long prec);
   57     operator long();
   58     void print(std::ostream& os) const;
   59     void add_callback(digits_changed_callback callback);
   60 // member variables
   61 private:
   62     long digits;                        ///< Number of decimal digits
   63     static bool too_late;               ///< Already one object present
   64     // Holds a list of functions that get called when digits is changed.
   65     std::vector<digits_changed_callback> callbacklist;
   66 };
   67 
   68 
   69 /** Exception class thrown when a singularity is encountered. */
   70 class pole_error : public std::domain_error {
   71 public:
   72     explicit pole_error(const std::string& what_arg, int degree);
   73     int degree() const;
   74 private:
   75     int deg;
   76 };
   77 
   78 
   79 /** This class is a wrapper around CLN-numbers within the GiNaC class
   80  *  hierarchy. Objects of this type may directly be created by the user.*/
   81 class numeric : public basic
   82 {
   83     GINAC_DECLARE_REGISTERED_CLASS(numeric, basic)
   84     
   85 // member functions
   86     
   87     // other constructors
   88 public:
   89     numeric(int i);
   90     numeric(unsigned int i);
   91     numeric(long i);
   92     numeric(unsigned long i);
   93     numeric(long long i);
   94     numeric(unsigned long long i);
   95     numeric(long numer, long denom);
   96     numeric(double d);
   97     numeric(const char *);
   98     
   99     // functions overriding virtual functions from base classes
  100 public:
  101     unsigned precedence() const override {return 30;}
  102     bool info(unsigned inf) const override;
  103     bool is_polynomial(const ex & var) const override;
  104     int degree(const ex & s) const override;
  105     int ldegree(const ex & s) const override;
  106     ex coeff(const ex & s, int n = 1) const override;
  107     bool has(const ex &other, unsigned options = 0) const override;
  108     ex eval() const override;
  109     ex evalf() const override;
  110     ex subs(const exmap & m, unsigned options = 0) const override { return subs_one_level(m, options); } // overwrites basic::subs() for performance reasons
  111     ex normal(exmap & repl, exmap & rev_lookup, lst & modifier) const override;
  112     ex to_rational(exmap & repl) const override;
  113     ex to_polynomial(exmap & repl) const override;
  114     numeric integer_content() const override;
  115     ex smod(const numeric &xi) const override;
  116     numeric max_coefficient() const override;
  117     ex conjugate() const override;
  118     ex real_part() const override;
  119     ex imag_part() const override;
  120     /** Save (a.k.a. serialize) object into archive. */
  121     void archive(archive_node& n) const override;
  122     /** Read (a.k.a. deserialize) object from archive. */
  123     void read_archive(const archive_node& n, lst& syms) override;
  124 protected:
  125     /** Implementation of ex::diff for a numeric always returns 0.
  126      *  @see ex::diff */
  127     ex derivative(const symbol &s) const override { return 0; }
  128     bool is_equal_same_type(const basic &other) const override;
  129     unsigned calchash() const override;
  130     
  131     // new virtual functions which can be overridden by derived classes
  132     // (none)
  133     
  134     // non-virtual functions in this class
  135 public:
  136     const numeric add(const numeric &other) const;
  137     const numeric sub(const numeric &other) const;
  138     const numeric mul(const numeric &other) const;
  139     const numeric div(const numeric &other) const;
  140     const numeric power(const numeric &other) const;
  141     const numeric & add_dyn(const numeric &other) const;
  142     const numeric & sub_dyn(const numeric &other) const;
  143     const numeric & mul_dyn(const numeric &other) const;
  144     const numeric & div_dyn(const numeric &other) const;
  145     const numeric & power_dyn(const numeric &other) const;
  146     const numeric & operator=(int i);
  147     const numeric & operator=(unsigned int i);
  148     const numeric & operator=(long i);
  149     const numeric & operator=(unsigned long i);
  150     const numeric & operator=(double d);
  151     const numeric & operator=(const char *s);
  152     const numeric inverse() const;
  153     numeric step() const;
  154     int csgn() const;
  155     int compare(const numeric &other) const;
  156     bool is_equal(const numeric &other) const;
  157     bool is_zero() const;
  158     bool is_positive() const;
  159     bool is_negative() const;
  160     bool is_integer() const;
  161     bool is_pos_integer() const;
  162     bool is_nonneg_integer() const;
  163     bool is_even() const;
  164     bool is_odd() const;
  165     bool is_prime() const;
  166     bool is_rational() const;
  167     bool is_real() const;
  168     bool is_cinteger() const;
  169     bool is_crational() const;
  170     bool operator==(const numeric &other) const;
  171     bool operator!=(const numeric &other) const;
  172     bool operator<(const numeric &other) const;
  173     bool operator<=(const numeric &other) const;
  174     bool operator>(const numeric &other) const;
  175     bool operator>=(const numeric &other) const;
  176     int to_int() const;
  177     long to_long() const;
  178     double to_double() const;
  179     cln::cl_N to_cl_N() const;
  180     const numeric real() const;
  181     const numeric imag() const;
  182     const numeric numer() const;
  183     const numeric denom() const;
  184     int int_length() const;
  185     // converting routines for interfacing with CLN:
  186     explicit numeric(const cln::cl_N &z);
  187 
  188 protected:
  189     void print_numeric(const print_context & c, const char *par_open, const char *par_close, const char *imag_sym, const char *mul_sym, unsigned level) const;
  190     void do_print(const print_context & c, unsigned level) const;
  191     void do_print_latex(const print_latex & c, unsigned level) const;
  192     void do_print_csrc(const print_csrc & c, unsigned level) const;
  193     void do_print_csrc_cl_N(const print_csrc_cl_N & c, unsigned level) const;
  194     void do_print_tree(const print_tree & c, unsigned level) const;
  195     void do_print_python_repr(const print_python_repr & c, unsigned level) const;
  196 
  197 // member variables
  198 
  199 protected:
  200     cln::cl_N value;
  201 };
  202 GINAC_DECLARE_UNARCHIVER(numeric); 
  203 
  204 
  205 // global constants
  206 
  207 extern const numeric I;
  208 extern _numeric_digits Digits;
  209 
  210 // global functions
  211 
  212 const numeric exp(const numeric &x);
  213 const numeric log(const numeric &x);
  214 const numeric sin(const numeric &x);
  215 const numeric cos(const numeric &x);
  216 const numeric tan(const numeric &x);
  217 const numeric asin(const numeric &x);
  218 const numeric acos(const numeric &x);
  219 const numeric atan(const numeric &x);
  220 const numeric atan(const numeric &y, const numeric &x);
  221 const numeric sinh(const numeric &x);
  222 const numeric cosh(const numeric &x);
  223 const numeric tanh(const numeric &x);
  224 const numeric asinh(const numeric &x);
  225 const numeric acosh(const numeric &x);
  226 const numeric atanh(const numeric &x);
  227 const numeric Li2(const numeric &x);
  228 const numeric zeta(const numeric &x);
  229 const numeric lgamma(const numeric &x);
  230 const numeric tgamma(const numeric &x);
  231 const numeric psi(const numeric &x);
  232 const numeric psi(const numeric &n, const numeric &x);
  233 const numeric factorial(const numeric &n);
  234 const numeric doublefactorial(const numeric &n);
  235 const numeric binomial(const numeric &n, const numeric &k);
  236 const numeric bernoulli(const numeric &n);
  237 const numeric fibonacci(const numeric &n);
  238 const numeric isqrt(const numeric &x);
  239 const numeric sqrt(const numeric &x);
  240 const numeric abs(const numeric &x);
  241 const numeric mod(const numeric &a, const numeric &b);
  242 const numeric smod(const numeric &a, const numeric &b);
  243 const numeric irem(const numeric &a, const numeric &b);
  244 const numeric irem(const numeric &a, const numeric &b, numeric &q);
  245 const numeric iquo(const numeric &a, const numeric &b);
  246 const numeric iquo(const numeric &a, const numeric &b, numeric &r);
  247 const numeric gcd(const numeric &a, const numeric &b);
  248 const numeric lcm(const numeric &a, const numeric &b);
  249 
  250 // wrapper functions around member functions
  251 inline const numeric pow(const numeric &x, const numeric &y)
  252 { return x.power(y); }
  253 
  254 inline const numeric inverse(const numeric &x)
  255 { return x.inverse(); }
  256 
  257 inline numeric step(const numeric &x)
  258 { return x.step(); }
  259 
  260 inline int csgn(const numeric &x)
  261 { return x.csgn(); }
  262 
  263 inline bool is_zero(const numeric &x)
  264 { return x.is_zero(); }
  265 
  266 inline bool is_positive(const numeric &x)
  267 { return x.is_positive(); }
  268 
  269 inline bool is_negative(const numeric &x)
  270 { return x.is_negative(); }
  271 
  272 inline bool is_integer(const numeric &x)
  273 { return x.is_integer(); }
  274 
  275 inline bool is_pos_integer(const numeric &x)
  276 { return x.is_pos_integer(); }
  277 
  278 inline bool is_nonneg_integer(const numeric &x)
  279 { return x.is_nonneg_integer(); }
  280 
  281 inline bool is_even(const numeric &x)
  282 { return x.is_even(); }
  283 
  284 inline bool is_odd(const numeric &x)
  285 { return x.is_odd(); }
  286 
  287 inline bool is_prime(const numeric &x)
  288 { return x.is_prime(); }
  289 
  290 inline bool is_rational(const numeric &x)
  291 { return x.is_rational(); }
  292 
  293 inline bool is_real(const numeric &x)
  294 { return x.is_real(); }
  295 
  296 inline bool is_cinteger(const numeric &x)
  297 { return x.is_cinteger(); }
  298 
  299 inline bool is_crational(const numeric &x)
  300 { return x.is_crational(); }
  301 
  302 inline int to_int(const numeric &x)
  303 { return x.to_int(); }
  304 
  305 inline long to_long(const numeric &x)
  306 { return x.to_long(); }
  307 
  308 inline double to_double(const numeric &x)
  309 { return x.to_double(); }
  310 
  311 inline const numeric real(const numeric &x)
  312 { return x.real(); }
  313 
  314 inline const numeric imag(const numeric &x)
  315 { return x.imag(); }
  316 
  317 inline const numeric numer(const numeric &x)
  318 { return x.numer(); }
  319 
  320 inline const numeric denom(const numeric &x)
  321 { return x.denom(); }
  322 
  323 // numeric evaluation functions for class constant objects:
  324 
  325 ex PiEvalf();
  326 ex EulerEvalf();
  327 ex CatalanEvalf();
  328 
  329 
  330 } // namespace GiNaC
  331 
  332 #endif // ndef GINAC_NUMERIC_H