ostat.h

图像处理的压缩算法

/*------------------------------------------------------------------------------*
 * File Name: OStat.h															*
 * Creation: GJL 7/24/2001														*
 * Purpose: Origin C Header for OStat											*
 * Copyright (c) OriginLab Corp.	2000-2002									*
 * All Rights Reserved															*
 * 																				*
 * Modification Log:															*
 *------------------------------------------------------------------------------*/

#ifndef _OSTAT_H
#define _OSTAT_H

// Define OStat Structures
// Structure to hold a single row in the Two-Way ANOVA table
typedef struct {
	double	dDF;		// Degrees of Freedom
	double	dSS;		// Residual Sum of Squares
	double	dMS;		// Mean Squares
	double	dF;			// F Value
	double	dP;			// P Value
} ANOVA2_Row;
// End Define OStat Structures

// Declare functions in OStat.c
double osTTest_ProbT( double dt, int ddf );
int	osTTest_Table_Output_to_ResultsLog( int iTwoSampleTest, double dPairedVar, string strNullHypot,
	 string strAltHypot, double dt, int iDoF, double dP, int iAltRBChoice, double dSigLevel, double dTestVal );
int	osTTest_ConIntervals_Output_to_ResultsLog( int iTwoSampleTest, string strConLevelDataName,
		 string strLLimitDataName, string strULimitDataName );
int	osSummary_Stat_Output_to_ResultsLog( int iTest, int nData );
int osPower_Output_to_ResultsLog( int iPower, double dAlpha, int iSSType, int iActualSS,
	 double dActualPower, string strHypotSSDataName, string strHypotPowerDataName );
double osANOVA_Power( double dFval, double ddf1, double ddf2, double dnc );
int osANOVA_Compute_StdErr_MeanDiffs( int inData, double dmse, vector<int> &vNPTS, vector<double> &vC );

int	osANOVA1_Table_Output_to_ResultsLog( string strTestType, double ddf1, double dssb, double dmsb,
	 double dF, double dP, double ddf2, double dsse, double dmse, double dSigLevel );
int osANOVA1Way_Means_Comparison( int iTest, int inData, string strNPTS, double ddf2, string strMEAN,
	 double dmse, double dSigLevel );
int osANOVA1Way_Means_Comparison_Output_to_ResultsLog( string strTestName, int inData, vector<double> &vMEAN,
	 vector<double> &vCIL, vector<double> &vCIU, vector<int> &vISIG, double dSigLevel );

int osANOVA2Way( double dSigLevel, int iInteractions, int iSpecifyLevelsBy, int nData, int iPower, double dPowerAlpha,
	 string strSampleSizes, int iTest );
int osANOVA2Way_Get_Data( int iSpecifyLevelsBy, int nData, vector<string> &vDataNames, vector<int> &vFACTOR_A,
	 vector<string> &vLEVELSA, int &nLevelsA, vector<int> &vFACTOR_B, vector<string> &vLEVELSB, int &nLevelsB,
	 vector<double> &vDEP_VAR, int &iSize );
int	osANOVA2Way_Count_Values_Per_Cell( vector<int> &v1, vector<int> &v2, matrix<int> &mCount, int iThreshold, int &iRow, int &iCol );
int osANOVA2Way_Add_String_to_Vector( string strIn, vector<string> &vSTRINGS );
int osANOVA2Way_Count_Unique_Values( int nPts, Dataset &dsDATASET, int &nCount );
//---- CPY 5/4/03 
//int osANOVA2Way_Compute_ANOVA_Table( int iInteractions, vector<int> &vFACTOR_A, int nLevelsA, vector<int> &vFACTOR_B,
//	 int nLevelsB, vector<double> &vDEP_VAR, int nPts, ANOVA2_Row &arANOVA2_Table );
int osANOVA2Way_Compute_ANOVA_Table( int iInteractions, vector<int> &vFACTOR_A, int nLevelsA, vector<int> &vFACTOR_B,
	 int nLevelsB, vector<double> &vDEP_VAR, int nPts, ANOVA2_Row* parANOVA2_Table );
