ginac/add.cpp

   1 /** @file add.cpp
   2  *
   3  *  Implementation of GiNaC's sums of expressions. */
   4
   5 /*
   6  *  GiNaC Copyright (C) 1999-2001 Johannes Gutenberg University Mainz, Germany
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include <iostream>
  24 #include <stdexcept>
  25
  26 #include "add.h"
  27 #include "mul.h"
  28 #include "archive.h"
  29 #include "debugmsg.h"
  30 #include "utils.h"
  31
  32 namespace GiNaC {
  33
  34 GINAC_IMPLEMENT_REGISTERED_CLASS(add, expairseq)
  35
  36 //////////
  37 // default constructor, destructor, copy constructor assignment operator and helpers
  38 //////////
  39
  40 add::add()
  41 {
  42         debugmsg("add default constructor",LOGLEVEL_CONSTRUCT);
  43         tinfo_key = TINFO_add;
  44 }
  45
  46 DEFAULT_COPY(add)
  47 DEFAULT_DESTROY(add)
  48
  49 //////////
  50 // other constructors
  51 //////////
  52
  53 // public
  54
  55 add::add(const ex & lh, const ex & rh)
  56 {
  57         debugmsg("add constructor from ex,ex",LOGLEVEL_CONSTRUCT);
  58         tinfo_key = TINFO_add;
  59         overall_coeff = _ex0();
  60         construct_from_2_ex(lh,rh);
  61         GINAC_ASSERT(is_canonical());
  62 }
  63
  64 add::add(const exvector & v)
  65 {
  66         debugmsg("add constructor from exvector",LOGLEVEL_CONSTRUCT);
  67         tinfo_key = TINFO_add;
  68         overall_coeff = _ex0();
  69         construct_from_exvector(v);
  70         GINAC_ASSERT(is_canonical());
  71 }
  72
  73 add::add(const epvector & v)
  74 {
  75         debugmsg("add constructor from epvector",LOGLEVEL_CONSTRUCT);
  76         tinfo_key = TINFO_add;
  77         overall_coeff = _ex0();
  78         construct_from_epvector(v);
  79         GINAC_ASSERT(is_canonical());
  80 }
  81
  82 add::add(const epvector & v, const ex & oc)
  83 {
  84         debugmsg("add constructor from epvector,ex",LOGLEVEL_CONSTRUCT);
  85         tinfo_key = TINFO_add;
  86         overall_coeff = oc;
  87         construct_from_epvector(v);
  88         GINAC_ASSERT(is_canonical());
  89 }
  90
  91 add::add(epvector * vp, const ex & oc)
  92 {
  93         debugmsg("add constructor from epvector *,ex",LOGLEVEL_CONSTRUCT);
  94         tinfo_key = TINFO_add;
  95         GINAC_ASSERT(vp!=0);
  96         overall_coeff = oc;
  97         construct_from_epvector(*vp);
  98         delete vp;
  99         GINAC_ASSERT(is_canonical());
 100 }
 101
 102 //////////
 103 // archiving
 104 //////////
 105
 106 DEFAULT_ARCHIVING(add)
 107
 108 //////////
 109 // functions overriding virtual functions from bases classes
 110 //////////
 111
 112 // public
 113
 114 void add::print(const print_context & c, unsigned level) const
 115 {
 116         debugmsg("add print", LOGLEVEL_PRINT);
 117
 118         if (is_of_type(c, print_tree)) {
 119
 120                 inherited::print(c, level);
 121
 122         } else if (is_of_type(c, print_csrc)) {
 123
 124                 if (precedence <= level)
 125                         c.s << "(";
 126
 127                 // Print arguments, separated by "+"
 128                 epvector::const_iterator it = seq.begin(), itend = seq.end();
 129                 while (it != itend) {
 130
 131                         // If the coefficient is -1, it is replaced by a single minus sign
 132                         if (it->coeff.compare(_num1()) == 0) {
 133                                 it->rest.bp->print(c, precedence);
 134                         } else if (it->coeff.compare(_num_1()) == 0) {
 135                                 c.s << "-";
 136                                 it->rest.bp->print(c, precedence);
 137                         } else if (ex_to_numeric(it->coeff).numer().compare(_num1()) == 0) {
 138                                 it->rest.bp->print(c, precedence);
 139                                 c.s << "/";
 140                                 ex_to_numeric(it->coeff).denom().print(c, precedence);
 141                         } else if (ex_to_numeric(it->coeff).numer().compare(_num_1()) == 0) {
 142                                 c.s << "-";
 143                                 it->rest.bp->print(c, precedence);
 144                                 c.s << "/";
 145                                 ex_to_numeric(it->coeff).denom().print(c, precedence);
 146                         } else {
 147                                 it->coeff.bp->print(c, precedence);
 148                                 c.s << "*";
 149                                 it->rest.bp->print(c, precedence);
 150                         }
 151
 152                         // Separator is "+", except if the following expression would have a leading minus sign
 153                         it++;
 154                         if (it != itend && !(it->coeff.compare(_num0()) < 0 || (it->coeff.compare(_num1()) == 0 && is_ex_exactly_of_type(it->rest, numeric) && it->rest.compare(_num0()) < 0)))
 155                                 c.s << "+";
 156                 }
 157
 158                 if (!overall_coeff.is_zero()) {
 159                         if (overall_coeff.info(info_flags::positive))
 160                                 c.s << '+';
 161                         overall_coeff.bp->print(c, precedence);
 162                 }
 163
 164                 if (precedence <= level)
 165                         c.s << ")";
 166
 167         } else {
 168
 169                 if (precedence <= level) {
 170                         if (is_of_type(c, print_latex))
 171                                 c.s << "{(";
 172                         else
 173                                 c.s << "(";
 174                 }
 175
 176                 numeric coeff;
 177                 bool first = true;
 178
 179                 // First print the overall numeric coefficient, if present
 180                 if (!overall_coeff.is_zero()) {
 181                         if (!is_of_type(c, print_tree))
 182                                 overall_coeff.print(c, 0);
 183                         else
 184                                 overall_coeff.print(c, precedence);
 185                         first = false;
 186                 }
 187
 188                 // Then proceed with the remaining factors
 189                 epvector::const_iterator it = seq.begin(), itend = seq.end();
 190                 while (it != itend) {
 191                         coeff = ex_to_numeric(it->coeff);
 192                         if (!first) {
 193                                 if (coeff.csgn() == -1) c.s << '-'; else c.s << '+';
 194                         } else {
 195                                 if (coeff.csgn() == -1) c.s << '-';
 196                                 first = false;
 197                         }
 198                         if (!coeff.is_equal(_num1()) &&
 199                             !coeff.is_equal(_num_1())) {
 200                                 if (coeff.is_rational()) {
 201                                         if (coeff.is_negative())
 202                                                 (-coeff).print(c);
 203                                         else
 204                                                 coeff.print(c);
 205                                 } else {
 206                                         if (coeff.csgn() == -1)
 207                                                 (-coeff).print(c, precedence);
 208                                         else
 209                                                 coeff.print(c, precedence);
 210                                 }
 211                                 if (is_of_type(c, print_latex))
 212                                         c.s << ' ';
 213                                 else
 214                                         c.s << '*';
 215                         }
 216                         it->rest.print(c, precedence);
 217                         it++;
 218                 }
 219
 220                 if (precedence <= level) {
 221                         if (is_of_type(c, print_latex))
 222                                 c.s << ")}";
 223                         else
 224                                 c.s << ")";
 225                 }
 226         }
 227 }
 228
 229 bool add::info(unsigned inf) const
 230 {
 231         switch (inf) {
 232                 case info_flags::polynomial:
 233                 case info_flags::integer_polynomial:
 234                 case info_flags::cinteger_polynomial:
 235                 case info_flags::rational_polynomial:
 236                 case info_flags::crational_polynomial:
 237                 case info_flags::rational_function: {
 238                         for (epvector::const_iterator i=seq.begin(); i!=seq.end(); ++i) {
 239                                 if (!(recombine_pair_to_ex(*i).info(inf)))
 240                                         return false;
 241                         }
 242                         return overall_coeff.info(inf);
 243                 }
 244                 case info_flags::algebraic: {
 245                         for (epvector::const_iterator i=seq.begin(); i!=seq.end(); ++i) {
 246                                 if ((recombine_pair_to_ex(*i).info(inf)))
 247                                         return true;
 248                         }
 249                         return false;
 250                 }
 251         }
 252         return inherited::info(inf);
 253 }
 254
 255 int add::degree(const ex & s) const
 256 {
 257         int deg = INT_MIN;
 258         if (!overall_coeff.is_equal(_ex0()))
 259                 deg = 0;
 260
 261         int cur_deg;
 262         for (epvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
 263                 cur_deg = (*cit).rest.degree(s);
 264                 if (cur_deg>deg)
 265                         deg = cur_deg;
 266         }
 267         return deg;
 268 }
 269
 270 int add::ldegree(const ex & s) const
 271 {
 272         int deg = INT_MAX;
 273         if (!overall_coeff.is_equal(_ex0()))
 274                 deg = 0;
 275
 276         int cur_deg;
 277         for (epvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
 278                 cur_deg = (*cit).rest.ldegree(s);
 279                 if (cur_deg<deg) deg=cur_deg;
 280         }
 281         return deg;
 282 }
 283
 284 ex add::coeff(const ex & s, int n) const
 285 {
 286         epvector coeffseq;
 287         coeffseq.reserve(seq.size());
 288
 289         epvector::const_iterator it=seq.begin();
 290         while (it!=seq.end()) {
 291                 coeffseq.push_back(combine_ex_with_coeff_to_pair((*it).rest.coeff(s,n),
 292                                                                  (*it).coeff));
 293                 ++it;
 294         }
 295         if (n==0) {
 296                 return (new add(coeffseq,overall_coeff))->setflag(status_flags::dynallocated);
 297         }
 298         return (new add(coeffseq))->setflag(status_flags::dynallocated);
 299 }
 300
 301 ex add::eval(int level) const
 302 {
 303         // simplifications: +(;c) -> c
 304         //                  +(x;1) -> x
 305
 306         debugmsg("add eval",LOGLEVEL_MEMBER_FUNCTION);
 307
 308         epvector * evaled_seqp = evalchildren(level);
 309         if (evaled_seqp!=0) {
 310                 // do more evaluation later
 311                 return (new add(evaled_seqp,overall_coeff))->
 312                        setflag(status_flags::dynallocated);
 313         }
 314
 315 #ifdef DO_GINAC_ASSERT
 316         for (epvector::const_iterator cit=seq.begin(); cit!=seq.end(); ++cit) {
 317                 GINAC_ASSERT(!is_ex_exactly_of_type((*cit).rest,add));
 318                 if (is_ex_exactly_of_type((*cit).rest,numeric))
 319                         dbgprint();
 320                 GINAC_ASSERT(!is_ex_exactly_of_type((*cit).rest,numeric));
 321         }
 322 #endif // def DO_GINAC_ASSERT
 323
 324         if (flags & status_flags::evaluated) {
 325                 GINAC_ASSERT(seq.size()>0);
 326                 GINAC_ASSERT(seq.size()>1 || !overall_coeff.is_zero());
 327                 return *this;
 328         }
 329
 330         int seq_size = seq.size();
 331         if (seq_size==0) {
 332                 // +(;c) -> c
 333                 return overall_coeff;
 334         } else if ((seq_size==1) && overall_coeff.is_equal(_ex0())) {
 335                 // +(x;0) -> x
 336                 return recombine_pair_to_ex(*(seq.begin()));
 337         }
 338         return this->hold();
 339 }
 340
 341 ex add::simplify_ncmul(const exvector & v) const
 342 {
 343         if (seq.size()==0) {
 344                 return inherited::simplify_ncmul(v);
 345         }
 346         return (*seq.begin()).rest.simplify_ncmul(v);
 347 }
 348
 349 // protected
 350
 351 /** Implementation of ex::diff() for a sum. It differentiates each term.
 352  *  @see ex::diff */
 353 ex add::derivative(const symbol & s) const
 354 {
 355         // D(a+b+c)=D(a)+D(b)+D(c)
 356         return (new add(diffchildren(s)))->setflag(status_flags::dynallocated);
 357 }
 358
 359 int add::compare_same_type(const basic & other) const
 360 {
 361         return inherited::compare_same_type(other);
 362 }
 363
 364 bool add::is_equal_same_type(const basic & other) const
 365 {
 366         return inherited::is_equal_same_type(other);
 367 }
 368
 369 unsigned add::return_type(void) const
 370 {
 371         if (seq.size()==0) {
 372                 return return_types::commutative;
 373         }
 374         return (*seq.begin()).rest.return_type();
 375 }
 376
 377 unsigned add::return_type_tinfo(void) const
 378 {
 379         if (seq.size()==0) {
 380                 return tinfo_key;
 381         }
 382         return (*seq.begin()).rest.return_type_tinfo();
 383 }
 384
 385 ex add::thisexpairseq(const epvector & v, const ex & oc) const
 386 {
 387         return (new add(v,oc))->setflag(status_flags::dynallocated);
 388 }
 389
 390 ex add::thisexpairseq(epvector * vp, const ex & oc) const
 391 {
 392         return (new add(vp,oc))->setflag(status_flags::dynallocated);
 393 }
 394
 395 expair add::split_ex_to_pair(const ex & e) const
 396 {
 397         if (is_ex_exactly_of_type(e,mul)) {
 398                 const mul &mulref = ex_to_mul(e);
 399                 ex numfactor = mulref.overall_coeff;
 400                 mul *mulcopyp = new mul(mulref);
 401                 mulcopyp->overall_coeff = _ex1();
 402                 mulcopyp->clearflag(status_flags::evaluated);
 403                 mulcopyp->clearflag(status_flags::hash_calculated);
 404                 mulcopyp->setflag(status_flags::dynallocated);
 405                 return expair(*mulcopyp,numfactor);
 406         }
 407         return expair(e,_ex1());
 408 }
 409
 410 expair add::combine_ex_with_coeff_to_pair(const ex & e,
 411                                                                                   const ex & c) const
 412 {
 413         GINAC_ASSERT(is_ex_exactly_of_type(c, numeric));
 414         if (is_ex_exactly_of_type(e, mul)) {
 415                 const mul &mulref = ex_to_mul(e);
 416                 ex numfactor = mulref.overall_coeff;
 417                 mul *mulcopyp = new mul(mulref);
 418                 mulcopyp->overall_coeff = _ex1();
 419                 mulcopyp->clearflag(status_flags::evaluated);
 420                 mulcopyp->clearflag(status_flags::hash_calculated);
 421                 mulcopyp->setflag(status_flags::dynallocated);
 422                 if (are_ex_trivially_equal(c, _ex1()))
 423                         return expair(*mulcopyp, numfactor);
 424                 else if (are_ex_trivially_equal(numfactor, _ex1()))
 425                         return expair(*mulcopyp, c);
 426                 else
 427                         return expair(*mulcopyp, ex_to_numeric(numfactor).mul_dyn(ex_to_numeric(c)));
 428         } else if (is_ex_exactly_of_type(e, numeric)) {
 429                 if (are_ex_trivially_equal(c, _ex1()))
 430                         return expair(e, _ex1());
 431                 return expair(ex_to_numeric(e).mul_dyn(ex_to_numeric(c)), _ex1());
 432         }
 433         return expair(e, c);
 434 }
 435
 436 expair add::combine_pair_with_coeff_to_pair(const expair & p,
 437                                                                                         const ex & c) const
 438 {
 439         GINAC_ASSERT(is_ex_exactly_of_type(p.coeff,numeric));
 440         GINAC_ASSERT(is_ex_exactly_of_type(c,numeric));
 441
 442         if (is_ex_exactly_of_type(p.rest,numeric)) {
 443                 GINAC_ASSERT(ex_to_numeric(p.coeff).is_equal(_num1())); // should be normalized
 444                 return expair(ex_to_numeric(p.rest).mul_dyn(ex_to_numeric(c)),_ex1());
 445         }
 446
 447         return expair(p.rest,ex_to_numeric(p.coeff).mul_dyn(ex_to_numeric(c)));
 448 }
 449
 450 ex add::recombine_pair_to_ex(const expair & p) const
 451 {
 452         if (ex_to_numeric(p.coeff).is_equal(_num1()))
 453                 return p.rest;
 454         else
 455                 return p.rest*p.coeff;
 456 }
 457
 458 ex add::expand(unsigned options) const
 459 {
 460         if (flags & status_flags::expanded)
 461                 return *this;
 462
 463         epvector * vp = expandchildren(options);
 464         if (vp==0) {
 465                 // the terms have not changed, so it is safe to declare this expanded
 466                 setflag(status_flags::expanded);
 467                 return *this;
 468         }
 469
 470         return (new add(vp,overall_coeff))->setflag(status_flags::expanded | status_flags::dynallocated);
 471 }
 472
 473 //////////
 474 // static member variables
 475 //////////
 476
 477 // protected
 478
 479 unsigned add::precedence = 40;
 480
 481 } // namespace GiNaC