void do_boundaries_fcs(int nloc, fcs_float *pos) { int l, i; /* PBC in x direction */ if (1==pbc_dirs.x) for (l=0; l<3*nloc; l+=3) { i = -FLOOR( SPRODFCS(pos+l,tbox_x) ); pos[l ] += i * box_x.x; pos[l+1] += i * box_x.y; pos[l+2] += i * box_x.z; } /* PBC in y direction */ if (1==pbc_dirs.y) for (l=0; l<3*nloc; l+=3) { i = -FLOOR( SPRODFCS(pos+l,tbox_y) ); pos[l ] += i * box_y.x; pos[l+1] += i * box_y.y; pos[l+2] += i * box_y.z; } /* PBC in z direction */ if (1==pbc_dirs.z) for (l=0; l<3*nloc; l+=3) { i = -FLOOR( SPRODFCS(pos+l,tbox_z) ); pos[l ] += i * box_z.x; pos[l+1] += i * box_z.y; pos[l+2] += i * box_z.z; } }
void aubio_pitchmcomb_do (aubio_pitchmcomb_t * p, cvec_t * fftgrain, fvec_t * output) { uint_t j; smpl_t instfreq; fvec_t *newmag = (fvec_t *) p->newmag; //smpl_t hfc; //fe=instfreq(theta1,theta,ops); //theta1=theta; /* copy incoming grain to newmag */ for (j = 0; j < newmag->length; j++) newmag->data[j] = fftgrain->norm[j]; /* detect only if local energy > 10. */ //if (aubio_level_lin (newmag) * newmag->length > 10.) { //hfc = fvec_local_hfc(newmag); //not used aubio_pitchmcomb_spectral_pp (p, newmag); aubio_pitchmcomb_combdet (p, newmag); //aubio_pitchmcomb_sort_cand_freq(p->candidates,p->ncand); //return p->candidates[p->goodcandidate]->ebin; j = (uint_t) FLOOR (p->candidates[p->goodcandidate]->ebin + .5); instfreq = aubio_unwrap2pi (fftgrain->phas[j] - p->theta->data[j] - j * p->phasediff); instfreq *= p->phasefreq; /* store phase for next run */ for (j = 0; j < p->theta->length; j++) { p->theta->data[j] = fftgrain->phas[j]; } //return p->candidates[p->goodcandidate]->ebin; output->data[0] = FLOOR (p->candidates[p->goodcandidate]->ebin + .5) + instfreq; /*} else { return -1.; } */ }
/** *@brief fold space to extend the domain over which we can take * noise values. * *@n x, y, z are set to the noise space location for the source point. *@n ix, iy, iz are the integer lattice point (integer portion of x, y, z) *@n fx, fy, fz are the fractional lattice distance above ix, iy, iz * * The noise function has a finite domain, which can be exceeded when * using fractal textures with very high frequencies. This routine is * designed to extend the effective domain of the function, albeit by * introducing periodicity. -FKM 4/93 */ static void filter_args(fastf_t *src, fastf_t *p, fastf_t *f, int *ip) { register int i; point_t dst; static unsigned long max2x = ~((unsigned long)0); static unsigned long max = (~((unsigned long)0)) >> 1; for (i=0; i < 3; i++) { /* assure values are positive */ if (src[i] < 0) dst[i] = -src[i]; else dst[i] = src[i]; /* fold space */ while (dst[i] > max || dst[i]<0) { if (dst[i] > max) { dst[i] = max2x - dst[i]; } else { dst[i] = -dst[i]; } } } p[X] = dst[0]; ip[X] = FLOOR(p[X]); f[X] = p[X] - ip[X]; p[Y] = dst[1]; ip[Y] = FLOOR(p[Y]); f[Y] = p[Y] - ip[Y]; p[Z] = dst[2]; ip[Z] = FLOOR(p[Z]); f[Z] = p[Z] - ip[Z]; }
static int _fill_polygon_gray8(uint8_t *img, int npoints, Edge *e, uint8_t intensity, int w, int h, int rowstride) { int i, j; float *xx; int ymin, ymax; float y; if (npoints <= 0) return 0; /* Find upper and lower polygon boundary (within image) */ ymin = e[0].ymin; ymax = e[0].ymax; for (i = 1; i < npoints; i++) { if (e[i].ymin < ymin) ymin = e[i].ymin; if (e[i].ymax > ymax) ymax = e[i].ymax; } if (ymin < 0) ymin = 0; if (ymax >= h) ymax = h-1; /* Process polygon edges */ xx = malloc(npoints * sizeof(float)); if (!xx) return -1; for (;ymin <= ymax; ymin++) { y = ymin+0.5F; for (i = j = 0; i < npoints; i++) { if (y >= e[i].ymin && y <= e[i].ymax) { if (e[i].d == 0) draw_hline_gray8(img, e[i].xmin, ymin, e[i].xmax, intensity, w, h, rowstride); else xx[j++] = (y-e[i].y0) * e[i].dx + e[i].x0; } } if (j == 2) { if (xx[0] < xx[1]) draw_hline_gray8(img, CEIL(xx[0]-0.5), ymin, FLOOR(xx[1]+0.5), intensity, w, h, rowstride); else draw_hline_gray8(img, CEIL(xx[1]-0.5), ymin, FLOOR(xx[0]+0.5), intensity, w, h, rowstride); } else { qsort(xx, j, sizeof(float), x_cmp); for (i = 0; i < j-1 ; i += 2) draw_hline_gray8(img, CEIL(xx[i]-0.5), ymin, FLOOR(xx[i+1]+0.5), intensity, w, h, rowstride); } } free(xx); return 0; }
void JelloMesh::GetCell(int idx, int& i, int &j, int& k) const { float rows = m_rows+1; float cols = m_cols+1; float stacks = m_stacks+1; // derived from idx = cols*(rows*k + i) + j float tmp = FLOOR(idx/cols); j = (int) ROUND(cols*(FRACT(idx/cols))); i = (int) ROUND(rows*(FRACT(tmp/rows))); k = (int) FLOOR(tmp/rows); }
double fprec(double x, double digits) { double l10, pow10, sgn, p10, P10; int e10, e2, do_round, dig; /* Max.expon. of 10 (=308.2547) */ const double max10e = numeric_limits<double>::max_exponent * M_LOG10_2; #ifdef IEEE_754 if (ISNAN(x) || ISNAN(digits)) return x + digits; if (!R_FINITE(x)) return x; if (!R_FINITE(digits)) { if(digits > 0) return x; else return 0; } #endif if(x == 0) return x; dig = (int)FLOOR(digits+0.5); if (dig > MAX_DIGITS) { return x; } else if (dig < 1) dig = 1; sgn = 1.0; if(x < 0.0) { sgn = -sgn; x = -x; } l10 = log10(x); e10 = (int)(dig-1-FLOOR(l10)); if(fabs(l10) < max10e - 2) { p10 = 1.0; if(e10 > max10e) { p10 = std::pow(10., e10-max10e); e10 = static_cast<int>(max10e); } else if(e10 < - max10e) { p10 = std::pow(10., e10+max10e); e10 = static_cast<int>(-max10e); } pow10 = std::pow(10., e10); return(sgn*(FLOOR((x*pow10)*p10+0.5)/pow10)/p10); } else { /* -- LARGE or small -- */ do_round = max10e - l10 >= std::pow(10., -dig); e2 = dig + ((e10>0)? 1 : -1) * MAX_DIGITS; p10 = std::pow(10., e2); x *= p10; P10 = std::pow(10., e10-e2); x *= P10; /*-- p10 * P10 = 10 ^ e10 */ if(do_round) x += 0.5; x = FLOOR(x) / p10; return(sgn*x/P10); } }
/** * @brief Prepares a list of items on the floor at given entity position. * @param[in] ent Pointer to an entity being an actor. * @return pointer to edict_t being a floor (with items) or @c NULL in case no items were found * on the edict grid position. */ edict_t *G_GetFloorItems (edict_t * ent) { edict_t *floor = G_GetFloorItemsFromPos(ent->pos); /* found items */ if (floor) { FLOOR(ent) = FLOOR(floor); return floor; } /* no items on ground found */ FLOOR(ent) = NULL; return NULL; }
static bool G_InventoryPlaceItemAdjacent (edict_t *ent) { vec2_t oldPos; /* if we have to place it to adjacent */ edict_t *floorAdjacent; int i; Vector2Copy(ent->pos, oldPos); floorAdjacent = NULL; for (i = 0; i < DIRECTIONS; i++) { /** @todo Check whether movement is possible here - otherwise don't use this field */ /* extend pos with the direction vectors */ /** @todo Don't know why the adjacent stuff has been disabled, but if it was buggy, it's probably */ /** because the third ent->pos in the next line should be pos[1] ?!. (Duke, 13.1.11) */ Vector2Set(ent->pos, ent->pos[0] + dvecs[i][0], ent->pos[0] + dvecs[i][1]); /* now try to get a floor entity for that new location */ floorAdjacent = G_GetFloorItems(ent); if (!floorAdjacent) { floorAdjacent = G_SpawnFloor(ent->pos); } else { /* destroy this edict (send this event to all clients that see the edict) */ G_EventPerish(floorAdjacent); G_VisFlagsReset(floorAdjacent); } INVSH_FindSpace(&floorAdjacent->i, &ic->item, INVDEF(gi.csi->idFloor), &x, &y, ic); if (x != NONE) { ic->x = x; ic->y = y; ic->next = FLOOR(floorAdjacent); FLOOR(floorAdjacent) = ic; break; } /* restore original pos */ Vector2Copy(oldPos, ent->pos); } /* added to adjacent pos? */ if (i < DIRECTIONS) { /* restore original pos - if no free space, this was done * already in the for loop */ Vector2Copy(oldPos, ent->pos); return false; } if (floorAdjacent) G_CheckVis(floorAdjacent, true); return true; }
/* So, all of the encodings point to the ->screen->frameBuffer, * We need to change this! */ void rfbScaledCorrection(rfbScreenInfoPtr from, rfbScreenInfoPtr to, int *x, int *y, int *w, int *h, char *function) { double x1,y1,w1,h1, x2, y2, w2, h2; double scaleW = ((double) to->width) / ((double) from->width); double scaleH = ((double) to->height) / ((double) from->height); /* * rfbLog("rfbScaledCorrection(%p -> %p, %dx%d->%dx%d (%dXx%dY-%dWx%dH)\n", * from, to, from->width, from->height, to->width, to->height, *x, *y, *w, *h); */ /* If it's the original framebuffer... */ if (from==to) return; x1 = ((double) *x) * scaleW; y1 = ((double) *y) * scaleH; w1 = ((double) *w) * scaleW; h1 = ((double) *h) * scaleH; /*cast from double to int is same as "*x = floor(x1);" */ x2 = FLOOR(x1); y2 = FLOOR(y1); /* include into W and H the jitter of scaling X and Y */ w2 = CEIL(w1 + ( x1 - x2 )); h2 = CEIL(h1 + ( y1 - y2 )); /* * rfbLog("%s (%dXx%dY-%dWx%dH -> %fXx%fY-%fWx%fH) {%dWx%dH -> %dWx%dH}\n", * function, *x, *y, *w, *h, x2, y2, w2, h2, * from->width, from->height, to->width, to->height); */ /* simulate ceil() without math library */ *x = (int)x2; *y = (int)y2; *w = (int)w2; *h = (int)h2; /* Small changes for a thumbnail may be scaled to zero */ if (*w==0) (*w)++; if (*h==0) (*h)++; /* scaling from small to big may overstep the size a bit */ if (*x+*w > to->width) *w=to->width - *x; if (*y+*h > to->height) *h=to->height - *y; }
// Init random ............................................................. void FileName::initRandom(int length) { randomize_random_generator(); *this = ""; for (int i = 0; i < length; i++) *this += 'a' + FLOOR(rnd_unif(0, 26)); }
int tabler_init(CSOUND *csound, TABL *p) { int ndx, len; int mask; if (UNLIKELY((p->ftp = csound->FTnp2Find(csound, p->ftable)) == NULL)) return csound->InitError(csound, Str("table: could not find ftable %d"), (int) *p->ftable); mask = p->ftp->lenmask; p->np2 = mask ? 0 : 1; len = p->ftp->flen; if (*p->mode) p->mul = len; else p->mul = 1; ndx = FLOOR((*p->ndx + *p->offset)*p->mul); if (*p->wrap) { if (p->np2) { while(ndx >= len) ndx -= len; while(ndx < 0) ndx += len; } else ndx &= mask; } else { if (UNLIKELY(ndx >= len)) ndx = len - 1; else if (UNLIKELY(ndx < 0)) ndx = 0; } *p->sig = p->ftp->ftable[ndx]; return OK; }
glm::vec3 WrappedFbmTexture::getColor(const ShadeRec& sr)const { float noiseV = expansionNumber * noise->valueFBM(sr.localHitPoint); float value = noiseV - FLOOR(noiseV); return lerp(value, colorMin, colorMax); }
int bestPrecision(float F, int _width) { // If it is 0 if (F == 0) return 1; // Otherwise int exp = FLOOR(log10(ABS(F))); int advised_prec; if (exp >= 0) if (exp > _width - 3) advised_prec = -1; else advised_prec = _width - 2; else { advised_prec = _width + (exp - 1) - 3; if (advised_prec <= 0) advised_prec = -1; } if (advised_prec < 0) advised_prec = -1; // Choose exponential format return advised_prec; }
void aubio_hist_dyn_notnull (aubio_hist_t *s, fvec_t *input) { uint_t i; sint_t tmp = 0; smpl_t ilow = fvec_min(input); smpl_t ihig = fvec_max(input); smpl_t step = (ihig-ilow)/(smpl_t)(s->nelems); /* readapt */ aubio_scale_set_limits (s->scaler, ilow, ihig, 0, s->nelems); /* recalculate centers */ s->cent->data[0] = ilow + 0.5f * step; for (i=1; i < s->nelems; i++) s->cent->data[i] = s->cent->data[0] + i * step; /* scale */ aubio_scale_do(s->scaler, input); /* reset data */ fvec_zeros(s->hist); /* run accum */ for (i=0; i < input->length; i++) { if (input->data[i] != 0) { tmp = (sint_t)FLOOR(input->data[i]); if ((tmp >= 0) && (tmp < (sint_t)s->nelems)) s->hist->data[tmp] += 1; } } }
static smpl_t interp_2(fvec_t *input, smpl_t pos) { uint_t idx = (uint_t)FLOOR(pos); smpl_t frac = pos - (smpl_t)idx; smpl_t a = input->data[idx]; smpl_t b = input->data[idx + 1]; return a + frac * ( b - a ); }
/* execute tempo detection function on iput buffer */ void aubio_tempo_do(aubio_tempo_t *o, fvec_t * input, fvec_t * tempo) { uint_t i; uint_t winlen = o->winlen; uint_t step = o->step; fvec_t * thresholded; aubio_pvoc_do (o->pv, input, o->fftgrain); aubio_specdesc_do (o->od, o->fftgrain, o->of); /*if (usedoubled) { aubio_specdesc_do(o2,fftgrain, onset2); onset->data[0] *= onset2->data[0]; }*/ /* execute every overlap_size*step */ if (o->blockpos == (signed)step -1 ) { /* check dfframe */ aubio_beattracking_do(o->bt,o->dfframe,o->out); /* rotate dfframe */ for (i = 0 ; i < winlen - step; i++ ) o->dfframe->data[i] = o->dfframe->data[i+step]; for (i = winlen - step ; i < winlen; i++ ) o->dfframe->data[i] = 0.; o->blockpos = -1; } o->blockpos++; aubio_peakpicker_do (o->pp, o->of, o->onset); tempo->data[1] = o->onset->data[0]; thresholded = aubio_peakpicker_get_thresholded_input(o->pp); o->dfframe->data[winlen - step + o->blockpos] = thresholded->data[0]; /* end of second level loop */ tempo->data[0] = 0; /* reset tactus */ i=0; for (i = 1; i < o->out->data[0]; i++ ) { /* if current frame is a predicted tactus */ if (o->blockpos == FLOOR(o->out->data[i])) { tempo->data[0] = o->out->data[i] - FLOOR(o->out->data[i]); /* set tactus */ /* test for silence */ /* if (aubio_silence_detection(input, o->silence)==1) { tempo->data[0] = 0; // unset beat if silent } */ o->last_beat = o->total_frames + (uint_t)ROUND(tempo->data[0] * o->hop_size); } } o->total_frames += o->hop_size; return; }
void CL_ActorStateChange (const eventRegister_t *self, struct dbuffer *msg) { le_t *le; int entnum, state; character_t *chr; NET_ReadFormat(msg, self->formatString, &entnum, &state); le = LE_Get(entnum); if (!le) LE_NotFoundError(entnum); if (!LE_IsActor(le)) { Com_Printf("StateChange message ignored... LE is no actor (number: %i, state: %i, type: %i)\n", entnum, state, le->type); return; } /* If standing up or crouching down remove the reserved-state for crouching. */ if (((state & STATE_CROUCHED) && !LE_IsCrouched(le)) || (!(state & STATE_CROUCHED) && LE_IsCrouched(le))) { if (CL_ActorUsableTUs(le) < TU_CROUCH && CL_ActorReservedTUs(le, RES_CROUCH) >= TU_CROUCH) { /* We have not enough non-reserved TUs, * but some reserved for crouching/standing up. * i.e. we only reset the reservation for crouching if it's the very last attempt. */ CL_ActorReserveTUs(le, RES_CROUCH, 0); /* Reset reserved TUs (0 TUs) */ } } /* killed by the server: no animation is played, etc. */ if ((state & STATE_DEAD) && LE_IsLivingActor(le)) { le->state = state; FLOOR(le) = NULL; LE_SetThink(le, NULL); VectorCopy(player_dead_maxs, le->maxs); CL_ActorRemoveFromTeamList(le); return; } else { le->state = state; LE_SetThink(le, LET_StartIdle); } /* save those states that the actor should also carry over to other missions */ chr = CL_ActorGetChr(le); if (!chr) return; chr->state = (le->state & STATE_REACTION); /* change reaction button state */ if (!(le->state & STATE_REACTION)) { UI_ExecuteConfunc("disable_reaction"); } else { UI_ExecuteConfunc("startreaction"); } /* state change may have affected move length */ CL_ActorConditionalMoveCalc(le); }
static void quilted (const Vector3d& EPoint, const TNORMAL *Tnormal, Vector3d& normal) { Vector3d value; DBL t; value[X] = EPoint[X]-FLOOR(EPoint[X])-0.5; value[Y] = EPoint[Y]-FLOOR(EPoint[Y])-0.5; value[Z] = EPoint[Z]-FLOOR(EPoint[Z])-0.5; t = value.length(); t = quilt_cubic(t, dynamic_cast<QuiltedPattern*>(Tnormal->pattern.get())->Control0, dynamic_cast<QuiltedPattern*>(Tnormal->pattern.get())->Control1); value *= t; normal += (DBL)Tnormal->Amount * value; }
//#define DEBUG blobtype best_blob(double alpha_0, double alpha_F, double inc_alpha, double a_0, double a_F, double inc_a, double w, double *target_att, int target_length) { blobtype retval; retval.order = 2; int alpha_size = FLOOR((alpha_F - alpha_0) / inc_alpha + 1); int a_size = FLOOR((a_F - a_0) / inc_a + 1); Image<double> att, ops; att().resize(alpha_size, a_size); ops().resize(alpha_size, a_size); int i, j; double a, alpha, best_a = -1, best_alpha = -1; double best_ops = 1e10, best_att = 0; for (i = 0, alpha = alpha_0; i < alpha_size; alpha += inc_alpha, i++) for (j = 0, a = a_0; j < a_size; a += inc_a, j++) { retval.radius = a; retval.alpha = alpha; A2D_ELEM(att(), i, j) = blob_att(w, retval); A2D_ELEM(ops(), i, j) = blob_ops(w, retval); if (j > 0) for (int n = target_length - 1; n >= 0; n--) if (A2D_ELEM(att(), i, j - 1) > target_att[n] && A2D_ELEM(att(), i, j) < target_att[n]) { A2D_ELEM(att(), i, j) = 0; if (A2D_ELEM(ops(), i, j - 1) < best_ops && A2D_ELEM(att(), i, j - 1) >= best_att) { best_alpha = alpha; best_a = a - inc_a; best_ops = A2D_ELEM(ops(), i, j - 1); best_att = target_att[n]; } } } #ifdef DEBUG att.write((std::string)"att" + floatToString(w) + ".xmp"); ops.write((std::string)"ops" + floatToString(w) + ".xmp"); #endif retval.radius = best_a; retval.alpha = best_alpha; return retval; }
ssfloat ExpMgr::gnoise(ssfloat x, ssfloat y, ssfloat z) { int ix, iy, iz; ssfloat fx0, fx1, fy0, fy1, fz0, fz1; ssfloat wx, wy, wz; ssfloat vx0, vx1, vy0, vy1, vz0, vz1; static int initialized = 0; if (!initialized) { gradientTabInit(665); initialized = 1; } ix = FLOOR(x); fx0 = x - ix; fx1 = fx0 - 1; wx = SMOOTHSTEP(fx0); iy = FLOOR(y); fy0 = y - iy; fy1 = fy0 - 1; wy = SMOOTHSTEP(fy0); iz = FLOOR(z); fz0 = z - iz; fz1 = fz0 - 1; wz = SMOOTHSTEP(fz0); vx0 = glattice(ix,iy,iz,fx0,fy0,fz0); vx1 = glattice(ix+1,iy,iz,fx1,fy0,fz0); vy0 = LERP(wx, vx0, vx1); vx0 = glattice(ix,iy+1,iz,fx0,fy1,fz0); vx1 = glattice(ix+1,iy+1,iz,fx1,fy1,fz0); vy1 = LERP(wx, vx0, vx1); vz0 = LERP(wy, vy0, vy1); vx0 = glattice(ix,iy,iz+1,fx0,fy0,fz1); vx1 = glattice(ix+1,iy,iz+1,fx1,fy0,fz1); vy0 = LERP(wx, vx0, vx1); vx0 = glattice(ix,iy+1,iz+1,fx0,fy1,fz1); vx1 = glattice(ix+1,iy+1,iz+1,fx1,fy1,fz1); vy1 = LERP(wx, vx0, vx1); vz1 = LERP(wy, vy0, vy1); return LERP(wz, vz0, vz1); }
void fmat_rev(fmat_t *s) { uint_t i,j; for (i=0; i< s->height; i++) { for (j=0; j< FLOOR(s->length/2); j++) { ELEM_SWAP(s->data[i][j], s->data[i][s->length-1-j]); } } }
static int64_t alignTimeDown(int64_t ts, int unit, int count) { switch (unit) { case FT_SECOND: ts = FLOOR(ts, count * 1000); break; case FT_MINUTE: ts = FLOOR(ts, count * 60 * 1000); break; case FT_HOUR: ts = FLOOR(ts, count * 3600 * 1000); default: // TODO: more FT_XXX break; } return ts; }
void aubio_pitchyinfft_do (aubio_pitchyinfft_t * p, fvec_t * input, fvec_t * output) { uint_t tau, l; uint_t halfperiod; smpl_t tmp, sum; cvec_t *res = (cvec_t *) p->res; fvec_t *yin = (fvec_t *) p->yinfft; l = 0; tmp = 0.; sum = 0.; for (l = 0; l < input->length; l++) { p->winput->data[l] = p->win->data[l] * input->data[l]; } aubio_fft_do (p->fft, p->winput, p->fftout); for (l = 0; l < p->fftout->length; l++) { p->sqrmag->data[l] = SQR (p->fftout->norm[l]); p->sqrmag->data[l] *= p->weight->data[l]; } for (l = 1; l < p->fftout->length; l++) { p->sqrmag->data[(p->fftout->length - 1) * 2 - l] = SQR (p->fftout->norm[l]); p->sqrmag->data[(p->fftout->length - 1) * 2 - l] *= p->weight->data[l]; } for (l = 0; l < p->sqrmag->length / 2 + 1; l++) { sum += p->sqrmag->data[l]; } sum *= 2.; aubio_fft_do (p->fft, p->sqrmag, res); yin->data[0] = 1.; for (tau = 1; tau < yin->length; tau++) { yin->data[tau] = sum - res->norm[tau] * COS (res->phas[tau]); tmp += yin->data[tau]; yin->data[tau] *= tau / tmp; } tau = fvec_min_elem (yin); if (yin->data[tau] < p->tol) { /* no interpolation */ //return tau; /* 3 point quadratic interpolation */ //return fvec_quadint_min(yin,tau,1); /* additional check for (unlikely) octave doubling in higher frequencies */ if (tau > 35) { output->data[0] = fvec_quadint (yin, tau); } else { /* should compare the minimum value of each interpolated peaks */ halfperiod = FLOOR (tau / 2 + .5); if (yin->data[halfperiod] < p->tol) output->data[0] = fvec_quadint (yin, halfperiod); else output->data[0] = fvec_quadint (yin, tau); } } else { output->data[0] = 0.; } }
static void quilted (const VECTOR EPoint, const TNORMAL *Tnormal, VECTOR normal) { VECTOR value; DBL t; value[X] = EPoint[X]-FLOOR(EPoint[X])-0.5; value[Y] = EPoint[Y]-FLOOR(EPoint[Y])-0.5; value[Z] = EPoint[Z]-FLOOR(EPoint[Z])-0.5; t = sqrt(value[X]*value[X]+value[Y]*value[Y]+value[Z]*value[Z]); t = quilt_cubic(t, Tnormal->Vals.Quilted.Control0, Tnormal->Vals.Quilted.Control1); value[X] *= t; value[Y] *= t; value[Z] *= t; VAddScaledEq (normal, Tnormal->Amount,value); }
float NoiseSampler::vnoise(const glm::vec3& p) { int ix = FLOOR(p[0]); int iy = FLOOR(p[1]); int iz = FLOOR(p[2]); float fy = p[1]-iy; float fx = p[0]-ix; float fz = p[2]-iz; float xp[4], yp[4], zp[4]; for(int k = -1; k <= 2; k++) { for(int j = -1; j <= 2; j++) { for(int i = -1; i <= 2; i++) { xp[i+1] = m_value_table[INDEX_3(ix+i, iy+j, iz+k)]; } yp[j+1] = catmull_rom4(fx, xp); } zp[k+1] = catmull_rom4(fy, yp); } return catmull_rom4(fz, zp); }
/** * @brief Called whenever an entity disappears from view * @sa CL_EntAppear */ void CL_EntPerish (const eventRegister_t *self, struct dbuffer *msg) { int entnum; int type; le_t *le, *actor; NET_ReadFormat(msg, self->formatString, &entnum, &type); le = LE_Get(entnum); if (!le) LE_NotFoundWithTypeError(entnum, type); switch (le->type) { case ET_ITEM: cls.i.EmptyContainer(&cls.i, &le->i, INVDEF(csi.idFloor)); /* search owners (there can be many, some of them dead) */ actor = NULL; while ((actor = LE_GetNextInUse(actor))) { if ((actor->type == ET_ACTOR || actor->type == ET_ACTOR2x2) && VectorCompare(actor->pos, le->pos)) { Com_DPrintf(DEBUG_CLIENT, "CL_EntPerish: le of type ET_ITEM hidden\n"); FLOOR(actor) = NULL; } } break; case ET_ACTOR: case ET_ACTOR2x2: cls.i.DestroyInventory(&cls.i, &le->i); break; #ifdef DEBUG case ET_ACTORHIDDEN: Com_DPrintf(DEBUG_CLIENT, "CL_EntPerish: It should not happen that we perish a hidden actor\n"); return; #endif case ET_PARTICLE: CL_ParticleFree(le->ptl); le->ptl = NULL; break; case ET_BREAKABLE: case ET_DOOR: case ET_DOOR_SLIDING: break; default: break; } le->invis = qtrue; /* decrease the count of spotted aliens (also stunned) */ cl.numEnemiesSpotted = CL_CountVisibleEnemies(); }
static void ellipsePoint(int cx, int cy, int w, int h, float i, int *x, int *y) { float i_cos, i_sin; float x_f, y_f; double modf_int; i_cos = cos(i*M_PI/180); i_sin = sin(i*M_PI/180); x_f = (i_cos * w/2) + cx; y_f = (i_sin * h/2) + cy; if (modf(x_f, &modf_int) == 0.5) { *x = i_cos > 0 ? FLOOR(x_f) : CEIL(x_f); } else { *x = FLOOR(x_f + 0.5); } if (modf(y_f, &modf_int) == 0.5) { *y = i_sin > 0 ? FLOOR(y_f) : CEIL(y_f); } else { *y = FLOOR(y_f + 0.5); } }
int main() { int Number; int MaxValue; unsigned char i = 0; int Sec[DEFINED_MAX_NUM_LETTERS]; char *Letters[DEFINED_MAX_NUM_LETTERS]; //make sure all the sec numbers are 0 for (i = 0; i < DEFINED_MAX_NUM_LETTERS; i++) {Sec[i] = 0;} //Calculate the max value based on number of letters for (i = 0; i < DEFINED_MAX_NUM_LETTERS; i++) { MaxValue *= 24; MaxValue += 24; } do { if (Number > MaxValue) { printf("Error, the number you have entered is incorrect. The number must be between 0 & %d\n", MaxValue); printf("Due to current coding, the program cannot go higher than this number\n"); getchar(); } printf("\n\n"); printf("Please enter a number: "); scanf ("%d",&Number); printf("\n\n\n\n\n\n"); } while (Number > MaxValue || Number < 0); Sec[0] = Number; //Get Section Numbers for (i = 0; i < DEFINED_MAX_NUM_LETTERS; i++) { if (Sec[i] > 24 && i != DEFINED_MAX_NUM_LETTERS - 1) { Sec[i + 1] = FLOOR( ( Sec[i] - 1) / 24); Sec[i] -= Sec[i + 1] * 24; } //end if } //end for //get the letters for (i = 0; i < DEFINED_MAX_NUM_LETTERS; i++) { Letters[i] = Greek(Sec[i]); } //In reverse order write all the letters for (i = DEFINED_MAX_NUM_LETTERS; i > 0; i--) { printf(" %s", Letters[i - 1]); } printf("\n"); getchar(); return 0; }
void aubio_hist_do_notnull (aubio_hist_t *s, fvec_t *input) { uint_t j; sint_t tmp = 0; aubio_scale_do(s->scaler, input); /* reset data */ fvec_zeros(s->hist); /* run accum */ for (j=0; j < input->length; j++) { if (input->data[j] != 0) { tmp = (sint_t)FLOOR(input->data[j]); if ((tmp >= 0) && (tmp < (sint_t)s->nelems)) s->hist->data[tmp] += 1; } } }
double qnchisq(double p, double n, double lambda, int lower_tail, int log_p) { const double acu = 1e-12; const double Eps = 1e-6; /* must be > acu */ double ux, lx, nx; #ifdef IEEE_754 if (ISNAN(p) || ISNAN(n) || ISNAN(lambda)) return p + n + lambda; #endif if (!R_FINITE(n)) ML_ERR_return_NAN; n = FLOOR(n + 0.5); if (n < 1 || lambda < 0) ML_ERR_return_NAN; R_Q_P01_check(p); if (p == R_DT_0) return 0; /* Invert pnchisq(.) finding an upper and lower bound; then interval halfing : */ p = R_D_qIv(p); if(lower_tail) { for(ux = 1.; pnchisq_raw(ux, n, lambda, Eps, 128) < p * (1 + Eps); ux *= 2){} for(lx = ux; pnchisq_raw(lx, n, lambda, Eps, 128) > p * (1 - Eps); lx *= 0.5){} } else { for(ux = 1.; pnchisq_raw(ux, n, lambda, Eps, 128) + p < 1 + Eps; ux *= 2){} for(lx = ux; pnchisq_raw(lx, n, lambda, Eps, 128) + p > 1 - Eps; lx *= 0.5){} } p = R_D_Lval(p); do { nx = 0.5 * (lx + ux); if (pnchisq_raw(nx, n, lambda, acu, 1000) > p) ux = nx; else lx = nx; } while ((ux - lx) / nx > acu); return 0.5 * (ux + lx); }