//----
int osANOVA2Way_Compute_Dummy_Vars( int nPts, int nLevels, vector<int> &vFACT, matrix<double> &mX );
int osANOVA2Way_Compute_FACTsAxB_Dummy_Vars( int nPts, int nLevelsA, matrix<int> &mX_FACT_A, int nLevelsB,
	 matrix<int> &mX_FACT_B, matrix<int> &mX_FACTs_AxB );
int osANOVA2Way_Copy_Matrix( int nPts, int nCols, matrix<double> &mXfrom, int nStartCol, matrix<double> &mXinto );
int osANOVA2Way_Perform_Linear_Regression( int nPts, int nTdx, matrix<double> &mX, vector<double> &vY,
	 double &dRss, double &dDf );
int osANOVA2Way_ANOVA_Table_Output_to_ResultsLog( int iSpecifyLevelsBy, int nData, vector<string> &vDataNames,
	 int iInteractions, ANOVA2_Row *arANOVA2_Table );
int osANOVA2Way_Means_Comparison( char cFactor, int iTest, vector<int> &vFACTOR, vector<string> &vLEVELS,
	 int nLevels, vector<double> &vDEP_VAR, int nPts, double dDFE, double dMSE, double dSigLevel );
int osANOVA2Way_Compute_MEANS_of_Levels( vector<int> &vFACTOR, int nLevels, vector<double> &vDEP_VAR, int nPts,
	 vector<int> &vNPTS, vector<double> &vMEANS );
int osANOVA2Way_Means_Comparison_Output_to_ResultsLog( char cFactor, string strTestName, int nLevels, vector<string> &vLEVELS,
	 vector<double> &vMEAN, vector<double> &vCIL, vector<double> &vCIU, vector<int> &vISIG, double dSigLevel );
int osANOVA2Way_Power( int iPower, int iInteractions, double dPowerAlpha, int nPts, string strSampleSizes,
	 ANOVA2_Row *arANOVA2_Table );
int osANOVA2Way_Compute_Power( int iPower, int iInteractions, double dAlpha, int nPts, int iSize,
	 ANOVA2_Row *arANOVA2_Table, int iSource, vector<double> &vSS, double &dPower, vector<double> &vSSPOW );
int osANOVA2Way_Power_Output_to_ResultsLog( int iInteractions, int iSource, double dPowerAlpha, int nPts,
	 double dPower, int iPower, vector<double> &vSS, vector<double> &vSSPOW, Worksheet &wksPowerTable );
string osANOVA2Way_Get_Localized_Var_Name( int iVarTypeCode );

int osNormalityTest( string strDataset, double dNormTestSL );
// End declare functions in OStat.c

// Define OStat constants NOT needing localization
#define OSTAT_NO_ERROR					0
#define OSTAT_CONF_INT_ERROR1			100
#define OSTAT_CONF_INT_ERROR2			101
#define OSTAT_CONF_INT_ERROR3			102
#define OSTAT_SHAPIRO_WILK_ERROR		103
#define OSTAT_TOO_FEW_DATAPTS_WARNING	104
#define OSTAT_TOO_MANY_DATAPTS_WARNING	105
#define OSTAT_DATA_SORT_ERROR1			106
#define OSTAT_ANOVA2_ERROR				107
#define OSTAT_NAG_DUMMY_VARS_ERROR		108
#define OSTAT_GET_DATA_NAME_ERROR		109
#define OSTAT_DATA_SORT_ERROR2			110
#define OSTAT_CONF_INT_ERROR4			111
#define OSTAT_CONF_INT_ERROR5			112
#define OSTAT_CONF_INT_ERROR6			113
#define OSTAT_NAG_F_DEVIATE_ERROR1		114
#define OSTAT_NAG_F_DEVIATE_ERROR2		115	
#define OSTAT_ANOVA2_POWER_ERROR1		116
#define OSTAT_ANOVA2_POWER_ERROR2		117
#define OSTAT_ANOVA2_POWER_ERROR3		118
#define OSTAT_ZERO_DOF_RESID_ERROR		119
#define OSTAT_PAIRED_SD_IS_0_ERROR		120
#define OSTAT_ANOVA2_LIN_REGR_ERROR		121
#define OSTAT_ANOVA2_PROB_F_ERROR		125
#define OSTAT_ANOVA2_DOF_ERROR			129
#define OSTAT_ANOVA2_FVALUE_ERROR		133
#define OSTAT_ANOVA2_PVALUE_ERROR		137

