int ShadedSurfaceLayer::DrawTriangle(float x1, float y1, float z1, int c1,
float x2, float y2, float z2, int c2,
float x3, float y3, float z3, int c3) const
{
int retval = NVN_NOERR;
float ux, uy, uz;
float vx, vy, vz;
ux = x2 - x1; vx = x3 - x1;
uy = y2 - y1; vy = y3 - y1;
uz = z2 - z1; vz = z3 - z1;
glNormal3f(uy*vz - uz*vy,
uz*vx - ux*vz,
ux*vy - uy*vx);
glColor4ub(GetR(c1), GetG(c1), GetB(c1), GetA(c1));
glVertex3f(x1, y1, z1);
glColor4ub(GetR(c2), GetG(c2), GetB(c2), GetA(c2));
glVertex3f(x2, y2, z2);
glColor4ub(GetR(c3), GetG(c3), GetB(c3), GetA(c3));
glVertex3f(x3, y3, z3);
}
func Hit()
{
if(!GBackLiquid())
{
for(var i=15; i>0; i--)
{
var iX=Sin(GetR(), RandomX(4,8)), iY=-Cos(GetR(), RandomX(4,8)), iXDir=GetWind()*30/100, iYDir=-Cos(GetR()+RandomX(-2,2), Random(7));
InsertMaterial(Material("Water"), iX, iY, iXDir, iYDir);
}
SetEmpty();
}
}
func FillCheck()
{
++iTimer;
if(!(iTimer%5))
{
var iX = Sin(GetR(), RandomX(-4,8) );
var iY = -Cos(GetR(), RandomX(-4,4) );
if(!Contained())
CreateParticle("NoGravSpark", iX, iY,0,0,RandomX(25, 55),RGBa(255,255,0,120));
iTimer=0;
}
if(GetMaterial() == Material("Water"))
{
if((iFill+=ExtractMaterialAmount(0,2, Material("Water"), 6))>=10 )
ChangeDef(GBLT);
}
}
private func Hit()
{
Sound("DullMetalHit?");
if (iVolume >= 1)
{
if (GBackLiquid(0, 7) && GetMaterial(0, 7) != szLiquid)
return 0;
EmptyBarrel(GetR());
Sound("Splash1");
}
}
wxSVGRect wxSVGCircleElement::GetBBox(wxSVG_COORDINATES coordinates) {
if (coordinates == wxSVG_COORDINATES_USER) {
return wxSVGRect(GetCx().GetAnimVal() - GetR().GetAnimVal(), GetCy().GetAnimVal() - GetR().GetAnimVal(),
2 * GetR().GetAnimVal(), 2 * GetR().GetAnimVal());
}
wxSVGMatrix matrix = GetMatrix(coordinates);
double angles[4];
angles[0] = atan(matrix.GetC() / matrix.GetA());
angles[1] = atan(matrix.GetD() / matrix.GetB());
angles[2] = angles[0] + pi;
angles[3] = angles[1] + pi;
wxSVGPointList points = wxSVGPointList();
for (int i = 0; i < 4; i++) {
points.Add(wxSVGPoint(GetR().GetAnimVal() * cos(angles[i]) + GetCx().GetAnimVal(),
GetR().GetAnimVal() * sin(angles[i]) + GetCy().GetAnimVal()));
}
wxSVGPoint p0 = points[0].MatrixTransform(matrix);
wxSVGRect bbox(p0.GetX(), p0.GetY(), 0, 0);
wxSVGPoint pi = wxSVGPoint();
for (int i = 1; i < (int) points.Count(); i++) {
pi = points[i].MatrixTransform(matrix);
if (bbox.GetX() > pi.GetX()) {
bbox.SetWidth(bbox.GetWidth() + bbox.GetX() - pi.GetX());
bbox.SetX(pi.GetX());
}
if (bbox.GetY() > pi.GetY()) {
bbox.SetHeight(bbox.GetHeight() + bbox.GetY() - pi.GetY());
bbox.SetY(pi.GetY());
}
if (bbox.GetX() + bbox.GetWidth() < pi.GetX())
bbox.SetWidth(pi.GetX() - bbox.GetX());
if (bbox.GetY() + bbox.GetHeight() < pi.GetY())
bbox.SetHeight(pi.GetY() - bbox.GetY());
}
return bbox.MatrixTransform(matrix);
}
/**
* Write the RGB colour for the next \a iLength pixels, starting from the \a iCount offset.
* @param oBase Base image to encode.
* @param iCount Current index in the image.
* @param iLength Number of pixels to process.
* @param pDest Destination to write to.
*/
static void WriteColour(const Image32bpp &oBase, uint32 iCount, int iLength, Output *pDest)
{
while (iLength > 0)
{
uint32 iColour = oBase.Get(iCount);
iCount++;
pDest->Uint8(GetR(iColour));
pDest->Uint8(GetG(iColour));
pDest->Uint8(GetB(iColour));
iLength--;
}
}
func FillCheck()
{
if(!Contained())
if(Inside(GetR(), 20, 340))
Hit();
if(!(iTimer%5))
{
var iX = Sin(GetR(), RandomX(-4,4) );
var iY = -Cos(GetR(), RandomX(-4,1) );
if(!Contained())
CreateParticle("NoGravSpark", iX, iY,0,0,RandomX(25, 55),RGBa(255,255,0,120));
}
iTimer++;
if(iTimer>=17)
{
if(GetOCF(Contained()) & OCF_CrewMember())
DoEnergy(+1, Contained());
iTimer=0;
}
return(1);
}
/**
* Write the table index for the next \a iLength pixels, starting from the \a iCount offset.
* @param oBase Base image to encode.
* @param iCount Current index in the image.
* @param iLength Number of pixels to process.
* @param pDest Destination to write to.
*/
static void WriteTableIndex(const Image32bpp &oBase, uint32 iCount, int iLength, Output *pDest)
{
while (iLength > 0)
{
uint32 iColour = oBase.Get(iCount);
iCount++;
uint8 biggest = GetR(iColour);
if (biggest < GetG(iColour)) biggest = GetG(iColour);
if (biggest < GetB(iColour)) biggest = GetB(iColour);
pDest->Uint8(biggest);
iLength--;
}
}
Color::operator RGBA() const
{
RGBA color;
if(IsNullInstance())
Zero(color);
else {
color.r = GetR();
color.g = GetG();
color.b = GetB();
color.a = 255;
}
return color;
}
/** Rotiert ein Objekt um einen beliebigen Punkt herum. */
global func RelSetR(int rotation, int xPos, int yPos) {
// Winkel zu den gedrehten Koordinaten
var angle1 = Angle(0, 0, xPos, yPos);
var angle2 = angle1 + GetR();
var radius = Distance(0, 0, xPos, yPos);
// angle2 + Radius => Umgerechneter Drehpunkt
var rotX = (Sin(angle2, 100) * radius) / 100;
var rotY = (-Cos(angle2, 100) * radius) / 100;
// rotation + angle1 + Radius + umgerechneter Drehpunkt => Endpunkt
angle1 += rotation;
var targetX = (-Sin(angle1, 100) * radius) / 100 + rotX;
var targetY = (Cos(angle1, 100) * radius) / 100 + rotY;
SetPosition(GetX() + targetX, GetY() + targetY);
SetR(rotation);
}
void Color::Jsonize(JsonIO& jio)
{
int r, g, b;
if(IsNullInstance()) {
r = g = b = Null;
}
else {
r = GetR();
g = GetG();
b = GetB();
}
jio("red", r)("green", g)("blue", b);
if(IsNull(r))
*this = Null;
else
*this = Color(r, g, b);
}
void Color::Xmlize(XmlIO& xio)
{
int r, g, b;
if(IsNullInstance()) {
r = g = b = Null;
}
else {
r = GetR();
g = GetG();
b = GetB();
}
xio
.Attr("red", r)
.Attr("green", g)
.Attr("blue", b)
;
if(IsNull(r))
*this = Null;
else
*this = Color(r, g, b);
}
void CVisualizerStatic::Draw()
{
const char STR[] = "0CC-FamiTracker"; // // //
const size_t COUNT = std::size(STR);
static long long t = 0;
const auto FixRGB = [] (int x) { return MakeRGB(GetB(x), GetG(x), GetR(x)); };
const COLORREF Back[] = {
FixRGB(FTEnv.GetSettings()->Appearance.iColBackground),
FixRGB(FTEnv.GetSettings()->Appearance.iColBackgroundHilite),
FixRGB(FTEnv.GetSettings()->Appearance.iColBackgroundHilite2),
};
const COLORREF Color = FixRGB(FTEnv.GetSettings()->Appearance.iColPatternText);
const COLORREF Shadow = BlendColors(Color, 1, Back[0], 2);
for (int y = m_iHeight - 1; y >= 0; --y)
for (int x = m_iWidth - 1; x >= 0; --x) {
int Dist = (abs(x - m_iWidth / 2) + abs(y - m_iHeight / 2) - t / 5) % 12;
if (Dist < 0) Dist += 12;
m_pBlitBuffer[y * m_iWidth + x] = Back[Dist / 4];
}
for (size_t i = 0; i < COUNT; ++i) {
double Phase = .07 * t - .9 * i;
double x = sin(Phase) * 2. + m_iWidth + 11. * i - .4 * t;
double y = sin(Phase) * 7.;
const double MAX = m_iWidth + 120.;
if (x < 0) {
x = fmod(x, MAX);
if (x < -40.) x += MAX;
}
DrawChar(STR[i], static_cast<int>(x) + 1, static_cast<int>(m_iHeight / 2. - 3.5 - y) + 1, Shadow);
DrawChar(STR[i], static_cast<int>(x), static_cast<int>(m_iHeight / 2. - 3.5 - y), Color);
}
++t;
}
int GlmTest::summary(glm *fit)
{
double lambda;
unsigned int k;
unsigned int nRows=tm->nRows, nVars=tm->nVars, nParam=tm->nParam;
unsigned int mtype = fit->mmRef->model-1;
PoissonGlm pNull(fit->mmRef), pAlt(fit->mmRef);
BinGlm binNull(fit->mmRef), binAlt(fit->mmRef);
NBinGlm nbNull(fit->mmRef), nbAlt(fit->mmRef);
glm *PtrNull[3] = { &pNull, &nbNull, &binNull };
glm *PtrAlt[3] = { &pAlt, &nbAlt, &binAlt };
gsl_vector_view teststat, unitstat;
gsl_matrix_view L1;
// To estimate initial Beta from PtrNull->Beta
// gsl_vector *ref=gsl_vector_alloc(nParam);
// gsl_matrix *BetaO=gsl_matrix_alloc(nParam, nVars);
smryStat = gsl_matrix_alloc((nParam+1), nVars+1);
Psmry = gsl_matrix_alloc((nParam+1), nVars+1);
gsl_matrix_set_zero (Psmry);
// initialize the design matrix for all hypo tests
GrpMat *GrpXs = (GrpMat *)malloc((nParam+2)*sizeof(GrpMat));
GrpXs[0].matrix = gsl_matrix_alloc(nRows, nParam);
gsl_matrix_memcpy(GrpXs[0].matrix, fit->Xref); // the alt X
GrpXs[1].matrix = gsl_matrix_alloc(nRows, 1); // overall test
gsl_matrix_set_all (GrpXs[1].matrix, 1.0);
for (k=2; k<nParam+2; k++) { // significance tests
GrpXs[k].matrix = gsl_matrix_alloc(nRows, nParam-1);
subX2(fit->Xref, k-2, GrpXs[k].matrix);
}
// Calc test statistics
if ( tm->test == WALD ) {
// the overall test compares to mean
teststat = gsl_matrix_row(smryStat, 0);
L1=gsl_matrix_submatrix(L,1,0,nParam-1,nParam);
lambda=gsl_vector_get(tm->smry_lambda, 0);
GetR(fit->Res, tm->corr, lambda, Rlambda);
GeeWald(fit, &L1.matrix, &teststat.vector);
// the significance test
for (k=2; k<nParam+2; k++) {
teststat = gsl_matrix_row(smryStat, k-1);
L1 = gsl_matrix_submatrix(L, k-2, 0, 1, nParam);
GeeWald(fit, &L1.matrix, &teststat.vector);
}
}
else if (tm->test==SCORE) {
for (k=1; k<nParam+2; k++) {
teststat=gsl_matrix_row(smryStat, k-1);
PtrNull[mtype]->regression(fit->Yref,GrpXs[k].matrix,fit->Oref,NULL);
lambda=gsl_vector_get(tm->smry_lambda, k);
GetR(PtrNull[mtype]->Res, tm->corr, lambda, Rlambda);
GeeScore(GrpXs[0].matrix, PtrNull[mtype], &teststat.vector);
}
}
else {
for (k=1; k<nParam+2; k++) {
teststat=gsl_matrix_row(smryStat, k-1);
PtrNull[mtype]->regression(fit->Yref,GrpXs[k].matrix,fit->Oref,NULL);
GeeLR(fit, PtrNull[mtype], &teststat.vector); // works better
}
}
// sort id if the unitvaraite test is free step-down
gsl_permutation **sortid;
sortid=(gsl_permutation **)malloc((nParam+1)*sizeof(gsl_permutation *));
for ( k=0; k<(nParam+1); k++ ) {
teststat = gsl_matrix_row (smryStat, k);
unitstat = gsl_vector_subvector(&teststat.vector, 1, nVars);
sortid[k] = gsl_permutation_alloc(nVars);
gsl_sort_vector_index (sortid[k], &unitstat.vector);
gsl_permutation_reverse(sortid[k]); // rearrange in descending order
}
if (tm->resamp==MONTECARLO) {
lambda=gsl_vector_get(tm->smry_lambda,0);
GetR(fit->Res, tm->corr, lambda, Sigma);
setMonteCarlo(fit, XBeta, Sigma);
}
nSamp=0;
double *suj, *buj, *puj;
gsl_matrix *bStat = gsl_matrix_alloc((nParam+1), nVars+1);
gsl_matrix_set_zero (bStat);
gsl_matrix *bY = gsl_matrix_alloc(nRows, nVars);
gsl_matrix *bO = gsl_matrix_alloc(nRows, nVars);
gsl_matrix_memcpy (bO, fit->Eta);
double diff, timelast=0;
clock_t clk_start=clock();
for ( unsigned int i=0; i<tm->nboot; i++) {
if ( tm->resamp==CASEBOOT )
resampSmryCase(fit,bY,GrpXs,bO,i);
else resampNonCase(fit, bY, i);
if ( tm->test == WALD ) {
PtrAlt[mtype]->regression(bY,GrpXs[0].matrix,bO,NULL);
// the overall test compares to mean
teststat = gsl_matrix_row(bStat, 0);
L1=gsl_matrix_submatrix(L,1,0,nParam-1,nParam);
lambda=gsl_vector_get(tm->smry_lambda, 0);
GetR(PtrAlt[mtype]->Res, tm->corr, lambda, Rlambda);
GeeWald(PtrAlt[mtype], &L1.matrix, &teststat.vector);
// the significance test
for (k=2; k<nParam+2; k++) {
teststat = gsl_matrix_row(bStat, k-1);
L1 = gsl_matrix_submatrix(L, k-2, 0, 1, nParam);
GeeWald(PtrAlt[mtype], &L1.matrix, &teststat.vector);
}
}
else if (tm->test==SCORE) {
for (k=1; k<nParam+2; k++) {
teststat=gsl_matrix_row(bStat, k-1);
PtrNull[mtype]->regression(bY,GrpXs[k].matrix,bO,NULL);
lambda=gsl_vector_get(tm->smry_lambda,k);
GetR(PtrNull[mtype]->Res, tm->corr, lambda, Rlambda);
GeeScore(GrpXs[0].matrix, PtrNull[mtype], &teststat.vector);
}
}
else { // use single bAlt estimate works better
PtrAlt[mtype]->regression(bY,GrpXs[0].matrix,bO,NULL);
for (k=1; k<nParam+2; k++) {
teststat=gsl_matrix_row(bStat, k-1);
PtrNull[mtype]->regression(bY,GrpXs[k].matrix,bO,NULL);
GeeLR(PtrAlt[mtype], PtrNull[mtype], &teststat.vector);
}
}
for (k=0; k<(nParam+1); k++) {
buj = gsl_matrix_ptr (bStat, k, 0);
suj = gsl_matrix_ptr (smryStat, k, 0);
puj = gsl_matrix_ptr (Psmry, k, 0);
if ( *buj >= *suj ) *puj=*puj+1;
calcAdjustP(tm->punit, nVars, buj+1, suj+1, puj+1, sortid[k]);
} // end for j loop
nSamp++;
// Prompts
if ((tm->showtime==TRUE)&(i%100==0)) {
diff=(float)(clock()-clk_start)/(float)CLOCKS_PER_SEC;
timelast+=(double)diff/60;
printf("\tResampling run %d finished. Time elapsed: %.2f min ...\n", i, timelast);
clk_start=clock();
}
} // end for i loop
// ========= Get P-values ========= //
if ( tm->punit == FREESTEP ) {
for (k=0; k<(nParam+1); k++) {
puj = gsl_matrix_ptr (Psmry, k, 1);
reinforceP( puj, nVars, sortid[k] );
} }
// p = (#exceeding observed stat + 1)/(#nboot+1)
gsl_matrix_add_constant (Psmry, 1.0);
gsl_matrix_scale (Psmry, (double)1.0/(nSamp+1));
for (k=0; k<nVars; k++) aic[k]=-fit->ll[k]+2*(nParam+1);
// === release memory ==== //
PtrAlt[mtype]->releaseGlm();
if ( tm->test!=WALD )
PtrNull[mtype]->releaseGlm();
gsl_matrix_free(bStat);
gsl_matrix_free(bY);
gsl_matrix_free(bO);
for (k=0; k<nParam+1; k++)
if (sortid[k]!=NULL) gsl_permutation_free(sortid[k]);
free(sortid);
if ( GrpXs != NULL ) {
for ( unsigned int k=0; k<nParam+2; k++ )
if ( GrpXs[k].matrix != NULL )
gsl_matrix_free (GrpXs[k].matrix);
free(GrpXs);
}
return SUCCESS;
}
int GlmTest::anova(glm *fit, gsl_matrix *isXvarIn)
{
// Assume the models have been already sorted (in R)
Xin = isXvarIn;
nModels = Xin->size1;
double *rdf = new double [nModels];
unsigned int nP, i, j, k;
unsigned int ID0, ID1, nP0, nP1;
unsigned int nRows=tm->nRows, nVars=tm->nVars, nParam=tm->nParam;
unsigned int mtype = fit->mmRef->model-1;
dfDiff = new unsigned int [nModels-1];
anovaStat = gsl_matrix_alloc((nModels-1), nVars+1);
Panova = gsl_matrix_alloc((nModels-1), nVars+1);
gsl_vector *bStat = gsl_vector_alloc(nVars+1);
gsl_matrix_set_zero (anovaStat);
gsl_matrix_set_zero (Panova);
gsl_vector_set_zero (bStat);
PoissonGlm pNull(fit->mmRef), pAlt(fit->mmRef);
BinGlm binNull(fit->mmRef), binAlt(fit->mmRef);
NBinGlm nbNull(fit->mmRef), nbAlt(fit->mmRef);
PoissonGlm pNullb(fit->mmRef), pAltb(fit->mmRef);
BinGlm binNullb(fit->mmRef), binAltb(fit->mmRef);
NBinGlm nbNullb(fit->mmRef), nbAltb(fit->mmRef);
glm *PtrNull[3] = { &pNull, &nbNull, &binNull };
glm *PtrAlt[3] = { &pAlt, &nbAlt, &binAlt };
glm *bNull[3] = { &pNullb, &nbNullb, &binNullb };
glm *bAlt[3] = { &pAltb, &nbAltb, &binAltb };
double *suj, *buj, *puj;
gsl_vector_view teststat, unitstat,ref1, ref0;
gsl_matrix *X0=NULL, *X1=NULL, *L1=NULL, *tmp1=NULL, *BetaO=NULL;
gsl_matrix *bO=NULL, *bY=gsl_matrix_alloc(nRows, nVars);
bO = gsl_matrix_alloc(nRows, nVars);
gsl_permutation *sortid=NULL;
if (tm->punit==FREESTEP) sortid = gsl_permutation_alloc(nVars);
// ======= Fit the (first) Alt model =========//
for (i=0; i<nModels; i++) {
nP = 0;
for (k=0; k<nParam; k++)
if (gsl_matrix_get(Xin,i,k)!=FALSE) nP++;
rdf[i] = nRows-nP;
}
for (i=1; i<nModels; i++) {
// ======= Fit the Null model =========//
ID0 = i; ID1 = i-1;
nP0 = nRows - (unsigned int)rdf[ID0];
nP1 = nRows - (unsigned int)rdf[ID1];
// Degrees of freedom
dfDiff[i-1] = nP1 - nP0;
ref1=gsl_matrix_row(Xin, ID1);
ref0=gsl_matrix_row(Xin, ID0);
X0 = gsl_matrix_alloc(nRows, nP0);
subX(fit->Xref, &ref0.vector, X0);
X1 = gsl_matrix_alloc(nRows, nP1);
subX(fit->Xref, &ref1.vector, X1);
// ======= Get multivariate test statistics =======//
// Estimate shrinkage parametr only once under H1
// See "FW: Doubts R package "mvabund" (12/14/11)
teststat = gsl_matrix_row(anovaStat, (i-1));
PtrNull[mtype]->regression(fit->Yref, X0, fit->Oref, NULL);
if (tm->test == SCORE) {
lambda = gsl_vector_get(tm->anova_lambda, ID0);
GetR(PtrNull[mtype]->Res, tm->corr, lambda, Rlambda);
GeeScore(X1, PtrNull[mtype], &teststat.vector);
}
else if (tm->test==WALD) {
PtrAlt[mtype]->regression(fit->Yref, X1, fit->Oref, NULL);
L1 = gsl_matrix_alloc (nP1-nP0, nP1);
tmp1 = gsl_matrix_alloc (nParam, nP1);
subX(L, &ref1.vector, tmp1);
subXrow1(tmp1, &ref0.vector, &ref1.vector, L1);
lambda = gsl_vector_get(tm->anova_lambda, ID1);
GetR(PtrAlt[mtype]->Res, tm->corr, lambda, Rlambda);
GeeWald(PtrAlt[mtype], L1, &teststat.vector);
}
else {
BetaO = gsl_matrix_alloc(nP1, nVars);
addXrow2(PtrNull[mtype]->Beta, &ref1.vector, BetaO);
PtrAlt[mtype]->regression(fit->Yref, X1, fit->Oref, BetaO);
GeeLR(PtrAlt[mtype], PtrNull[mtype], &teststat.vector);
}
if (tm->resamp==MONTECARLO) {
lambda=gsl_vector_get(tm->anova_lambda,ID0);
GetR(fit->Res, tm->corr, lambda, Sigma);
setMonteCarlo (PtrNull[mtype], XBeta, Sigma);
}
// ======= Get univariate test statistics =======//
if (tm->punit == FREESTEP) {
unitstat=gsl_vector_subvector(&teststat.vector,1,nVars);
gsl_sort_vector_index (sortid, &unitstat.vector);
gsl_permutation_reverse(sortid);
}
// ======= Get resampling distribution under H0 ===== //
nSamp=0;
double dif, timelast=0;
clock_t clk_start=clock();
if (tm->showtime==TRUE)
printf("Resampling begins for test %d.\n", i);
for (j=0; j<tm->nboot; j++) {
// printf("simu %d :", j);
gsl_vector_set_zero (bStat);
if ( tm->resamp == CASEBOOT ) {
resampAnovaCase(PtrAlt[mtype],bY,X1,bO,j);
subX(X1, &ref0.vector, X0);
}
else {
resampNonCase(PtrNull[mtype], bY, j);
gsl_matrix_memcpy(bO, fit->Oref);
}
if ( tm->test == WALD ) {
bAlt[mtype]->regression(bY,X1,bO,NULL);
lambda = gsl_vector_get(tm->anova_lambda, ID1);
GetR(bAlt[mtype]->Res, tm->corr, lambda, Rlambda);
GeeWald(bAlt[mtype], L1, bStat);
}
else if ( tm->test == SCORE ) {
bNull[mtype]->regression(bY,X0,bO,NULL);
lambda = gsl_vector_get(tm->anova_lambda, ID0);
GetR(bNull[mtype]->Res, tm->corr, lambda, Rlambda);
GeeScore(X1, bNull[mtype], bStat);
}
else {
bNull[mtype]->regression(bY,X0,bO,NULL);
addXrow2(bNull[mtype]->Beta, &ref1.vector, BetaO);
bAlt[mtype]->regression(bY,X1,bO,BetaO);
GeeLR(bAlt[mtype], bNull[mtype], bStat);
}
// ----- get multivariate counts ------- //
buj = gsl_vector_ptr (bStat,0);
suj = gsl_matrix_ptr (anovaStat, i-1, 0);
puj = gsl_matrix_ptr (Panova, i-1, 0);
if ( *(buj) > (*(suj)-1e-8) ) *puj=*puj+1;
// ------ get univariate counts ---------//
calcAdjustP(tm->punit,nVars,buj+1,suj+1,puj+1,sortid);
nSamp++;
// Prompts
if ((tm->showtime==TRUE)&(j%100==0)) {
dif = (float)(clock() - clk_start)/(float)CLOCKS_PER_SEC;
timelast+=(double)dif/60;
printf("\tResampling run %d finished. Time elapsed: %.2f minutes...\n", j, timelast);
clk_start=clock();
}
} // end j for loop
// ========= get p-values ======== //
if ( tm->punit == FREESTEP) {
puj = gsl_matrix_ptr (Panova, i-1, 1);
reinforceP(puj, nVars, sortid);
}
if (BetaO!=NULL) gsl_matrix_free(BetaO);
if (X0!=NULL) gsl_matrix_free(X0);
if (X1!=NULL) gsl_matrix_free(X1);
if (tm->test == WALD) {
if (L1!=NULL) gsl_matrix_free(L1);
if (tmp1!=NULL) gsl_matrix_free(tmp1);
}
} // end i for loop and test for loop
// p = (#exceeding observed stat + 1)/(#nboot+1)
gsl_matrix_add_constant (Panova, 1.0);
gsl_matrix_scale (Panova, (double)1/(nSamp+1.0));
bAlt[mtype]->releaseGlm();
PtrAlt[mtype]->releaseGlm();
if ( tm->test!=WALD ) {
bNull[mtype]->releaseGlm();
PtrNull[mtype]->releaseGlm();
}
delete []rdf;
if (sortid != NULL )
gsl_permutation_free(sortid);
gsl_vector_free(bStat);
gsl_matrix_free(bY);
if (bO!=NULL) gsl_matrix_free(bO);
return SUCCESS;
}
/*-- Particle Cannon --*/
#strict 2
#include FLAK
private func CalculateRifle(&oX, &oY)
{
var angle = Crosshair->GetAngle() + GetR();
// Korrektur für Mitte (speziell für diese Grafik)
var correction = CenterFix();
var x = +Sin(angle, 25-(correction/5));
var y = -Cos(angle, 15+correction/20);
// circle x,y
// min->max breite: 0->4
// min->max höhe: 1->2
var cx, cy;
cx = correction/25;
cy = 2 - correction/90;
x += Sin(30+180*Rifle, cx);
y += Cos(60+180*Rifle, cy);
if(++Rifle > 1)
Rifle = 0;
oX = x;
oY = y-3;
}
func FxRotateTimer(target, fx)
{
if(this)
SetR(GetR() + 25 * fx.dir);
}
