X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Fnumeric.h;h=30091760507018a5943819d9a1e35253f9c3c32c;hp=88b7d9537c91f63600c1ddb3cd9c154b974456ff;hb=02a1c658c196cdf0090fdd134a9aeb884a671922;hpb=52b8a6451d4d5f32e45e3dbf93c22369fc2f99c2

diff --git a/ginac/numeric.h b/ginac/numeric.h
index 88b7d953..30091760 100644
--- a/ginac/numeric.h
+++ b/ginac/numeric.h
@@ -3,7 +3,7 @@
  *  Makes the interface to the underlying bignum package available. */
 
 /*
- *  GiNaC Copyright (C) 1999 Johannes Gutenberg University Mainz, Germany
+ *  GiNaC Copyright (C) 1999-2000 Johannes Gutenberg University Mainz, Germany
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -24,13 +24,15 @@
 #define __GINAC_NUMERIC_H__
 
 #include <strstream>
-#include <ginac/basic.h>
-#include <ginac/ex.h>
+#include "basic.h"
+#include "ex.h"
 
 class cl_N;     // We want to include cln.h only in numeric.cpp in order to 
                 // avoid namespace pollution and keep compile-time low.
 
+#ifndef NO_NAMESPACE_GINAC
 namespace GiNaC {
+#endif // ndef NO_NAMESPACE_GINAC
 
 #define HASHVALUE_NUMERIC 0x80000001U
 
@@ -61,40 +63,38 @@ private:
  *  hierarchy. Objects of this type may directly be created by the user.*/
 class numeric : public basic
 {
+    GINAC_DECLARE_REGISTERED_CLASS(numeric, basic)
+
 // friends
-    friend numeric exp(numeric const & x);
-    friend numeric log(numeric const & x);
-    friend numeric sin(numeric const & x);
-    friend numeric cos(numeric const & x);
-    friend numeric tan(numeric const & x);
-    friend numeric asin(numeric const & x);
-    friend numeric acos(numeric const & x);
-    friend numeric atan(numeric const & x);
-    friend numeric atan(numeric const & y, numeric const & x);
-    friend numeric sinh(numeric const & x);
-    friend numeric cosh(numeric const & x);
-    friend numeric tanh(numeric const & x);
-    friend numeric asinh(numeric const & x);
-    friend numeric acosh(numeric const & x);
-    friend numeric atanh(numeric const & x);
-    friend numeric bernoulli(numeric const & n);
-    friend numeric abs(numeric const & x);
-    friend numeric mod(numeric const & a, numeric const & b);
-    friend numeric smod(numeric const & a, numeric const & b);
-    friend numeric irem(numeric const & a, numeric const & b);
-    friend numeric irem(numeric const & a, numeric const & b, numeric & q);
-    friend numeric iquo(numeric const & a, numeric const & b);
-    friend numeric iquo(numeric const & a, numeric const & b, numeric & r);
-    friend numeric sqrt(numeric const & x);
-    friend numeric isqrt(numeric const & x);
-    friend numeric gcd(numeric const & a, numeric const & b);
-    friend numeric lcm(numeric const & a, numeric const & b);
-    friend numeric const & numZERO(void);
-    friend numeric const & numONE(void);
-    friend numeric const & numTWO(void);
-    friend numeric const & numTHREE(void);
-    friend numeric const & numMINUSONE(void);
-    friend numeric const & numHALF(void);
+    friend const numeric exp(const numeric & x);
+    friend const numeric log(const numeric & x);
+    friend const numeric sin(const numeric & x);
+    friend const numeric cos(const numeric & x);
+    friend const numeric tan(const numeric & x);
+    friend const numeric asin(const numeric & x);
+    friend const numeric acos(const numeric & x);
+    friend const numeric atan(const numeric & x);
+    friend const numeric atan(const numeric & y, const numeric & x);
+    friend const numeric sinh(const numeric & x);
+    friend const numeric cosh(const numeric & x);
+    friend const numeric tanh(const numeric & x);
+    friend const numeric asinh(const numeric & x);
+    friend const numeric acosh(const numeric & x);
+    friend const numeric atanh(const numeric & x);
+    friend const numeric zeta(const numeric & x);
+    friend const numeric bernoulli(const numeric & n);
+    friend const numeric fibonacci(const numeric & n);
+    friend numeric abs(const numeric & x);
+    friend numeric mod(const numeric & a, const numeric & b);
+    friend numeric smod(const numeric & a, const numeric & b);
+    friend numeric irem(const numeric & a, const numeric & b);
+    friend numeric irem(const numeric & a, const numeric & b, numeric & q);
+    friend numeric iquo(const numeric & a, const numeric & b);
+    friend numeric iquo(const numeric & a, const numeric & b, numeric & r);
+    friend numeric sqrt(const numeric & x);
+    friend numeric isqrt(const numeric & x);
+    friend numeric gcd(const numeric & a, const numeric & b);
+    friend numeric lcm(const numeric & a, const numeric & b);
 
 // member functions
 
@@ -103,10 +103,10 @@ class numeric : public basic
 public:
     numeric();
     ~numeric();
-    numeric(numeric const & other);
-    numeric const & operator=(numeric const & other);
+    numeric(const numeric & other);
+    const numeric & operator=(const numeric & other);
 protected:
-    void copy(numeric const & other);
+    void copy(const numeric & other);
     void destroy(bool call_parent);
 
     // other constructors
@@ -117,63 +117,55 @@ public:
     explicit numeric(unsigned long i);
     explicit numeric(long numer, long denom);
     explicit numeric(double d);
-    explicit numeric(char const *);
-    numeric(cl_N const & z);
-
+    explicit numeric(const char *);
+    numeric(const cl_N & z);
+    
     // functions overriding virtual functions from bases classes
 public:
     basic * duplicate() const;
+    void print(ostream & os, unsigned precedence=0) const;
     void printraw(ostream & os) const;
     void printtree(ostream & os, unsigned indent) const;
-    void print(ostream & os, unsigned precedence=0) const;
     void printcsrc(ostream & os, unsigned type, unsigned precedence=0) const;
     bool info(unsigned inf) const;
+    bool has(const ex & other) const;
+    ex eval(int level=0) const;
     ex evalf(int level=0) const;
-    ex diff(symbol const & s) const;
     ex normal(lst &sym_lst, lst &repl_lst, int level=0) const;
     numeric integer_content(void) const;
-    ex smod(numeric const &xi) const;
+    ex smod(const numeric &xi) const;
     numeric max_coefficient(void) const;
 protected:
-    int compare_same_type(basic const & other) const;
-    bool is_equal_same_type(basic const & other) const;
-    unsigned calchash(void) const {
-        hashvalue=HASHVALUE_NUMERIC;
-        return HASHVALUE_NUMERIC;
-    }
+    ex derivative(const symbol & s) const;
+    int compare_same_type(const basic & other) const;
+    bool is_equal_same_type(const basic & other) const;
+    unsigned calchash(void) const;
 
     // new virtual functions which can be overridden by derived classes
     // (none)
 
     // non-virtual functions in this class
 public:
-    numeric add(numeric const & other) const;
-    numeric sub(numeric const & other) const;
-    numeric mul(numeric const & other) const;
-    numeric div(numeric const & other) const;
-    numeric power(numeric const & other) const;
-    numeric const & add_dyn(numeric const & other) const;
-    numeric const & sub_dyn(numeric const & other) const;
-    numeric const & mul_dyn(numeric const & other) const;
-    numeric const & div_dyn(numeric const & other) const;
-    numeric const & power_dyn(numeric const & other) const;
-    numeric const & operator=(int i);
-    numeric const & operator=(unsigned int i);
-    numeric const & operator=(long i);
-    numeric const & operator=(unsigned long i);
-    numeric const & operator=(double d);
-    numeric const & operator=(char const * s);
-    /*
-    numeric add_dyn(numeric const & other) const   { return add(other);   }
-    numeric sub_dyn(numeric const & other) const   { return sub(other);   }
-    numeric mul_dyn(numeric const & other) const   { return mul(other);   }
-    numeric div_dyn(numeric const & other) const   { return div(other);   }
-    numeric power_dyn(numeric const & other) const { return power(other); }
-    */
+    numeric add(const numeric & other) const;
+    numeric sub(const numeric & other) const;
+    numeric mul(const numeric & other) const;
+    numeric div(const numeric & other) const;
+    numeric power(const numeric & other) const;
+    const numeric & add_dyn(const numeric & other) const;
+    const numeric & sub_dyn(const numeric & other) const;
+    const numeric & mul_dyn(const numeric & other) const;
+    const numeric & div_dyn(const numeric & other) const;
+    const numeric & power_dyn(const numeric & other) const;
+    const numeric & operator=(int i);
+    const numeric & operator=(unsigned int i);
+    const numeric & operator=(long i);
+    const numeric & operator=(unsigned long i);
+    const numeric & operator=(double d);
+    const numeric & operator=(const char * s);
     numeric inverse(void) const;
     int csgn(void) const;
-    int compare(numeric const & other) const;
-    bool is_equal(numeric const & other) const;
+    int compare(const numeric & other) const;
+    bool is_equal(const numeric & other) const;
     bool is_zero(void) const;
     bool is_positive(void) const;
     bool is_negative(void) const;
@@ -185,13 +177,16 @@ public:
     bool is_prime(void) const;
     bool is_rational(void) const;
     bool is_real(void) const;
-    bool operator==(numeric const & other) const;
-    bool operator!=(numeric const & other) const;
-    bool operator<(numeric const & other) const;
-    bool operator<=(numeric const & other) const;
-    bool operator>(numeric const & other) const;
-    bool operator>=(numeric const & other) const;
+    bool is_cinteger(void) const;
+    bool is_crational(void) const;
+    bool operator==(const numeric & other) const;
+    bool operator!=(const numeric & other) const;
+    bool operator<(const numeric & other) const;
+    bool operator<=(const numeric & other) const;
+    bool operator>(const numeric & other) const;
+    bool operator>=(const numeric & other) const;
     int to_int(void) const;
+    long to_long(void) const;
     double to_double(void) const;
     numeric real(void) const;
     numeric imag(void) const;
@@ -210,55 +205,54 @@ protected:
 
 extern const numeric some_numeric;
 extern const numeric I;
-extern type_info const & typeid_numeric;
+extern const type_info & typeid_numeric;
 extern _numeric_digits Digits;
 
-#define is_a_numeric_hash(x) ((x)==HASHVALUE_NUMERIC)
+//#define is_a_numeric_hash(x) ((x)==HASHVALUE_NUMERIC)
 // may have to be changed to ((x)>=0x80000000U)
 
+// has been changed
+//#define is_a_numeric_hash(x) ((x)&0x80000000U)
+
 // global functions
 
-numeric const & numZERO(void);
-numeric const & numONE(void);
-numeric const & numTWO(void);
-numeric const & numMINUSONE(void);
-numeric const & numHALF(void);
-
-numeric exp(numeric const & x);
-numeric log(numeric const & x);
-numeric sin(numeric const & x);
-numeric cos(numeric const & x);
-numeric tan(numeric const & x);
-numeric asin(numeric const & x);
-numeric acos(numeric const & x);
-numeric atan(numeric const & x);
-numeric atan(numeric const & y, numeric const & x);
-numeric sinh(numeric const & x);
-numeric cosh(numeric const & x);
-numeric tanh(numeric const & x);
-numeric asinh(numeric const & x);
-numeric acosh(numeric const & x);
-numeric atanh(numeric const & x);
-numeric zeta(numeric const & x);
-numeric gamma(numeric const & x);
-numeric psi(numeric const & n, numeric const & x);
-numeric factorial(numeric const & n);
-numeric doublefactorial(numeric const & n);
-numeric binomial(numeric const & n, numeric const & k);
-numeric bernoulli(numeric const & n);
-
-numeric abs(numeric const & x);
-numeric mod(numeric const & a, numeric const & b);
-numeric smod(numeric const & a, numeric const & b);
-numeric irem(numeric const & a, numeric const & b);
-numeric irem(numeric const & a, numeric const & b, numeric & q);
-numeric iquo(numeric const & a, numeric const & b);
-numeric iquo(numeric const & a, numeric const & b, numeric & r);
-numeric sqrt(numeric const & x);
-numeric isqrt(numeric const & x);
-
-numeric gcd(numeric const & a, numeric const & b);
-numeric lcm(numeric const & a, numeric const & b);
+const numeric exp(const numeric & x);
+const numeric log(const numeric & x);
+const numeric sin(const numeric & x);
+const numeric cos(const numeric & x);
+const numeric tan(const numeric & x);
+const numeric asin(const numeric & x);
+const numeric acos(const numeric & x);
+const numeric atan(const numeric & x);
+const numeric atan(const numeric & y, const numeric & x);
+const numeric sinh(const numeric & x);
+const numeric cosh(const numeric & x);
+const numeric tanh(const numeric & x);
+const numeric asinh(const numeric & x);
+const numeric acosh(const numeric & x);
+const numeric atanh(const numeric & x);
+const numeric zeta(const numeric & x);
+const numeric gamma(const numeric & x);
+const numeric psi(const numeric & x);
+const numeric psi(const numeric & n, const numeric & x);
+const numeric factorial(const numeric & n);
+const numeric doublefactorial(const numeric & n);
+const numeric binomial(const numeric & n, const numeric & k);
+const numeric bernoulli(const numeric & n);
+const numeric fibonacci(const numeric & n);
+
+numeric abs(const numeric & x);
+numeric mod(const numeric & a, const numeric & b);
+numeric smod(const numeric & a, const numeric & b);
+numeric irem(const numeric & a, const numeric & b);
+numeric irem(const numeric & a, const numeric & b, numeric & q);
+numeric iquo(const numeric & a, const numeric & b);
+numeric iquo(const numeric & a, const numeric & b, numeric & r);
+numeric sqrt(const numeric & x);
+numeric isqrt(const numeric & x);
+
+numeric gcd(const numeric & a, const numeric & b);
+numeric lcm(const numeric & a, const numeric & b);
 
 /** Exception thrown by numeric members to signal failure */
 struct numeric_fail
@@ -268,65 +262,79 @@ struct numeric_fail
 };
 
 // wrapper functions around member functions