#define OSTAT_NEXT_ERROR				141

#define OSTAT_ABORT_NO_ERROR_MSG		999

#define AN_POWER_TOLERANCE				5e-6
#define AN_POWER_ITERATIONS				500
// SET_AN_MAX_TUKEY_RESID_DF QA70-688
#define AN_MAX_TUKEY_RESID_DF			2000.0
// END SET_AN_MAX_TUKEY_RESID_DF QA70-688

#define AN2_LINEAR_REGRESS_TOLERANCE	5e-6
#define AN2_MIN_VALUES_PER_CELL			1
#define AN2_DEP_VAR_CODE				1
#define AN2_FACTOR_A_CODE				2
#define AN2_FACTOR_B_CODE				3

#define OSTAT_ROUND_FACTOR1				10000

#define OSTAT_SEPARATOR_CHAR		'|'
#define OSTAT_STR_TOKEN				"%c%s"
#define OSTAT_EIGHT_DASHES			"--------"
#define OSTAT_TEN_DASHES			"----------"
#define OSTAT_SIG_CON_LEVEL_FORMAT	"%.4g"
#define OSTAT_MAX_DIGITS_FORMAT		"%.15g"
#define OSTAT_OGW_SUBFOLDER			"Tables"
// End Define OStat constants NOT needing localization

//// Subset of basic NAG definitions from <NAG\nag_types> needed by OStat.c 
//#ifndef _ONAG_BASIC
//#define _ONAG_BASIC
//
//#define NE_NOERROR 0
//#define NE_REAL_ARG_CONS 9
//#define NE_ZERO_DOF_RESID 426
//#define NAG_ERROR_BUF_LEN 512
//
//#define Nag_TailProbability_start 264
//#define Nag_IncludeMean_start 285
//#define Nag_DummyType_start 384
//#define Nag_IntervalType_start 389
//
//typedef enum {Nag_LowerTail=Nag_TailProbability_start, Nag_UpperTail, Nag_TwoTailSignif,
	//Nag_TwoTailConfid, Nag_TwoTail, Nag_Central} Nag_TailProbability;
//typedef enum {Nag_TukeyInterval=Nag_IntervalType_start, Nag_BonferroniInterval, Nag_DunnInterval,
	//Nag_FisherInterval, Nag_ScheffeInterval} Nag_IntervalType;
//typedef enum {Nag_Poly=Nag_DummyType_start, Nag_Helmert, Nag_FirstLevel,
	//Nag_LastLevel, Nag_AllLevels} Nag_DummyType;
//typedef enum {Nag_MeanInclude=Nag_IncludeMean_start, Nag_MeanZero} Nag_IncludeMean;
	      //
//typedef struct {
	//int	code;    // Out: Error Code
	//BOOL	print;   // In: print? yes/no, not used in Origin C 
	//char	message[NAG_ERROR_BUF_LEN];      // InOut: Error message
	//UINT	handler; //Error handling function, not used from OriginC
	//int	errnum;  // May hold useful value for some errors
//} NagError;
//
//#endif // !_ONAG_BASIC
//
//// Functions below are implemented in ONAG DLL prepared by OriginLab and are needed by OStat.c
//#pragma dll(ONAG)
//
//// From <NAG\OCN_g01.h>: g01ebc nag_prob_students_t 
//double nag_prob_students_t(
	//Nag_TailProbability tail,
	//double t,	// the value of the Student 抯 t variate
	//double df,	// the degree of freedom
	//NagError* fail=NULL // NAG error structure
//);	// Probabilities for Student's t-distribution
//
//// From <NAG\OCN_g01.h>: g01gdc nag_prob_non_central_f_dist
//double nag_prob_non_central_f_dist(
	//double f,  // the deviate from the F-distribution, F
	//double df1,	// the degree of freedom of the numerator variance, v1
	//double df2,	 // the degree of freedom of the denominator variance, v2
	//double lambda, // the non-centrality parameter
	//double tol=5e-6,	// the required accuracy of the solution
	//int max_iter = 500, // the maximum number of iterations to be performed
	//NagError *fail=NULL	// NAG error structure
