Esempio n. 1
0
	Rational& operator /=(const Rational& x) {
		Rational res = divide(rhs);
		swap(res);
		return *this;
	}
Esempio n. 2
0
static CYTHON_INLINE struct ZZX* ZZX_div(struct ZZX* x, struct ZZX* y, int* divisible)
{
    struct ZZX* z = new ZZX();
    *divisible = divide(*z, *x, *y);
    return z;
}
Esempio n. 3
0
 ll sort(T *a1,T *b1,int n1){
     a=a1;b=b1;n=n1;
     num=0;
     divide(0,n-1);
     return num;
 }
	vec3& vec3::operator/=(const vec3& other){
		return divide(other);
	}
Esempio n. 5
0
int main(void)
{
	struct 
	{
		ULONG a;
		UWORD b;
		ULONG r;
	} div[] =
	{
		{0,1,0x00000000},
		{1,1,0x00000001},
		{1,2,0x00010000},
		{1,3,0x00010000},
		{1,4,0x00010000},
		{1,1000,0x00010000},
		{1,6000,0x00010000},
		{10000,666,0x000a000f},
		{80000,666,0x01de0015},
		{80000,1,0x00003880},
	};
	const div_numof = sizeof(div) / sizeof(div[0]);
	int i;
	UBYTE tmp[256], *p;
	UBYTE t2[64];

	printf("\ndivide:\n");

	for (i = 0; i< div_numof; i++)
	{
		printf("%d / %d = 0x%08x\n", div[i].a, div[i].b, divide(div[i].a, div[i].b));
		if (divide(div[i].a, div[i].b) != div[i].r)
		{
			printf("failed!\n");
			return 5;
		}
	}

	printf("\nctodstr:\n");
	ctodstr("", tmp);
	if (tmp[0] != 0 || memcmp(tmp+1, "", 1)) { printf("failed \"\"!\n"); return 5; }
	ctodstr("foobar", tmp);
	if (tmp[0] != 6 || memcmp(tmp+1, "foobar", 6)) { printf("failed \"foobar\"!\n"); return 5; }

	printf("\nstcu_d:\n");
	stcu_d(tmp, 0);
	if (strcmp(tmp, "0")) { printf("failed 0\n"); return 5; }
	stcu_d(tmp, 123456);
	if (strcmp(tmp, "123456")) { printf("failed 123456\n"); return 5; }
	stcu_d(tmp, 10000000);
	if (strcmp(tmp, "10000000")) { printf("failed 10000000\n"); return 5; }

	printf("\nstpcpy:\n");
	p = stpcpy(tmp, "");
	if (p != tmp || strcmp(tmp, "")) { printf("failed \"\"\n"); return 5; }
	p = stpcpy(tmp, "foobar");
	if (p != tmp + 6 || strcmp(tmp, "foobar")) { printf("failed \"foobar\"\n"); return 5; }

	printf("\nintltoupper:\n");

	ctodstr("", tmp);
	intltoupper(tmp);
	if (tmp[0] != 0) { printf("failed \"\"\n"); return 5; }
	ctodstr("fooBarφδείπ!@£", tmp);
	intltoupper(tmp);
	if (tmp[0] != 14 || memcmp(tmp + 1, "FOOBARΦΔΕίΠ!@£", 14)) { printf("failed \"fooBarφδείπ!@£\"\n"); return 5; }

	printf("\nintlcmp:\n");
	ctodstr("foo", tmp);
	intltoupper(tmp);
	if (intlcmp(tmp, tmp) != 1) { printf("failed \"foo\" selfcompare\n"); return 5; }
	ctodstr("foo", tmp);
	intltoupper(tmp);
	ctodstr("foo", t2);
	if (intlcmp(tmp, t2) != 1) { printf("failed \"FOO\" vs \"foo\"\n"); return 5; }
	ctodstr("fooBarφδείπ!@£", tmp);
	intltoupper(tmp);
	if (intlcmp(tmp, tmp) != 1) { printf("failed \"fooBarφδείπ!@£\" selfcompare\n"); return 5; }
	ctodstr("fooBar", t2);
	intltoupper(t2);
	if (intlcmp(tmp, t2) != 0) { printf("failed \"fooBarφδείπ!@£\" vs \"fooBar\"\n"); return 5; }
	ctodstr("fooBarφδείπ!@£xxx", t2);
	intltoupper(t2);
	if (intlcmp(tmp, t2) != 0) { printf("failed \"fooBarφδείπ!@£\" vs \"fooBarφδείπ!@£xxx\"\n"); return 5; }
	ctodstr("fooBaxφδείπ!@£", t2);
	if (intlcmp(tmp, t2) != 0) { printf("failed \"fooBarφδείπ!@£\" vs \"fooBaxφδείπ!@£\"\n"); return 5; }
	ctodstr("fooBar", t2);
	if (intlcmp(tmp, t2) != 0) { printf("failed \"fooBarφδείπ!@£\" vs \"fooBar\"\n"); return 5; }
	ctodstr("fooBarφδείπ!@£xxx", t2);
	if (intlcmp(tmp, t2) != 0) { printf("failed \"fooBarφδείπ!@£\" vs \"fooBarφδείπ!@£xxx\"\n"); return 5; }
	ctodstr("fooBaxφδείπ!@£", t2);
	if (intlcmp(tmp, t2) != 0) { printf("failed \"fooBarφδείπ!@£\" vs \"fooBaxφδείπ!@£\"\n"); return 5; }

	printf("\nintlcdcmp:\n");
	ctodstr("", tmp);
	intltoupper(tmp);
	if (intlcdcmp("", tmp) != 1) { printf("failed \"\"\n"); return 5; }
	ctodstr("A", tmp);
	if (intlcdcmp("A", tmp) != 1) { printf("failed \"A\" vs \"A\"\n"); return 5; }
	ctodstr("a", tmp);
	if (intlcdcmp("A", tmp) != 1) { printf("failed \"A\" vs \"a\"\n"); return 5; }
	ctodstr("abcDEF", tmp);
	if (intlcdcmp("ABCDEF", tmp) != 1) { printf("failed \"ABCDEF\" vs \"abcDEF\"\n"); return 5; }
	ctodstr("fooBarφδείπ!@£", tmp);
	if (intlcdcmp("FOOBARΦΔΕίΠ!@£", tmp) != 1) { printf("failed \"FOOBARΦΔΕίΠ!@£\" vs \"fooBarφδείπ!@£\"n"); return 5; }
	ctodstr("fooBarφδείπ!@£", tmp);
	if (intlcdcmp("FOOBARΦΔΕίΠ!@£", tmp) != 1) { printf("failed \"FOOBARΦΔΕίΠ!@£\" vs \"fooBarφδείπ!@£\"\n"); return 5; }
	ctodstr("fooBarφδείπ!@£", tmp);
	if (intlcdcmp("FOOBAXΦΔΕίΠ!@£", tmp) != 0) { printf("failed \"FOOBAXΦΔΕίΠ!@£\" vs \"fooBarφδείπ!@£\"\n"); return 5; }
	ctodstr("fooBarφδείπ!@£", tmp);
	if (intlcdcmp("FOOBAR", tmp) != 0) { printf("failed \"FOOBAR\" vs \"fooBarφδείπ!@£\"\n"); return 5; }
	ctodstr("fooBarφδείπ!@£", tmp);
	if (intlcdcmp("FOOBARΦΔΕίΠ!@£XXX", tmp) != 0) { printf("failed \"FOOBARΦΔΕίΠ!@£XXX\" vs \"fooBarφδείπ!@£\"\n"); return 5; }

	return 0;
}
LRESULT CALLBACK WndProc(HWND hWnd, UINT message,
				 WPARAM wParam, LPARAM lParam)
{	

	switch(message){
		case WM_DESTROY:{ PostQuitMessage(0); break;}
		case WM_CREATE:{
			infoEdit = CreateWindow("edit","0",WS_CHILD|WS_VISIBLE|WS_BORDER|ES_RIGHT|ES_READONLY, 10, 30, 265, 20, hWnd,(HMENU)201,hInst,0);
			buttons[0] =  CreateWindow("button","7", WS_CHILD|WS_VISIBLE, 10,70,65,65, hWnd, (HMENU)107, hInst, 0);
			buttons[1] =  CreateWindow("button","8", WS_CHILD|WS_VISIBLE, 75,70,65,65, hWnd, (HMENU)108, hInst, 0);
			buttons[2] =  CreateWindow("button","9", WS_CHILD|WS_VISIBLE, 140,70,65,65, hWnd, (HMENU)109, hInst, 0);
			buttons[3] =  CreateWindow("button","+", WS_CHILD|WS_VISIBLE, 205,70,65,65, hWnd, (HMENU)110, hInst, 0);
			buttons[4] =  CreateWindow("button","4", WS_CHILD|WS_VISIBLE, 10,135,65,65, hWnd, (HMENU)104, hInst, 0);
			buttons[5] =  CreateWindow("button","5", WS_CHILD|WS_VISIBLE, 75,135,65,65, hWnd, (HMENU)105, hInst, 0);
			buttons[6] =  CreateWindow("button","6", WS_CHILD|WS_VISIBLE, 140,135,65,65, hWnd, (HMENU)106, hInst, 0);
			buttons[7] =  CreateWindow("button","-", WS_CHILD|WS_VISIBLE, 205,135,65,65, hWnd, (HMENU)111, hInst, 0);
			buttons[8] =  CreateWindow("button","1", WS_CHILD|WS_VISIBLE, 10,200,65,65, hWnd, (HMENU)101, hInst, 0);
			buttons[9] =  CreateWindow("button","2", WS_CHILD|WS_VISIBLE, 75,200,65,65, hWnd, (HMENU)102, hInst, 0);
			buttons[10] =  CreateWindow("button","3", WS_CHILD|WS_VISIBLE, 140,200,65,65, hWnd, (HMENU)103, hInst, 0);
			buttons[11] =  CreateWindow("button","*", WS_CHILD|WS_VISIBLE, 205,200,65,65, hWnd, (HMENU)112, hInst, 0);
			buttons[12] =  CreateWindow("button","C", WS_CHILD|WS_VISIBLE, 10,265,65,65, hWnd, (HMENU)113, hInst, 0);
			buttons[13] =  CreateWindow("button","0", WS_CHILD|WS_VISIBLE, 75,265,65,65, hWnd, (HMENU)100, hInst, 0);
			buttons[14] =  CreateWindow("button","=", WS_CHILD|WS_VISIBLE, 140,265,65,65, hWnd, (HMENU)114, hInst, 0);
			buttons[15] =  CreateWindow("button","/", WS_CHILD|WS_VISIBLE, 205,265,65,65, hWnd, (HMENU)115, hInst, 0);
			break;
		}
		case WM_COMMAND:{
			if(HIWORD(wParam)==BN_CLICKED){
				switch (LOWORD(wParam)){
					case 100: case 101: case 102: case 103: case 104: 
					case 105: case 106: case 107: case 108: case 109:{
						if(count<9&&second<214748364){
							if(znak==0)	second=0;
							second=second*10+LOWORD(wParam)-100;
							itoa(second, buff, 10);
							SetWindowText(infoEdit, buff); 
							count++;
						}
						break;
					}
					case 110: case 111: case 112: case 115:{
						switch(znak){
							case 0: result=second; break;
							case 1: {   if(plus(result, second))
											result=plus(result, second); 
									else {
										result=0;
										count=0;
										znak=1;
										strcpy(buff, "!Error!");
										SetWindowText(infoEdit, buff); 
									}  
									break;
								}
							case 2: {   if(minus(result, second))
											result=minus(result, second); 
									else {
										result=0;
										count=0;
										znak=1;
										strcpy(buff, "!Error!");
										SetWindowText(infoEdit, buff); 
									}  
									break;
								}
							case 3: {   if(multiply(result, second))
											result=multiply(result, second); 
									else {
										result=0;
										count=0;
										znak=1;
										strcpy(buff, "!Error!");
										SetWindowText(infoEdit, buff); 
									}  
									break;
								}
							case 4: {
									if(second){   
										if(divide(result, second))
											result=divide(result, second); 
										else {
											result=0;
											count=0;
											znak=1;
											strcpy(buff, "!Error!");
											SetWindowText(infoEdit, buff); 
										}  
									}
									else{
										result=0;
										count=0;
										znak=1;
										strcpy(buff, "!Dev by 0!");
										SetWindowText(infoEdit, buff); 
									}
									break;
									}
							default: break;
						};
						if(strcmp(buff, "!Dev by 0!")&&strcmp(buff, "!Error!")){
							sprintf (buff, "%f", result);
							/*MessageBox(NULL, buff, "Title", MB_OK);*/
							while(strrchr(buff, '0')&&(strrchr(buff, '0'))>(strchr(buff, '.')))
								buff[strlen(buff)-1]='\0';
							if(buff[strlen(buff)-1]=='.')
								buff[strlen(buff)-1]='\0';
							SetWindowText(infoEdit, buff); 
							strcpy(buff, "\0");
							count=0;
							second=0;
							if(LOWORD(wParam)==110) znak=1; 
							if(LOWORD(wParam)==111) znak=2; 
							if(LOWORD(wParam)==112) znak=3; 
							if(LOWORD(wParam)==115) znak=4; 
						}
						break;
					}
					case 113:{
						result=0;
						second=0;
						count=0;
						sprintf (buff, "%f", result);
						while(strrchr(buff, '0')&&(strrchr(buff, '0'))>(strchr(buff, '.')))
							buff[strlen(buff)-1]='\0';
						if(buff[strlen(buff)-1]=='.')
							buff[strlen(buff)-1]='\0';
						SetWindowText(infoEdit, buff); 
						znak=1;
						break;
					}
					case 114:{
						switch(znak){
							case 0: result=second; break;
							case 1: {   if(plus(result, second))
											result=plus(result, second); 
									else {
										result=0;
										count=0;
										znak=1;
										strcpy(buff, "!Error!");
										SetWindowText(infoEdit, buff); 
									}  
									break;
								}
							case 2: {   if(minus(result, second))
											result=minus(result, second); 
									else {
										result=0;
										count=0;
										znak=1;
										strcpy(buff, "!Error!");
										SetWindowText(infoEdit, buff); 
									}  
									break;
								}
							case 3: {   if(multiply(result, second))
											result=multiply(result, second); 
									else {
										result=0;
										count=0;
										znak=1;
										strcpy(buff, "!Error!");
										SetWindowText(infoEdit, buff); 
									}  
									break;
								}
							case 4: {
									if(second){   
										if(divide(result, second))
											result=divide(result, second); 
										else {
											result=0;
											count=0;
											znak=1;
											strcpy(buff, "!Error!");
											SetWindowText(infoEdit, buff); 
										}  
									}
									else{
										result=0;
										count=0;
										znak=1;
										strcpy(buff, "!Dev by 0!");
										SetWindowText(infoEdit, buff); 
									}
									break;
									}
							default: break;
						};
						if(strcmp(buff, "!Dev by 0!")&&strcmp(buff, "!Error!")){
							sprintf (buff, "%f", result);
							while(strrchr(buff, '0')&&(strrchr(buff, '0'))>(strchr(buff, '.')))
								buff[strlen(buff)-1]='\0';
							if(buff[strlen(buff)-1]=='.')
								buff[strlen(buff)-1]='\0';
							SetWindowText(infoEdit, buff); 
							count=0;
							second=result;
							znak=0;
						}
						break;
					}
					default: break;
				}
			}	
			break;
		}
		default: break;
	};
	return DefWindowProc(hWnd, message, wParam, lParam);
}
Esempio n. 7
0
static int euclid(_MIPD_ big x,int num)
{ /* outputs next c.f. quotient from gcd(w5,w6) */
    mr_small sr,m;
#ifdef MR_FP
    mr_small dres;
#endif
    mr_small lr,lq;
    big t;
#ifndef MR_GENERIC_MT
    miracl *mr_mip=get_mip();
#endif
    if (num==0)
    {
        mr_mip->oldn=(-1);
        mr_mip->carryon=FALSE;
        mr_mip->last=FALSE;
        if (compare(mr_mip->w6,mr_mip->w5)>0)
        { /* ensure w5>w6 */
            t=mr_mip->w5,mr_mip->w5=mr_mip->w6,mr_mip->w6=t;
            return (mr_mip->q=0);
        }
    }
    else if (num==mr_mip->oldn || mr_mip->q<0) return mr_mip->q;
    mr_mip->oldn=num;
    if (mr_mip->carryon) goto middle;
start:
    if (size(mr_mip->w6)==0) return (mr_mip->q=(-1));
    mr_mip->ndig=(int)mr_mip->w5->len;
    mr_mip->carryon=TRUE;
    mr_mip->a=1;
    mr_mip->b=0;
    mr_mip->c=0;
    mr_mip->d=1;
    if (mr_mip->ndig==1)
    {
        mr_mip->last=TRUE;
        mr_mip->u=mr_mip->w5->w[0];
        mr_mip->v=mr_mip->w6->w[0];
    }
    else
    {
        m=mr_mip->w5->w[mr_mip->ndig-1]+1;
        if (mr_mip->base==0)
        {
#ifndef MR_NOFULLWIDTH
            if (m==0)
            {
                mr_mip->u=mr_mip->w5->w[mr_mip->ndig-1];
                mr_mip->v=mr_mip->w6->w[mr_mip->ndig-1];
            }
            else
            {
                mr_mip->u=muldvm(mr_mip->w5->w[mr_mip->ndig-1],mr_mip->w5->w[mr_mip->ndig-2],m,&sr);
                mr_mip->v=muldvm(mr_mip->w6->w[mr_mip->ndig-1],mr_mip->w6->w[mr_mip->ndig-2],m,&sr);
            }
#endif
        }
        else
        {
            mr_mip->u=muldiv(mr_mip->w5->w[mr_mip->ndig-1],mr_mip->base,mr_mip->w5->w[mr_mip->ndig-2],m,&sr);
            mr_mip->v=muldiv(mr_mip->w6->w[mr_mip->ndig-1],mr_mip->base,mr_mip->w6->w[mr_mip->ndig-2],m,&sr);
        }
    }
    mr_mip->ku=mr_mip->u;
    mr_mip->kv=mr_mip->v;
middle:
    forever
    { /* work only with most significant piece */
        if (mr_mip->last)
        {
            if (mr_mip->v==0) return (mr_mip->q=(-1));
            lq=MR_DIV(mr_mip->u,mr_mip->v);
        }
        else
        {
            if (((mr_mip->v+mr_mip->c)==0) || ((mr_mip->v+mr_mip->d)==0)) break;
            lq=MR_DIV((mr_mip->u+mr_mip->a),(mr_mip->v+mr_mip->c));
            if (lq!=MR_DIV((mr_mip->u+mr_mip->b),(mr_mip->v+mr_mip->d))) break;
        }
        if (lq>=(mr_small)(MR_TOOBIG/mr_abs(mr_mip->d))) break;

        mr_mip->q=(int)lq;
        mr_mip->r=mr_mip->a-mr_mip->q*mr_mip->c;
        mr_mip->a=mr_mip->c;
        mr_mip->c=mr_mip->r;
        mr_mip->r=mr_mip->b-mr_mip->q*mr_mip->d;
        mr_mip->b=mr_mip->d;
        mr_mip->d=mr_mip->r;
        lr=mr_mip->u-lq*mr_mip->v;
        mr_mip->u=mr_mip->v;
        mr_mip->v=lr;
        return mr_mip->q;
    }
    mr_mip->carryon=FALSE;
    if (mr_mip->b==0)
    { /* update w5 and w6 */
        mr_mip->check=OFF;
        divide(_MIPP_ mr_mip->w5,mr_mip->w6,mr_mip->w7);
        mr_mip->check=ON;
        if (mr_lent(mr_mip->w7)>mr_mip->nib) return (mr_mip->q=(-2));
        t=mr_mip->w5,mr_mip->w5=mr_mip->w6,mr_mip->w6=t;   /* swap(w5,w6) */
        copy(mr_mip->w7,x);
        return (mr_mip->q=size(x));
    }
    else
    {
        mr_mip->check=OFF;
        premult(_MIPP_ mr_mip->w5,mr_mip->c,mr_mip->w7);
        premult(_MIPP_ mr_mip->w5,mr_mip->a,mr_mip->w5);
        premult(_MIPP_ mr_mip->w6,mr_mip->b,mr_mip->w0);
        premult(_MIPP_ mr_mip->w6,mr_mip->d,mr_mip->w6);
        add(_MIPP_ mr_mip->w5,mr_mip->w0,mr_mip->w5);
        add(_MIPP_ mr_mip->w6,mr_mip->w7,mr_mip->w6);
        mr_mip->check=ON;
    }
    goto start;
}
Esempio n. 8
0
int divide(struct NUMBER *a,struct NUMBER *b,struct NUMBER *c,struct NUMBER *d)
{
	int k,res = 0;
	struct NUMBER tmp_a,n,m,l,abs_a,abs_b;

	copyNumber(a,&tmp_a);//aが破壊されないようにtmp_aにコピー

	if(isZero(b) == 0)//isZeroは0か-1が返るので
		return(-1);

	clearByZero(c);
	clearByZero(d);//c,dを0でクリア
	clearByZero(&n);
	clearByZero(&m);
	clearByZero(&l);//作業用変数n,m,lを0でクリア

	setInt(&n,1);//適当な変数に1を突っ込む
	if(numComp(b,&n) == 0)//除数が1ならば
	{
		copyNumber(a,c);//c = a;
		return(0);
	}


	getAbs(a,&abs_a);
	getAbs(b,&abs_b);//a,bの絶対値をとる

	if((getSign(a) == 1) && (getSign(b) == 1))
	{
		while(1)//xから何回yを引けるか調べる
		{
			if(numComp(&tmp_a,b) == -1)//a < bならば
				break;
			copyNumber(b,&n);//bを作業用変数nに代入
			setInt(&m,1);//作業用変数mに1を代入
			while(1)
			{
				copyNumber(&n,&l);
				mulBy10(&l,&n);
				copyNumber(&m,&l);
				mulBy10(&l,&m);//mとnを10倍
				if(numComp(&tmp_a,&n) == -1)//a < nならば
				{
					copyNumber(&n,&l);
					divBy10(&l,&n);
					copyNumber(&m,&l);
					divBy10(&l,&m);//10倍しちゃったので10で割る。いい方法を模索中、一時的に保存する?
					break;
				}
			}
			while(1)
			{
				copyNumber(&tmp_a,&l);//lに現在のaを代入
				sub(&l,&n,&tmp_a);//a = l -n; すなわち a -= n; 
				copyNumber(c,&l);//lにcを代入
				add(&l,&m,c);//c = l + m;すわなち c += m;
				if(numComp(&tmp_a,&n) == -1)
					break;
			}
		}
		copyNumber(&tmp_a,d);//残ったtmp_aがすなわち剰余
	}


	if((getSign(a) == 1) && (getSign(b) == -1)) 
	{
		res = divide(a,&abs_b,c,d);
		setSign(c,-1);//+ / -は解が負であるため
	}
	if((getSign(a) == -1) && (getSign(b) == 1))
	{
		res = divide(&abs_a,b,c,d);
		setSign(c,-1);//- / +は解が負であるため
		setSign(d,-1);//- / +は剰余が負であるため
	}
	if((getSign(a) == -1)&& (getSign(b) == -1))
	{
		res = divide(&abs_a,&abs_b,c,d);//-x / -yは解が正であるためなにもしない
		setSign(d,-1);//- / -は剰余が負であるため
	}
	return(res);
}
Esempio n. 9
0
void point::normalize()
{
    divide(length());
}
Esempio n. 10
0
 Quat Quat::operator / ( const Real& scalar)
 {
  Quat r;
  divide(r, *this, scalar);
  return r;
 }
