rpndivide Class Reference

#include <rpnfunc.h>

Inheritance diagram for rpndivide:

Collaboration diagram for rpndivide:

List of all members.

Public Member Functions

rpndivide ()

rpndivide (deque< rpnbase * > &ds, bool const evaluate=true)

~rpndivide ()

rpnbase * copy () const

void visit (deque< rpnbase * > &ds, rpninteger &n)

void visit (deque< rpnbase * > &ds, rpnreal &n)

void visit (deque< rpnbase * > &ds, rpncomplex &n)

string const name () const

void eval (deque< rpnbase * > &ds)

Detailed Description

Definition at line 913 of file rpnfunc.h.

Constructor & Destructor Documentation

rpndivide::rpndivide ( ) [inline]

Definition at line 917 of file rpnfunc.h.

Referenced by copy().

00917 {}

rpndivide::rpndivide	(	deque< rpnbase * > &	ds,
		bool const	evaluate = `true`
	)

Definition at line 2771 of file rpnfunc.cpp.

References eval().

02772 {
02773   if (evaluate)
02774     eval(ds);
02775   else
02776     ds.push_front(this);
02777 }

rpndivide::~rpndivide ( ) [inline]

Definition at line 919 of file rpnfunc.h.

00919 {}

Member Function Documentation

rpnbase * rpndivide::copy ( ) const [virtual]

Reimplemented from rpnfunction.

Definition at line 2779 of file rpnfunc.cpp.

References rpndivide().

02780 {
02781   return new rpndivide();
02782 }

void rpndivide::eval ( deque< rpnbase * > & ds ) [virtual]

Reimplemented from rpnfunction.

Definition at line 2784 of file rpnfunc.cpp.

References rpnbase::accept(), and rpnbase::dec().

Referenced by rpndivide().

02785 {
02786   if (ds.size()>1)
02787     ds[0]->accept(ds,*this);
02788 
02789   dec();
02790 }

string const rpndivide::name ( ) const [inline, virtual]

Reimplemented from rpnfunction.

Definition at line 926 of file rpnfunc.h.

00926 { return string("/"); }

void rpndivide::visit	(	deque< rpnbase * > &	ds,
		rpncomplex &	n
	)			`[virtual]`

Reimplemented from rpnfunction.

Definition at line 2872 of file rpnfunc.cpp.

References rpnbase::dec(), rpnbase::iscomplex(), rpnbase::isinteger(), rpnbase::isreal(), and rpncomplex::num.

02873 {
02874   rpnbase* x0 = ds.front();
02875   ds.pop_front();
02876   rpnbase* x1 = ds.front();
02877 
02878   if ( x1->iscomplex())
02879   {
02880     ((rpncomplex*)x1)->num /= n.num;
02881     x0->dec();
02882     return;
02883   }
02884   else
02885   if ( x1->isreal())
02886   {
02887     n.num = ((rpnreal*)x1)->num / n.num;
02888     ds.pop_front();
02889     ds.push_front(x0);
02890     x1->dec();
02891     return;
02892   }
02893   else
02894   if ( x1->isinteger())
02895   {
02896     
02897     n.num = complex<long double>(1.0,0.0) / n.num;
02898     n.num *= ((rpninteger*)x1)->num;
02899     ds.pop_front();
02900     ds.push_front(x0);
02901     x1->dec();
02902     return;
02903   }
02904  
02905   // Restore the stack. 
02906   ds.push_front(x0);
02907 }

void rpndivide::visit	(	deque< rpnbase * > &	ds,
		rpnreal &	n
	)			`[virtual]`

Reimplemented from rpnfunction.

Definition at line 2792 of file rpnfunc.cpp.

References rpnbase::dec(), rpnbase::iscomplex(), rpnbase::isinteger(), rpnbase::isreal(), and rpnreal::num.

02793 {
02794   rpnbase* x0 = ds.front();
02795   ds.pop_front();
02796   rpnbase* x1 = ds.front();
02797   ds.pop_front();
02798 
02799   if (x1->isreal())
02800   {
02801     ((rpnreal*)x1)->num /= n.num;
02802     ds.push_front(x1);
02803     x0->dec();
02804     return;
02805   }
02806   else
02807   if (x1->iscomplex())
02808   {
02809     ((rpncomplex*)x1)->num /= n.num;
02810     ds.push_front(x1);
02811     x0->dec();
02812     return;
02813   }
02814   else
02815   if ( x1->isinteger())
02816   {
02817     new rpnreal(ds,((rpninteger*)x1)->num / n.num);
02818     x0->dec();
02819     x1->dec();
02820     return;
02821   }
02822 
02823   // Error so restore stack 
02824   ds.push_front(x1);
02825   ds.push_front(x0);
02826 }

void rpndivide::visit	(	deque< rpnbase * > &	ds,
		rpninteger &	n
	)			`[virtual]`

Reimplemented from rpnfunction.

Definition at line 2828 of file rpnfunc.cpp.

References rpnbase::dec(), rpnbase::iscomplex(), rpnbase::isinteger(), rpnbase::isreal(), and rpninteger::num.

02829 {
02830   rpnbase* x0 = ds.front();
02831   ds.pop_front();
02832   rpnbase* x1 = ds.front();
02833 
02834   if ( x1->isinteger() )
02835   {
02836     if ( ((rpninteger*)x1)->num % n.num == 0 )
02837     {
02838       ((rpninteger*)x1)->num /= n.num;
02839       x0->dec();
02840       return;
02841     }
02842     else
02843     {
02844       long double w = ((rpninteger*)x1)->num;
02845       ds.pop_front();
02846       new rpnreal(ds,w/n.num);
02847       
02848       x0->dec();
02849       x1->dec();
02850       return;
02851     }
02852   }
02853   else
02854   if ( x1->isreal())
02855   {
02856     ((rpnreal*)x1)->num /= n.num;
02857     x0->dec();
02858     return;
02859   }
02860   else
02861   if ( x1->iscomplex())
02862   {
02863     ((rpncomplex*)x1)->num /= n.num;
02864     x0->dec();
02865     return;
02866   }
02867 
02868   // Restore the stack. 
02869   ds.push_front(x0);
02870 }

The documentation for this class was generated from the following files:

rpn/rpnfunc.h
rpn/rpnfunc.cpp


Public Member Functions
	rpndivide ()
	rpndivide (deque< rpnbase * > &ds, bool const evaluate=true)
	~rpndivide ()
rpnbase *	copy () const
void	visit (deque< rpnbase * > &ds, rpninteger &n)
void	visit (deque< rpnbase * > &ds, rpnreal &n)
void	visit (deque< rpnbase * > &ds, rpncomplex &n)
string const	name () const
void	eval (deque< rpnbase * > &ds)