// other ctors
//////////
-power::power(const ex & lh, const ex & rh) : inherited(TINFO_power), basis(lh), exponent(rh)
-{
- debugmsg("power ctor from ex,ex",LOGLEVEL_CONSTRUCT);
-}
-
-/** Ctor from an ex and a bare numeric. This is somewhat more efficient than
- * the normal ctor from two ex whenever it can be used. */
-power::power(const ex & lh, const numeric & rh) : inherited(TINFO_power), basis(lh), exponent(rh)
-{
- debugmsg("power ctor from ex,numeric",LOGLEVEL_CONSTRUCT);
-}
+// all inlined
//////////
// archiving
DEFAULT_UNARCHIVE(power)
//////////
-// functions overriding virtual functions from bases classes
+// functions overriding virtual functions from base classes
//////////
// public
bool basis_is_numerical = false;
bool exponent_is_numerical = false;
- numeric * num_basis;
- numeric * num_exponent;
+ const numeric *num_basis;
+ const numeric *num_exponent;
if (is_exactly_of_type(*ebasis.bp,numeric)) {
basis_is_numerical = true;
- num_basis = static_cast<numeric *>(ebasis.bp);
+ num_basis = static_cast<const numeric *>(ebasis.bp);
}
if (is_exactly_of_type(*eexponent.bp,numeric)) {
exponent_is_numerical = true;
- num_exponent = static_cast<numeric *>(eexponent.bp);
+ num_exponent = static_cast<const numeric *>(eexponent.bp);
}
// ^(x,0) -> 1 (0^0 also handled here)
// ^(x,1) -> x
if (eexponent.is_equal(_ex1()))
return ebasis;
-
+
// ^(0,c1) -> 0 or exception (depending on real value of c1)
if (ebasis.is_zero() && exponent_is_numerical) {
if ((num_exponent->real()).is_zero())
else
return _ex0();
}
-
+
// ^(1,x) -> 1
if (ebasis.is_equal(_ex1()))
return _ex1();
-
+
if (exponent_is_numerical) {
// ^(c1,c2) -> c1^c2 (c1, c2 numeric(),
// except if c1,c2 are rational, but c1^c2 is not)
if (basis_is_numerical) {
- bool basis_is_crational = num_basis->is_crational();
- bool exponent_is_crational = num_exponent->is_crational();
- numeric res = num_basis->power(*num_exponent);
-
- if ((!basis_is_crational || !exponent_is_crational)
- || res.is_crational()) {
+ const bool basis_is_crational = num_basis->is_crational();
+ const bool exponent_is_crational = num_exponent->is_crational();
+ if (!basis_is_crational || !exponent_is_crational) {
+ // return a plain float
+ return (new numeric(num_basis->power(*num_exponent)))->setflag(status_flags::dynallocated |
+ status_flags::evaluated |
+ status_flags::expanded);
+ }
+
+ const numeric res = num_basis->power(*num_exponent);
+ if (res.is_crational()) {
return res;
}
GINAC_ASSERT(!num_exponent->is_integer()); // has been handled by now
- // ^(c1,n/m) -> *(c1^q,c1^(n/m-q)), 0<(n/m-h)<1, q integer
+ // ^(c1,n/m) -> *(c1^q,c1^(n/m-q)), 0<(n/m-q)<1, q integer
if (basis_is_crational && exponent_is_crational
- && num_exponent->is_real()
- && !num_exponent->is_integer()) {
- numeric n = num_exponent->numer();
- numeric m = num_exponent->denom();
+ && num_exponent->is_real()
+ && !num_exponent->is_integer()) {
+ const numeric n = num_exponent->numer();
+ const numeric m = num_exponent->denom();
numeric r;
numeric q = iquo(n, m, r);
if (r.is_negative()) {
- r = r.add(m);
- q = q.sub(_num1());
+ r += m;
+ --q;
}
- if (q.is_zero()) // the exponent was in the allowed range 0<(n/m)<1
+ if (q.is_zero()) { // the exponent was in the allowed range 0<(n/m)<1
+ if (num_basis->is_rational() && !num_basis->is_integer()) {
+ // try it for numerator and denominator separately, in order to
+ // partially simplify things like (5/8)^(1/3) -> 1/2*5^(1/3)
+ const numeric bnum = num_basis->numer();
+ const numeric bden = num_basis->denom();
+ const numeric res_bnum = bnum.power(*num_exponent);
+ const numeric res_bden = bden.power(*num_exponent);
+ if (res_bnum.is_integer())
+ return (new mul(power(bden,-*num_exponent),res_bnum))->setflag(status_flags::dynallocated | status_flags::evaluated);
+ if (res_bden.is_integer())
+ return (new mul(power(bnum,*num_exponent),res_bden.inverse()))->setflag(status_flags::dynallocated | status_flags::evaluated);
+ }
return this->hold();
- else {
- epvector res;
- res.push_back(expair(ebasis,r.div(m)));
- return (new mul(res,ex(num_basis->power_dyn(q))))->setflag(status_flags::dynallocated | status_flags::evaluated);
+ } else {
+ // assemble resulting product, but allowing for a re-evaluation,
+ // because otherwise we'll end up with something like
+ // (7/8)^(4/3) -> 7/8*(1/2*7^(1/3))
+ // instead of 7/16*7^(1/3).
+ ex prod = power(*num_basis,r.div(m));
+ return prod*power(*num_basis,q);
}
}
}
const numeric & num_coeff = ex_to<numeric>(mulref.overall_coeff);
if (num_coeff.is_real()) {
if (num_coeff.is_positive()) {
- mul * mulp = new mul(mulref);
+ mul *mulp = new mul(mulref);
mulp->overall_coeff = _ex1();
mulp->clearflag(status_flags::evaluated);
mulp->clearflag(status_flags::hash_calculated);
} else {
GINAC_ASSERT(num_coeff.compare(_num0())<0);
if (num_coeff.compare(_num_1())!=0) {
- mul * mulp = new mul(mulref);
+ mul *mulp = new mul(mulref);
mulp->overall_coeff = _ex_1();
mulp->clearflag(status_flags::evaluated);
mulp->clearflag(status_flags::hash_calculated);
}
if (are_ex_trivially_equal(ebasis,basis) &&
- are_ex_trivially_equal(eexponent,exponent)) {
+ are_ex_trivially_equal(eexponent,exponent)) {
return this->hold();
}
return (new power(ebasis, eexponent))->setflag(status_flags::dynallocated |
- status_flags::evaluated);
+ status_flags::evaluated);
}
ex power::evalf(int level) const
{
debugmsg("power evalf",LOGLEVEL_MEMBER_FUNCTION);
-
+
ex ebasis;
ex eexponent;
ex power::evalm(void) const
{
- ex ebasis = basis.evalm();
- ex eexponent = exponent.evalm();
+ const ex ebasis = basis.evalm();
+ const ex eexponent = exponent.evalm();
if (is_ex_of_type(ebasis,matrix)) {
if (is_ex_of_type(eexponent,numeric)) {
return (new matrix(ex_to<matrix>(ebasis).pow(eexponent)))->setflag(status_flags::dynallocated);
if (options == 0 && (flags & status_flags::expanded))
return *this;
- ex expanded_basis = basis.expand(options);
- ex expanded_exponent = exponent.expand(options);
+ const ex expanded_basis = basis.expand(options);
+ const ex expanded_exponent = exponent.expand(options);
// x^(a+b) -> x^a * x^b
if (is_ex_exactly_of_type(expanded_exponent, add)) {
upper_limit[l] = n;
}
- while (1) {
+ while (true) {
exvector term;
term.reserve(m+1);
for (l=0; l<m-1; l++) {
term.push_back(f);
- /*
- cout << "begin term" << endl;
- for (int i=0; i<m-1; i++) {
- cout << "k[" << i << "]=" << k[i] << endl;
- cout << "k_cum[" << i << "]=" << k_cum[i] << endl;
- cout << "upper_limit[" << i << "]=" << upper_limit[i] << endl;
- }
- for_each(term.begin(), term.end(), ostream_iterator<ex>(cout, "\n"));
- cout << "end term" << endl;
- */
-
- // TODO: optimize this
+ // TODO: Can we optimize this? Alex seemed to think so...
sum.push_back((new mul(term))->setflag(status_flags::dynallocated));
// increment k[]
l = m-2;
- while ((l>=0)&&((++k[l])>upper_limit[l])) {
+ while ((l>=0) && ((++k[l])>upper_limit[l])) {
k[l] = 0;
--l;
}
upper_limit[i] = n-k_cum[i-1];
}
return (new add(sum))->setflag(status_flags::dynallocated |
- status_flags::expanded );
+ status_flags::expanded );
}
// power(+(x,...,z;c),2)=power(+(x,...,z;0),2)+2*c*+(x,...,z;0)+c*c
// first part: ignore overall_coeff and expand other terms
for (epvector::const_iterator cit0=a.seq.begin(); cit0!=last; ++cit0) {
- const ex & r = (*cit0).rest;
- const ex & c = (*cit0).coeff;
+ const ex & r = cit0->rest;
+ const ex & c = cit0->coeff;
GINAC_ASSERT(!is_ex_exactly_of_type(r,add));
GINAC_ASSERT(!is_ex_exactly_of_type(r,power) ||
}
for (epvector::const_iterator cit1=cit0+1; cit1!=last; ++cit1) {
- const ex & r1 = (*cit1).rest;
- const ex & c1 = (*cit1).coeff;
+ const ex & r1 = cit1->rest;
+ const ex & c1 = cit1->coeff;
sum.push_back(a.combine_ex_with_coeff_to_pair((new mul(r,r1))->setflag(status_flags::dynallocated),
_num2().mul(ex_to<numeric>(c)).mul_dyn(ex_to<numeric>(c1))));
}
return (new mul(distrseq,ex_to<numeric>(m.overall_coeff).power_dyn(n)))->setflag(status_flags::dynallocated);
}
-/*
-ex power::expand_noncommutative(const ex & basis, const numeric & exponent,
- unsigned options) const
-{
- ex rest_power = ex(power(basis,exponent.add(_num_1()))).
- expand(options | expand_options::internal_do_not_expand_power_operands);
-
- return ex(mul(rest_power,basis),0).
- expand(options | expand_options::internal_do_not_expand_mul_operands);
-}
-*/
-
// helper function
ex sqrt(const ex & a)
git://www.ginac.de / ginac.git / blobdiff