-inline numeric inverse(numeric const & x)
+inline numeric pow(const numeric & x, const numeric & y)
+{ return x.power(y); }
+
+inline numeric inverse(const numeric & x)
 { return x.inverse(); }
 
-inline bool csgn(numeric const & x)
+inline bool csgn(const numeric & x)
 { return x.csgn(); }
 
-inline bool is_zero(numeric const & x)
+inline bool is_zero(const numeric & x)
 { return x.is_zero(); }
 
-inline bool is_positive(numeric const & x)
+inline bool is_positive(const numeric & x)
 { return x.is_positive(); }
 
-inline bool is_integer(numeric const & x)
+inline bool is_integer(const numeric & x)
 { return x.is_integer(); }
 
-inline bool is_pos_integer(numeric const & x)
+inline bool is_pos_integer(const numeric & x)
 { return x.is_pos_integer(); }
 
-inline bool is_nonneg_integer(numeric const & x)
+inline bool is_nonneg_integer(const numeric & x)
 { return x.is_nonneg_integer(); }
 
-inline bool is_even(numeric const & x)
+inline bool is_even(const numeric & x)
 { return x.is_even(); }
 
-inline bool is_odd(numeric const & x)
+inline bool is_odd(const numeric & x)
 { return x.is_odd(); }
 
