exvector delta8vec;
exvector fvec;
exvector dvec;
- vector<exvector> Tvecs;
+ exvectorvector Tvecs;
Tvecs.resize(MAX_REPRESENTATION_LABELS);
- vector<exvector> ONEvecs;
+ exvectorvector ONEvecs;
ONEvecs.resize(MAX_REPRESENTATION_LABELS);
exvector unknownvec;
void split_color_string_in_parts(exvector const & v, exvector & delta8vec,
exvector & fvec, exvector & dvec,
- vector<exvector> & Tvecs,
- vector<exvector> & ONEvecs,
+ exvectorvector & Tvecs,
+ exvectorvector & ONEvecs,
exvector & unknownvec)
{
// if not all elements are of type color, put all Ts in unknownvec to
}
exvector recombine_color_string(exvector & delta8vec, exvector & fvec,
- exvector & dvec, vector<exvector> & Tvecs,
- vector<exvector> & ONEvecs, exvector & unknownvec)
+ exvector & dvec, exvectorvector & Tvecs,
+ exvectorvector & ONEvecs, exvector & unknownvec)
{
unsigned sz=delta8vec.size()+fvec.size()+dvec.size()+unknownvec.size();
for (unsigned rl=0; rl<MAX_REPRESENTATION_LABELS; ++rl) {
exvector delta8vec;
exvector fvec;
exvector dvec;
- vector<exvector> Tvecs;
+ exvectorvector Tvecs;
Tvecs.resize(MAX_REPRESENTATION_LABELS);
- vector<exvector> ONEvecs;
+ exvectorvector ONEvecs;
ONEvecs.resize(MAX_REPRESENTATION_LABELS);
exvector unknownvec;
exvector delta8vec;
exvector fvec;
exvector dvec;
- vector<exvector> Tvecs;
+ exvectorvector Tvecs;
Tvecs.resize(MAX_REPRESENTATION_LABELS);
- vector<exvector> ONEvecs;
+ exvectorvector ONEvecs;
ONEvecs.resize(MAX_REPRESENTATION_LABELS);
exvector unknownvec;
const unsigned COLOR_EIGHT = 8; // N*N-1
const unsigned COLOR_THREE = 3; // N
+typedef vector<exvector,malloc_alloc> exvectorvector;
+
/** Base class for color object */
class color : public indexed
{
friend unsigned subs_index_in_exvector(exvector & v, ex const & is, ex const & ir);
friend void split_color_string_in_parts(exvector const & v, exvector & delta8vec,
exvector & fvec, exvector & dvec,
- vector<exvector> & Tvecs,
- vector<exvector> & ONEvecs,
+ exvectorvector & Tvecs,
+ exvectorvector & ONEvecs,
exvector & unknownvec);
friend exvector recombine_color_string(exvector & delta8vec, exvector & fvec,
- exvector & dvec, vector<exvector> & Tvecs,
- vector<exvector> & ONEvecs, exvector & unknownvec);
+ exvector & dvec, exvectorvector & Tvecs,
+ exvectorvector & ONEvecs, exvector & unknownvec);
friend ex color_trace_of_one_representation_label(exvector const & v);
friend ex color_trace(exvector const & v, unsigned const rl);
friend ex simplify_pure_color_string(ex const & e);
color color_delta8(ex const & a, ex const & b);
void split_color_string_in_parts(exvector const & v, exvector & delta8vec,
exvector & fvec, exvector & dvec,
- vector<exvector> & Tvecs,
- vector<exvector> & ONEvecs,
+ exvectorvector & Tvecs,
+ exvectorvector & ONEvecs,
exvector & unknownvec);
exvector recombine_color_string(exvector & delta8vec, exvector & fvec,
- exvector & dvec, vector<exvector> & Tvecs,
- vector<exvector> & ONEvecs, exvector & unknownvec);
+ exvector & dvec, exvectorvector & Tvecs,
+ exvectorvector & ONEvecs, exvector & unknownvec);
ex color_trace_of_one_representation_label(exvector const & v);
ex color_trace(exvector const & v, unsigned const rl=0);
ex simplify_pure_color_string(ex const & e);
// public
-constant::constant(string const & initname, ex (*efun)()) :
+constant::constant(string const & initname, evalffunctype efun) :
basic(TINFO_constant), name(initname), ef(efun),
// number(0), fct_assigned(true), serial(next_serial++)
number(0), serial(next_serial++)
namespace GiNaC {
#endif // ndef NO_GINAC_NAMESPACE
+typedef ex (*evalffunctype)(void);
+
/** This class holds constants, symbols with specific numerical value. Each
* object of this class must either provide their own function to evaluate it
* to class numeric or provide the constant as a numeric (if it's an exact
// other constructors
public:
- constant(string const & initname, ex (*efun)()=0);
+ constant(string const & initname, evalffunctype efun=0);
constant(string const & initname, numeric const & initnumber);
// functions overriding virtual functions from bases classes
private:
string name;
- ex (*ef)();
+ evalffunctype ef;
numeric * number;
// bool fct_assigned;
unsigned serial; //!< unique serial number for comparision
GINAC_ASSERT(exZERO().bp->flags & status_flags::dynallocated);
GINAC_ASSERT(bp!=0);
++bp->refcount;
+#ifdef OBSCURE_CINT_HACK
+ update_last_created_or_assigned_bp();
+#endif // def OBSCURE_CINT_HACK
}
#else
;
GINAC_ASSERT(bp!=0);
GINAC_ASSERT((bp->flags) & status_flags::dynallocated);
++bp->refcount;
+#ifdef OBSCURE_CINT_HACK
+ update_last_created_or_assigned_bp();
+#endif // def OBSCURE_CINT_HACK
}
#else
;
delete bp;
}
bp=tmpbp;
+#ifdef OBSCURE_CINT_HACK
+ update_last_created_or_assigned_bp();
+#endif // def OBSCURE_CINT_HACK
return *this;
}
#else
public:
ex(basic const & other)
#ifdef INLINE_EX_CONSTRUCTORS
- {
- construct_from_basic(other);
- }
+ {
+ construct_from_basic(other);
+#ifdef OBSCURE_CINT_HACK
+ update_last_created_or_assigned_bp();
+#endif // def OBSCURE_CINT_HACK
+ }
#else
;
#endif // def INLINE_EX_CONSTRUCTORS
void construct_from_basic(basic const & other);
void makewriteable();
+#ifdef OBSCURE_CINT_HACK
+public:
+ static bool last_created_or_assigned_bp_can_be_converted_to_ex(void)
+ {
+ if (last_created_or_assigned_bp==0) return false;
+ if ((last_created_or_assigned_bp->flags &
+ status_flags::dynallocated)==0) return false;
+ if ((last_created_or_assigned_bp->flags &
+ status_flags::evaluated)==0) return false;
+ return true;
+ }
+protected:
+ void update_last_created_or_assigned_bp(void)
+ {
+ if (last_created_or_assigned_bp!=0) {
+ if (--last_created_or_assigned_bp->refcount == 0) {
+ delete last_created_or_assigned_bp;
+ }
+ }
+ last_created_or_assigned_bp=bp;
+ ++last_created_or_assigned_bp->refcount;
+ last_created_or_assigned_bp_modified=true;
+ }
+#endif // def OBSCURE_CINT_HACK
+
// member variables
public:
basic *bp;
+#ifdef OBSCURE_CINT_HACK
+ static basic *last_created_or_assigned_bp;
+ static bool last_created_or_assigned_bp_modified;
+#endif // def OBSCURE_CINT_HACK
};
// utility functions
// protected
/** Ctor from representation, for internal use only. */
-matrix::matrix(int r, int c, vector<ex> const & m2)
+matrix::matrix(int r, int c, exvector const & m2)
: basic(TINFO_matrix), row(r), col(c), m(m2)
{
- debugmsg("matrix constructor from int,int,vector<ex>",LOGLEVEL_CONSTRUCT);
+ debugmsg("matrix constructor from int,int,exvector",LOGLEVEL_CONSTRUCT);
}
//////////
/** expands the elements of a matrix entry by entry. */
ex matrix::expand(unsigned options) const
{
- vector<ex> tmp(row*col);
+ exvector tmp(row*col);
for (int i=0; i<row*col; ++i) {
tmp[i]=m[i].expand(options);
}
if (is_equal(*other.bp)) return true;
// search all the elements
- for (vector<ex>::const_iterator r=m.begin(); r!=m.end(); ++r) {
+ for (exvector::const_iterator r=m.begin(); r!=m.end(); ++r) {
if ((*r).has(other)) return true;
}
return false;
}
// eval() entry by entry
- vector<ex> m2(row*col);
+ exvector m2(row*col);
--level;
for (int r=0; r<row; ++r) {
for (int c=0; c<col; ++c) {
}
// evalf() entry by entry
- vector<ex> m2(row*col);
+ exvector m2(row*col);
--level;
for (int r=0; r<row; ++r) {
for (int c=0; c<col; ++c) {
throw (std::logic_error("matrix::add(): incompatible matrices"));
}
- vector<ex> sum(this->m);
- vector<ex>::iterator i;
- vector<ex>::const_iterator ci;
+ exvector sum(this->m);
+ exvector::iterator i;
+ exvector::const_iterator ci;
for (i=sum.begin(), ci=other.m.begin();
i!=sum.end();
++i, ++ci) {
throw (std::logic_error("matrix::sub(): incompatible matrices"));
}
- vector<ex> dif(this->m);
- vector<ex>::iterator i;
- vector<ex>::const_iterator ci;
+ exvector dif(this->m);
+ exvector::iterator i;
+ exvector::const_iterator ci;
for (i=dif.begin(), ci=other.m.begin();
i!=dif.end();
++i, ++ci) {
throw (std::logic_error("matrix::mul(): incompatible matrices"));
}
- vector<ex> prod(row*other.col);
+ exvector prod(row*other.col);
for (int i=0; i<row; ++i) {
for (int j=0; j<other.col; ++j) {
for (int l=0; l<col; ++l) {
* represents the transposed. */
matrix matrix::transpose(void) const
{
- vector<ex> trans(col*row);
+ exvector trans(col*row);
for (int r=0; r<col; ++r) {
for (int c=0; c<row; ++c) {
}
// check, if there are non-numeric entries in the matrix:
- for (vector<ex>::const_iterator r=m.begin(); r!=m.end(); ++r) {
+ for (exvector::const_iterator r=m.begin(); r!=m.end(); ++r) {
if (!(*r).info(info_flags::numeric)) {
if (normalized) {
return determinant_symbolic_minor(*this).normal();
}
// assemble the solution matrix
- vector<ex> sol(v.row*v.col);
+ exvector sol(v.row*v.col);
for (int c=0; c<v.col; ++c) {
for (int r=col-1; r>=0; --r) {
sol[r*v.col+c] = tmp[r*tmp.col+c];
// other constructors
public:
matrix(int r, int c);
- matrix(int r, int c, vector<ex> const & m2);
+ matrix(int r, int c, exvector const & m2);
// functions overriding virtual functions from bases classes
public:
protected:
int row; /**< number of rows */
int col; /**< number of columns */
- vector<ex> m; /**< representation (cols indexed first) */
+ exvector m; /**< representation (cols indexed first) */
static unsigned precedence;
};