Exemple #1
0
int
main(int argc, char **argv)
{
	register int i;
	register char *file;
	struct unit u1, u2;
	double f;

	if(argc>1 && *argv[1]=='-') {
		argc--;
		argv++;
		dumpflg++;
	}
	file = dfile;
	if(argc > 1)
		file = argv[1];
	if ((inp = fopen(file, "r")) == NULL) {
		printf("no table\n");
		exit(1);
	}
	sigset(SIGFPE, fperr);
	init();

loop:
	fperrc = 0;
	printf("you have: ");
	if(convr(&u1))
		goto loop;
	if(fperrc)
		goto fp;
loop1:
	printf("you want: ");
	if(convr(&u2))
		goto loop1;
	for(i=0; i<NDIM; i++)
		if(u1.dim[i] != u2.dim[i])
			goto conform;
	f = u1.factor/u2.factor;
	if(fperrc)
		goto fp;
	printf("\t* %e\n", f);
	printf("\t/ %e\n", 1./f);
	goto loop;

conform:
	if(fperrc)
		goto fp;
	printf("conformability\n");
	units(&u1);
	units(&u2);
	goto loop;

fp:
	printf("underflow or overflow\n");
	goto loop;
}
Exemple #2
0
//////////////////////////////////////////////synths//////////////////////////////////////////////////////////////////////////
void mBior53::synthrows(char** dest, char** sour, unsigned int w, unsigned int h) const      //w,h of the LO part
{
        char srclo[8] = {0, 0, 0, 0, 0, 0, 0, 0};
        char srchi[8] = {0, 0, 0, 0, 0, 0, 0, 0};

        //int n;
        float s2k, s2k1;

        const vec1D& H2m = getH2m();
        const vec1D& G2m = getG2m();
        const vec1D& H2m1 = getH2m1();
        const vec1D& G2m1 = getG2m1();

        for (unsigned int y = 0; y < 2*h; y++) {

                unsigned int k;

                //k = [0; 2)
                for (k = 0; k < 2; k++) {
                        s2k = 0;
                        s2k1 = 0;

                        if (k == 0) {
                                srclo[0] = sour[y][2];
                                srclo[1] = sour[y][1];
                                srclo[2] = sour[y][0];
                                srclo[3] = sour[y][1];
                                srchi[0] = sour[y][2+w];
                                srchi[1] = sour[y][1+w];
                                srchi[2] = sour[y][0+w];
                                srchi[3] = sour[y][1+w];
                        }
                        if (k == 1) {
                                srclo[0] = sour[y][1];
                                srclo[1] = sour[y][0];
                                srclo[2] = sour[y][1];
                                srclo[3] = sour[y][2];
                                srchi[0] = sour[y][1+w];
                                srchi[1] = sour[y][0+w];
                                srchi[2] = sour[y][1+w];
                                srchi[3] = sour[y][2+w];
                        }

                        s2k += H2m[0] * float(sour[y][k]);      //s2k even H
                        s2k += convr(G2m.data(), srchi);

                        s2k1 += convr(H2m1.data(), srclo);
                        s2k1 += convr(G2m1.data(), srchi);

                        dest[y][2*k] = mmxround(2.0f * s2k);
                        dest[y][2*k+1] = mmxround(2.0f * s2k1);
                }


                //k = [2; w-1)
                for (k = 2; k < w - 1; k++) {
                        s2k = 0;
                        s2k1 = 0;

                        s2k += H2m[0] * float(sour[y][k]);              //s2k even H
                        s2k += convr(G2m.data(), &sour[y][k-2+w]);      //s2k even G

                        s2k1 += convr(H2m1.data(), &sour[y][k-2]);       //s2k1 odd H
                        s2k1 += convr(G2m1.data(), &sour[y][k-2+w]);     //s2k1 odd G

                        dest[y][2*k] = mmxround(2.0f * s2k);
                        dest[y][2*k+1] = mmxround(2.0f * s2k1);
                }


                //k = w-1
                k = w - 1;

                srclo[0] = sour[y][k-2];
                srclo[1] = sour[y][k-1];
                srclo[2] = sour[y][k];
                srclo[3] = sour[y][k-1];
                srchi[0] = sour[y][k-2+w];
                srchi[1] = sour[y][k-1+w];
                srchi[2] = sour[y][k+w];
                srchi[3] = sour[y][k-1+w];

                s2k = H2m[0] * float(sour[y][k]);          //s2k even H
                s2k += convr(G2m.data(), srchi);           //s2k even G

                s2k1 = convr(H2m1.data(), srclo);          //s2k1 odd H
                s2k1 += convr(G2m1.data(), srchi);         //s2k1 odd G

                dest[y][2*k] = mmxround(2.0f * s2k);
                dest[y][2*k+1] = mmxround(2.0f * s2k1);
        }
}
Exemple #3
0
static void
init(void)
{
	register char *cp;
	register struct table *tp, *lp;
	int c, i, f, t;
	char *np;

	cp = names;
	for(i=0; i<NDIM; i++) {
		np = cp;
		*cp++ = '*';
		*cp++ = i+'a';
		*cp++ = '*';
		*cp++ = 0;
		lp = hash(np);
		lp->name = np;
		lp->factor = 1.0;
		lp->dim[i] = 1;
	}
	lp = hash("");
	lp->name = cp-1;
	lp->factor = 1.0;

l0:
	c = get();
	if(c == 0) {
		if(dumpflg) {
			printf("%d units; %ld bytes\n\n", i, (long)(cp-names));
			for(tp = &table[0]; tp < &table[NTAB]; tp++) {
				if(tp->name == 0)
					continue;
				printf("%s", tp->name);
				units((struct unit *)tp);
			}
		}
		fclose(inp);
		inp = stdin;
		return;
	}
	if(c == '/') {
		while(c != '\n' && c != 0)
			c = get();
		goto l0;
	}
	if(c == '\n')
		goto l0;
	np = cp;
	while(c != ' ' && c != '\t') {
		*cp++ = c;
		c = get();
		if (c==0)
			goto l0;
		if(c == '\n') {
			*cp++ = 0;
			tp = hash(np);
			if(tp->name)
				goto redef;
			tp->name = np;
			tp->factor = lp->factor;
			for(c=0; c<NDIM; c++)
				tp->dim[c] = lp->dim[c];
			i++;
			goto l0;
		}
	}
	*cp++ = 0;
	lp = hash(np);
	if(lp->name)
		goto redef;
	convr((struct unit *)lp);
	lp->name = np;
	f = 0;
	i++;
	if(lp->factor != 1.0)
		goto l0;
	for(c=0; c<NDIM; c++) {
		t = lp->dim[c];
		if(t>1 || (f>0 && t!=0))
			goto l0;
		if(f==0 && t==1) {
			if(unames[c])
				goto l0;
			f = c+1;
		}
	}
	if(f>0)
		unames[f-1] = np;
	goto l0;

redef:
	printf("redefinition %s\n", np);
	goto l0;
}