int main()
{
GLFWwindow* window = myCreateWindow();
GLchar* earth = "Model/earth/earth.obj";
GLchar* moon = "Model/moon/moon.obj";
vector<const GLchar*> faces;
faces.push_back("Texture/sky/purplenebula_rt.tga");
faces.push_back("Texture/sky/purplenebula_lf.tga");
faces.push_back("Texture/sky/purplenebula_up.tga");
faces.push_back("Texture/sky/purplenebula_dn.tga");
faces.push_back("Texture/sky/purplenebula_bk.tga");
faces.push_back("Texture/sky/purplenebula_ft.tga");
//GLuint skyID = loadCubemap(faces);
Star Earth(0.001,45.0f);
Earth.init(earth);
Star Moon(0.002, 45.0f,glm::vec3(0.0f,0.0f,0.0f), 2.0f);
Moon.init(moon);
while (!glfwWindowShouldClose(window))
{
GLfloat currentFrame = glfwGetTime();
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
Do_Movement();
glfwPollEvents();
glClearColor(0.05f, 0.05f, 0.05f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Earth.drawStar();
Moon.drawStar();
glfwSwapBuffers(window);
}
glfwTerminate();
return 0;
}
//-----------------------------------------------------------------------------
static void TestEarth(char sTestName[],
double (__cdecl *func)(const double xrow[], const int iResponse),
const int nCases, const int nResponses, const int nPreds,
const int nMaxDegree, const int nMaxTerms,
const double Trace, const bool Format,
const double ForwardStepThresh,
const int nFastK, const double FastBeta, const double NewVarPenalty,
const int seed,
const double Collinear = 0) // used for testing NewVarPenalty
{
#define y_(i,iResponse) y[(i) + (iResponse)*(nCases)]
int *LinPreds = (int *)calloc(nPreds, sizeof(int));
double *x = (double *)malloc(nCases * nPreds * sizeof(double));
double *y = (double *)malloc(nCases * nResponses * sizeof(double));
double *bx = (double *)malloc(nCases * nMaxTerms * sizeof(double));
bool *BestSet = (bool *) malloc(nMaxTerms * sizeof(bool));
int *Dirs = (int *) malloc(nMaxTerms * nPreds * sizeof(int));
double *Cuts = (double *)malloc(nMaxTerms * nPreds * sizeof(double));
double *Residuals = (double *)malloc(nCases * nResponses * sizeof(double));
double *Betas = (double *)malloc(nMaxTerms * nResponses * sizeof(double));
static int nTest;
nTest++;
printf("=============================================================================\n");
printf("TEST %d: %s n=%d p=%d\n", nTest, sTestName, nCases, nPreds);
// init x
srand(seed);
int i;
for (i = 0; i < nCases; i++)
for (int iPred = 0; iPred < nPreds; iPred++) {
double xtemp;
xtemp = (double)((rand() % 20000) - 10000) / 10000; // rand number from -1 to +1
x[i + iPred * nCases] = xtemp;
}
// sort the first column of x, makes debugging easier
qsort(x, nCases, sizeof(double), cmp);
if (Collinear > 0) {
// copy column 0 to 1 with added noise
for (i = 0; i < nCases; i++)
x[i + 1 * nCases] = x[i] + Collinear * RandGauss();
}
// init y
double *xrow = (double *)malloc(nPreds * sizeof(double));
for (i = 0; i < nCases; i++) {
for (int iPred = 0; iPred < nPreds; iPred++)
xrow[iPred] = x[i + iPred * nCases];
for (int iResponse = 0; iResponse < nResponses; iResponse++)
y_(i, iResponse) = func(xrow, iResponse);
}
free(xrow);
double BestGcv;
int nTerms, iReason;
const double Penalty = ((nMaxDegree>1)? 3:2);
clock_t Time = clock();
if(Trace >= 4) {
if(nResponses != 1)
error("cannot use Trace>=4 with nResponses!=1");
printf(" y");
for(int iPred = 0; iPred < nPreds; iPred++)
printf(" x%d", iPred);
printf("\n");
for(int i = 0; i < nCases; i++) {
printf("%4d % 7.5f", i, y[i]);
for(int iPred = 0; iPred < nPreds; iPred++) {
printf(" % 7.5f", x[i + iPred * nCases]);
}
printf("\n");
}
printf("\n");
}
Earth(&BestGcv, &nTerms, &iReason, BestSet, bx, Dirs, Cuts, Residuals, Betas,
x, y, NULL, // weights are NULL
nCases, nResponses, nPreds, nMaxDegree, nMaxTerms, Penalty, ForwardStepThresh,
0, 0, // MinSpan, EndSpan
true, // Prune
nFastK, FastBeta, NewVarPenalty, LinPreds,
2 /*AdjustEndSpan*/, true /*AutoLinPred*/, true /*UseBetaCache*/,
Trace, NULL);
// calc nUsedTerms
int nUsedTerms = 0;
for (int iTerm = 0; iTerm < nTerms; iTerm++)
if (BestSet[iTerm])
nUsedTerms++;
// calc RSquared, GRSquared
for (int iResponse = 0; iResponse < nResponses; iResponse++) {
double Rss = 0, Tss = 0, meanY = 0;
for (i = 0; i < nCases; i++)
meanY += y_(i, iResponse);
meanY /= nCases;
xrow = (double *)malloc(nPreds * sizeof(double));
double *yHat = (double *)malloc(nResponses * sizeof(double));
for (i = 0; i < nCases; i++) {
for (int iPred = 0; iPred < nPreds; iPred++)
xrow[iPred] = x[i + iPred * nCases];
PredictEarth(yHat, xrow, BestSet, Dirs, Cuts, Betas, nPreds, nResponses, nTerms, nMaxTerms);
double Residual = y_(i,iResponse) - yHat[iResponse];
Rss += sq(Residual);
Tss += sq(y_(i,iResponse) - meanY);
}
free(yHat);
free(xrow);
const double RSq = 1 - Rss/Tss;
const double GcvNull = getGcv(1, nCases, Tss, Penalty);
const double GRSq = 1 - getGcv(nUsedTerms, nCases, Rss, Penalty) / GcvNull;
#if PRINT_TIME
double TimeDelta = (double)(clock() - Time) / CLOCKS_PER_SEC;
#else
double TimeDelta = 99.99;
#endif
// show results
if (nResponses > 1) {
printf("RESULT %d Response %d: GRSq %.5g RSq %.5g nTerms %d of %d of %d",
nTest, iResponse+1, GRSq, RSq,
nUsedTerms, nTerms, nMaxTerms);
if (iResponse == 0)
printf(" FUNCTION %s n=%d p=%d [%.2f secs]",
sTestName, nCases, nPreds, TimeDelta);
printf("\n");
}
else
printf("RESULT %d: GRSq %g RSq %g nTerms %d of %d of %d "
"FUNCTION %s n=%d p=%d [%.2f secs]\n",
nTest, GRSq, RSq, nUsedTerms, nTerms, nMaxTerms,
sTestName, nCases, nPreds, TimeDelta);
}
if (Format && Trace != 0) {
printf("\nTEST %d: FUNCTION %s n=%d p=%d\n", nTest, sTestName, nCases, nPreds);
FormatEarth(BestSet, Dirs, Cuts, Betas, nPreds, nResponses, nTerms, nMaxTerms, 3, 1e-6);
printf("\n");
}
free(LinPreds);
free(x);
free(y);
free(BestSet);
free(Dirs);
free(Cuts);
free(Residuals);
free(Betas);
free(bx);
}
void EarthComponent::setUp(void)
{
Earth earth = Earth(10 ,3 ,0); // CHANGE
}
