#include "add.h"
#include "power.h"
#include "debugmsg.h"
+#include "utils.h"
+#ifndef NO_GINAC_NAMESPACE
namespace GiNaC {
+#endif // ndef NO_GINAC_NAMESPACE
//////////
// default constructor, destructor, copy constructor assignment operator and helpers
{
debugmsg("mul constructor from ex,ex",LOGLEVEL_CONSTRUCT);
tinfo_key = TINFO_mul;
- overall_coeff=exONE();
+ overall_coeff=_ex1();
construct_from_2_ex(lh,rh);
- ASSERT(is_canonical());
+ GINAC_ASSERT(is_canonical());
}
mul::mul(exvector const & v)
{
debugmsg("mul constructor from exvector",LOGLEVEL_CONSTRUCT);
tinfo_key = TINFO_mul;
- overall_coeff=exONE();
+ overall_coeff=_ex1();
construct_from_exvector(v);
- ASSERT(is_canonical());
+ GINAC_ASSERT(is_canonical());
}
/*
} else {
construct_from_epvector(v);
}
- ASSERT(is_canonical());
+ GINAC_ASSERT(is_canonical());
}
*/
{
debugmsg("mul constructor from epvector",LOGLEVEL_CONSTRUCT);
tinfo_key = TINFO_mul;
- overall_coeff=exONE();
+ overall_coeff=_ex1();
construct_from_epvector(v);
- ASSERT(is_canonical());
+ GINAC_ASSERT(is_canonical());
}
mul::mul(epvector const & v, ex const & oc)
tinfo_key = TINFO_mul;
overall_coeff=oc;
construct_from_epvector(v);
- ASSERT(is_canonical());
+ GINAC_ASSERT(is_canonical());
}
mul::mul(epvector * vp, ex const & oc)
{
debugmsg("mul constructor from epvector *,ex",LOGLEVEL_CONSTRUCT);
tinfo_key = TINFO_mul;
- ASSERT(vp!=0);
+ GINAC_ASSERT(vp!=0);
overall_coeff=oc;
construct_from_epvector(*vp);
delete vp;
- ASSERT(is_canonical());
+ GINAC_ASSERT(is_canonical());
}
mul::mul(ex const & lh, ex const & mh, ex const & rh)
factors.push_back(lh);
factors.push_back(mh);
factors.push_back(rh);
- overall_coeff=exONE();
+ overall_coeff=_ex1();
construct_from_exvector(factors);
- ASSERT(is_canonical());
+ GINAC_ASSERT(is_canonical());
}
//////////
return new mul(*this);
}
+void mul::print(ostream & os, unsigned upper_precedence) const
+{
+ debugmsg("mul print",LOGLEVEL_PRINT);
+ if (precedence<=upper_precedence) os << "(";
+ bool first=true;
+ // first print the overall numeric coefficient:
+ if (ex_to_numeric(overall_coeff).csgn()==-1) os << '-';
+ if (!overall_coeff.is_equal(_ex1()) &&
+ !overall_coeff.is_equal(_ex_1())) {
+ if (ex_to_numeric(overall_coeff).csgn()==-1)
+ (_num_1()*overall_coeff).print(os, precedence);
+ else
+ overall_coeff.print(os, precedence);
+ os << '*';
+ }
+ // then proceed with the remaining factors:
+ for (epvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
+ if (!first) {
+ os << '*';
+ } else {
+ first=false;
+ }
+ recombine_pair_to_ex(*cit).print(os,precedence);
+ }
+ if (precedence<=upper_precedence) os << ")";
+}
+
+void mul::printraw(ostream & os) const
+{
+ debugmsg("mul printraw",LOGLEVEL_PRINT);
+
+ os << "*(";
+ for (epvector::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
+ os << "(";
+ (*it).rest.bp->printraw(os);
+ os << ",";
+ (*it).coeff.bp->printraw(os);
+ os << "),";
+ }
+ os << ",hash=" << hashvalue << ",flags=" << flags;
+ os << ")";
+}
+
+void mul::printcsrc(ostream & os, unsigned type, unsigned upper_precedence) const
+{
+ debugmsg("mul print csrc", LOGLEVEL_PRINT);
+ if (precedence <= upper_precedence)
+ os << "(";
+
+ if (!overall_coeff.is_equal(_ex1())) {
+ overall_coeff.bp->printcsrc(os,type,precedence);
+ os << "*";
+ }
+
+ // Print arguments, separated by "*" or "/"
+ epvector::const_iterator it = seq.begin();
+ epvector::const_iterator itend = seq.end();
+ while (it != itend) {
+
+ // If the first argument is a negative integer power, it gets printed as "1.0/<expr>"
+ if (it == seq.begin() && ex_to_numeric(it->coeff).is_integer() && it->coeff.compare(_num0()) < 0) {
+ if (type == csrc_types::ctype_cl_N)
+ os << "recip(";
+ else
+ os << "1.0/";
+ }
+
+ // If the exponent is 1 or -1, it is left out
+ if (it->coeff.compare(_ex1()) == 0 || it->coeff.compare(_num_1()) == 0)
+ it->rest.bp->printcsrc(os, type, precedence);
+ else
+ // outer parens around ex needed for broken gcc-2.95 parser:
+ (ex(power(it->rest, abs(ex_to_numeric(it->coeff))))).bp->printcsrc(os, type, upper_precedence);
+
+ // Separator is "/" for negative integer powers, "*" otherwise
+ it++;
+ if (it != itend) {
+ if (ex_to_numeric(it->coeff).is_integer() && it->coeff.compare(_num0()) < 0)
+ os << "/";
+ else
+ os << "*";
+ }
+ }
+ if (precedence <= upper_precedence)
+ os << ")";
+}
+
bool mul::info(unsigned inf) const
{
// TODO: optimize
- if (inf==info_flags::polynomial || inf==info_flags::integer_polynomial || inf==info_flags::rational_polynomial || inf==info_flags::rational_function) {
+ if (inf==info_flags::polynomial ||
+ inf==info_flags::integer_polynomial ||
+ inf==info_flags::cinteger_polynomial ||
+ inf==info_flags::rational_polynomial ||
+ inf==info_flags::crational_polynomial ||
+ inf==info_flags::rational_function) {
for (epvector::const_iterator it=seq.begin(); it!=seq.end(); ++it) {
if (!(recombine_pair_to_ex(*it).info(inf)))
return false;
}
- return true;
+ return overall_coeff.info(inf);
} else {
return expairseq::info(inf);
}
return (new mul(coeffseq))->setflag(status_flags::dynallocated);
}
- return exZERO();
-}
-
-/*
-ex mul::eval(int level) const
-{
- // simplifications: *(...,x,(c1,1),(c2,1)) -> *(...,x,(c1*c2,1)) (c1, c2 numeric(), move pairs to end first)
- // *(...,x,1) -> *(...,x)
- // *(...,x,0) -> 0
- // *(+(x,y,...),(c,1)) -> *(+(*(x,c),*(y,c),...)) (c numeric())
- // *(x) -> x
- // *() -> 1
-
- debugmsg("mul eval",LOGLEVEL_MEMBER_FUNCTION);
-
- if ((level==1)&&(flags & status_flags::evaluated)) {
-#ifdef DOASSERT
- for (epvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
- ASSERT((!is_ex_exactly_of_type((*cit).rest,mul))||
- (!(ex_to_numeric((*cit).coeff).is_integer())));
- }
-
- // test if all numerics were moved to the end and
- // all numerics with coeff 1 to the very end
- if (seq.size()!=0) {
- epvector::const_iterator cit=seq.end();
- bool all_coeff_1=true;
- bool all_numeric=true;
- do {
- cit--;
- if (is_ex_exactly_of_type((*cit).rest,numeric)) {
- ASSERT(all_numeric);
- if ((*cit).coeff.is_equal(exONE())) {
- ASSERT(all_coeff_1);
- } else {
- all_coeff_1=false;
- }
- } else {
- all_numeric=false;
- }
- } while (cit!=seq.begin());
- }
-#endif // def DOASSERT
- return *this;
- }
-
- epvector newseq;
- epvector::iterator it1,it2;
- bool seq_copied=false;
-
- epvector * evaled_seqp=evalchildren(level);
- if (evaled_seqp!=0) {
- // do more evaluation later
- return (new mul(evaled_seqp))->setflag(status_flags::dynallocated);
- }
-
- // combine pairs with coeff 1 (all numerics should be at end, assert below)
- if (seq.size()>1) {
- // count number of pairs with coeff 1
- unsigned num_coeff_1=0;
- bool still_numeric=true;
- epvector::const_iterator cit=seq.end();
- unsigned first_pos;
- unsigned second_pos;
- do {
- cit--;
- if (is_ex_exactly_of_type((*cit).rest,numeric)) {
- if ((*cit).coeff.is_equal(exONE())) {
- num_coeff_1++;
- }
- } else {
- still_numeric=false;
- }
- } while ((cit!=seq.begin())&&still_numeric);
- if (num_coeff_1>1) {
- newseq=seq;
-
- }
-
-
-#ifdef DOASSERT
- for (epvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
- ASSERT((!is_ex_exactly_of_type((*cit).rest,mul))||
- (!(ex_to_numeric((*cit).coeff).is_integer())));
- }
-
- // test if all numerics were moved to the end and
- // all numerics with coeff 1 to the very end
- if (seq.size()!=0) {
- epvector::const_iterator cit=seq.end();
- bool all_coeff_1=true;
- bool all_numeric=true;
- do {
- cit--;
- if (is_ex_exactly_of_type((*cit).rest,numeric)) {
- ASSERT(all_numeric);
- if ((*cit).coeff.is_equal(exONE())) {
- ASSERT(all_coeff_1);
- } else {
- all_coeff_1=false;
- }
- } else {
- all_numeric=false;
- }
- } while (cit!=seq.begin());
- }
-#endif // def DOASSERT
-
- if (flags & status_flags::evaluated) {
- return *this;
- }
-
- expair const & last_expair=*(seq.end()-1);
- expair const & next_to_last_expair=*(seq.end()-2);
- int seq_size = seq.size();
-
- // *(...,x,(c1,1),(c2,1)) -> *(...,x,(c1*c2,1)) (c1, c2 numeric())
- if ((!seq_copied) && (seq_size>=2) &&
- is_ex_exactly_of_type(last_expair.rest,numeric) &&
- ex_to_numeric(last_expair.coeff).is_equal(numONE()) &&
- is_ex_exactly_of_type(next_to_last_expair.rest,numeric) &&
- ex_to_numeric(next_to_last_expair.coeff).is_equal(numONE()) ) {
- newseq=seq;
- seq_copied=true;
- it2=newseq.end()-1;
- it1=it2-1;
- }
- while (seq_copied && (newseq.size()>=2) &&
- is_ex_exactly_of_type((*it1).rest,numeric) &&
- ex_to_numeric((*it1).coeff).is_equal(numONE()) &&
- is_ex_exactly_of_type((*it2).rest,numeric) &&
- ex_to_numeric((*it2).coeff).is_equal(numONE()) ) {
- *it1=expair(ex_to_numeric((*it1).rest).mul_dyn(ex_to_numeric((*it2).rest)),exONE());
- newseq.pop_back();
- it2=newseq.end()-1;
- it1=it2-1;
- }
-
- // *(...,x,1) -> *(...,x)
- if ((!seq_copied) && (seq_size>=1) &&
- (is_ex_exactly_of_type(last_expair.rest,numeric)) &&
- (ex_to_numeric(last_expair.rest).compare(numONE())==0)) {
- newseq=seq;
- seq_copied=true;
- it2=newseq.end()-1;
- }
- if (seq_copied && (newseq.size()>=1) &&
- (is_ex_exactly_of_type((*it2).rest,numeric)) &&
- (ex_to_numeric((*it2).rest).compare(numONE())==0)) {
- newseq.pop_back();
- it2=newseq.end()-1;
- }
-
- // *(...,x,0) -> 0
- if ((!seq_copied) && (seq_size>=1) &&
- (is_ex_exactly_of_type(last_expair.rest,numeric)) &&
- (ex_to_numeric(last_expair.rest).is_zero())) {
- return exZERO();
- }
- if (seq_copied && (newseq.size()>=1) &&
- (is_ex_exactly_of_type((*it2).rest,numeric)) &&
- (ex_to_numeric((*it2).rest).is_zero())) {
- return exZERO();
- }
-
- // *(+(x,y,...),c) -> +(*(x,c),*(y,c),...) (c numeric(), no powers of +())
- if ((!seq_copied) && (seq_size==2) &&
- is_ex_exactly_of_type(next_to_last_expair.rest,add) &&
- is_ex_exactly_of_type(last_expair.rest,numeric) &&
- ex_to_numeric(last_expair.coeff).is_equal(numONE()) &&
- (ex_to_numeric(next_to_last_expair.coeff).compare(numONE())==0)) {
- add const & addref=ex_to_add(next_to_last_expair.rest);
- epvector distrseq;
- distrseq.reserve(addref.seq.size());
- for (epvector::const_iterator cit=addref.seq.begin(); cit!=addref.seq.end(); ++cit) {
- distrseq.push_back(addref.combine_pair_with_coeff_to_pair(*cit,
- last_expair.rest));
- }
- // special treatment for the last element if it is numeric (to
- // avoid terms like (2/3)*(3/2)) is no longer necessary, this
- // is handled in add::combine_pair_with_coeff_to_pair()
- return (new add(distrseq,1))->setflag(status_flags::dynallocated |
- status_flags::evaluated );
- }
- if (seq_copied && (newseq.size()==2) &&
- is_ex_exactly_of_type(newseq[0].rest,add) &&
- is_ex_exactly_of_type(newseq[1].rest,numeric) &&
- ex_to_numeric(newseq[1].coeff).is_equal(numONE()) &&
- (ex_to_numeric(newseq[0].coeff).compare(numONE())==0)) {
- add const & addref=ex_to_add(newseq[0].rest);
- epvector distrseq;
- distrseq.reserve(addref.seq.size());
- for (epvector::const_iterator cit=addref.seq.begin(); cit!=addref.seq.end(); ++cit) {
- distrseq.push_back(addref.combine_pair_with_coeff_to_pair(*cit,
- newseq[1].rest));
- }
- // special treatment for the last element if it is numeric (to
- // avoid terms like (2/3)*(3/2)) is no longer necessary, this
- // is handled in add::combine_pair_with_coeff_to_pair()
- return (new add(distrseq,1))->setflag(status_flags::dynallocated |
- status_flags::evaluated );
- }
-
- // *() -> 1
- if ((!seq_copied) && (seq_size==0)) {
- return exONE();
- } else if (seq_copied && (newseq.size()==0)) {
- return exONE();
- }
-
- // *(x) -> x
- if ((!seq_copied) && (seq_size==1)) {
- return recombine_pair_to_ex(*(seq.begin()));
- } else if (seq_copied && (newseq.size()==1)) {
- return recombine_pair_to_ex(*(newseq.begin()));
- }
-
- if (!seq_copied) return this->hold();
-
- return (new mul(newseq,1))->setflag(status_flags::dynallocated |
- status_flags::evaluated );
+ return _ex0();
}
-*/
ex mul::eval(int level) const
{
setflag(status_flags::dynallocated);
}
-#ifdef DOASSERT
+#ifdef DO_GINAC_ASSERT
for (epvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
- ASSERT((!is_ex_exactly_of_type((*cit).rest,mul))||
+ GINAC_ASSERT((!is_ex_exactly_of_type((*cit).rest,mul))||
(!(ex_to_numeric((*cit).coeff).is_integer())));
- ASSERT(!((*cit).is_numeric_with_coeff_1()));
+ GINAC_ASSERT(!((*cit).is_numeric_with_coeff_1()));
if (is_ex_exactly_of_type(recombine_pair_to_ex(*cit),numeric)) {
printtree(cerr,0);
}
- ASSERT(!is_ex_exactly_of_type(recombine_pair_to_ex(*cit),numeric));
+ GINAC_ASSERT(!is_ex_exactly_of_type(recombine_pair_to_ex(*cit),numeric));
/* for paranoia */
expair p=split_ex_to_pair(recombine_pair_to_ex(*cit));
- ASSERT(p.rest.is_equal((*cit).rest));
- ASSERT(p.coeff.is_equal((*cit).coeff));
+ GINAC_ASSERT(p.rest.is_equal((*cit).rest));
+ GINAC_ASSERT(p.coeff.is_equal((*cit).coeff));
/* end paranoia */
}
-#endif // def DOASSERT
+#endif // def DO_GINAC_ASSERT
if (flags & status_flags::evaluated) {
- ASSERT(seq.size()>0);
- ASSERT((seq.size()>1)||!overall_coeff.is_equal(exONE()));
+ GINAC_ASSERT(seq.size()>0);
+ GINAC_ASSERT((seq.size()>1)||!overall_coeff.is_equal(_ex1()));
return *this;
}
int seq_size=seq.size();
- if (overall_coeff.is_equal(exZERO())) {
+ if (overall_coeff.is_equal(_ex0())) {
// *(...,x;0) -> 0
- return exZERO();
+ return _ex0();
} else if (seq_size==0) {
// *(;c) -> c
return overall_coeff;
- } else if ((seq_size==1)&&overall_coeff.is_equal(exONE())) {
+ } else if ((seq_size==1)&&overall_coeff.is_equal(_ex1())) {
// *(x;1) -> x
return recombine_pair_to_ex(*(seq.begin()));
} else if ((seq_size==1) &&
is_ex_exactly_of_type((*seq.begin()).rest,add) &&
- ex_to_numeric((*seq.begin()).coeff).is_equal(numONE())) {
+ ex_to_numeric((*seq.begin()).coeff).is_equal(_num1())) {
// *(+(x,y,...);c) -> +(*(x,c),*(y,c),...) (c numeric(), no powers of +())
add const & addref=ex_to_add((*seq.begin()).rest);
epvector distrseq;
return this->hold();
}
-/*
-ex mul::eval(int level) const
-{
- // simplifications: *(...,x,c1,c2) -> *(...,x,c1*c2) (c1, c2 numeric())
- // *(...,(c1,c2)) -> (...,(c1^c2,1)) (normalize)
- // *(...,x,1) -> +(...,x)
- // *(...,x,0) -> 0
- // *(+(x,y,...),c) -> *(+(*(x,c),*(y,c),...)) (c numeric())
- // *(x) -> x
- // *() -> 1
-
- debugmsg("mul eval",LOGLEVEL_MEMBER_FUNCTION);
-
- epvector newseq=seq;
- epvector::iterator it1,it2;
-
- // *(...,x,c1,c2) -> *(...,x,c1*c2) (c1, c2 numeric())
- it2=newseq.end()-1;
- it1=it2-1;
- while ((newseq.size()>=2)&&is_exactly_of_type(*(*it1).rest.bp,numeric)&&
- is_exactly_of_type(*(*it2).rest.bp,numeric)) {
- *it1=expair(ex_to_numeric((*it1).rest).power(ex_to_numeric((*it1).coeff))
- .mul(ex_to_numeric((*it2).rest).power(ex_to_numeric((*it2).coeff))),exONE());
- newseq.pop_back();
- it2=newseq.end()-1;
- it1=it2-1;
- }
-
- if ((newseq.size()>=1)&&is_exactly_of_type(*(*it2).rest.bp,numeric)) {
- // *(...,(c1,c2)) -> (...,(c1^c2,1)) (normalize)
- *it2=expair(ex_to_numeric((*it2).rest).power(ex_to_numeric((*it2).coeff)),exONE());
- // *(...,x,1) -> *(...,x)
- if (static_cast<numeric &>(*(*it2).rest.bp).compare(numONE())==0) {
- newseq.pop_back();
- it2=newseq.end()-1;
- }
- }
-
- // *(...,x,0) -> 0
- if ((newseq.size()>=1)&&is_exactly_of_type(*(*it2).rest.bp,numeric)) {
- if (static_cast<numeric &>(*(*it2).rest.bp).is_zero()==0) {
- return exZERO();
- }
- }
-
- // *(+(x,y,...),c) -> +(*(x,c),*(y,c),...) (c numeric(), no powers of +())
- if ((newseq.size()==2)&&is_ex_exactly_of_type(newseq[0].rest,add)&&
- is_ex_exactly_of_type(newseq[1].rest,numeric)&&
- (ex_to_numeric(newseq[0].coeff).compare(numONE())==0)) {
- add const & addref=ex_to_add(newseq[0].rest);
- numeric const & numref=ex_to_numeric(newseq[1].rest);
- epvector distrseq;
- distrseq.reserve(addref.seq.size());
- for (epvector::const_iterator cit=addref.seq.begin(); cit!=addref.seq.end(); ++cit) {
- distrseq.push_back(expair((*cit).rest,ex_to_numeric((*cit).coeff).mul(numref)));
- }
- return (new add(distrseq,1))->setflag(status_flags::dynallocated |
- status_flags::evaluated );
- }
-
- if (newseq.size()==0) {
- // *() -> 1
- return exONE();
- } else if (newseq.size()==1) {
- // *(x) -> x
- return recombine_pair_to_ex(*newseq.begin());
- }
-
- return (new mul(newseq,1))->setflag(status_flags::dynallocated |
- status_flags::evaluated );
-}
-*/
-
exvector mul::get_indices(void) const
{
// return union of indices of factors
all_commutative=0;
}
if ((rt==return_types::noncommutative)&&(!all_commutative)) {
- // another nc element found, compare type_infos
+ // another nc element found, compare type_infos
if ((*cit_noncommutative_element).rest.return_type_tinfo()!=(*cit).rest.return_type_tinfo()) {
- // diffent types -> mul is ncc
- return return_types::noncommutative_composite;
+ // diffent types -> mul is ncc
+ return return_types::noncommutative_composite;
}
}
}
return expair(powerref.basis,powerref.exponent);
}
}
- return expair(e,exONE());
+ return expair(e,_ex1());
}
expair mul::combine_ex_with_coeff_to_pair(ex const & e,
// we create a temporary power object
// otherwise it would be hard to correctly simplify
// expression like (4^(1/3))^(3/2)
- if (are_ex_trivially_equal(c,exONE())) {
+ if (are_ex_trivially_equal(c,_ex1())) {
return split_ex_to_pair(e);
}
return split_ex_to_pair(power(e,c));
// we create a temporary power object
// otherwise it would be hard to correctly simplify
// expression like (4^(1/3))^(3/2)
- if (are_ex_trivially_equal(c,exONE())) {
+ if (are_ex_trivially_equal(c,_ex1())) {
return p;
}
return split_ex_to_pair(power(recombine_pair_to_ex(p),c));
ex mul::recombine_pair_to_ex(expair const & p) const
{
- // if (p.coeff.compare(exONE())==0) {
- // if (are_ex_trivially_equal(p.coeff,exONE())) {
- if (ex_to_numeric(p.coeff).is_equal(numONE())) {
+ // if (p.coeff.compare(_ex1())==0) {
+ // if (are_ex_trivially_equal(p.coeff,_ex1())) {
+ if (ex_to_numeric(p.coeff).is_equal(_num1())) {
return p.rest;
} else {
return power(p.rest,p.coeff);
*it=ep;
return true;
}
- if (ex_to_numeric((*it).coeff).is_equal(numONE())) {
+ if (ex_to_numeric((*it).coeff).is_equal(_num1())) {
// combined pair has coeff 1 and must be moved to the end
return true;
}
ex mul::default_overall_coeff(void) const
{
- return exONE();
+ return _ex1();
}
void mul::combine_overall_coeff(ex const & c)
{
- ASSERT(is_ex_exactly_of_type(overall_coeff,numeric));
- ASSERT(is_ex_exactly_of_type(c,numeric));
+ GINAC_ASSERT(is_ex_exactly_of_type(overall_coeff,numeric));
+ GINAC_ASSERT(is_ex_exactly_of_type(c,numeric));
overall_coeff = ex_to_numeric(overall_coeff).mul_dyn(ex_to_numeric(c));
}
void mul::combine_overall_coeff(ex const & c1, ex const & c2)
{
- ASSERT(is_ex_exactly_of_type(overall_coeff,numeric));
- ASSERT(is_ex_exactly_of_type(c1,numeric));
- ASSERT(is_ex_exactly_of_type(c2,numeric));
+ GINAC_ASSERT(is_ex_exactly_of_type(overall_coeff,numeric));
+ GINAC_ASSERT(is_ex_exactly_of_type(c1,numeric));
+ GINAC_ASSERT(is_ex_exactly_of_type(c2,numeric));
overall_coeff = ex_to_numeric(overall_coeff).
mul_dyn(ex_to_numeric(c1).power(ex_to_numeric(c2)));
}
bool mul::can_make_flat(expair const & p) const
{
- ASSERT(is_ex_exactly_of_type(p.coeff,numeric));
+ GINAC_ASSERT(is_ex_exactly_of_type(p.coeff,numeric));
// this assertion will probably fail somewhere
// it would require a more careful make_flat, obeying the power laws
// probably should return true only if p.coeff is integer
- return ex_to_numeric(p.coeff).is_equal(numONE());
+ return ex_to_numeric(p.coeff).is_equal(_num1());
}
ex mul::expand(unsigned options) const
epvector::const_iterator last=expanded_seq.end();
for (epvector::const_iterator cit=expanded_seq.begin(); cit!=last; ++cit) {
if (is_ex_exactly_of_type((*cit).rest,add)&&
- (ex_to_numeric((*cit).coeff).is_equal(numONE()))) {
+ (ex_to_numeric((*cit).coeff).is_equal(_num1()))) {
positions_of_adds[number_of_adds]=current_position;
add const & expanded_addref=ex_to_add((*cit).rest);
int addref_nops=expanded_addref.nops();
term=expanded_seq;
for (l=0; l<number_of_adds; l++) {
add const & addref=ex_to_add(expanded_seq[positions_of_adds[l]].rest);
- ASSERT(term[positions_of_adds[l]].coeff.compare(exONE())==0);
+ GINAC_ASSERT(term[positions_of_adds[l]].coeff.compare(_ex1())==0);
term[positions_of_adds[l]]=split_ex_to_pair(addref.op(k[l]));
}
/*
status_flags::expanded);
}
-/*
-ex mul::expand(unsigned options) const
-{
- exvector sub_expanded_seq;
- intvector positions_of_adds;
- intvector number_of_add_operands;
-
- sub_expanded_seq.resize(seq.size());
- positions_of_adds.resize(seq.size());
- number_of_add_operands.reserve(seq.size());
-
- int number_of_adds=0;
- int number_of_expanded_terms=1;
- for (unsigned current_position=0; current_position<seq.size(); current_position++) {
- ex const & expanded_ex=recombine_pair_to_ex(seq[current_position]).expand(options);
- if (is_ex_exactly_of_type(expanded_ex,add)) {
- positions_of_adds[number_of_adds]=current_position;
- add const & expanded_addref=ex_to_add(expanded_ex);
- number_of_add_operands[number_of_adds]=expanded_addref.seq.size();
- number_of_expanded_terms *= expanded_addref.seq.size();
- number_of_adds++;
- }
- sub_expanded_seq.push_back(expanded_ex);
- }
-
- exvector distrseq;
- distrseq.reserve(number_of_expanded_terms);
-
- intvector k;
- k.resize(number_of_adds);
-
- int l;
- for (l=0; l<number_of_adds; l++) {
- k[l]=0;
- }
-
- while (1) {
- exvector term;
- term=sub_expanded_seq;
- for (l=0; l<number_of_adds; l++) {
- add const & addref=ex_to_add(sub_expanded_seq[positions_of_adds[l]]);
- term[positions_of_adds[l]]=addref.recombine_pair_to_ex(addref.seq[k[l]]);
- }
- distrseq.push_back((new mul(term))->setflag(status_flags::dynallocated |
- status_flags::expanded));
-
- // increment k[]
- l=number_of_adds-1;
- while ((l>=0)&&((++k[l])>=number_of_add_operands[l])) {
- k[l]=0;
- l--;
- }
- if (l<0) break;
- }
-
- return (new add(distrseq))->setflag(status_flags::dynallocated |
- status_flags::expanded);
-}
-*/
-
//////////
// new virtual functions which can be overridden by derived classes
//////////
const mul some_mul;
type_info const & typeid_mul=typeid(some_mul);
+#ifndef NO_GINAC_NAMESPACE
} // namespace GiNaC
+#endif // ndef NO_GINAC_NAMESPACE
git://www.ginac.de / ginac.git / blobdiff