July 22, 1999 Ver 1.1
Author:M.Ozawa

Change history


Test function calling sequence

Z Test

int ZTest_1s( int type, ZTEST1s *dat);

	typedef struct ztest1s{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		int	mu;	// ( 0:!=mu0 / 1:<mu0 / -1:>mu0 )
		OBCD	mu0;	// assumed population mean
		OBCD	sig;	// population standard deviation
		OBCD	mean;	// sample mean ( No use when Data type is "List" )
		OBCD	n;	// sample size ( No use when Data type is "List" )
		int	list;	// List No ( 1~20:List1~20 ) ( No use when Data type is "Valiable" )
		int	freq;	// Frequency ( 1~20:List1~20 / 0:All 1 ) ( No use when Data type is "Valiable" )
		OBCD	ans[5];	// Answer
				// ( Data Type: List
				//	ans[0]:Z score
				//	ans[1]:p-value
				//	ans[2]:sample mean
				//	ans[3]:sample standard deviation
				//	ans[4]:sample size
				//   Data Type: Variable
				//	ans[0]:Z score
				//	ans[1]:p-value
				//	ans[2]:sample mean
				//	ans[3]:No use
				//	ans[4]:No use
				// )
	} ZTEST1s;




int ZTest_2s( int type, ZTEST2s *dat);

	typedef struct ztest2s{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		int	mu1;	// ( 0:!=mu2 / 1:<mu2 / -1:>mu2 )
		OBCD	sig1;	// population standard deviation of sample 1
		OBCD	sig2;	// population standard deviation of sample 2
		OBCD	mean1;	// sample 1 mean ( No use when Data type is "List" )
		OBCD	mean2;	// sample 2 mean ( No use when Data type is "List" )
		OBCD	n1;	// sample 1 size ( No use when Data type is "List" )
		OBCD	n2;	// sample 2 size ( No use when Data type is "List" )
		int	list1;	// List1 No( 1~20:List1~20 ) ( No use when Data type is "Valiable" )
		int	list2;	// List2 No( 1~20:List1~20 ) ( No use when Data type is "Valiable" )
		int	freq1;	// Frequency1 ( 1~20:List1~20 / 0:All 1 ) ( No use when Data type is "Valiable" )
		int	freq2;	// Frequency2 ( 1~20:List1~20 / 0:All 1 ) ( No use when Data type is "Valiable" )
		OBCD	ans[8];	// Answer
				// ( Data Type: List
				//	ans[0]:Z score
				//	ans[1]:p-value
				//	ans[2]:sample 1 mean
				//	ans[3]:sample 2 mean
				//	ans[4]:sample 1 standard deviation
				//	ans[5]:sample 2 standard deviation
				//	ans[6]:sample 1 size
				//	ans[7]:sample 2 size
				//   Data Type: Variable
				//	ans[0]:Z score
				//	ans[1]:p-value
				//	ans[2]:sample 1 mean
				//	ans[3]:sample 2 mean
				//	ans[4]:No use
				//	ans[5]:No use
				//	ans[6]:No use
				//	ans[7]:No use
				// )



int ZTest_1p( int type, ZTEST1p *dat);

	typedef struct ztest1p{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		int	prop;	// ( 0:!=p0 / 1:<p0 / -1:>p0 )
		OBCD	p0;	// expected sample proportion
		OBCD	x;	// sample value
		OBCD	n;	// sample size
		OBCD	ans[3];	// ans[0]:Z score
				// ans[1]:p-value
				// ans[2]:estimated sample poplation
	} ZTEST1p;




int ZTest_2p( int type, ZTEST2p *dat);

	typedef struct ztest2p{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		int	p1;	// ( 0:!=p2 / 1:<p2 / -1:>p2 )
		OBCD	x1;	// sample 1 data value
		OBCD	x2;	// sample 2 data value
		OBCD	n1;	// sample 1 size
		OBCD	n2;	// sample 2 size
		OBCD	ans[5];	// ans[0]:Z score
				// ans[1]:p-value
				// ans[2]:estimated poplation of population 1
				// ans[3]:estimated poplation of population 2
				// ans[4]:estimated sample poplation
	} ZTEST2p;




t Test

int tTest_1s( int type, tTEST1s *dat);


	typedef struct ttest1s{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		int	mu;	// ( 0:!=mu0 / 1:<mu0 / -1:>mu0 )
		OBCD	mu0;	// assumed population mean
		OBCD	mean;	// sample mean ( No use when Data type is "List" )
		OBCD	sdev;	// sample standard deviation ( No use when Data type is "List" )
		OBCD	n;	// sample size ( No use when Data type is "List" )
		int	list;	// List No( 1~20:List1~20 ) ( No use when Data type is "Valiable" )
		int	freq;	// Frequency ( 1~20:List1~20 / 0:All 1 ) ( No use when Data type is "Valiable" )
		OBCD	ans[5];	// Answer
				// ( Data Type: List
				//	ans[0]:t-value
				//	ans[1]:p-value
				//	ans[2]:sample mean
				//	ans[3]:sample standard deviation
				//	ans[4]:sample size
				//   Data Type: Variable
				//	ans[0]:t-value
				//	ans[1]:p-value
				//	ans[2]:no use
				//	ans[3]:no use
				//	ans[4]:no use
	} tTEST1s;




int tTest_2s( int type, tTEST2s *dat);


	typedef struct ttest2s{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		int	mu1;	// ( 0:!=mu2 / 1:<mu2 / -1:>mu2 )
		OBCD	mean1;	// sample 1 mean ( No use when Data type is "List" )
		OBCD	mean2;	// sample 2 mean ( No use when Data type is "List" )
		OBCD	sdev1;	// sample 1 standard deviation ( No use when Data type is "List" )
		OBCD	sdev2;	// sample 2 standard deviation ( No use when Data type is "List" )
		OBCD	n1;	// sample 1 size ( No use when Data type is "List" )
		OBCD	n2;	// sample 2 size ( No use when Data type is "List" )
		int	list1;	// List1 No( 1~20:List1~20 ) ( No use when Data type is "Valiable" )
		int	list2;	// List2 No( 1~20:List1~20 ) ( No use when Data type is "Valiable" )
		int	freq1;	// Frequency1 ( 1~20:List1~20 / 0:All 1 ) ( No use when Data type is "Valiable" )
		int	freq2;	// Frequency2 ( 1~20:List1~20 / 0:All 1 ) ( No use when Data type is "Valiable" )
		int	pooled;	// pooling On or Off ( 0:OFF / 1:ON )
		OBCD	ans[10];	// Answer
				// ( Data Type: List
				//	ans[0]:t-value
				//	ans[1]:p-value
				//	ans[2]:degrees of freedom
				//	ans[3]:sample 1 mean
				//	ans[4]:sample 2 mean
				//	ans[5]:sample 1 standard deviation
				//	ans[6]:sample 2 standard deviation
				//	ans[7]:sample 1 size
				//	ans[8]:sample 2 size
				//	ans[9]:pooled sample standard devision
				//   Data Type: Variable
				//	ans[0]:t-value
				//	ans[1]:p-value
				//	ans[2]:degrees of freedom
				//	ans[3]:no use
				//	ans[4]:no use
				//	ans[5]:no use
				//	ans[6]:no use
				//	ans[7]:no use
				//	ans[8]:no use
				//	ans[9]:pooled sample standard devision
	} tTEST2s;





int tTest_lin( int type, tTESTlin *dat);


	typedef struct ttestlin{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
	//(version1.1)		int	bp;	// ( 0:!=0 / 1:<0 / 2:>0 )
		int	bp;	// ( 0:!=0 / 1:<0 / -1:>0 ) (version1.1)
		int	xlist;	// List for x-axis data ( 1~20:List1~20 )
		int	ylist;	// List for y-axis data ( 1~20:List1~20 )
		int	freq;	// Frequency ( 1~20:List1~20 / 0:All 1 )
		OBCD	ans[8];	// Answer
				//	ans[0]:t-value
				//	ans[1]:p-value
				//	ans[2]:degrees of freedom
				//	ans[3]:(a) constant team
				//	ans[4]:(b) coefficient
				//	ans[5]:standard error
				//	ans[6]:correlation coefficient
				//	ans[7]:coefficient of determination
	} tTESTlin;



Chi-square Test

int ChiTest( int type, chiTEST *dat);


	typedef struct chitest{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		int	mat;	// mat no (1:MatA / 2:MatB /...../26:MatZ)
		OBCD	ans[3];	// Answer
				//	ans[0]:chi-square value
				//	ans[1]:p-value
				//	ans[2]:degrees of freedom
	} chiTEST;




F Test

int FTest( int type, FTEST *dat);


	typedef struct ftest{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		int	sigma1;	// ( 0:!=sigma2 / 1:<sigma2 / -1:>sigma2 )
		int	list1;	// List1 No( 1~20:List1~20 ) ( No use when Data type is "Valiable" )
		int	list2;	// List2 No( 1~20:List1~20 ) ( No use when Data type is "Valiable" )
		int	freq1;	// Frequency1 ( 1~20:List1~20 / 0:All 1 ) ( No use when Data type is "Valiable" )
		int	freq2;	// Frequency2 ( 1~20:List1~20 / 0:All 1 ) ( No use when Data type is "Valiable" )
		OBCD	sdev1;	// sample 1 standard deviation ( No use when Data type is "List" )
		OBCD	sdev2;	// sample 2 standard deviation ( No use when Data type is "List" )
		OBCD	n1;	// sample 1 size ( No use when Data type is "List" )
		OBCD	n2;	// sample 2 size ( No use when Data type is "List" )
		OBCD	ans[9];	// Answer
				// ( Data Type: List
				//	ans[0]:F value
				//	ans[1]:p-value
				//	ans[2]:sample 1 standard deviation
				//	ans[3]:sample 2 standard deviation
				//	ans[4]:sample 1 mean
				//	ans[5]:sample 2 mean
				//	ans[7]:sample 1 size
				//	ans[8]:sample 2 size
				// ( Data Type: Value
				//	ans[0]:F value
				//	ans[1]:p-value
				//	ans[2]:no use
				//	ans[3]:no use
				//	ans[4]:sample 1 mean
				//	ans[5]:sample 2 mean
				//	ans[7]:no use
				//	ans[8]:no use
	} FTEST




Analysis of variance

int onewayANOVA_test( int type, ANOVA1w *dat);


	typedef struct anova{
		OBCD	df;		// numerator degrees of freedom
		OBCD	SS;		// factor sum of squares
		OBCD	MS;		// factor mean squares
		OBCD	F;		// F value
		OBCD	p;		// p-value
	} ANOVA;

	typedef struct anovaer{
		OBCD	Edf;	// error degrees of freedom
		OBCD	SSe;	// error sum of squares
		OBCD	MSe;	// error mean squares
	} ANOVAer;


	typedef struct anova1w{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		int	fact;	// Factor list No( 1~20:List1~20 )
		int	dep;	// Dependent list No( 1~20:List1~20 )
	//(version1.1)	OBCD	ans_p;	// pooled sample standard deviation
		ANOVA	ans;	// F value 
				// p-value
				// numerator degrees of freedom
				// factor sum of squares
				// factor mean squares
		ANOVAer	ERans;	// error degrees of freedom
				// error sum of squares
				// error mean squares
	} ANOVA1w;




int twowayANOVA_test( int type, ANOVA2w *dat);


	typedef struct anova{
		OBCD	df;		// numerator degrees of freedom
		OBCD	SS;		// factor sum of squares
		OBCD	MS;		// factor mean squares
		OBCD	F;		// F value
		OBCD	p;		// p-value
	} ANOVA;

	typedef struct anovaer{
		OBCD	Edf;	// error degrees of freedom
		OBCD	SSe;	// error sum of squares
		OBCD	MSe;	// error mean squares
	} ANOVAer;

	typedef struct anova2w{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		int	factA;	// FactorA list No( 1~20:List1~20 )
		int	factB;	// FactorB list No( 1~20:List1~20 )
		int	dep;	// Dependent list No( 1~20:List1~20 )
		int	intr;	// Interact ( 0:Yes / 1:No )
		ANOVA	Aansa;	// A:  F value 
				// A:  p-value
				// A:  numerator degrees of freedom
				// A:  factor sum of squares
				// A:  factor mean squares
		ANOVA	Bansa;	// B:  F value 
				// B:  p-value
				// B:  numerator degrees of freedom
				// B:  factor sum of squares
				// B:  factor mean squares
		ANOVA	ABansa;	// AB: F value 
				// AB: p-value
				// AB: numerator degrees of freedom
				// AB: factor sum of squares
				// AB: factor mean squares
		ANOVAer	ERans;	// error degrees of freedom
				// error sum of squares
				// error mean squares
	} ANOVA2w;





Confidence Interval function calling sequence

Z Confidence Interval

int ZInterval_1s( int type, ZINTR1s *dat);


	typedef struct zintr1s{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		OBCD	clev;	// confidence level
		OBCD	sigma;	// poplation standard deviation
		OBCD	mean;	// sample mean ( No use when Data type is "List" )
		OBCD	n;	// sample size ( No use when Data type is "List" )
		int	list;	// List No( 1~20:List1~20 ) ( No use when Data type is "Valiable" )
		int	freq;	// Frequency ( 1~20:List1~20 / 0:All 1 ) ( No use when Data type is "Valiable" )
		OBCD	ans[5];	// Answer
				// ( Data Type: List
				//	ans[0]:interval lower limit(left edge)
				//	ans[1]:interval upper limit(right edge)
				//	ans[2]:sample standard deviation
				//	ans[3]:sample mean
				//	ans[4]:sample size
				// ( Data Type: Value
				//	ans[0]:interval lower limit(left edge)
				//	ans[1]:interval upper limit(right edge)
				//	ans[2]:sample standard deviation
				//	ans[3]:no use
				//	ans[4]:no use
	} ZINTR1s;




int ZInterval_2s( int type, ZINTR2s *dat);


	typedef struct zintr2s{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		OBCD	clev;	// confidence level
		OBCD	sigma1;	// poplation standard deviation of sample 1
		OBCD	sigma2;	// poplation standard deviation of sample 2
		OBCD	mean1;	// sample 1 mean ( No use when Data type is "List" )
		OBCD	mean2;	// sample 2 mean ( No use when Data type is "List" )
		OBCD	n1;	// sample 1 size ( No use when Data type is "List" )
		OBCD	n2;	// sample 2 size ( No use when Data type is "List" )
		int	list1;	// List1 No( 1~20:List1~20 ) ( No use when Data type is "Valiable" )
		int	list2;	// List2 No( 1~20:List1~20 ) ( No use when Data type is "Valiable" )
		int	freq1;	// Frequency1 ( 1~20:List1~20 / 0:All 1 ) ( No use when Data type is "Valiable" )
		int	freq2;	// Frequency2 ( 1~20:List1~20 / 0:All 1 ) ( No use when Data type is "Valiable" )
		OBCD	ans[8];	// Answer
				// ( Data Type: List
				//	ans[0]:interval lower limit(left edge)
				//	ans[1]:interval upper limit(right edge)
				//	ans[2]:sample 1 standard deviation
				//	ans[3]:sample 2 standard deviation
				//	ans[4]:sample 1 mean
				//	ans[5]:sample 2 mean
				//	ans[6]:sample 1 size
				//	ans[7]:sample 2 size
				// ( Data Type: Value
				//	ans[0]:interval lower limit(left edge)
				//	ans[1]:interval upper limit(right edge)
				//	ans[2]:sample 1 standard deviation
				//	ans[3]:sample 2 standard deviation
				//	ans[4]:no use
				//	ans[5]:no use
				//	ans[6]:no use
				//	ans[7]:no use
	} ZINTR2s;




int ZInterval_1p( int type, ZINTR1p *dat);


	typedef struct zintr1p{
		int	angle;	// // Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		OBCD	clev;	// confidence level
		OBCD	x;	// data
		OBCD	n;	// sample size
		OBCD	ans[3];	// Answer
				//	ans[0]:interval lower limit(left edge)
				//	ans[1]:interval upper limit(right edge)
				//	ans[2]:expected p-value
	} ZINTR1p;




int ZInterval_2p( int type, ZINTR2p *dat);


	typedef struct zintr2p{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		OBCD	clev;	// confidence level
		OBCD	x1;	// sample 1 data value
		OBCD	x2;	// sample 2 data value
		OBCD	n1;	// sample 1 size
		OBCD	n2;	// sample 2 size
		OBCD	ans[4];	// Answer
				//	ans[0]:interval lower limit(left edge)
				//	ans[1]:interval upper limit(right edge)
				//	ans[2]:expected p-value 1
				//	ans[3]:expected p-value 2
	} ZINTR2p;




t Confidence Test

int tI nterval_1s( int type, tINTR1s *dat);


	typedef struct tintr1s{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		OBCD	clev;	// confidence level
		OBCD	mean;	// sample mean ( No use when Data type is "List" )
		OBCD	sdev;	// sample standard deviation ( No use when Data type is "List" )
		OBCD	n;	// sample size ( No use when Data type is "List" )
		int	list;	// List No( 1~20:List1~20 ) ( No use when Data type is "Valiable" )
		int	freq;	// Frequency ( 1~20:List1~20 / 0:All 1 ) ( No use when Data type is "Valiable" )
		OBCD	ans[5];	// Answer
				// ( Data Type: List
				//	ans[0]:interval lower limit(left edge)
				//	ans[1]:interval upper limit(right edge)
				//	ans[2]:sample standard deviation
				//	ans[3]:sample mean
				//	ans[4]:sample size
				// ( Data Type: Value
				//	ans[0]:interval lower limit(left edge)
				//	ans[1]:interval upper limit(right edge)
				//	ans[2]:no use
				//	ans[3]:no use
				//	ans[4]:no use
	} tINTR1s;





int tInterval_2s( int type, tINTR2s *dat);


	typedef struct tintr2s{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		OBCD	clev;	// confidence level
		OBCD	mean1;	// sample 1 mean ( No use when Data type is "List" )
		OBCD	mean2;	// sample 2 mean ( No use when Data type is "List" )
		OBCD	sdev1;	// sample 1 standard deviation ( No use when Data type is "List" )
		OBCD	sdev2;	// sample 2 standard deviation ( No use when Data type is "List" )
		OBCD	n1;	// sample 1 size ( No use when Data type is "List" )
		OBCD	n2;	// sample 2 size ( No use when Data type is "List" )
		int	list1;	// List1 No( 1~20:List1~20 ) ( No use when Data type is "Valiable" )
		int	list2;	// List2 No( 1~20:List1~20 ) ( No use when Data type is "Valiable" )
		int	freq1;	// Frequency1 ( 1~20:List1~20 / 0:All 1 ) ( No use when Data type is "Valiable" )
		int	freq2;	// Frequency2 ( 1~20:List1~20 / 0:All 1 ) ( No use when Data type is "Valiable" )
		int	pooled;	// pooling On or Off ( 0:OFF / 1:ON )
		OBCD	ans[9];	// Answer
				// ( Data Type: List
				//	ans[0]:interval lower limit(left edge)
				//	ans[1]:interval upper limit(right edge)
				//	ans[2]:degree of freedom
				//	ans[3]:sample 1 standard deviation
				//	ans[4]:sample 2 standard deviation
				//	ans[5]:sample 1 mean
				//	ans[6]:sample 2 mean
				//	ans[7]:sample 1 size
				//	ans[8]:sample 2 size
				// ( Data Type: Value
				//	ans[0]:interval lower limit(left edge)
				//	ans[1]:interval upper limit(right edge)
				//	ans[2]:degree of freedom
				//	ans[3]:no use
				//	ans[4]:no use
				//	ans[5]:no use
				//	ans[6]:no use
				//	ans[7]:no use
				//	ans[8]:no use
	} tINTR2s;




Distribution function calling sequence

Normal Distribution

int NormPDist( int type, NDIST *dat);


	typedef struct ndist{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		int	tail;	// Tail(-1:LEFT / 0:CENTRAL / 1:RIGHT) ( Use when FUNCTION type is "InvNormDist()" only)(from version1.1)
		OBCD	x;	// data ( Use when FUNCTION type is "NormPDist()" only)
		OBCD	low;	// lower boundary( Use when FUNCTION type is "NormCDist()" only)
		OBCD	up;	// upper boundary( Use when FUNCTION type is "NormCDist()" only)
		OBCD	area;	// probablitity value( Use when FUNCTION type is "InvNormDist()" only)
		OBCD	sig;	// population standard deviation
		OBCD	mu;	// population mean
	//(Version1.1)	OBCD	ans[3];	// Answer
		OBCD	ans[6];	// Answer(form version1.1)
				//	ans[0]:normal probability dencity ( Use when FUNCTION type is "NormPDist()" only)
				//	ans[1]:normal distribution probability ( Use when FUNCTION type is "NormCDist()" only)
				//	ans[2]:inverse cumulative normal distribution( Use when FUNCTION type is "InvNormDist()" only)
				//	ans[3]:inverse cumulative normal distribution2( Use when FUNCTION type is "InvNormDist()"(CENTRAL); only)(from version1.1)
				//	ans[4]:z:Low ( Use when FUNCTION type is "NormCDist()" only)(from version1.1)
				//	ans[5]:z:Up ( Use when FUNCTION type is "NormCDist()" only)(from version1.1)
	} NDIST;




int NormCDist( int type, NDIST *dat);


	typedef struct ndist{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		OBCD	x;	// data ( Use when FUNCTION type is "NormPDist()" only)
		OBCD	low;	// lower boundary( Use when FUNCTION type is "NormCDist()" only)
		OBCD	up;	// upper boundary( Use when FUNCTION type is "NormCDist()" only)
		OBCD	area;	// probablitity value( Use when FUNCTION type is "InvNormDist()" only)
		OBCD	sig;	// population standard deviation
		OBCD	mu;	// population mean
		OBCD	ans[3];	// Answer
				//	ans[0]:normal probability dencity ( Use when FUNCTION type is "NormPDist()" only)
				//	ans[1]:normal distribution probability ( Use when FUNCTION type is "NormCDist()" only)
				//	ans[2]:inverse cumulative normal distribution( Use when FUNCTION type is "InvNormDist()" only)
	} NDIST;



int InvNormDist( int type, NDIST *dat);

	typedef struct ndist{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		OBCD	x;	// data ( Use when FUNCTION type is "NormPDist()" only)
		OBCD	low;	// lower boundary( Use when FUNCTION type is "NormCDist()" only)
		OBCD	up;	// upper boundary( Use when FUNCTION type is "NormCDist()" only)
		OBCD	area;	// probablitity value( Use when FUNCTION type is "InvNormDist()" only)
		OBCD	sig;	// population standard deviation
		OBCD	mu;	// population mean
		OBCD	ans[3];	// Answer
				//	ans[0]:normal probability dencity ( Use when FUNCTION type is "NormPDist()" only)
				//	ans[1]:normal distribution probability ( Use when FUNCTION type is "NormCDist()" only)
				//	ans[2]:inverse cumulative normal distribution( Use when FUNCTION type is "InvNormDist()" only)
	} NDIST;



Student-t Distribution

int tPDist( int type, TDIST *dat);


	typedef struct tdist{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		OBCD	x;	// data ( Use when FUNCTION type is "tPDist()" only)
		OBCD	low;	// lower boundary( Use when FUNCTION type is "tCDist()" only)
		OBCD	up;	// upper boundary( Use when FUNCTION type is "tCDist()" only)
		OBCD	df;	// degrees of freedom
	//(version1.1)	OBCD	ans[2];	// Answer
		OBCD	ans[4];	// Answer(from version1.1)
				//	ans[0]:Student-t probability dencity ( Use when FUNCTION type is "tPDist()" only)
				//	ans[1]:Student-t distribution probability ( Use when FUNCTION type is "tCDist()" only)
				//	ans[2]:t:Low( Use when FUNCTION type is "tCDist()" only)(from version1.1)
				//	ans[3]:t:Up( Use when FUNCTION type is "tCDist()" only)(from version1.1)
	} TDIST;



int tCDist( int type, TDIST *dat);


	typedef struct tdist{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		OBCD	x;	// data ( Use when FUNCTION type is "tPDist()" only)
		OBCD	low;	// lower boundary( Use when FUNCTION type is "tCDist()" only)
		OBCD	up;	// upper boundary( Use when FUNCTION type is "tCDist()" only)
		OBCD	df;	// degrees of freedom
		OBCD	ans[2];	// Answer
				//	ans[0]:Student-t probability dencity ( Use when FUNCTION type is "tPDist()" only)
				//	ans[1]:Student-t distribution probability ( Use when FUNCTION type is "tCDist()" only)
	} TDIST;




Chi-square Distribution

int ChiPDist( int type, chiDIST *dat);


	typedef struct chidist{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		OBCD	x;	// data ( Use when FUNCTION type is "chiPDist()" only)
		OBCD	low;	// lower boundary( Use when FUNCTION type is "chiCDist()" only)
		OBCD	up;	// upper boundary( Use when FUNCTION type is "chiCDist()" only)
		OBCD	df;	// degrees of freedom
		OBCD	ans[2];	// Answer
				//	ans[0]:chi-square probability dencity ( Use when FUNCTION type is "chiPDist()" only)
				//	ans[1]:chi-square distribution probability ( Use when FUNCTION type is "chiCDist()" only)
	} chiDIST;




int ChiCDist( int type, chiDIST *dat);


	typedef struct chidist{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		OBCD	x;	// data ( Use when FUNCTION type is "chiPDist()" only)
		OBCD	low;	// lower boundary( Use when FUNCTION type is "chiCDist()" only)
		OBCD	up;	// upper boundary( Use when FUNCTION type is "chiCDist()" only)
		OBCD	df;	// degrees of freedom
		OBCD	ans[2];	// Answer
				//	ans[0]:chi-square probability dencity ( Use when FUNCTION type is "chiPDist()" only)
				//	ans[1]:chi-square distribution probability ( Use when FUNCTION type is "chiCDist()" only)
	} chiDIST;




F Distribution

int FPDist( int type, FDIST *dat);


	typedef struct fdist{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		OBCD	x;	// data ( Use when FUNCTION type is "FPDist()" only)
		OBCD	low;	// lower boundary( Use when FUNCTION type is "FCDist()" only)
		OBCD	up;	// upper boundary( Use when FUNCTION type is "FCDist()" only)
		OBCD	ndf;	// numerator degrees of freedom
		OBCD	ddf;	// denominator degrees of freedom
		OBCD	ans[2];	// Answer
				//	ans[0]:F probability dencity ( Use when FUNCTION type is "FPDist()" only)
				//	ans[1]:F distribution probability ( Use when FUNCTION type is "FCDist()" only)
	} FDIST;




int FCDist( int type, FDIST *dat);


	typedef struct fdist{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		OBCD	x;	// data ( Use when FUNCTION type is "FPDist()" only)
		OBCD	low;	// lower boundary( Use when FUNCTION type is "FCDist()" only)
		OBCD	up;	// upper boundary( Use when FUNCTION type is "FCDist()" only)
		OBCD	ndf;	// numerator degrees of freedom
		OBCD	ddf;	// denominator degrees of freedom
		OBCD	ans[2];	// Answer
				//	ans[0]:F probability dencity ( Use when FUNCTION type is "FPDist()" only)
				//	ans[1]:F distribution probability ( Use when FUNCTION type is "FCDist()" only)
	} FDIST;




Binomial Distribution
int BinoPDist( int type, BDIST *dat);


	typedef struct bdist{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		int	list;	// List No( 1~20:List1~20 ) ( No use when Data type is "Valiable" )
		OBCD	num;	// number of trals
		OBCD	p;	// success probability
		OBCD	x;	// integer from 0 to n ( No use when Data type is "List" )
		OBCD	ans;	// ( No use when Data type is "List" )
	} BDIST;




int BinoCDist( int type, BDIST *dat);


	typedef struct bdist{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		int	list;	// List No( 1~20:List1~20 ) ( No use when Data type is "Valiable" )
		OBCD	num;	// number of trals
		OBCD	p;	// success probability
		OBCD	x;	// integer from 0 to n ( No use when Data type is "List" )
		OBCD	ans;	// ( No use when Data type is "List" )
	} BDIST;



Poisson Distribution
int PoissonPDist( int type, PDIST *dat);


	typedef struct pdist{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		int	list;	// List No( 1~20:List1~20 ) ( No use when Data type is "Valiable" )
		OBCD	mu;	// population mean
		OBCD	x;	// value ( No use when Data type is "List" )
		OBCD	ans;	// ( No use when Data type is "List" )
	} PDIST;





int PoissonCDist( int type, PDIST *dat);

	typedef struct pdist{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		int	list;	// List No( 1~20:List1~20 ) ( No use when Data type is "Valiable" )
		OBCD	mu;	// population mean
		OBCD	x;	// value ( No use when Data type is "List" )
		OBCD	ans;	// ( No use when Data type is "List" )
	} PDIST;



Geometric Distribution
int GeoPDist( int type, GDIST *dat);


	typedef struct gdist{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		int	list;	// List No( 1~20:List1~20 ) ( No use when Data type is "Valiable" )
		OBCD	p;	// success probability
		OBCD	x;	// value ( No use when Data type is "List" )
		OBCD	ans;	// ( No use when Data type is "List" )
	} GDIST;





int GeoCDist( int type, GDIST *dat);


	typedef struct gdist{
		int	angle;	// Angle(DEG: Degree / RAD:Radian / GRA:Grads)
		int	list;	// List No( 1~20:List1~20 ) ( No use when Data type is "Valiable" )
		OBCD	p;	// success probability
		OBCD	x;	// value ( No use when Data type is "List" )
		OBCD	ans;	// ( No use when Data type is "List" )
	} GDIST;