to compile, install and work properly:
Cint version | is known to work with | is known not to work with
---------------+---------------------------+-----------------------------
- < 5.14.37 | | (incompatible with GiNaC)
- 5.14.38 | egcs 1.1.1 (problematic) | gcc.2.95.2
+--------------+---------------------------+------------------------------
+ < 5.14.39 | `verboten' by license (please bite your favorite lawyer)
5.14.39 | egcs 1.1.1, gcc.2.95.2 | gcc <= 2.7.2.3
5.14.40 | egcs 1.1.1, gcc.2.95.2 | gcc <= 2.7.2.3
#endif // def OBSCURE_CINT_HACK
return;
}
-//----+----#----+----#----+----#----+----#----+----#----+----#----+----#----+----#
-// __, _______ Cint: Copyright 1995-2000 Masaharu Goto and Agilent Technologies, JP." << endl
+
void greeting(void)
{
cout << "Welcome to GiNaC-cint (" << PACKAGE << " V" << VERSION << ")" << endl;
echo "$ac_t""creating cint/Makefile" 1>&6
(cd cint && \
$MAKECINT -mk Makefile.makecint -o ginaccint.bin -m \
- -D OBSCURE_CINT_HACK -cc "$CXXFLAGS" \
+ -D OBSCURE_CINT_HACK "$CPPFLAGS" -cc "$CXXFLAGS" \
-I .. -I $CINTSYSDIR -m -H ../ginac/ginac.h \
-C++ ginaccint.bin.cpp \
-l -L../ginac/.libs -lginac -lcln \
}
} else {
if (other.flags & status_flags::dynallocated) {
+ // it's on the heap, so just copy bp:
bp = &const_cast<basic &>(other);
} else {
+ // create a duplicate on the heap:
bp = other.duplicate();
bp->setflag(status_flags::dynallocated);
}
;
#endif // def INLINE_EX_CONSTRUCTORS
-#ifdef CINT_CONVERSION_WORKAROUND
- // workaround to fix the missing automatic derived->basic->ex conversion
- const ex & operator=(const basic & other)
- {
- return *this=ex(other);
- }
-#endif // def CINT_CONVERSION_WORKAROUND
// other constructors
public:
unsigned nops() const;
ex expand(unsigned options=0) const;
bool has(const ex & other) const;
-#ifdef CINT_CONVERSION_WORKAROUND
- bool has(basic const & other) const { return has(ex(other)); }
-#endif // def CINT_CONVERSION_WORKAROUND
int degree(const symbol & s) const;
int ldegree(const symbol & s) const;
ex coeff(const symbol & s, int n=1) const;
numeric integer_content(void) const;
ex primpart(const symbol &x) const;
ex primpart(const symbol &x, const ex &cont) const;
-#ifdef CINT_CONVERSION_WORKAROUND
- ex primpart(const symbol &x, const basic &cont) const { return primpart(x,ex(cont)); }
-#endif // def CINT_CONVERSION_WORKAROUND
ex normal(int level = 0) const;
ex to_rational(lst &repl_lst) const;
ex smod(const numeric &xi) const;
ex evalf(int level = 0) const;
ex diff(const symbol & s, unsigned nth = 1) const;
ex series(const ex & r, int order) const;
-#ifdef CINT_CONVERSION_WORKAROUND
- ex series(const basic & r, int order) const { return series(ex(r),order); }
-#endif // def CINT_CONVERSION_WORKAROUND
ex subs(const lst & ls, const lst & lr) const;
ex subs(const ex & e) const;
-#ifdef CINT_CONVERSION_WORKAROUND
- ex subs(const basic & e) const { return subs(ex(e)); }
-#endif // def CINT_CONVERSION_WORKAROUND
exvector get_indices(void) const;
ex simplify_ncmul(const exvector & v) const;
ex operator[](const ex & index) const;
-#ifdef CINT_CONVERSION_WORKAROUND
- ex operator[](const basic & index) const { return operator[](ex(index)); }
-#endif // def CINT_CONVERSION_WORKAROUND
ex operator[](int i) const;
ex op(int i) const;
ex & let_op(int i);
#else
;
#endif // def INLINE_EX_CONSTRUCTORS
-#ifdef CINT_CONVERSION_WORKAROUND
- int compare(const basic & other) const { return compare(ex(other)); }
-#endif // def CINT_CONVERSION_WORKAROUND
bool is_equal(const ex & other) const
#ifdef INLINE_EX_CONSTRUCTORS
{
#else
;
#endif // def INLINE_EX_CONSTRUCTORS
-#ifdef CINT_CONVERSION_WORKAROUND
- bool is_equal(const basic & other) const { return is_equal(ex(other)); }
-#endif // def CINT_CONVERSION_WORKAROUND
bool is_zero(void) const {return compare(_ex0())==0;};
unsigned return_type(void) const;
unsigned gethash(void) const;
ex exadd(const ex & rh) const;
-#ifdef CINT_CONVERSION_WORKAROUND
- ex exadd(const basic & rh) const { return exadd(ex(rh)); }
-#endif // def CINT_CONVERSION_WORKAROUND
ex exmul(const ex & rh) const;
-#ifdef CINT_CONVERSION_WORKAROUND
- ex exmul(const basic & rh) const { return exmul(ex(rh)); }
-#endif // def CINT_CONVERSION_WORKAROUND
ex exncmul(const ex & rh) const;
-#ifdef CINT_CONVERSION_WORKAROUND
- ex exncmul(const basic & rh) const { return exncmul(ex(rh)); }
-#endif // def CINT_CONVERSION_WORKAROUND
private:
void construct_from_basic(const basic & other);
void construct_from_int(int i);
}
$declare_function_macro_namespace = <<'END_OF_DECLARE_FUNCTION_1_AND_2P_MACRO_NAMESPACE';
-#ifdef CINT_CONVERSION_WORKAROUND
-
-#define DECLARE_FUNCTION_1P(NAME) \
-extern const unsigned function_index_##NAME; \
-inline GiNaC::function NAME(const GiNaC::ex & p1) { \
- return GiNaC::function(function_index_##NAME, p1); \
-} \
-inline GiNaC::function NAME(const GiNaC::basic & p1) { \
- return GiNaC::function(function_index_##NAME, GiNaC::ex(p1)); \
-}
-#define DECLARE_FUNCTION_2P(NAME) \
-extern const unsigned function_index_##NAME; \
-inline GiNaC::function NAME(const GiNaC::ex & p1, const GiNaC::ex & p2) { \
- return GiNaC::function(function_index_##NAME, p1, p2); \
-} \
-inline GiNaC::function NAME(const GiNaC::basic & p1, const GiNaC::ex & p2) { \
- return GiNaC::function(function_index_##NAME, GiNaC::ex(p1), p2); \
-} \
-inline GiNaC::function NAME(const GiNaC::ex & p1, const GiNaC::basic & p2) { \
- return GiNaC::function(function_index_##NAME, p1, GiNaC::ex(p2)); \
-} \
-inline GiNaC::function NAME(const GiNaC::basic & p1, const GiNaC::basic & p2) { \
- return GiNaC::function(function_index_##NAME, GiNaC::ex(p1), GiNaC::ex(p2)); \
-}
-
-#else // def CINT_CONVERSION_WORKAROUND
-
#define DECLARE_FUNCTION_1P(NAME) \
extern const unsigned function_index_##NAME; \
inline GiNaC::function NAME(const GiNaC::ex & p1) { \
return GiNaC::function(function_index_##NAME, p1, p2); \
}
-#endif // def CINT_CONVERSION_WORKAROUND
-
END_OF_DECLARE_FUNCTION_1_AND_2P_MACRO_NAMESPACE
$declare_function_macro_namespace .= generate_from_to(
END_OF_DECLARE_FUNCTION_MACRO_NAMESPACE
$declare_function_macro_no_namespace = <<'END_OF_DECLARE_FUNCTION_1_AND_2P_MACRO_NO_NAMESPACE';
-#ifdef CINT_CONVERSION_WORKAROUND
-
-#define DECLARE_FUNCTION_1P(NAME) \
-extern const unsigned function_index_##NAME; \
-inline function NAME(const ex & p1) { \
- return function(function_index_##NAME, p1); \
-} \
-inline function NAME(const basic & p1) { \
- return function(function_index_##NAME, ex(p1)); \
-}
-#define DECLARE_FUNCTION_2P(NAME) \
-extern const unsigned function_index_##NAME; \
-inline function NAME(const ex & p1, const ex & p2) { \
- return function(function_index_##NAME, p1, p2); \
-} \
-inline function NAME(const basic & p1, const ex & p2) { \
- return function(function_index_##NAME, ex(p1), p2); \
-} \
-inline function NAME(const ex & p1, const basic & p2) { \
- return function(function_index_##NAME, p1, ex(p2)); \
-} \
-inline function NAME(const basic & p1, const basic & p2) { \
- return function(function_index_##NAME, ex(p1), ex(p2)); \
-}
-
-#else // def CINT_CONVERSION_WORKAROUND
-
#define DECLARE_FUNCTION_1P(NAME) \
extern const unsigned function_index_##NAME; \
inline function NAME(const ex & p1) { \
return function(function_index_##NAME, p1, p2); \
}
-#endif // def CINT_CONVERSION_WORKAROUND
-
END_OF_DECLARE_FUNCTION_1_AND_2P_MACRO_NO_NAMESPACE
$declare_function_macro_no_namespace .= generate_from_to(
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
-{
- int failval;
- numeric_fail(int n) { failval = n; }
-};
-
// wrapper functions around member functions
inline numeric pow(const numeric & x, const numeric & y)
{ return x.power(y); }
ex operator/(const ex & lh, const ex & rh)
{
- debugmsg("operator*(ex,ex)",LOGLEVEL_OPERATOR);
+ debugmsg("operator/(ex,ex)",LOGLEVEL_OPERATOR);
return lh.exmul(power(rh,_ex_1()));
}
ex operator+(const ex & lh)
{
+ debugmsg("operator+(ex)",LOGLEVEL_OPERATOR);
return lh;
}
ex operator-(const ex & lh)
{
+ debugmsg("operator-(ex)",LOGLEVEL_OPERATOR);
return lh.exmul(_ex_1());
}
numeric operator+(const numeric & lh)
{
+ debugmsg("operator+(numeric)",LOGLEVEL_OPERATOR);
return lh;
}
numeric operator-(const numeric & lh)
{
+ debugmsg("operator-(numeric)",LOGLEVEL_OPERATOR);
return _num_1()*lh;
}
/** Numeric prefix increment. Adds 1 and returns incremented number. */
numeric& operator++(numeric & rh)
{
+ debugmsg("operator++(numeric)",LOGLEVEL_OPERATOR);
rh = rh+_num1();
return rh;
}
/** Numeric prefix decrement. Subtracts 1 and returns decremented number. */
numeric& operator--(numeric & rh)
{
+ debugmsg("operator--(numeric)",LOGLEVEL_OPERATOR);
rh = rh-_num1();
return rh;
}
* incremented by 1. */
numeric operator++(numeric & lh, int)
{
+ debugmsg("operator++(numeric,int)",LOGLEVEL_OPERATOR);
numeric tmp = lh;
lh = lh+_num1();
return tmp;
* decremented by 1. */
numeric operator--(numeric & lh, int)
{
+ debugmsg("operator--(numeric,int)",LOGLEVEL_OPERATOR);
numeric tmp = lh;
lh = lh-_num1();
return tmp;
return relational(lh,rh,relational::greater_or_equal);
}
-/*
-
-// binary relational operators ex with numeric
-
-relational operator==(const ex & lh, const numeric & rh)
-{
- debugmsg("operator==(ex,numeric)",LOGLEVEL_OPERATOR);
- return relational(lh,rh,relational::equal);
-}
-
-relational operator!=(const ex & lh, const numeric & rh)
-{
- debugmsg("operator!=(ex,numeric)",LOGLEVEL_OPERATOR);
- return relational(lh,rh,relational::not_equal);
-}
-
-relational operator<(const ex & lh, const numeric & rh)
-{
- debugmsg("operator<(ex,numeric)",LOGLEVEL_OPERATOR);
- return relational(lh,rh,relational::less);
-}
-
-relational operator<=(const ex & lh, const numeric & rh)
-{
- debugmsg("operator<=(ex,numeric)",LOGLEVEL_OPERATOR);
- return relational(lh,rh,relational::less_or_equal);
-}
-
-relational operator>(const ex & lh, const numeric & rh)
-{
- debugmsg("operator>(ex,numeric)",LOGLEVEL_OPERATOR);
- return relational(lh,rh,relational::greater);
-}
-
-relational operator>=(const ex & lh, const numeric & rh)
-{
- debugmsg("operator>=(ex,numeric)",LOGLEVEL_OPERATOR);
- return relational(lh,rh,relational::greater_or_equal);
-}
-
-// binary relational operators numeric with ex
-
-relational operator==(const numeric & lh, const ex & rh)
-{
- debugmsg("operator==(numeric,ex)",LOGLEVEL_OPERATOR);
- return relational(lh,rh,relational::equal);
-}
-
-relational operator!=(const numeric & lh, const ex & rh)
-{
- debugmsg("operator!=(numeric,ex)",LOGLEVEL_OPERATOR);
- return relational(lh,rh,relational::not_equal);
-}
-
-relational operator<(const numeric & lh, const ex & rh)
-{
- debugmsg("operator<(numeric,ex)",LOGLEVEL_OPERATOR);
- return relational(lh,rh,relational::less);
-}
-
-relational operator<=(const numeric & lh, const ex & rh)
-{
- debugmsg("operator<=(numeric,ex)",LOGLEVEL_OPERATOR);
- return relational(lh,rh,relational::less_or_equal);
-}
-
-relational operator>(const numeric & lh, const ex & rh)
-{
- debugmsg("operator>(numeric,ex)",LOGLEVEL_OPERATOR);
- return relational(lh,rh,relational::greater);
-}
-
-relational operator>=(const numeric & lh, const ex & rh)
-{
- debugmsg("operator>=(numeric,ex)",LOGLEVEL_OPERATOR);
- return relational(lh,rh,relational::greater_or_equal);
-}
-
-*/
-
// input/output stream operators
ostream & operator<<(ostream & os, const ex & e)