Esempio n. 11
0
  void Quat::operator /=( const Real& scalar)
 {
  Quat r;
  divide(r, *this, scalar);
  set(r);
 }
Esempio n. 12
0
  void Quat::operator /=( const Quat& other)
 {
  Quat r;
  divide(r, *this, other);
  set(r);
 }
Esempio n. 13
0
  Quat Quat::operator / ( const Quat& other)
 {
  Quat r;
  divide(r, *this, other);
  return r;
 }
Esempio n. 14
0
	constexpr Rational operator /(const Rational& rhs) const {
		return divide(rhs);
	}
Esempio n. 15
0
Polynom& Polynom::operator %= (const Polynom& _another) {
	Polynom result = divide(_another).second;
	a = result.a;

	return *this;
}
int main(int argc, char* argv[]){
	
	DynArr *dyn;
	dyn = createDynArr(2);
	double a,b,c,d,e,f,g,h;
	a = 3;
	b = 4;
	c = 10;
	d = 6;
	e = 5; 
	f = 20;
	printf("\n\nTesting addDynArr...\n");
	addDynArr(dyn, a);
	addDynArr(dyn, b);
	addDynArr(dyn, c);
	addDynArr(dyn, d);
	addDynArr(dyn, e);
	
	printf("The array's content: [3,4,10,6,5]\n");
	assertTrue(EQ(getDynArr(dyn, 0), a), "Test 1st element == 3");
	assertTrue(EQ(getDynArr(dyn, 1), b), "Test 2nd element == 4");
	assertTrue(EQ(getDynArr(dyn, 2), c), "Test 3rd element == 10");
	assertTrue(EQ(getDynArr(dyn, 3), d), "Test 4th element == 5");
	assertTrue(EQ(getDynArr(dyn, 4), e), "Test 5th element == 6");
	assertTrue(sizeDynArr(dyn) == 5, "Test size = 5");
	
	printf("\n\nTesting add...\nCalling addDynArr(dyn)\n");
	add(dyn); 
	printf("The array's content: [3,4,7,6,5]\n");
	assertTrue(EQ(getDynArr(dyn, 3), (double)11), "Test 3rd element == 11");
	assertTrue(sizeDynArr(dyn) == 4, "Test size = 4");
	
	//removing result of add test and restoring array
	removeDynArr(dyn, 3);
	addDynArr(dyn, d);
	addDynArr(dyn, e);
	
	printf("\n\nTesting sub...");
	subtract(dyn); 
	printf("The array's content: [3,4,7,6,5]\n");
	assertTrue(EQ(getDynArr(dyn, 3), (double)1), "Test 3rd element == 1");
	assertTrue(sizeDynArr(dyn) == 4, "Test size = 4");	
	//printf("%d \n", sizeDynArr(dyn));
	printf("Top: %f \n", topDynArr(dyn));	
		//removing result of add test and restoring array
	popDynArr(dyn);
	printf("Top: %f \n", topDynArr(dyn));
	pushDynArr(dyn, f);
	pushDynArr(dyn, e);
	printf("Top: %f \n", topDynArr(dyn));
	
	printf("\n\nTesting divide...");
	divide(dyn); 
	//printf("The array's content: [3,4,10,20,5]\n");
	//assertTrue(EQ(getDynArr(dyn, 3),(double)4), "Test 3rd element == 4");
	//assertTrue(sizeDynArr(dyn) == 4, "Test size = 4");	
/* 	printf("At 4: %f \n", topDynArr(dyn));
	removeDynArr(dyn,4);
	printf("At 3: %f \n", topDynArr(dyn));
	removeDynArr(dyn,3);
	printf("At 2: %f \n", topDynArr(dyn));	
	removeDynArr(dyn,2);
	printf("At 1: %f \n", topDynArr(dyn));	
	printf("%d \n",sizeDynArr(dyn)); */
	
			//removing result of add test and restoring array
	printf("\nTop: %f \n", topDynArr(dyn));
	popDynArr(dyn);
	printf("Top: %f \n", topDynArr(dyn));
	pushDynArr(dyn, f);
	pushDynArr(dyn, e);
	printf("Top: %f \n", topDynArr(dyn));
	
	printf("\n\nTesting multiply...\nCalling addDynArr(dyn)\n");
	multiply(dyn); 
	//printf("The array's content: [3,4,10,6,5]\n");
	//assertTrue(EQ(getDynArr(dyn, 3),(float)30), "Test 3rd element == 30");
	//assertTrue(sizeDynArr(dyn) == (float)4, "Test size = 4");
	
	
	printf("Before pop Top: %f \n", topDynArr(dyn));			//removing result of add test and restoring array
	popDynArr(dyn);
	printf("After pop Top: %f \n", topDynArr(dyn));
	pushDynArr(dyn,(double) 2);
	pushDynArr(dyn,(double) 1);
	printf("After 2 push Top: %f \n", topDynArr(dyn));	
	printf("\n\nTesting power of...n");
	powerOf(dyn); 
	//printf("The array's content: [3,4,10,6,5]\n");
	//assertTrue(EQ(getDynArr(dyn, 3),(float)2), "Test 3rd element == 2");
	//assertTrue(sizeDynArr(dyn) == (float)4, "Test size = 4");
	


	
}
Esempio n. 17
0
void
cosine_of_angle(void)
{
	int n;
	double d;

	if (car(p1) == symbol(ARCCOS)) {
		push(cadr(p1));
		return;
	}

	if (isdouble(p1)) {
		d = cos(p1->u.d);
		if (fabs(d) < 1e-10)
			d = 0.0;
		push_double(d);
		return;
	}

	// cosine function is symmetric, cos(-x) = cos(x)

	if (isnegative(p1)) {
		push(p1);
		negate();
		p1 = pop();
	}

	// cos(arctan(x)) = 1 / sqrt(1 + x^2)

	// see p. 173 of the CRC Handbook of Mathematical Sciences

	if (car(p1) == symbol(ARCTAN)) {
		push_integer(1);
		push(cadr(p1));
		push_integer(2);
		power();
		add();
		push_rational(-1, 2);
		power();
		return;
	}

	// multiply by 180/pi

	push(p1);
	push_integer(180);
	multiply();
	push_symbol(PI);
	divide();

	n = pop_integer();

	if (n < 0) {
		push(symbol(COS));
		push(p1);
		list(2);
		return;
	}

	switch (n % 360) {
	case 90:
	case 270:
		push_integer(0);
		break;
	case 60:
	case 300:
		push_rational(1, 2);
		break;
	case 120:
	case 240:
		push_rational(-1, 2);
		break;
	case 45:
	case 315:
		push_rational(1, 2);
		push_integer(2);
		push_rational(1, 2);
		power();
		multiply();
		break;
	case 135:
	case 225:
		push_rational(-1, 2);
		push_integer(2);
		push_rational(1, 2);
		power();
		multiply();
		break;
	case 30:
	case 330:
		push_rational(1, 2);
		push_integer(3);
		push_rational(1, 2);
		power();
		multiply();
		break;
	case 150:
	case 210:
		push_rational(-1, 2);
		push_integer(3);
		push_rational(1, 2);
		power();
		multiply();
		break;
	case 0:
		push_integer(1);
		break;
	case 180:
		push_integer(-1);
		break;
	default:
		push(symbol(COS));
		push(p1);
		list(2);
		break;
	}
}
Esempio n. 18
0
	// ----------------------------------------------------------------------------
	//	parses the next command from m_instrStream
	// ----------------------------------------------------------------------------
	void CRPNCalc::parse()
	{
		double number = 0;
		while (m_buffer.length() != 0)
		{
			bool delDecimal = false;
			//erase the spaces at the beginning of the string
			while(m_buffer[0] == ' ')
				m_buffer.erase(m_buffer.begin());
			number = atof(m_buffer.c_str());
			//if it is a number
			if((number != 0 && m_buffer[0] != '+') || m_buffer[0] == '0')
			{
				if(m_buffer[0] == '-')
					m_buffer.erase(m_buffer.begin());
				while((m_buffer[0] >= '0' && m_buffer[0] <= '9')
					|| m_buffer[0] == '.')
				{
					if(m_buffer[0] == '.')
						if(delDecimal == false)
							delDecimal = true;
						else
							break;
					m_buffer.erase(m_buffer.begin());
					if(m_buffer.length() == 0)
						break;
				}
				m_stack.push_front(number);
			}
			else
			{
				string token;
				//if the beginning is a character
				if(m_buffer.length() >= 2)
				{
					//special situation with CE
					if(toupper(m_buffer[0]) == 'C' 
						&& toupper(m_buffer[1]) == 'E')
					{
						m_buffer.erase(m_buffer.begin(),m_buffer.begin() + 2);
						clearAll();
						continue;
					}
					//special situation with -0
					else if(m_buffer[0] == '-' && m_buffer[1] == '0')
					{
						m_buffer.erase(m_buffer.begin());
						while(m_buffer[0] == '0')
						{
							m_buffer.erase(m_buffer.begin());
							if(m_buffer.length() == 0)
								break;
						}
						m_stack.push_front(number);
						neg();
						continue;
					}
					//special situation with S0-9
					else if(toupper(m_buffer[0]) == 'S' && 
						m_buffer[1] >= '0' && m_buffer[1] <= '9')
					{
						m_buffer.erase(m_buffer.begin()); // delete the 'S' to get the number
						char index = m_buffer[0];
						setReg(static_cast<int>(index) - ZEROINASCII);
						m_buffer.erase(m_buffer.begin()); // delete the number
						continue;
					}
					//special situation with G0-9
					else if(toupper(m_buffer[0]) == 'G' && 
						m_buffer[1] >= '0' && m_buffer[1] <= '9')
					{
						m_buffer.erase(m_buffer.begin()); // delete the 'G' to get the number
						char index = m_buffer[0];
						getReg(static_cast<int>(index) - ZEROINASCII);
						m_buffer.erase(m_buffer.begin()); // delete the number
						continue;
					}
				}
				if (m_buffer.length() != 0)
				{
					token = m_buffer[0];
					if (0 == token.compare("+"))
						add();
					else if (0 == token.compare("-"))
						subtract();
					else if (0 == token.compare("*"))
						multiply();
					else if (0 == token.compare("/"))
						divide();
					else if (0 == token.compare("^"))
						exp();
					else if (0 == token.compare("%"))
						mod();
					else if (0 == token.compare("c") || 0 == token.compare("C"))
						clearEntry();
					else if (0 == token.compare("d") || 0 == token.compare("D"))
						rotateDown();
					else if (0 == token.compare("f") || 0 == token.compare("F"))
						saveToFile();
					else if (0 == token.compare("h") || 0 == token.compare("H"))
						m_helpOn = !m_helpOn;
					else if (0 == token.compare("l") || 0 == token.compare("L"))
						loadProgram();
					else if (0 == token.compare("m") || 0 == token.compare("M"))
						neg();
					else if (0 == token.compare("p") || 0 == token.compare("P"))
						recordProgram();
					else if (0 == token.compare("r") || 0 == token.compare("R"))
					{
						//the application only do this method and ignore other methods
						//if they are inputed at the same line
						runProgram();
						return;
					}
					else if (0 == token.compare("u") || 0 == token.compare("U"))
						rotateUp();
					else if (0 == token.compare("x") || 0 == token.compare("X"))
						m_on = false;
					else
						m_error = true;
					m_buffer.erase(m_buffer.begin());
				}
			}
		}
	}