//);	// Computes probabilities for the non-central F-distribution
//
//// From <NAG\OCN_g01.h>: g01ddc nag_shapiro_wilk_test
//int nag_shapiro_wilk_test(
	//int n,	// the sample size, 3 <= n <= 2000
	//const double x[],  // the ordered sample values
	//BOOL calc_wts, // calculate weight or not
	//double a[],	// weight
	//double* w,	// the value of the statistics, W
	//double* pw	// the significance level of W
//);	// Shapiro and Wilk's W test for Normality
//
//// From <NAG\OCN_g01.h>: g01edc nag_prob_f_dist
//double nag_prob_f_dist(
	//Nag_TailProbability tail,
	//double f,	// the value of the F variate
	//double df1,	// the degree of freedom of the numerator variance, v1
	//double df2,	// the degree of freedom of the denominator variance, v2
	//NagError* fail=NULL // NAG error structure
//);	// Probabilities for F-distribution
//
//// From <NAG\OCN_g02.h>: g02dac nag_regsn_mult_linear    
//int nag_regsn_mult_linear(
    //Nag_IncludeMean mean,
    //int n, 		    // the number of observations 
    //double x[],     //the variable for which ith observation for the jth potential indepent variable.
    //int tdx, 	  	// the second dimension of the array x.
    //int m, 		  	// the total number of independent variables in the data set.
    //int sx[], 	  	// indicates which of the potential independent variables are to be included in the model.
    //int ip, 	  	// the number p of independent variables in the model, including the mean or intercept if present.
    //double y[],   	// the observations on the dependent variable.
    //double wt[],  	// an (optional) weight is specified to be used in the weighted regression. 
    //double *rss,  	// the residual sum of squares for the regression.
    //double *df,   	// the degree of freedom associated with the residual sum of squares.
    //double b[],   	// return the least-squares estimates of the parameters of the regression model.
    //double se[],  	// return the standard errors of the ip parameter estimates given in b.
    //double cov[], 	// return the variance-covariance matrix of estimated parameters in b.
    //double res[], 	// return the (weighted) residuals.
    //double h[],   	// return the diagonal elements of H.
    //double q[],   	// return the results of the QR decomposition.
    //int tdq, 	  	// the second dimension of the array q. 
    //BOOL *svd,  	// return TRUE if a singular value decomposition has been performed, otherwise FALSE
    //int *rank, 	  	// return the rank of the independent variables.
    //double p[],   	// details of the QR decomposition and SVD if used.
    //double tol,   	// the value of tol is used to decide what is the rank of the independent variables. 
    //double com_ar[] // return information which is needed by nag_regsn_mult_linear_newyvar_if svd = TRUE.
//);	//  Parameter estimates, standard errors, residuals ... 
//
//// From <NAG\OCN_g04.h>: g04dbc nag_anova_confid_interval
//int nag_anova_confid_interval(
	//Nag_IntervalType type,
	//int nt,				// the number of treatment means
	//const double tmean[], // the treatment means
	//double rdf,			// the residual degrees of freedom
	//const double c[],	// the standard errors of the differences between the means
	//int ldc,			// the second dimension of the array c
	//double clevel,		// the confidence level for the computed intervals
	//double cil[],		// lower limit to the confidence interval
	//double ciu[],		// upper limit to the confidence interval
	//int isig[]			// difference between the ith and jth means in tmean is significant.
//);	// Computes confidence intervals for differences between means computed
//
//// From <NAG\OCN_g04.h>: g04eac nag_dummy_vars
//int nag_dummy_vars(
	//Nag_DummyType type,
	//int n,	// the number of observations for which the dummy variables are to be computed.
	//int levels,	// the number of levels of the factor.
	//const int ifact[], // the n values of the factor.
	//double x[],	// the n by k matrix of dummy variables
	//int tdx,	// the second dimension of the array x
	//const double v[], // If type equal Nag_Poly, the k distinct values of the underlying variable for which 
					//// the orthogonal polynomial is to be computed.  If type not equal Nag_Poly, v is not reference.
	//double rep[]	// contains the number of replications for each level
//);	// Computes orthogonal polynomials or dummy variables for factor/classification variable.

#endif // !_OSTAT_H