-inline bool is_prime(numeric const & x)
+inline bool is_prime(const numeric & x)
 { return x.is_prime(); }
 
-inline bool is_rational(numeric const & x)
+inline bool is_rational(const numeric & x)
 { return x.is_rational(); }
 
-inline bool is_real(numeric const & x)
+inline bool is_real(const numeric & x)
 { return x.is_real(); }
 
-inline numeric real(numeric const & x)
+inline bool is_cinteger(const numeric & x)
+{ return x.is_cinteger(); }
+
+inline bool is_crational(const numeric & x)
+{ return x.is_crational(); }
+
+inline numeric real(const numeric & x)
 { return x.real(); }
 
-inline numeric imag(numeric const & x)
+inline numeric imag(const numeric & x)
 { return x.imag(); }
 
-inline numeric numer(numeric const & x)
+inline numeric numer(const numeric & x)
 { return x.numer(); }
 
-inline numeric denom(numeric const & x)
+inline numeric denom(const numeric & x)
 { return x.denom(); }
 
-ex IEvalf(void);
+// numeric evaluation functions for class constant objects:
+
 ex PiEvalf(void);
 ex EulerGammaEvalf(void);
 ex CatalanEvalf(void);
 
+
 // utility functions
 inline const numeric &ex_to_numeric(const ex &e)
 {
-	return static_cast<const numeric &>(*e.bp);
+    return static_cast<const numeric &>(*e.bp);
 }
 
+
+#ifndef NO_NAMESPACE_GINAC
 } // namespace GiNaC
+#endif // ndef NO_NAMESPACE_GINAC
 
 #endif // ndef __GINAC_NUMERIC_H__