Esempio n. 19
0
int main()
{  /*  factoring program using Williams (p+1) method */
    int k,phase,m,nt,iv,pos,btch;
    long i,p,pa,interval;
    big b,q,n,fp,fvw,fd,fn,t;
    static big fu[1+MULT/2];
    static BOOL cp[1+MULT/2];
    mip=mirsys(30,0);
    b=mirvar(0);
    q=mirvar(0);
    n=mirvar(0);
    t=mirvar(0);
    fp=mirvar(0);
    fvw=mirvar(0);
    fd=mirvar(0);
    fn=mirvar(0);
    gprime(LIMIT1);
    for (m=1;m<=MULT/2;m+=2)
        if (igcd(MULT,m)==1)
        {
            fu[m]=mirvar(0);
            cp[m]=TRUE;
        }
        else cp[m]=FALSE;
    printf("input number to be factored\n");
    cinnum(n,stdin);
    if (isprime(n))
    {
        printf("this number is prime!\n");
        return 0;
    }
    for (nt=0,k=3;k<10;k++)
    { /* try more than once for p+1 condition (may be p-1) */
        convert(k,b);              /* try b=3,4,5..        */
        convert((k*k-4),t);
        if (egcd(t,n,t)!=1) continue; /* check (b*b-4,n)!=0 */
        nt++;
        phase=1;
        p=0;
        btch=50;
        i=0;
        printf("phase 1 - trying all primes less than %d\n",LIMIT1);
        printf("prime= %8ld",p);
        forever
        { /* main loop */
            if (phase==1)
            { /* looking for all factors of p+1 < LIMIT1 */
                p=mip->PRIMES[i];
                if (mip->PRIMES[i+1]==0)
                { /* now change gear */
                    phase=2;
                    printf("\nphase 2 - trying last prime less than %ld\n"
                           ,LIMIT2);
                    printf("prime= %8ld",p);
                    copy(b,fu[1]);
                    copy(b,fp);
                    mad(b,b,b,n,n,fd);
                    decr(fd,2,fd);     
                    negify(b,t);
                    mad(fd,b,t,n,n,fn);
                    for (m=5;m<=MULT/2;m+=2)
                    { /* store fu[m] = Vm(b) */
                        negify(fp,t);
                        mad(fn,fd,t,n,n,t);
                        copy(fn,fp);
                        copy(t,fn);
                        if (!cp[m]) continue;
                        copy(t,fu[m]);
                    }
                    convert(MULT,t);    
                    lucas(b,t,n,fp,fd);
                    iv=(int)(p/MULT);
                    if (p%MULT>MULT/2) iv++;
                    interval=(long)iv*MULT;
                    p=interval+1;
                    convert(iv,t);
                    lucas(fd,t,n,fp,fvw);
                    negify(fp,fp);
                    subtract(fvw,fu[p%MULT],q);
                    marks(interval);
                    btch*=100;
                    i++;
                    continue;
                }
                pa=p;
                while ((LIMIT1/p) > pa) pa*=p;
                convert((int)pa,t);   
                lucas(b,t,n,fp,q);
                copy(q,b);
                decr(q,2,q);
            }
            else
            { /* phase 2 - looking for last large prime factor of (p+1) */
                p+=2;
                pos=(int)(p%MULT);
                if (pos>MULT/2)
                { /* increment giant step */
                    iv++;
                    interval=(long)iv*MULT;
                    p=interval+1;
                    marks(interval);
                    pos=1;
                    copy(fvw,t);
                    mad(fvw,fd,fp,n,n,fvw);
                    negify(t,fp);
                }
                if (!cp[pos]) continue;

        /* if neither interval+/-pos is prime, don't bother */
                if (!plus[pos] && !minus[pos]) continue;
                subtract(fvw,fu[pos],t);
                mad(q,t,t,n,n,q);  /* batching gcds */
            }
            if (i++%btch==0)
            { /* try for a solution */
                printf("\b\b\b\b\b\b\b\b%8ld",p);
                fflush(stdout);
                egcd(q,n,t);
                if (size(t)==1)
                {
                    if (p>LIMIT2) break;
                    else continue;
                }
                if (compare(t,n)==0)
                {
                    printf("\ndegenerate case");
                    break;
                }
                printf("\nfactors are\n");
                if (isprime(t)) printf("prime factor     ");
                else          printf("composite factor ");
                cotnum(t,stdout);
                divide(n,t,n);
                if (isprime(n)) printf("prime factor     ");
                else          printf("composite factor ");
                cotnum(n,stdout);
                return 0;
            }
        } 
        if (nt>=NTRYS) break;
        printf("\ntrying again\n");
    }
    printf("\nfailed to factor\n");
    return 0;
}
Esempio n. 20
0
int main() {
    char char_response = 0;
    unsigned int first_operand = 0;
    unsigned int second_operand = 0;
    int end_of_operand_flag = 0;
    int operand_success = 0;
    int operation_success = 0;
    char operation = 0;

    printf("Let's test some simple expressions. Type \'N\' at any time to exit.\nPlease input an expression: ");
    while ((char_response = getchar()) != EOF) {
        putchar(char_response);

        if (char_response == 'N') {
            printf("\nThanks for playing. Goodbye.\n");
            break;
        }
        if (isNumChecker(char_response)) {
            if (operand_success == 0) {
                first_operand = makeOperand(char_response, first_operand);
                // printf("\nfirst_operand = %d\n", first_operand);
            }
            if (operand_success == 1) {
                second_operand = makeOperand(char_response, second_operand);
                // printf("\nsecond_operand = %d\n", second_operand);
            }
            end_of_operand_flag = 1;
        }
        if (!isNumChecker(char_response) && end_of_operand_flag == 1) {
            operand_success++;
            end_of_operand_flag = 0;
        }
        if (isOperator(char_response)) {
            if (operation_success == 0 && operand_success == 1) operation = char_response;
            // printf ("\noperator = %c\n", operation);
            operation_success++;
        }
        if (char_response == '\n') {
            // printf("Successful operands = %d\nSuccessful operations = %d\n", operand_success, operation_success);
            if (operation == 0 || operation_success > 1) printf("Invalid expression.\n");
            if (operand_success == 2 && operation_success == 1) {
                if (operation == '+') add(first_operand, second_operand);
                if (operation == '-') subtract(first_operand, second_operand);
                if (operation == '*') multiply(first_operand, second_operand);
                if (operation == '/') divide(first_operand, second_operand);
                if (operation == '%') modulo(first_operand, second_operand);
            }
            printf("Please input a valid expression: ");

            /* Reset all variables */
            first_operand = 0;
            second_operand = 0;
            end_of_operand_flag = 0;
            operand_success = 0;
            operation_success = 0;
            operation = 0;
        }
    }

    return 0;
}
Esempio n. 21
0
Bignum* modulus(Bignum *n1, Bignum *n2, Bignum *r) {
	Bignum aux1, aux2;
	return subtract(n1,multiply(divide(n1,n2,&aux1),n2,&aux2),r);
}
Esempio n. 22
0
Complex Complex::operator/(Complex c){
    return divide(c);
}
Esempio n. 23
0
CompositeWeight<W1, W2, W3> divide(CompositeWeight<W1, W2, W3> const& x, CompositeWeight<W1, W2, W3> const& y) {
  W1 w1(divide(x.weight1(), y.weight1()));
  W2 w2(divide(x.weight2(), y.weight2()));
  W3 w3(divide(x.weight3(), y.weight3()));
  return CompositeWeight<W1, W2, W3>(w1, w2, w3);
}
Esempio n. 24
0
int main()
{
    int a[] = {120, 140, 20, 30 ,40 , 50 ,60 ,70 , 800 , 1000, 10, 5};

    divide(a, sizeof(a)/ sizeof(int));
}
	vec2& vec2::operator/=(const vec2& other){
		return divide(other);
	}
