(Formatting should comply with http://www.cebix.net/indentation.html.)
18 files changed:
{
ex e = expand_dummy_sum(normal(simplify_indexed(e1) - e2), true);
{
ex e = expand_dummy_sum(normal(simplify_indexed(e1) - e2), true);
- for (int j=0; j<4; j++) {
+ for (int j=0; j<4; j++) {
ex esub = e.subs(
is_a<varidx>(mu)
? lst (
ex esub = e.subs(
is_a<varidx>(mu)
? lst (
static unsigned check_equal_simplify_term2(const ex & e1, const ex & e2)
{
static unsigned check_equal_simplify_term2(const ex & e1, const ex & e2)
{
- ex e = expand_dummy_sum(normal(simplify_indexed(e1) - e2), true);
+ ex e = expand_dummy_sum(normal(simplify_indexed(e1) - e2), true);
if (!(canonicalize_clifford(e).is_zero())) {
clog << "simplify_indexed(" << e1 << ") - (" << e2 << ") erroneously returned "
<< canonicalize_clifford(e) << " instead of 0" << endl;
if (!(canonicalize_clifford(e).is_zero())) {
clog << "simplify_indexed(" << e1 << ") - (" << e2 << ") erroneously returned "
<< canonicalize_clifford(e) << " instead of 0" << endl;
ex x1 = exp(2*Pi*I/13).evalf();
ex x2 = exp(24*Pi*I/13).evalf();
ex x1 = exp(2*Pi*I/13).evalf();
ex x2 = exp(24*Pi*I/13).evalf();
- ex r2 = Li(lst(2),lst(x1)).hold().evalf();
+ ex r2 = Li(lst(2),lst(x1)).hold().evalf();
ex r3 = Li(lst(2),lst(x2)).hold().evalf();
if ( abs(r2-conjugate(r3)) > prec ) {
clog << "Legacy test 2 seems to be wrong." << endl;
result++;
}
ex r3 = Li(lst(2),lst(x2)).hold().evalf();
if ( abs(r2-conjugate(r3)) > prec ) {
clog << "Legacy test 2 seems to be wrong." << endl;
result++;
}
- ex x3 = exp(5*Pi*I/3).evalf();
+ ex x3 = exp(5*Pi*I/3).evalf();
ex r4 = Li(lst(3),lst(x3)).hold().evalf();
if ( abs(r4 - numeric("0.40068563438653142847-0.95698384815740185713*I")) > prec ) {
clog << "Legacy test 3 seems to be wrong." << endl;
ex r4 = Li(lst(3),lst(x3)).hold().evalf();
if ( abs(r4 - numeric("0.40068563438653142847-0.95698384815740185713*I")) > prec ) {
clog << "Legacy test 3 seems to be wrong." << endl;
public:
Gamma(ijpair ij = ijpair(0,0)) : vertex(ij) { }
vertex* copy() const { return new Gamma(*this); }
public:
Gamma(ijpair ij = ijpair(0,0)) : vertex(ij) { }
vertex* copy() const { return new Gamma(*this); }
- ijpair get_increment() const { return ijpair(indices.first+indices.second+1, 0); }
+ ijpair get_increment() const { return ijpair(indices.first+indices.second+1, 0); }
const ex evaluate(const symbol &x, const unsigned grad) const;
private:
};
const ex evaluate(const symbol &x, const unsigned grad) const;
private:
};
static unsigned test_tree(const node tree_generator(unsigned))
{
const int edges = tree_generator(0).total_edges();
static unsigned test_tree(const node tree_generator(unsigned))
{
const int edges = tree_generator(0).total_edges();
- const int vertices = edges+1;
+ const int vertices = edges+1;
// fill a vector of all possible 2^edges combinations of cuts...
vector<node> counter;
// fill a vector of all possible 2^edges combinations of cuts...
vector<node> counter;
epvector::const_iterator i = seq.begin(), end = seq.end();
while (i != end) {
ex restcoeff = i->rest.coeff(s, n);
epvector::const_iterator i = seq.begin(), end = seq.end();
while (i != end) {
ex restcoeff = i->rest.coeff(s, n);
- if (!restcoeff.is_zero()) {
- if (do_clifford) {
- if (clifford_max_label(restcoeff) == -1) {
- coeffseq_cliff->push_back(combine_ex_with_coeff_to_pair(ncmul(restcoeff, dirac_ONE(rl)), i->coeff));
+ if (!restcoeff.is_zero()) {
+ if (do_clifford) {
+ if (clifford_max_label(restcoeff) == -1) {
+ coeffseq_cliff->push_back(combine_ex_with_coeff_to_pair(ncmul(restcoeff, dirac_ONE(rl)), i->coeff));
- coeffseq_cliff->push_back(combine_ex_with_coeff_to_pair(restcoeff, i->coeff));
+ coeffseq_cliff->push_back(combine_ex_with_coeff_to_pair(restcoeff, i->coeff));
}
coeffseq->push_back(combine_ex_with_coeff_to_pair(restcoeff, i->coeff));
}
}
coeffseq->push_back(combine_ex_with_coeff_to_pair(restcoeff, i->coeff));
}
throw(std::range_error(std::string("basic::op(): ") + class_name() + std::string(" has no operands")));
}
throw(std::range_error(std::string("basic::op(): ") + class_name() + std::string(" has no operands")));
}
-/** Return modifyable operand/member at position i. */
+/** Return modifiable operand/member at position i. */
ex & basic::let_op(size_t i)
{
ensure_if_modifiable();
ex & basic::let_op(size_t i)
{
ensure_if_modifiable();
GINAC_ASSERT(i<nops());
static ex rl = numeric(representation_label);
GINAC_ASSERT(i<nops());
static ex rl = numeric(representation_label);
- ensure_if_modifiable();
+ ensure_if_modifiable();
if (nops()-i == 1)
return rl;
else
if (nops()-i == 1)
return rl;
else
return trONE * I * (lorentz_eps(ex_to<idx>(i1).replace_dim(_ex4), ex_to<idx>(i2).replace_dim(_ex4), ex_to<idx>(i3).replace_dim(_ex4), ex_to<idx>(i4).replace_dim(_ex4)) * b1 * b2 * b3 * b4).simplify_indexed();
}
return trONE * I * (lorentz_eps(ex_to<idx>(i1).replace_dim(_ex4), ex_to<idx>(i2).replace_dim(_ex4), ex_to<idx>(i3).replace_dim(_ex4), ex_to<idx>(i4).replace_dim(_ex4)) * b1 * b2 * b3 * b4).simplify_indexed();
}
// I/4! * epsilon0123.mu1.mu2.mu3.mu4 * Tr gamma.mu1 gamma.mu2 gamma.mu3 gamma.mu4 S_2k
// (the epsilon is always 4-dimensional)
exvector ix(num-1), bv(num-1);
// I/4! * epsilon0123.mu1.mu2.mu3.mu4 * Tr gamma.mu1 gamma.mu2 gamma.mu3 gamma.mu4 S_2k
// (the epsilon is always 4-dimensional)
exvector ix(num-1), bv(num-1);
return v.op(0) * dirac_ONE(ex_to<clifford>(e).get_representation_label()) + indexed(sub_matrix(ex_to<matrix>(v), 0, 1, 1, dim), mu_toggle) * e;
else
return v.op(0) * dirac_ONE(ex_to<clifford>(e).get_representation_label()) + indexed(sub_matrix(ex_to<matrix>(v), 1, dim, 0, 1), mu_toggle) * e;
return v.op(0) * dirac_ONE(ex_to<clifford>(e).get_representation_label()) + indexed(sub_matrix(ex_to<matrix>(v), 0, 1, 1, dim), mu_toggle) * e;
else
return v.op(0) * dirac_ONE(ex_to<clifford>(e).get_representation_label()) + indexed(sub_matrix(ex_to<matrix>(v), 1, dim, 0, 1), mu_toggle) * e;
throw(std::invalid_argument("lst_to_clifford(): dimensions of vector and clifford unit mismatch"));
} else
throw(std::invalid_argument("lst_to_clifford(): first argument should be a vector (nx1 or 1xn matrix)"));
throw(std::invalid_argument("lst_to_clifford(): dimensions of vector and clifford unit mismatch"));
} else
throw(std::invalid_argument("lst_to_clifford(): first argument should be a vector (nx1 or 1xn matrix)"));
} else
throw(std::invalid_argument("lst_to_clifford(): the second argument should be a Clifford unit"));
}
} else
throw(std::invalid_argument("lst_to_clifford(): the second argument should be a Clifford unit"));
}
/** Auxiliary structure to define a function for striping one Clifford unit
* from vectors. Used in clifford_to_lst(). */
static ex get_clifford_comp(const ex & e, const ex & c)
/** Auxiliary structure to define a function for striping one Clifford unit
* from vectors. Used in clifford_to_lst(). */
static ex get_clifford_comp(const ex & e, const ex & c)
-/** Return modifyable operand/member at position i. */
+/** Return modifiable operand/member at position i. */
ex & ex::let_op(size_t i)
{
makewriteable();
ex & ex::let_op(size_t i)
{
makewriteable();
* has (at least) two possible different semantics but we want to inherit
* methods thus avoiding code duplication. Sometimes a method in expairseq
* has to create a new one of the same semantics, which cannot be done by a
* has (at least) two possible different semantics but we want to inherit
* methods thus avoiding code duplication. Sometimes a method in expairseq
* has to create a new one of the same semantics, which cannot be done by a
- * ctor because the name (add, mul,...) is unknown on the expaiseq level. In
+ * ctor because the name (add, mul,...) is unknown on the expairseq level. In
* order for this trick to work a derived class must of course override this
* definition. */
ex expairseq::thisexpairseq(const epvector &v, const ex &oc, bool do_index_renaming) const
* order for this trick to work a derived class must of course override this
* definition. */
ex expairseq::thisexpairseq(const epvector &v, const ex &oc, bool do_index_renaming) const
return ((log(_ex1+arg)-log(_ex1-arg))*_ex1_2).series(rel, order, options);
// ...and the branch cuts (the discontinuity at the cut being just I*Pi)
if (!(options & series_options::suppress_branchcut)) {
return ((log(_ex1+arg)-log(_ex1-arg))*_ex1_2).series(rel, order, options);
// ...and the branch cuts (the discontinuity at the cut being just I*Pi)
if (!(options & series_options::suppress_branchcut)) {
- // method:
- // This is the branch cut: assemble the primitive series manually and
- // then add the corresponding complex step function.
- const symbol &s = ex_to<symbol>(rel.lhs());
- const ex &point = rel.rhs();
- const symbol foo;
- const ex replarg = series(atanh(arg), s==foo, order).subs(foo==point, subs_options::no_pattern);
+ // method:
+ // This is the branch cut: assemble the primitive series manually and
+ // then add the corresponding complex step function.
+ const symbol &s = ex_to<symbol>(rel.lhs());
+ const ex &point = rel.rhs();
+ const symbol foo;
+ const ex replarg = series(atanh(arg), s==foo, order).subs(foo==point, subs_options::no_pattern);
ex Order0correction = replarg.op(0)+csgn(I*arg)*Pi*I*_ex1_2;
if (arg_pt<_ex0)
Order0correction += log((arg_pt+_ex_1)/(arg_pt+_ex1))*_ex1_2;
else
Order0correction += log((arg_pt+_ex1)/(arg_pt+_ex_1))*_ex_1_2;
ex Order0correction = replarg.op(0)+csgn(I*arg)*Pi*I*_ex1_2;
if (arg_pt<_ex0)
Order0correction += log((arg_pt+_ex_1)/(arg_pt+_ex1))*_ex1_2;
else
Order0correction += log((arg_pt+_ex1)/(arg_pt+_ex_1))*_ex_1_2;
seq.push_back(expair(Order0correction, _ex0));
seq.push_back(expair(Order0correction, _ex0));
- seq.push_back(expair(Order(_ex1), order));
- return series(replarg - pseries(rel, seq), rel, order);
+ seq.push_back(expair(Order(_ex1), order));
+ return series(replarg - pseries(rel, seq), rel, order);
- if (are_ex_trivially_equal(eintvar,x) && are_ex_trivially_equal(ea,a)
- && are_ex_trivially_equal(eb,b) && are_ex_trivially_equal(ef,f))
+ if (are_ex_trivially_equal(eintvar,x) && are_ex_trivially_equal(ea,a) &&
+ are_ex_trivially_equal(eb,b) && are_ex_trivially_equal(ef,f))
return this->hold();
return (new integral(eintvar, ea, eb, ef))
->setflag(status_flags::dynallocated | status_flags::evaluated);
return this->hold();
return (new integral(eintvar, ea, eb, ef))
->setflag(status_flags::dynallocated | status_flags::evaluated);
// 12.34 is just an arbitrary number used to check whether a number
// results after substituting a number for the integration variable.
// 12.34 is just an arbitrary number used to check whether a number
// results after substituting a number for the integration variable.
- if (is_exactly_a<numeric>(ea) && is_exactly_a<numeric>(eb)
- && is_exactly_a<numeric>(ef.subs(x==12.34).evalf())) {
+ if (is_exactly_a<numeric>(ea) && is_exactly_a<numeric>(eb) &&
+ is_exactly_a<numeric>(ef.subs(x==12.34).evalf())) {
return adaptivesimpson(x, ea, eb, ef);
}
return adaptivesimpson(x, ea, eb, ef);
}
- if (are_ex_trivially_equal(a, ea) && are_ex_trivially_equal(b, eb)
- && are_ex_trivially_equal(f, ef))
+ if (are_ex_trivially_equal(a, ea) && are_ex_trivially_equal(b, eb) &&
+ are_ex_trivially_equal(f, ef))
return *this;
else
return (new integral(x, ea, eb, ef))
return *this;
else
return (new integral(x, ea, eb, ef))
return (prefactor*integral(x, newa, newb, rest)).expand(options);
}
return (prefactor*integral(x, newa, newb, rest)).expand(options);
}
- if (are_ex_trivially_equal(a, newa) && are_ex_trivially_equal(b, newb)
- && are_ex_trivially_equal(f, newf)) {
+ if (are_ex_trivially_equal(a, newa) && are_ex_trivially_equal(b, newb) &&
+ are_ex_trivially_equal(f, newf)) {
if (options==0)
this->setflag(status_flags::expanded);
return *this;
if (options==0)
this->setflag(status_flags::expanded);
return *this;
ex conjb = b.conjugate();
ex conjf = f.conjugate().subs(x.conjugate()==x);
ex conjb = b.conjugate();
ex conjf = f.conjugate().subs(x.conjugate()==x);
- if (are_ex_trivially_equal(a, conja) && are_ex_trivially_equal(b, conjb)
- && are_ex_trivially_equal(f, conjf))
+ if (are_ex_trivially_equal(a, conja) && are_ex_trivially_equal(b, conjb) &&
+ are_ex_trivially_equal(f, conjf))
return *this;
return (new integral(x, conja, conjb, conjf))
return *this;
return (new integral(x, conja, conjb, conjf))
bool mul::has(const ex & pattern, unsigned options) const
{
bool mul::has(const ex & pattern, unsigned options) const
{
- if(!(options&has_options::algebraic))
+ if(!(options & has_options::algebraic))
return basic::has(pattern,options);
if(is_a<mul>(pattern)) {
exmap repls;
return basic::has(pattern,options);
if(is_a<mul>(pattern)) {
exmap repls;
// ncmul(x) -> x
if (assocseq.size()==1) return *(seq.begin());
// ncmul(x) -> x
if (assocseq.size()==1) return *(seq.begin());
// ncmul() -> 1
if (assocseq.empty()) return _ex1;
// ncmul() -> 1
if (assocseq.empty()) return _ex1;
GINAC_ASSERT(!all_commutative); // not all factors should commutate, because this is a ncmul();
return all_commutative ? return_types::commutative : return_types::noncommutative;
}
GINAC_ASSERT(!all_commutative); // not all factors should commutate, because this is a ncmul();
return all_commutative ? return_types::commutative : return_types::noncommutative;
}
return_type_t ncmul::return_type_tinfo() const
{
if (seq.empty())
return_type_t ncmul::return_type_tinfo() const
{
if (seq.empty())
if (ca)
*ca = ex_to<numeric>(aex)/g;
if (cb)
if (ca)
*ca = ex_to<numeric>(aex)/g;
if (cb)
{
if (cln::instanceof(x, cln::cl_I_ring)) {
{
if (cln::instanceof(x, cln::cl_I_ring)) {
- int dst;
- // fixnum
- if (coerce(dst, cln::the<cln::cl_I>(x))) {
- // can be converted to native int
- if (dst < 0)
- c.s << "(-" << dst << ")";
- else
- c.s << dst;
- } else {
- // bignum
- c.s << "cln::cl_I(\"";
- print_real_number(c, x);
- c.s << "\")";
- }
+ int dst;
+ // fixnum
+ if (coerce(dst, cln::the<cln::cl_I>(x))) {
+ // can be converted to native int
+ if (dst < 0)
+ c.s << "(-" << dst << ")";
+ else
+ c.s << dst;
+ } else {
+ // bignum
+ c.s << "cln::cl_I(\"";
+ print_real_number(c, x);
+ c.s << "\")";
+ }
} else if (cln::instanceof(x, cln::cl_RA_ring)) {
// Rational number
} else if (cln::instanceof(x, cln::cl_RA_ring)) {
// Rational number
if (cln::instanceof(r, cln::cl_RA_ring) && cln::instanceof(i, cln::cl_RA_ring)) {
const cln::cl_I s = cln::lcm(cln::denominator(r), cln::denominator(i));
return numeric(cln::complex(cln::numerator(r)*(cln::exquo(s,cln::denominator(r))),
if (cln::instanceof(r, cln::cl_RA_ring) && cln::instanceof(i, cln::cl_RA_ring)) {
const cln::cl_I s = cln::lcm(cln::denominator(r), cln::denominator(i));
return numeric(cln::complex(cln::numerator(r)*(cln::exquo(s,cln::denominator(r))),
- cln::numerator(i)*(cln::exquo(s,cln::denominator(i)))));
+ cln::numerator(i)*(cln::exquo(s,cln::denominator(i)))));
}
}
// at least one float encountered
}
}
// at least one float encountered
return *_num0_p;
if (x.is_real() && y.is_real())
return numeric(cln::atan(cln::the<cln::cl_R>(x.to_cl_N()),
return *_num0_p;
if (x.is_real() && y.is_real())
return numeric(cln::atan(cln::the<cln::cl_R>(x.to_cl_N()),
- cln::the<cln::cl_R>(y.to_cl_N())));
+ cln::the<cln::cl_R>(y.to_cl_N())));
// Compute -I*log((x+I*y)/sqrt(x^2+y^2))
// == -I*log((x+I*y)/sqrt((x+I*y)*(x-I*y)))
// Compute -I*log((x+I*y)/sqrt(x^2+y^2))
// == -I*log((x+I*y)/sqrt((x+I*y)*(x-I*y)))
{
cln::cl_N A = (*current_vector)[0];
int size = current_vector->size();
{
cln::cl_N A = (*current_vector)[0];
int size = current_vector->size();
- for (int i=1; i<size; ++i)
- A = A + (*current_vector)[i]/(x+cln::cl_I(-1+i));
+ for (int i=1; i<size; ++i)
+ A = A + (*current_vector)[i]/(x+cln::cl_I(-1+i));
- lgamma(1 - x);
cln::cl_N A = lc.calc_lanczos_A(x);
cln::cl_N temp = x + lc.get_order() - cln::cl_N(1)/2;
- lgamma(1 - x);
cln::cl_N A = lc.calc_lanczos_A(x);
cln::cl_N temp = x + lc.get_order() - cln::cl_N(1)/2;
- cln::cl_N result = log(cln::cl_I(2)*pi_val)/2
- + (x-cln::cl_N(1)/2)*log(temp)
- - temp
- + log(A);
- return result;
+ cln::cl_N result = log(cln::cl_I(2)*pi_val)/2
+ + (x-cln::cl_N(1)/2)*log(temp)
+ - temp
+ + log(A);
+ return result;
return pi_val/(cln::sin(pi_val*x))/tgamma(1 - x);
cln::cl_N A = lc.calc_lanczos_A(x);
cln::cl_N temp = x + lc.get_order() - cln::cl_N(1)/2;
return pi_val/(cln::sin(pi_val*x))/tgamma(1 - x);
cln::cl_N A = lc.calc_lanczos_A(x);
cln::cl_N temp = x + lc.get_order() - cln::cl_N(1)/2;
- cln::cl_N result
- = sqrt(cln::cl_I(2)*pi_val) * expt(temp, x - cln::cl_N(1)/2)
- * exp(-temp) * A;
- return result;
+ cln::cl_N result = sqrt(cln::cl_I(2)*pi_val)
+ * expt(temp, x - cln::cl_N(1)/2)
+ * exp(-temp) * A;
+ return result;
c = cln::exquo((c * (p+3-2*k)) * (p/2-k+1), cln::cl_I(2*k-1)*k);
b = b + c*results[k-1];
}
c = cln::exquo((c * (p+3-2*k)) * (p/2-k+1), cln::cl_I(2*k-1)*k);
b = b + c*results[k-1];
}
results.push_back(-b/(p+1));
}
next_r = n+2;
results.push_back(-b/(p+1));
}
next_r = n+2;
void power::do_print_csrc(const print_csrc & c, unsigned level) const
{
// Integer powers of symbols are printed in a special, optimized way
void power::do_print_csrc(const print_csrc & c, unsigned level) const
{
// Integer powers of symbols are printed in a special, optimized way
- if (exponent.info(info_flags::integer)
- && (is_a<symbol>(basis) || is_a<constant>(basis))) {
+ if (exponent.info(info_flags::integer) &&
+ (is_a<symbol>(basis) || is_a<constant>(basis))) {
int exp = ex_to<numeric>(exponent).to_int();
if (exp > 0)
c.s << '(';
int exp = ex_to<numeric>(exponent).to_int();
if (exp > 0)
c.s << '(';
if (is_exactly_a<numeric>(sub_exponent)) {
const numeric & num_sub_exponent = ex_to<numeric>(sub_exponent);
GINAC_ASSERT(num_sub_exponent!=numeric(1));
if (is_exactly_a<numeric>(sub_exponent)) {
const numeric & num_sub_exponent = ex_to<numeric>(sub_exponent);
GINAC_ASSERT(num_sub_exponent!=numeric(1));
- if (num_exponent->is_integer() || (abs(num_sub_exponent) - (*_num1_p)).is_negative()
- || (num_sub_exponent == *_num_1_p && num_exponent->is_positive())) {
+ if (num_exponent->is_integer() || (abs(num_sub_exponent) - (*_num1_p)).is_negative() ||
+ (num_sub_exponent == *_num_1_p && num_exponent->is_positive())) {
return power(sub_basis,num_sub_exponent.mul(*num_exponent));
}
}
return power(sub_basis,num_sub_exponent.mul(*num_exponent));
}
}
return basic::has(other, options);
if (!is_a<power>(other))
return basic::has(other, options);
return basic::has(other, options);
if (!is_a<power>(other))
return basic::has(other, options);
- if (!exponent.info(info_flags::integer)
- || !other.op(1).info(info_flags::integer))
+ if (!exponent.info(info_flags::integer) ||
+ !other.op(1).info(info_flags::integer))
return basic::has(other, options);
return basic::has(other, options);
- if (exponent.info(info_flags::posint)
- && other.op(1).info(info_flags::posint)
- && ex_to<numeric>(exponent) > ex_to<numeric>(other.op(1))
- && basis.match(other.op(0)))
+ if (exponent.info(info_flags::posint) &&
+ other.op(1).info(info_flags::posint) &&
+ ex_to<numeric>(exponent) > ex_to<numeric>(other.op(1)) &&
+ basis.match(other.op(0)))
- if (exponent.info(info_flags::negint)
- && other.op(1).info(info_flags::negint)
- && ex_to<numeric>(exponent) < ex_to<numeric>(other.op(1))
- && basis.match(other.op(0)))
+ if (exponent.info(info_flags::negint) &&
+ other.op(1).info(info_flags::negint) &&
+ ex_to<numeric>(exponent) < ex_to<numeric>(other.op(1)) &&
+ basis.match(other.op(0)))
return true;
return basic::has(other, options);
}
return true;
return basic::has(other, options);
}
}
// do not bother to rename indices if there are no any.
}
// do not bother to rename indices if there are no any.
- if ((!(options & expand_options::expand_rename_idx))
- && m.info(info_flags::has_indices))
+ if (!(options & expand_options::expand_rename_idx) &&
+ m.info(info_flags::has_indices))
options |= expand_options::expand_rename_idx;
// Leave it to multiplication since dummy indices have to be renamed
if ((options & expand_options::expand_rename_idx) &&
options |= expand_options::expand_rename_idx;
// Leave it to multiplication since dummy indices have to be renamed
if ((options & expand_options::expand_rename_idx) &&
- (get_all_dummy_indices(m).size() > 0) && n.is_positive()) {
+ (get_all_dummy_indices(m).size() > 0) && n.is_positive()) {
ex result = m;
exvector va = get_all_dummy_indices(m);
sort(va.begin(), va.end(), ex_is_less());
ex result = m;
exvector va = get_all_dummy_indices(m);
sort(va.begin(), va.end(), ex_is_less());
orderloop++;
real_ldegree = buf.series(r, orderloop, options).ldegree(sym);
} while ((real_ldegree == orderloop)
orderloop++;
real_ldegree = buf.series(r, orderloop, options).ldegree(sym);
} while ((real_ldegree == orderloop)
- && ( factor*real_ldegree < degbound));
+ && (factor*real_ldegree < degbound));
ldegrees[j] = factor * real_ldegree;
degbound -= factor * real_ldegree;
}
ldegrees[j] = factor * real_ldegree;
degbound -= factor * real_ldegree;
}
GINAC_ASSERT(lh.return_type()==rh.return_type());
return lh.return_type();
}
GINAC_ASSERT(lh.return_type()==rh.return_type());
return lh.return_type();
}
return_type_t relational::return_type_tinfo() const
{
GINAC_ASSERT(lh.return_type_tinfo()==rh.return_type_tinfo());
return_type_t relational::return_type_tinfo() const
{
GINAC_ASSERT(lh.return_type_tinfo()==rh.return_type_tinfo());
break;
case greater:
case greater_or_equal:
break;
case greater:
case greater_or_equal:
}
default:
throw(std::logic_error("remember_table_list::add_entry(): invalid remember_strategy"));
}
default:
throw(std::logic_error("remember_table_list::add_entry(): invalid remember_strategy"));
GINAC_ASSERT(size()==max_assoc_size-1);
}
push_back(remember_table_entry(f,result));
GINAC_ASSERT(size()==max_assoc_size-1);
}
push_back(remember_table_entry(f,result));