void test_divmod_with_a_float() { Fixnum* one = as<Fixnum>(Fixnum::from(15)); Array* ary1 = one->divmod(state, Float::create(state, -3.3)); Object* o1 = ary1->get(state, 0); Object* o2 = ary1->get(state, 1); TS_ASSERT(o1->fixnum_p()); TS_ASSERT_EQUALS(as<Integer>(o1)->to_native(), -5); check_float(as<Float>(o2), Float::create(state, -1.5)); }
TInt CTestFloat_blr::fma_test() { // Create temporary variables in stack char chParam[MAX_SIZE]; FLOAT input1; FLOAT input2; FLOAT input3; FLOAT expected; FLOAT max_ulp; FLOAT gen_ulp; // Read parameters ReadStringParam ( chParam); ReadFloatParam ( input1); ReadFloatParam ( input2); ReadFloatParam ( input3); ReadFloatParam ( expected); ReadFloatParam ( max_ulp); // TBuf<MAX_SIZE> buf; TInt len = strlen(chParam); for (TInt j =0; j<len;j++) { buf.Append(chParam[j]); } // Do some testing FLOAT res = FUNC(fma) (input1, input2, input3); if(check_float(res, expected, max_ulp, gen_ulp)) { INFO_PRINTF1(_L("Test passed.")); } else { ERR_PRINTF1(_L("Test Failed.")); return KErrGeneral; } INFO_PRINTF1(_L("_________________________________________\n")); INFO_PRINTF2(_L("TestCase : %S\n"), &buf ); INFO_PRINTF2(_L("Input Value 1 : %f\n"), input1 ); INFO_PRINTF2(_L("Input Value 2 : %f\n"), input2 ); INFO_PRINTF2(_L("Input Value 3 : %f\n"), input3 ); INFO_PRINTF2(_L("Expected Value : %f\n"), expected ); INFO_PRINTF2(_L("Max ULP value : %f\n"), max_ulp ); INFO_PRINTF2(_L("Result : %f\n"), res ); INFO_PRINTF2(_L("Generated Ulp : %f\n"), gen_ulp ); INFO_PRINTF1(_L("_________________________________________\n")); return KErrNone; }
static int gritobj_update_sphere (lua_State *L) { TRY_START check_args(L,3); GET_UD_MACRO(GritObjectPtr,self,1,GRITOBJ_TAG); Vector3 pos = check_v3(L,2); float r = check_float(L,3); self->updateSphere(pos, r); return 0; TRY_END }
int main (int argc, char *argv[]) { tests_start_mpfr (); check_nans (); check_exact (); check_float (); check53("6.9314718055994530941514e-1", "0.0", MPFR_RNDZ, "0.0"); check53("0.0", "6.9314718055994530941514e-1", MPFR_RNDZ, "0.0"); check_sign(); check53("-4.165000000e4", "-0.00004801920768307322868063274915", MPFR_RNDN, "2.0"); check53("2.71331408349172961467e-08", "-6.72658901114033715233e-165", MPFR_RNDZ, "-1.8251348697787782844e-172"); check53("2.71331408349172961467e-08", "-6.72658901114033715233e-165", MPFR_RNDA, "-1.8251348697787786e-172"); check53("0.31869277231188065", "0.88642843322303122", MPFR_RNDZ, "2.8249833483992453642e-1"); check("8.47622108205396074254e-01", "3.24039313247872939883e-01", MPFR_RNDU, 28, 45, 2, "0.375"); check("8.47622108205396074254e-01", "3.24039313247872939883e-01", MPFR_RNDA, 28, 45, 2, "0.375"); check("2.63978122803639081440e-01", "6.8378615379333496093e-1", MPFR_RNDN, 34, 23, 31, "0.180504585267044603"); check("1.0", "0.11835170935876249132", MPFR_RNDU, 6, 41, 36, "0.1183517093595583"); check53("67108865.0", "134217729.0", MPFR_RNDN, "9.007199456067584e15"); check("1.37399642157394197284e-01", "2.28877275604219221350e-01", MPFR_RNDN, 49, 15, 32, "0.0314472340833162888"); check("4.03160720978664954828e-01", "5.854828e-1" /*"5.85483042917246621073e-01"*/, MPFR_RNDZ, 51, 22, 32, "0.2360436821472831"); check("3.90798504668055102229e-14", "9.85394674650308388664e-04", MPFR_RNDN, 46, 22, 12, "0.385027296503914762e-16"); check("4.58687081072827851358e-01", "2.20543551472118792844e-01", MPFR_RNDN, 49, 3, 2, "0.09375"); check_max(); check_min(); check_regression (); test_generic (2, 500, 100); data_check ("data/mulpi", mpfr_mulpi, "mpfr_mulpi"); valgrind20110503 (); tests_end_mpfr (); return 0; }
static int global_physics_sweep_cylinder (lua_State *L) { TRY_START int base_line = 7; check_args_min(L, base_line); float radius = check_float(L, 1); float height = check_float(L, 2); Quaternion q = check_quat(L, 3); Vector3 start = check_v3(L, 4); Vector3 ray = check_v3(L, 5); bool nearest_only = check_bool(L, 6); unsigned long flags = check_t<unsigned long>(L, 7); LuaSweepCallback lcb(nearest_only, flags); init_cast_blacklist(L, base_line, lcb); physics_sweep_cylinder(start, q, start+ray, lcb, radius, height); return lcb.pushResults(L); TRY_END }
int main(int argc, char const* argv[]) { srand((unsigned)time(NULL)); int i; for ( int i = 0; i < 100000; i++ ) { if ( !check_float( rand_float() ) ) { printf( "失敗\n" ); return 0; } } printf( "成功\n" ); return 0; }
bool Sol_MultigridPressure3DBase::initialize_base_storage(int nx_val, int ny_val, int nz_val, double hx_val, double hy_val, double hz_val) { // pre-validate if (!check_float(hx_val) || !check_float(hy_val) || !check_float(hz_val)) { printf("[ERROR] Sol_MultigridPressure3DBase::initialize_storage - garbage hx,hy,hz value %f %f %f\n", hx_val, hy_val, hz_val); return false; } // do allocation and initialization _num_levels = num_levels(nx_val, ny_val, nz_val); _h = new double[_num_levels]; _dim = new int3[_num_levels]; _h[0] = min3(hx_val, hy_val, hz_val); _fx = (_h[0] * _h[0]) / (hx_val * hx_val); _fy = (_h[0] * _h[0]) / (hy_val * hy_val); _fz = (_h[0] * _h[0]) / (hz_val * hz_val); _omega = optimal_omega(_fx, _fy, _fz); _dim[0].x = nx_val; _dim[0].y = ny_val; _dim[0].z = nz_val; int level; for (level=1; level < _num_levels; level++) { int this_nx = nx(level-1)/2; int this_ny = ny(level-1)/2; int this_nz = nz(level-1)/2; _h[level] = get_h(level-1)*2; _dim[level].x = this_nx; _dim[level].y = this_ny; _dim[level].z = this_nz; } return true; }
int plot_v3_make (lua_State *L) { TRY_START PlotV3 *self = new PlotV3(); check_args(L,1); int table = lua_gettop(L); if (!lua_istable(L,table)) my_lua_error(L,"Parameter should be a table"); for (lua_pushnil(L) ; lua_next(L,table)!=0 ; lua_pop(L,1)) { // the name is held in the object anyway float k = check_float(L,-2); Vector3 v = check_v3(L,-1); self->addPoint(k,v); } self->commit(); push(L,self,PLOT_V3_TAG); return 1; TRY_END }
/*---CONVERT ARRAY OF CHAR TO NUMBER---*/ float get_num(char a[]) { int i=0,n,j,l; float f=0; l = strlen(a); if(check_float(a)==1) { n = get_point(a); for(j = 0; j < n; j++) { i = i*10; i += a[j] - 48; } for(j = n+1;j<l;j++) { f = f*10; f += a[j]-48; } for(j = 0; j<(l-n-1);j++) { f = f/10; } f = i+f; return f; } else { for(j=0;j<l;j++) { i = i*10; i += a[j]-48; } f = i; return f; } }
void adjust_ra(FL_OBJECT *ob, long data) { char tbuf[50]; char *p; strcpy (tbuf, fl_get_input(ob)); p = strchr(tbuf, '\n'); if (p != NULL) { *p = '\0'; } if (check_float (tbuf) < 0) { fl_set_input (ob, "Format Error"); } else { ra = atof(tbuf); } }
bool Sol_MultigridPressure3DBase::solve(double &residual, double tolerance, int max_iter) { if (!check_float(tolerance)) { printf("[ERROR] Sol_MultigridPressure3DDevice::solve - garbage tolerance value %f\n", tolerance); return false; } if (tolerance < 0) { printf("[ERROR] Sol_MultigridPressure3DDevice::solve - negative tolerance value %f\n", tolerance); return false; } if (max_iter <= 0) { printf("[WARNING] Sol_MultigridPressure3DDevice::solve - non-positive max_iter %d\n", max_iter); return false; } double l2, linf; if (!do_fmg(tolerance, max_iter, l2, linf)) { // try again with initual solution vector set to 0. This can fix the problem // of certain error modes growing when resuing the previous solution as a // starting point. printf("[WARNING] Sol_MultigridPressure3DBase::solve - do_fmg did not converge, retrying with zeroed initial search vector\n"); clear_zero(0); if (!do_fmg(tolerance, max_iter, l2, linf)) { printf("[WARNING] Sol_MultigridPressure3DBase::solve - do_fmg failed\n"); residual = (convergence == CONVERGENCE_L2) ? l2 : linf; return false; } } residual = (convergence == CONVERGENCE_L2) ? l2 : linf; //printf("residual = %g\n", residual); return true; }
static int plot_index(lua_State *L) { TRY_START typedef Plot::Map Map; typedef Plot::MI MI; check_args(L,2); GET_UD_MACRO(Plot,self,1,PLOT_TAG); if (lua_type(L,2)==LUA_TNUMBER) { float k = check_float(L,2); lua_pushnumber(L,self[k]); } else { std::string key = luaL_checkstring(L,2); if (key=="minX") { lua_pushnumber(L,self.minX()); } else if (key=="maxX") { lua_pushnumber(L,self.maxX()); } else if (key=="points") { Map data = self.getPoints(); lua_createtable(L, data.size(), 0); for (MI i=data.begin(), i_=data.end() ; i!=i_ ; ++i) { lua_pushnumber(L,i->first); lua_pushnumber(L,i->second); lua_settable(L,-3); } } else if (key=="tangents") { Map data = self.getTangents(); lua_createtable(L, data.size(), 0); for (MI i=data.begin(), i_=data.end() ; i!=i_ ; ++i) { lua_pushnumber(L,i->first); lua_pushnumber(L,i->second); lua_settable(L,-3); } } else { my_lua_error(L,"Not a readable Plot member: "+key); } } return 1; TRY_END }
void adjust_sky_frequency (FL_OBJECT *ob, long data) { char *p; char tbuf[128]; p = (char *)fl_get_input (ob); strcpy (tbuf, p); if ((p = strchr (tbuf, '\n')) != NULL) { *p = '\0'; } if (strcmp (tbuf, "lock") == 0 || strcmp (tbuf, "locked") == 0 || strcmp (tbuf, "tuner") == 0 || strncmp (tbuf, "----", 4) == 0) { char d[128]; sky_locked = 1; sky_freq = frequency; sprintf (d, "%f", sky_freq); fl_set_input (ob, d); fl_set_button (fd_receiver_main->sky_lock_button, 1); } else { if (check_float (tbuf) < 0) { fl_set_input (ob, "Format Error"); } else { sky_freq = atof(tbuf); sky_locked = 0; } write_rcvr_params ("skyfreq", sky_freq); } }
void adjust_pulsar_rate(FL_OBJECT *ob, long data) { char tbuf[50]; char *p; double real_rate; int int_rate; double err; char str[64]; strcpy (tbuf, fl_get_input(ob)); p = strchr(tbuf, '\n'); if (p != NULL) { *p = '\0'; } if ((p = strchr(tbuf, '\r')) != NULL) { *p = '\0'; } if (check_float (tbuf) < 0) { fl_set_input (ob, "Format Error"); } else { pulsar_rate = (double)atof(tbuf); real_rate = (1.0/pulsar_rate)*(double)psr_rate; int_rate = (int)(real_rate); err = fabsf(real_rate - int_rate); err = err / real_rate; sprintf (str, "%8.2f", err*1.0e6); fl_set_object_label (fd_receiver_main->phase_display, str); } }
void test_mod_with_a_float() { Float* f = Fixnum::from(4)->mod(state, Float::create(state, -1.7)); check_float(f, Float::create(state, -1.1)); }
static int gritobj_newindex (lua_State *L) { TRY_START check_args(L,3); GET_UD_MACRO(GritObjectPtr,self,1,GRITOBJ_TAG); std::string key = check_string(L,2); if (key=="destroy") { my_lua_error(L,"Not a writeable GritObject member: "+key); } else if (key=="near") { if (lua_isnil(L,3)) { self->setNearObj(self,GritObjectPtr()); } else { GET_UD_MACRO(GritObjectPtr,v,3,GRITOBJ_TAG); self->setNearObj(self,v); } } else if (key=="far") { if (lua_isnil(L,3)) { self->setNearObj(self,GritObjectPtr()); } else { GET_UD_MACRO(GritObjectPtr,v,3,GRITOBJ_TAG); self->setFarObj(self,v); } } else if (key=="fade") { my_lua_error(L,"Not a writeable GritObject member: "+key); } else if (key=="updateSphere") { my_lua_error(L,"Not a writeable GritObject member: "+key); } else if (key=="pos") { self->updateSphere(check_v3(L,3)); } else if (key=="renderingDistance") { self->updateSphere(check_float(L,3)); } else if (key=="getSphere") { my_lua_error(L,"Not a writeable GritObject member: "+key); } else if (key=="activated") { my_lua_error(L,"Not a writeable GritObject member: "+key); } else if (key=="deactivate") { my_lua_error(L,"Not a writeable GritObject member: "+key); } else if (key=="activate") { my_lua_error(L,"Not a writeable GritObject member: "+key); } else if (key=="instance") { my_lua_error(L,"Not a writeable GritObject member: "+key); } else if (key=="hintAdvancePrepare") { my_lua_error(L,"Not a writeable GritObject member: "+key); } else if (key=="getAdvancePrepareHints") { my_lua_error(L,"Not a writeable GritObject member: "+key); } else if (key=="destroyed") { my_lua_error(L,"Not a writeable GritObject member: "+key); } else if (key=="class") { my_lua_error(L,"Not a writeable GritObject member: "+key); } else if (key=="className") { my_lua_error(L,"Not a writeable GritObject member: "+key); } else if (key=="name") { my_lua_error(L,"Not a writeable GritObject member: "+key); } else if (key=="needsFrameCallbacks") { self->setNeedsFrameCallbacks(self, check_bool(L,3)); } else if (key=="needsStepCallbacks") { self->setNeedsStepCallbacks(self, check_bool(L,3)); } else { GritClass *c = self->getClass(); if (c==NULL) my_lua_error(L,"GritObject destroyed"); const char *err = self->userValues.luaSet(L); if (err) my_lua_error(L, err); } return 0; TRY_END }
int main (void) { mpfr_prec_t p; int k; tests_start_mpfr (); for (p = MPFR_PREC_MIN; p <= 128; p++) { test_property1 (p, MPFR_RNDN, 0); test_property1 (p, MPFR_RNDU, 0); test_property1 (p, MPFR_RNDA, 0); test_property1 (p, MPFR_RNDN, 1); test_property1 (p, MPFR_RNDU, 1); test_property1 (p, MPFR_RNDA, 1); test_property2 (p, MPFR_RNDN); } check_diverse ("635030154261163106768013773815762607450069292760790610550915652722277604820131530404842415587328", 160, "796887792767063979679855997149887366668464780637"); special (); check_nan (); for (p=2; p<200; p++) for (k=0; k<200; k++) check_inexact (p); check_float(); check3 ("-0.0", MPFR_RNDN, "0.0"); check4 ("6.37983013646045901440e+32", MPFR_RNDN, "5.9bc5036d09e0c@13"); check4 ("1.0", MPFR_RNDN, "1"); check4 ("1.0", MPFR_RNDZ, "1"); check4 ("3.725290298461914062500000e-9", MPFR_RNDN, "4@-4"); check4 ("3.725290298461914062500000e-9", MPFR_RNDZ, "4@-4"); check4 ("1190456976439861.0", MPFR_RNDZ, "2.0e7957873529a@6"); check4 ("1219027943874417664.0", MPFR_RNDZ, "4.1cf2af0e6a534@7"); /* the following examples are bugs in Cygnus compiler/system, found by Fabrice Rouillier while porting mpfr to Windows */ check4 ("9.89438396044940256501e-134", MPFR_RNDU, "8.7af7bf0ebbee@-56"); check4 ("7.86528588050363751914e+31", MPFR_RNDZ, "1.f81fc40f32062@13"); check4 ("0.99999999999999988897", MPFR_RNDN, "f.ffffffffffff8@-1"); check4 ("1.00000000000000022204", MPFR_RNDN, "1"); /* the following examples come from the paper "Number-theoretic Test Generation for Directed Rounding" from Michael Parks, Table 4 */ check4 ("78652858805036375191418371571712.0", MPFR_RNDN, "1.f81fc40f32063@13"); check4 ("38510074998589467860312736661504.0", MPFR_RNDN, "1.60c012a92fc65@13"); check4 ("35318779685413012908190921129984.0", MPFR_RNDN, "1.51d17526c7161@13"); check4 ("26729022595358440976973142425600.0", MPFR_RNDN, "1.25e19302f7e51@13"); check4 ("22696567866564242819241453027328.0", MPFR_RNDN, "1.0ecea7dd2ec3d@13"); check4 ("22696888073761729132924856434688.0", MPFR_RNDN, "1.0ecf250e8e921@13"); check4 ("36055652513981905145251657416704.0", MPFR_RNDN, "1.5552f3eedcf33@13"); check4 ("30189856268896404997497182748672.0", MPFR_RNDN, "1.3853ee10c9c99@13"); check4 ("36075288240584711210898775080960.0", MPFR_RNDN, "1.556abe212b56f@13"); check4 ("72154663483843080704304789585920.0", MPFR_RNDN, "1.e2d9a51977e6e@13"); check4 ("78652858805036375191418371571712.0", MPFR_RNDZ, "1.f81fc40f32062@13"); check4 ("38510074998589467860312736661504.0", MPFR_RNDZ, "1.60c012a92fc64@13"); check4 ("35318779685413012908190921129984.0", MPFR_RNDZ, "1.51d17526c716@13"); check4 ("26729022595358440976973142425600.0", MPFR_RNDZ, "1.25e19302f7e5@13"); check4 ("22696567866564242819241453027328.0", MPFR_RNDZ, "1.0ecea7dd2ec3c@13"); check4 ("22696888073761729132924856434688.0", MPFR_RNDZ, "1.0ecf250e8e92@13"); check4 ("36055652513981905145251657416704.0", MPFR_RNDZ, "1.5552f3eedcf32@13"); check4 ("30189856268896404997497182748672.0", MPFR_RNDZ, "1.3853ee10c9c98@13"); check4 ("36075288240584711210898775080960.0", MPFR_RNDZ, "1.556abe212b56e@13"); check4 ("72154663483843080704304789585920.0", MPFR_RNDZ, "1.e2d9a51977e6d@13"); check4 ("78652858805036375191418371571712.0", MPFR_RNDU, "1.f81fc40f32063@13"); check4 ("38510074998589467860312736661504.0", MPFR_RNDU, "1.60c012a92fc65@13"); check4 ("35318779685413012908190921129984.0", MPFR_RNDU, "1.51d17526c7161@13"); check4 ("26729022595358440976973142425600.0", MPFR_RNDU, "1.25e19302f7e51@13"); check4 ("22696567866564242819241453027328.0", MPFR_RNDU, "1.0ecea7dd2ec3d@13"); check4 ("22696888073761729132924856434688.0", MPFR_RNDU, "1.0ecf250e8e921@13"); check4 ("36055652513981905145251657416704.0", MPFR_RNDU, "1.5552f3eedcf33@13"); check4 ("30189856268896404997497182748672.0", MPFR_RNDU, "1.3853ee10c9c99@13"); check4 ("36075288240584711210898775080960.0", MPFR_RNDU, "1.556abe212b56f@13"); check4 ("72154663483843080704304789585920.0", MPFR_RNDU, "1.e2d9a51977e6e@13"); check4 ("78652858805036375191418371571712.0", MPFR_RNDD, "1.f81fc40f32062@13"); check4 ("38510074998589467860312736661504.0", MPFR_RNDD, "1.60c012a92fc64@13"); check4 ("35318779685413012908190921129984.0", MPFR_RNDD, "1.51d17526c716@13"); check4 ("26729022595358440976973142425600.0", MPFR_RNDD, "1.25e19302f7e5@13"); check4 ("22696567866564242819241453027328.0", MPFR_RNDD, "1.0ecea7dd2ec3c@13"); check4 ("22696888073761729132924856434688.0", MPFR_RNDD, "1.0ecf250e8e92@13"); check4 ("36055652513981905145251657416704.0", MPFR_RNDD, "1.5552f3eedcf32@13"); check4 ("30189856268896404997497182748672.0", MPFR_RNDD, "1.3853ee10c9c98@13"); check4 ("36075288240584711210898775080960.0", MPFR_RNDD, "1.556abe212b56e@13"); check4 ("72154663483843080704304789585920.0", MPFR_RNDD, "1.e2d9a51977e6d@13"); /* check that rounding away is just rounding toward plus infinity */ check4 ("72154663483843080704304789585920.0", MPFR_RNDA, "1.e2d9a51977e6e@13"); test_generic (2, 300, 15); data_check ("data/sqrt", mpfr_sqrt, "mpfr_sqrt"); bad_cases (mpfr_sqrt, mpfr_sqr, "mpfr_sqrt", 8, -256, 255, 4, 128, 800, 50); tests_end_mpfr (); return 0; }
/** * This function executes vertex programs */ static GLboolean run_vp( struct gl_context *ctx, struct tnl_pipeline_stage *stage ) { TNLcontext *tnl = TNL_CONTEXT(ctx); struct vp_stage_data *store = VP_STAGE_DATA(stage); struct vertex_buffer *VB = &tnl->vb; struct gl_vertex_program *program = ctx->VertexProgram._Current; struct gl_program_machine *machine = &store->machine; GLuint outputs[VARYING_SLOT_MAX], numOutputs; GLuint i, j; if (!program) return GL_TRUE; /* ARB program or vertex shader */ _mesa_load_state_parameters(ctx, program->Base.Parameters); /* make list of outputs to save some time below */ numOutputs = 0; for (i = 0; i < VARYING_SLOT_MAX; i++) { if (program->Base.OutputsWritten & BITFIELD64_BIT(i)) { outputs[numOutputs++] = i; } } /* Allocate result vectors. We delay this until now to avoid allocating * memory that would never be used if we don't run the software tnl pipeline. */ if (!store->results[0].storage) { for (i = 0; i < VARYING_SLOT_MAX; i++) { assert(!store->results[i].storage); _mesa_vector4f_alloc( &store->results[i], 0, VB->Size, 32 ); store->results[i].size = 4; } } map_textures(ctx, program); for (i = 0; i < VB->Count; i++) { GLuint attr; init_machine(ctx, machine, tnl->CurInstance); #if 0 printf("Input %d: %f, %f, %f, %f\n", i, VB->AttribPtr[0]->data[i][0], VB->AttribPtr[0]->data[i][1], VB->AttribPtr[0]->data[i][2], VB->AttribPtr[0]->data[i][3]); printf(" color: %f, %f, %f, %f\n", VB->AttribPtr[3]->data[i][0], VB->AttribPtr[3]->data[i][1], VB->AttribPtr[3]->data[i][2], VB->AttribPtr[3]->data[i][3]); printf(" normal: %f, %f, %f, %f\n", VB->AttribPtr[2]->data[i][0], VB->AttribPtr[2]->data[i][1], VB->AttribPtr[2]->data[i][2], VB->AttribPtr[2]->data[i][3]); #endif /* the vertex array case */ for (attr = 0; attr < VERT_ATTRIB_MAX; attr++) { if (program->Base.InputsRead & BITFIELD64_BIT(attr)) { const GLubyte *ptr = (const GLubyte*) VB->AttribPtr[attr]->data; const GLuint size = VB->AttribPtr[attr]->size; const GLuint stride = VB->AttribPtr[attr]->stride; const GLfloat *data = (GLfloat *) (ptr + stride * i); #ifdef NAN_CHECK check_float(data[0]); check_float(data[1]); check_float(data[2]); check_float(data[3]); #endif COPY_CLEAN_4V(machine->VertAttribs[attr], size, data); } } /* execute the program */ _mesa_execute_program(ctx, &program->Base, machine); /* copy the output registers into the VB->attribs arrays */ for (j = 0; j < numOutputs; j++) { const GLuint attr = outputs[j]; #ifdef NAN_CHECK check_float(machine->Outputs[attr][0]); check_float(machine->Outputs[attr][1]); check_float(machine->Outputs[attr][2]); check_float(machine->Outputs[attr][3]); #endif COPY_4V(store->results[attr].data[i], machine->Outputs[attr]); } /* FOGC is a special case. Fragment shader expects (f,0,0,1) */ if (program->Base.OutputsWritten & BITFIELD64_BIT(VARYING_SLOT_FOGC)) { store->results[VARYING_SLOT_FOGC].data[i][1] = 0.0; store->results[VARYING_SLOT_FOGC].data[i][2] = 0.0; store->results[VARYING_SLOT_FOGC].data[i][3] = 1.0; } #ifdef NAN_CHECK ASSERT(machine->Outputs[0][3] != 0.0F); #endif #if 0 printf("HPOS: %f %f %f %f\n", machine->Outputs[0][0], machine->Outputs[0][1], machine->Outputs[0][2], machine->Outputs[0][3]); #endif } unmap_textures(ctx, program); if (program->IsPositionInvariant) { /* We need the exact same transform as in the fixed function path here * to guarantee invariance, depending on compiler optimization flags * results could be different otherwise. */ VB->ClipPtr = TransformRaw( &store->results[0], &ctx->_ModelProjectMatrix, VB->AttribPtr[0] ); /* Drivers expect this to be clean to element 4... */ switch (VB->ClipPtr->size) { case 1: /* impossible */ case 2: _mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 2 ); /* fall-through */ case 3: _mesa_vector4f_clean_elem( VB->ClipPtr, VB->Count, 3 ); /* fall-through */ case 4: break; } } else { /* Setup the VB pointers so that the next pipeline stages get * their data from the right place (the program output arrays). */ VB->ClipPtr = &store->results[VARYING_SLOT_POS]; VB->ClipPtr->size = 4; VB->ClipPtr->count = VB->Count; } VB->AttribPtr[VERT_ATTRIB_COLOR0] = &store->results[VARYING_SLOT_COL0]; VB->AttribPtr[VERT_ATTRIB_COLOR1] = &store->results[VARYING_SLOT_COL1]; VB->AttribPtr[VERT_ATTRIB_FOG] = &store->results[VARYING_SLOT_FOGC]; VB->AttribPtr[_TNL_ATTRIB_POINTSIZE] = &store->results[VARYING_SLOT_PSIZ]; VB->BackfaceColorPtr = &store->results[VARYING_SLOT_BFC0]; VB->BackfaceSecondaryColorPtr = &store->results[VARYING_SLOT_BFC1]; for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) { VB->AttribPtr[_TNL_ATTRIB_TEX0 + i] = &store->results[VARYING_SLOT_TEX0 + i]; } for (i = 0; i < ctx->Const.MaxVarying; i++) { if (program->Base.OutputsWritten & BITFIELD64_BIT(VARYING_SLOT_VAR0 + i)) { /* Note: varying results get put into the generic attributes */ VB->AttribPtr[VERT_ATTRIB_GENERIC0+i] = &store->results[VARYING_SLOT_VAR0 + i]; } } /* Perform NDC and cliptest operations: */ return do_ndc_cliptest(ctx, store); }
char* check_option(char **in,int n,int which,int type) { char test,*ret=NULL,wasfound=0,ok=1; int i; for (i=1;i<n;i++) { if (in[i] != NULL) { test= (in[i][0] == '-') && (in[i][1] == which); if (test) { wasfound=1; if (type != 'n') { if (strlen(in[i]) > 2) { switch(type) { case 'u': check_unsigned(in[i]+2,which);break; case 'd': check_integer(in[i]+2,which);break; case 'f': check_float(in[i]+2,which);break; case '2': check_two(in[i]+2,which);break; case '3': check_three(in[i]+2,which);break; } if (ret != NULL) free(ret); check_alloc(ret=(char*)calloc(strlen(in[i]+2)+1,(size_t)1)); strcpy(ret,in[i]+2); in[i]=NULL; } else { in[i]=NULL; i++; if (i < n) { if (in[i] != NULL) { switch(type) { case 'u': check_unsigned(in[i],which);break; case 'd': check_integer(in[i],which);break; case 'f': check_float(in[i],which);break; case '2': check_two(in[i],which);break; case '3': check_three(in[i]+2,which);break; case 'o': ok=check_optional(in[i],which);break; } if (ok) { if (ret != NULL) free(ret); check_alloc(ret=(char*)calloc(strlen(in[i])+1,(size_t)1)); strcpy(ret,in[i]); in[i]=NULL; } else { i--; if (ret != NULL) free(ret); ret=NULL; } } } else { if (ret != NULL) { free(ret); ret=NULL; } } } } else { in[i]=NULL; } } } } if (((type == 'o') || (type == 'n')) && (ret == NULL) && wasfound) return ""; if (wasfound && (ret == NULL)) { fprintf(stderr,"The option -%c needs some value. Exiting!\n",which); exit(CHECK_OPTION_C_NO_VALUE); } return ret; }
int main(int argc, char **argv) { char *daemon_dir = NULL; char *socket_name = NULL; const char *inpath=NULL; int input_fd = STDIN_FILENO; const char *outpath=NULL; int output_fd = STDOUT_FILENO; { int c, i; const char *short_opts = "i:o:d:c:hVr:p:v:w:W:t:P::lL"; while ((c=getopt_long(argc, argv, short_opts, program_options, &i)) != -1) { switch (c) { case 'V': show_version(argv[0]); return 0; case 'h': show_help(argv[0]); return 0; case 'r': check_float("rate", optarg); record_param("rate", optarg); break; case 'p': check_float("pitch", optarg); record_param("pitch", optarg); break; case 'v': check_float("volume", optarg); record_param("volume", optarg); break; case 't': if (strcmp(optarg, "text") == 0 || strcmp(optarg, "ssml") == 0 || strcmp(optarg, "characters") == 0) record_param("type", optarg); else { fprintf(stderr, "Incorrect value of --type: `%s'\n", optarg); exit(1); } break; case 'w': record_param("variant", optarg); break; case 'W': record_param("voice", optarg); break; case 'i': inpath = optarg; break; case 'o': outpath = optarg; break; case 'P': record_param("punct", optarg ? optarg : ""); break; case 'D': daemon_dir = optarg; break; case 0: break; default: show_help(argv[0]); return 1; } } } if (daemon_dir) add_path(&socket_name, daemon_dir); else { add_path(&socket_name, getenv("HOME")); add_path(&socket_name, ".rhvoice"); } add_path(&socket_name, "socket"); // Creates a socket and connects to it. int sock = socket(AF_UNIX, SOCK_STREAM, 0); if (sock == -1) { perror("socket"); exit(1); } struct sockaddr_un addr; memset(&addr, 0, sizeof(addr)); addr.sun_family = AF_UNIX; strncpy(addr.sun_path, socket_name, sizeof(addr.sun_path) - 1); if (connect(sock, (struct sockaddr *) &addr, sizeof(addr)) == -1) { perror("connect"); exit(1); } // Opens input/output files. if (inpath && (input_fd = open(inpath, O_RDONLY)) == -1) { perror(inpath); exit(1); } if (outpath && (output_fd = open(outpath, O_WRONLY|O_TRUNC, 0666)) == -1) { perror(outpath); exit(1); } if (isatty(output_fd)) { fprintf(stderr, "Cannot write to a terminal.\n"); exit(1); } int n, nw; /* number of read/written bytes */ if (used >= sizeof(buf)/2) { // The header is large so write it first. nw = 0; while (nw < used && (n = write(sock, buf+nw, used-nw)) != -1) nw += n; used = 0; } buf[used++] = '\n'; // First copies whole input to socket. while ((n = read(input_fd, buf+used, sizeof(buf)-used)) > 0) { used += n; nw = 0; while (nw < used && (n = write(sock, buf+nw, used-nw)) != -1) nw += n; used = 0; } shutdown(sock, SHUT_WR); // Copies response to output. while ((used = read(sock, buf, sizeof(buf))) > 0) { nw = 0; while (nw < used && (n = write(STDOUT_FILENO, buf+nw, used-nw)) != -1) nw += n; } return 0; }
static int rbody_newindex (lua_State *L) { TRY_START check_args(L, 3); GET_UD_MACRO(RigidBody, self, 1, RBODY_TAG); const char *key = luaL_checkstring(L, 2); if (!::strcmp(key, "linearVelocity")) { Vector3 v = check_v3(L, 3); self.setLinearVelocity(v); } else if (!::strcmp(key, "angularVelocity")) { Vector3 v = check_v3(L, 3); self.setAngularVelocity(v); } else if (!::strcmp(key, "worldPosition")) { Vector3 v = check_v3(L, 3); self.setPosition(v); } else if (!::strcmp(key, "worldOrientation")) { Quaternion v = check_quat(L, 3); self.setOrientation(v); } else if (!::strcmp(key, "contactProcessingThreshold")) { float v = check_float(L, 3); self.setContactProcessingThreshold(v); } else if (!::strcmp(key, "linearDamping")) { float v = check_float(L, 3); self.setLinearDamping(v); } else if (!::strcmp(key, "angularDamping")) { float v = check_float(L, 3); self.setAngularDamping(v); } else if (!::strcmp(key, "linearSleepThreshold")) { float v = check_float(L, 3); self.setLinearSleepThreshold(v); } else if (!::strcmp(key, "angularSleepThreshold")) { float v = check_float(L, 3); self.setAngularSleepThreshold(v); } else if (!::strcmp(key, "mass")) { float v = check_float(L, 3); self.setMass(v); } else if (!::strcmp(key, "ghost")) { bool v = check_bool(L, 3); self.setGhost(v); } else if (!::strcmp(key, "updateCallback")) { self.updateCallbackPtr.set(L); } else if (!::strcmp(key, "stepCallback")) { self.stepCallbackPtr.set(L); } else if (!::strcmp(key, "collisionCallback")) { self.collisionCallbackPtr.set(L); } else if (!::strcmp(key, "stabiliseCallback")) { self.stabiliseCallbackPtr.set(L); } else if (!::strcmp(key, "inertia")) { Vector3 v = check_v3(L, 3); self.setInertia(v); } else if (!::strcmp(key, "owner")) { if (lua_isnil(L, 3)) { self.owner.setNull(); } else { GET_UD_MACRO(GritObjectPtr, v, 3, GRITOBJ_TAG); self.owner = v; } } else { my_lua_error(L, "Not a writeable RigidBody member: "+std::string(key)); } return 0; TRY_END }
void test_add_a_float() { Fixnum* one = Fixnum::from(13); Float* res = one->add(state, Float::create(state, 1.4)); check_float(res, Float::create(state, 14.4)); }
void test_to_f() { Float* f = Fixnum::from(5)->to_f(state); check_float(f, Float::create(state, 5.0)); f = Fixnum::from(-2)->to_f(state); check_float(f, Float::create(state, -2.0)); }
void TestApp::test_matrix_mat4() { Console::write_line(" Class: Mat4"); Console::write_line(" Function: inverse()"); { Mat4f test_src = Mat4f::rotate((Angle(30, angle_degrees)), 1.0, 0.0, 0.0, true); Mat4f test_inv; Mat4f test_dest; Mat4f test_ident = Mat4f::identity(); test_dest = test_src; test_dest.inverse(); test_dest = test_dest * test_src; if (test_ident != test_dest) fail(); } static int test_a_values[] = {3, 1, 2, 4, 5 ,6, 4, 2, 1, 4, 6, 7, 6, 3, 7, 2}; static int test_b_values[] = {4, 7, 2, 5, 3, 5, 2, 9, 3, 3, 6, 9, 2, 4, 6, 2}; Mat4i test_a(test_a_values); Mat4i test_b(test_b_values); Console::write_line(" Function: add() and operator"); { int answer_values[] = {7, 8, 4, 9, 8, 11, 6, 11, 4, 7, 12, 16, 8, 7, 13, 4}; Mat4i answer(answer_values); Mat4i result = test_a + test_b; if (result != answer) fail(); result = Mat4i::add(test_a, test_b); if (result != answer) fail(); } Console::write_line(" Function: subtract() and operator"); { int answer_values[] = {-1, -6, 0, -1, 2, 1, 2, -7, -2, 1, 0, -2, 4, -1, 1, 0}; Mat4i answer(answer_values); Mat4i result = test_a - test_b; if (result != answer) fail(); result = Mat4i::subtract(test_a, test_b); if (result != answer) fail(); } Console::write_line(" Function: translate()"); { int answer_values[] = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 2, 3, 4, 1}; Mat4i answer(answer_values); Mat4i result = Mat4i::translate(2, 3, 4); if (result != answer) fail(); } Console::write_line(" Function: translate_self()"); { Mat4i answer(test_a); Mat4i result = test_a; result = result * Mat4i::translate(2, 3, 4); Mat4i result2 = test_a; result2.translate_self(2,3,4); if (result != result2) fail(); } Console::write_line(" Function: scale_self()"); { Mat4i answer(test_a); Mat4i result = test_a; result = result * Mat4i::scale(2, 3, 4); Mat4i result2 = test_a; result2.scale_self(2,3,4); if (result != result2) fail(); } Console::write_line(" Function: rotate (using euler angles) and get_euler"); { Angle angle_x(20, angle_degrees); Angle angle_y(30, angle_degrees); Angle angle_z(40, angle_degrees); Mat4f test_matrix; test_matrix = Mat4f::rotate(angle_x, angle_y, angle_z, order_YXZ); Vec3f angles = test_matrix.get_euler(order_YXZ); check_float(angles.x, angle_x.to_radians()); check_float(angles.y, angle_y.to_radians()); check_float(angles.z, angle_z.to_radians()); } }
void test_mul_a_float() { Fixnum* one = Fixnum::from(13); Float* res = one->mul(state, Float::create(state, 1.4)); check_float(res, Float::create(state, 18.2)); }
void test_sub_a_float() { Fixnum* one = Fixnum::from(13); Float* res = one->sub(state, Float::create(state, 1.4)); check_float(res, Float::create(state, 11.6)); }