Esempio n. 26
0
Polynom Polynom::operator / (const Polynom& _another) const {
	return divide(_another).first;
}
Esempio n. 27
0
bignum modulo (bignum x, bignum y) {
  return minus(x, multiply(y, divide(x, y)));
}
Esempio n. 28
0
Polynom Polynom::operator % (const Polynom& _another) const {
	return divide(_another).second;
}
Esempio n. 29
0
//TODO remove pModel
CEvaluationNode* CDerive::deriveBranch(const CEvaluationNode* node, const CCopasiObject * pObject,
                                       std::vector<const CEvaluationNode*>& env,
                                       //std::vector<const CCopasiObject*>& objenv,
                                       const CEvaluationTree* pTree,
                                       bool simplify)
{
  CEvaluationNode * newNode = NULL;

  const CEvaluationNodeOperator * pENO = dynamic_cast<const CEvaluationNodeOperator*>(node);

  if (pENO)
    {
      if (!pENO->getLeft() || !pENO->getRight()) return NULL;

      CEvaluationNode * pLeftDeriv = deriveBranch(pENO->getLeft(), pObject, env, pTree, simplify);

      if (!pLeftDeriv) return NULL;

      CEvaluationNode * pRightDeriv = deriveBranch(pENO->getRight(), pObject, env, pTree, simplify);

      if (!pRightDeriv) {delete pLeftDeriv; return NULL;}

      // we now know that derivations of the left and right branch exist

      switch (pENO->subType())
        {
          case CEvaluationNode::S_MULTIPLY:
          {
            CEvaluationNode * pLeftCopy = copyBranch_var2obj(pENO->getLeft(), env);
            CEvaluationNode * pRightCopy = copyBranch_var2obj(pENO->getRight(), env);

            CEvaluationNode * tmpNode1 = multiply(pRightCopy, pLeftDeriv, simplify);
            CEvaluationNode * tmpNode2 = multiply(pRightDeriv, pLeftCopy, simplify);

            return add(tmpNode1, tmpNode2, simplify);
          }
          break;

          case CEvaluationNode::S_DIVIDE:
          {
            CEvaluationNode * pLeftCopy = copyBranch_var2obj(pENO->getLeft(), env);
            CEvaluationNode * pRightCopy = copyBranch_var2obj(pENO->getRight(), env);

            //numerator
            CEvaluationNode * tmpNode1 = multiply(pRightCopy, pLeftDeriv, simplify);
            CEvaluationNode * tmpNode2 = multiply(pRightDeriv, pLeftCopy, simplify);

            CEvaluationNode * minusNode = subtract(tmpNode1, tmpNode2, simplify);

            minusNode->compile(NULL);

            //denominator
            CEvaluationNode * powerNode = power(copyBranch_var2obj(pENO->getRight(), env),
                                                new CEvaluationNodeNumber(CEvaluationNode::S_INTEGER, "2"),
                                                simplify);

            return divide(minusNode, powerNode, simplify);
          }
          break;

          case CEvaluationNode::S_PLUS:

            return add(pLeftDeriv, pRightDeriv, simplify);
            break;

          case CEvaluationNode::S_MINUS:

            return subtract(pLeftDeriv, pRightDeriv, simplify);
            break;

          case CEvaluationNode::S_POWER:
          {
            // b-1
            CEvaluationNode * tmpNode = subtract(copyBranch_var2obj(pENO->getRight(), env),
                                                 new CEvaluationNodeNumber(CEvaluationNode::S_INTEGER, "1"),
                                                 simplify);

            // a^(b-1)
            CEvaluationNode * powerNode = power(copyBranch_var2obj(pENO->getLeft(), env), tmpNode, simplify);

            // b*a'
            tmpNode = multiply(copyBranch_var2obj(pENO->getRight(), env),
                               pLeftDeriv, simplify);

            // ln a
            CEvaluationNodeFunction * funcNode = new CEvaluationNodeFunction(CEvaluationNode::S_LOG, "ln");
            funcNode->addChild(copyBranch_var2obj(pENO->getLeft(), env)); // add a

            // a * b' * ln a
            CEvaluationNode * tmpNode2 = multiply(copyBranch_var2obj(pENO->getLeft(), env),
                                                  multiply(pRightDeriv, funcNode, simplify),
                                                  simplify);

            // b*a + a*b * ln a
            CEvaluationNode * plusNode = add(tmpNode, tmpNode2, simplify);

            // a^(b-1)*(b*a + a*b * ln a)
            return multiply(powerNode, plusNode, simplify);
          }
          break;

          default:
            break;
        }
    }

  const CEvaluationNodeVariable * pENV = dynamic_cast<const CEvaluationNodeVariable*>(node);

  if (pENV)
    {
      if (!env[pENV->getIndex()])
        return NULL;

      //basically just expand the tree.
      return deriveBranch(env[pENV->getIndex()], pObject, env, pTree, simplify);
    }

  const CEvaluationNodeNumber * pENN = dynamic_cast<const CEvaluationNodeNumber*>(node);

  if (pENN)
    {
      newNode = new CEvaluationNodeNumber(CEvaluationNode::S_INTEGER, "0");
      return newNode;
    }

  const CEvaluationNodeObject *pENObj = dynamic_cast<const CEvaluationNodeObject*>(node);

  if (pENObj)
    {
      //first check whether the object is the derivation variable
      if (pObject->getCN() == pENObj->getObjectCN())
        {
          //std::cout << "*";
          return new CEvaluationNodeNumber(CEvaluationNode::S_INTEGER, "1");
        }

      //now we need to check if we know something about the object so that it needs to be expanded
      const CCopasiObject * tmpObj = (const CCopasiObject *)pENObj->getObjectInterfacePtr();

      if (!tmpObj)
        return NULL;

      //object is a concentration?
      if (tmpObj->getObjectName() == "Concentration")
        {
          //std::cout << "Concentration found" << std::endl;
          //In this context, the concentration is expanded as "amount of substance/volume"
          std::string tmpstr = tmpObj->getObjectParent() ? "<" + tmpObj->getObjectParent()->getCN() + ",Reference=ParticleNumber>" : "<>";
          CEvaluationNodeObject* amount = new CEvaluationNodeObject(CEvaluationNode::S_CN, tmpstr);
          amount->compile(pTree);

          tmpstr = tmpObj->getObjectAncestor("Compartment") ? "<" + tmpObj->getObjectAncestor("Compartment")->getCN() + ",Reference=Volume>"  : "<>";
          CEvaluationNodeObject* volume = new CEvaluationNodeObject(CEvaluationNode::S_CN, tmpstr);
          volume->compile(pTree);
          CEvaluationNodeObject* volume2 = new CEvaluationNodeObject(CEvaluationNode::S_CN, tmpstr); //we need this node twice
          volume2->compile(pTree);

          CEvaluationNode* damount = deriveBranch(amount, pObject, env, pTree, simplify);
          CEvaluationNode* dvolume = deriveBranch(volume, pObject, env, pTree, simplify);

          // A / V - A*V /V^2
          return
            subtract(divide(damount, volume, simplify),
                     divide(multiply(amount, dvolume, simplify),
                            power(volume2, new CEvaluationNodeNumber(CEvaluationNode::S_INTEGER, "2"), simplify),
                            simplify),
                     simplify);
        }

      //TODO:
      //object is an object with an assignment
      //object is dependent species
      //object is a reaction rate

      // otherwise return 0.
      return new CEvaluationNodeNumber(CEvaluationNode::S_INTEGER, "0");
    }

  const CEvaluationNodeCall  *pENCall = dynamic_cast<const CEvaluationNodeCall*>(node);

  if (pENCall)
    {

      //is it a function?
      const CFunction * tmpFunction = dynamic_cast<const CFunction*>(pENCall->getCalledTree());

//     const std::vector<CEvaluationNode *> getListOfChildNodes() const {return mCallNodes;}

      //create call environment for the called function
      std::vector<const CEvaluationNode*> subenv;
      size_t i, imax = pENCall->getListOfChildNodes().size();
      subenv.resize(imax);

      for (i = 0; i < imax; ++i)
        {
          CEvaluationNode* tmpnode = copyBranch_var2obj(pENCall->getListOfChildNodes()[i], env);
          compileTree(tmpnode, pTree);
          subenv[i] = tmpnode;
        }

      return deriveBranch(pENCall->getCalledTree()->getRoot(), pObject,
                          subenv,
                          pTree, simplify);
    }

  return newNode;
}
Esempio n. 30
0
Number* Operations::subtract(Number* firstNum, Number* secondNum)
{
	//Subtract two Integers
	if (firstNum->getType() == INTEGER_TYPE
		&& secondNum->getType() == INTEGER_TYPE) 
	{
		Integer* int1 = (Integer*) firstNum;
		Integer* int2 = (Integer*) secondNum;
		return new Integer(int1->value - int2->value);
	}

	//Subtract two Fractions
	else if (firstNum->getType() == FRACTION_TYPE
		&& secondNum->getType() == FRACTION_TYPE)
		
	{
		Fraction* f1 = (Fraction*) firstNum;
		Fraction* f2 = (Fraction*) secondNum;
		int num = f1->num * f2->den - f2->num * f1->den;
		int den = f1->den * f2->den;
		return (new Fraction(num,den))->simplify();
	}
	
	//Subtract one Fraction and one Integer
	else if (firstNum->getType() == INTEGER_TYPE && secondNum->getType() == FRACTION_TYPE){
	  Integer* int1 = (Integer*) firstNum;
	  Fraction* f2 = (Fraction*) secondNum;
	  int  newNum = f2-> num - f2->den * int1->value;
	  return (new Fraction(newNum, f2->den))->simplify();
	}
	else if (firstNum->getType() == FRACTION_TYPE && secondNum->getType() == INTEGER_TYPE){
	  Fraction* f1 = (Fraction*) firstNum;
	  Integer* int2 = (Integer*) secondNum;
	  int  newNum = f1->num - f1->den * int2->value;
	  return (new Fraction(newNum, f1->den))->simplify();
	}
	
	//Subtract two Logs
	else if (firstNum->getType() == LOG_TYPE
		&& secondNum->getType() == LOG_TYPE)
	{
		Log* log1 = (Log*) firstNum;
		Log* log2 = (Log*) secondNum;
		if ((log1->base)->equals(log2->base))
			{

				Number* newPower = divide(log1->power,log2->power);
				return (new Log(log1->base,newPower))->simplify();
			}
		else {
			return new Polynomial(log1,'+',log2);// OR Change-of-base?
		}		

	}
	
	//Subtract two Irrationals of same type
	else if (firstNum->getType() == IRRATIONAL_TYPE
		&& secondNum->getType() == IRRATIONAL_TYPE)
	{	
		Irrational* ir1 = (Irrational*) firstNum;
		Irrational* ir2 = (Irrational*) secondNum;
		if(ir1->name == ir2->name)
			return new Integer(0);
		else {
			return new Polynomial(firstNum, '-', secondNum);
		}
	}
	
	else if (firstNum->getType() == POLYNOMIAL_TYPE && secondNum->getType() == POLYNOMIAL_TYPE)
	{
		Polynomial* p1 = (Polynomial*) firstNum;
		Polynomial* p2 = (Polynomial*) secondNum;
		return p1->join(p2,'-');
	}
        else if(firstNum->getType() == POLYNOMIAL_TYPE)
        {
                Polynomial* p1 = (Polynomial*) firstNum;
                return p1->push_back(secondNum,'-');
        }
        else if(secondNum->getType() == POLYNOMIAL_TYPE)
        {
                Polynomial* p2 = (Polynomial*) secondNum;
                return p2->push_back(firstNum,'-');
        }

	//For any other case create Polynomial
	else 
	{
		return new Polynomial(firstNum,'-', secondNum);
	}

	//TODO For debugging
	throw  runtime_error("Number type not supported");
	return new Integer(-1);	
}