TEST_F(RandomTests, NextNumber_TwoArgument) { int a = rnd.nextInt(10, 20); EXPECT_THAT(a, Ge(10)); EXPECT_THAT(a, Lt(20)); long long b = rnd.nextLongLong(1000000000000ll, 2000000000000ll); EXPECT_THAT(b, Ge(1000000000000ll)); EXPECT_THAT(b, Lt(2000000000000ll)); double c = rnd.nextDouble(100.0, 200.0); EXPECT_THAT(c, Ge(100.0)); EXPECT_THAT(c, Le(200.0)); }
TEST_F(LogisticTransformTest, KernelSmallVector) { const int numberOfRows = 5; double e = 10e-5; Container::PinnedHostVector* hostVectorFrom = new Container::PinnedHostVector(numberOfRows); for(int i = 0; i < numberOfRows; ++i){ (*hostVectorFrom)(i) = i / 10; } Container::DeviceVector* logitDeviceVector = hostToDeviceStream1.transferVector(*hostVectorFrom); Container::DeviceVector* probDeviceVector = new Container::DeviceVector(numberOfRows); kernelWrapper.logisticTransform(*logitDeviceVector, *probDeviceVector); Container::HostVector* resultHostVector = deviceToHostStream1.transferVector(*probDeviceVector); stream->syncStream(); handleCudaStatus(cudaGetLastError(), "Error in LogisticTransform test: "); ASSERT_EQ(numberOfRows, resultHostVector->getNumberOfRows()); for(int i = 0; i < numberOfRows; ++i){ PRECISION x = i / 10; x = exp(x) / (1 + exp(x)); double l = x - e; double h = x + e; EXPECT_THAT((*resultHostVector)(i), Ge(l)); EXPECT_THAT((*resultHostVector)(i), Le(h)); } delete hostVectorFrom; delete logitDeviceVector; delete probDeviceVector; delete resultHostVector; }
TEST_F(EventTest, EventDifference) { const double e = 1e-2; StreamFactory streamFactory; Device device(0); device.setActiveDevice(); ASSERT_TRUE(device.isActive()); Stream* stream = streamFactory.constructStream(device); Event before(*stream); //TODO a kernel here that waits a while Event after(*stream); stream->syncStream(); float diff = after - before; const float realDiff = 1; float l = realDiff - e; float h = realDiff + e; EXPECT_THAT(diff, Ge(l)); EXPECT_THAT(diff, Le(h)); delete stream; }
// Solving Δt * Δt == n. TEST_F(RootFindersTest, SquareRoots) { Instant const t_0; Instant const t_max = t_0 + 10 * Second; Length const n_max = Pow<2>(t_max - t_0) * SIUnit<Acceleration>(); for (Length n = 1 * Metre; n < n_max; n += 1 * Metre) { int evaluations = 0; auto const equation = [t_0, n, &evaluations](Instant const& t) { ++evaluations; return Pow<2>(t - t_0) * SIUnit<Acceleration>() - n; }; EXPECT_THAT(Bisect(equation, t_0, t_max) - t_0, AlmostEquals(Sqrt(n / SIUnit<Acceleration>()), 0, 1)); if (n == 25 * Metre) { EXPECT_EQ(3, evaluations); } else { EXPECT_THAT(evaluations, AllOf(Ge(49), Le(58))); } } }
TEST_F(EmbeddedExplicitRungeKuttaNyströmIntegratorTest, MaxSteps) { AdaptiveStepSizeIntegrator<ODE> const& integrator = DormandElMikkawyPrince1986RKN434FM<Length>(); Length const x_initial = 1 * Metre; Speed const v_initial = 0 * Metre / Second; Speed const v_amplitude = 1 * Metre / Second; Time const period = 2 * π * Second; AngularFrequency const ω = 1 * Radian / Second; Instant const t_initial; Instant const t_final = t_initial + 10 * period; Length const length_tolerance = 1 * Milli(Metre); Speed const speed_tolerance = 1 * Milli(Metre) / Second; // The number of steps if no step limit is set. std::int64_t const steps_forward = 132; int evaluations = 0; auto const step_size_callback = [](bool tolerable) {}; std::vector<ODE::SystemState> solution; ODE harmonic_oscillator; harmonic_oscillator.compute_acceleration = std::bind(ComputeHarmonicOscillatorAcceleration, _1, _2, _3, &evaluations); IntegrationProblem<ODE> problem; problem.equation = harmonic_oscillator; ODE::SystemState const initial_state = {{x_initial}, {v_initial}, t_initial}; problem.initial_state = &initial_state; problem.t_final = t_final; problem.append_state = [&solution](ODE::SystemState const& state) { solution.push_back(state); }; AdaptiveStepSize<ODE> adaptive_step_size; adaptive_step_size.first_time_step = t_final - t_initial; adaptive_step_size.safety_factor = 0.9; adaptive_step_size.tolerance_to_error_ratio = std::bind(HarmonicOscillatorToleranceRatio, _1, _2, length_tolerance, speed_tolerance, step_size_callback); adaptive_step_size.max_steps = 100; auto const outcome = integrator.Solve(problem, adaptive_step_size); EXPECT_EQ(termination_condition::ReachedMaximalStepCount, outcome.error()); EXPECT_THAT(AbsoluteError( x_initial * Cos(ω * (solution.back().time.value - t_initial)), solution.back().positions[0].value), AllOf(Ge(8e-4 * Metre), Le(9e-4 * Metre))); EXPECT_THAT(AbsoluteError( -v_amplitude * Sin(ω * (solution.back().time.value - t_initial)), solution.back().velocities[0].value), AllOf(Ge(1e-3 * Metre / Second), Le(2e-3 * Metre / Second))); EXPECT_THAT(solution.back().time.value, Lt(t_final)); EXPECT_EQ(100, solution.size()); // Check that a |max_steps| greater than or equal to the unconstrained number // of steps has no effect. for (std::int64_t const max_steps : {steps_forward, steps_forward + 1234}) { solution.clear(); adaptive_step_size.max_steps = steps_forward; auto const outcome = integrator.Solve(problem, adaptive_step_size); EXPECT_EQ(termination_condition::Done, outcome.error()); EXPECT_THAT(AbsoluteError(x_initial, solution.back().positions[0].value), AllOf(Ge(3e-4 * Metre), Le(4e-4 * Metre))); EXPECT_THAT(AbsoluteError(v_initial, solution.back().velocities[0].value), AllOf(Ge(2e-3 * Metre / Second), Le(3e-3 * Metre / Second))); EXPECT_EQ(t_final, solution.back().time.value); EXPECT_EQ(steps_forward, solution.size()); } }
void Parser::executeAction(int production) try { if (d_token__ != _UNDETERMINED_) pushToken__(d_token__); // save an already available token // $insert defaultactionreturn // save default non-nested block $$ if (int size = s_productionInfo[production].d_size) d_val__ = d_vsp__[1 - size]; switch (production) { // $insert actioncases case 1: #line 43 "parser.yy" { d_val__.get<Tag__::basic>() = d_vsp__[0].data<Tag__::basic>(); res = d_val__.get<Tag__::basic>(); } break; case 2: #line 51 "parser.yy" { d_val__.get<Tag__::basic>() = add(d_vsp__[-2].data<Tag__::basic>(), d_vsp__[0].data<Tag__::basic>()); } break; case 3: #line 54 "parser.yy" { d_val__.get<Tag__::basic>() = sub(d_vsp__[-2].data<Tag__::basic>(), d_vsp__[0].data<Tag__::basic>()); } break; case 4: #line 57 "parser.yy" { d_val__.get<Tag__::basic>() = mul(d_vsp__[-2].data<Tag__::basic>(), d_vsp__[0].data<Tag__::basic>()); } break; case 5: #line 60 "parser.yy" { d_val__.get<Tag__::basic>() = div(d_vsp__[-2].data<Tag__::basic>(), d_vsp__[0].data<Tag__::basic>()); } break; case 6: #line 63 "parser.yy" { auto tup = parse_implicit_mul(d_vsp__[-2].data<Tag__::string>()); if (neq(*std::get<1>(tup), *one)) { d_val__.get<Tag__::basic>() = mul( std::get<0>(tup), pow(std::get<1>(tup), d_vsp__[0].data<Tag__::basic>())); } else { d_val__.get<Tag__::basic>() = pow(std::get<0>(tup), d_vsp__[0].data<Tag__::basic>()); } } break; case 7: #line 73 "parser.yy" { d_val__.get<Tag__::basic>() = pow(d_vsp__[-2].data<Tag__::basic>(), d_vsp__[0].data<Tag__::basic>()); } break; case 8: #line 76 "parser.yy" { d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>( Lt(d_vsp__[-2].data<Tag__::basic>(), d_vsp__[0].data<Tag__::basic>())); } break; case 9: #line 79 "parser.yy" { d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>( Gt(d_vsp__[-2].data<Tag__::basic>(), d_vsp__[0].data<Tag__::basic>())); } break; case 10: #line 82 "parser.yy" { d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>( Le(d_vsp__[-2].data<Tag__::basic>(), d_vsp__[0].data<Tag__::basic>())); } break; case 11: #line 85 "parser.yy" { d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>( Ge(d_vsp__[-2].data<Tag__::basic>(), d_vsp__[0].data<Tag__::basic>())); } break; case 12: #line 88 "parser.yy" { d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>( Eq(d_vsp__[-2].data<Tag__::basic>(), d_vsp__[0].data<Tag__::basic>())); } break; case 13: #line 91 "parser.yy" { set_boolean s; s.insert(rcp_static_cast<const Boolean>( d_vsp__[-2].data<Tag__::basic>())); s.insert(rcp_static_cast<const Boolean>( d_vsp__[0].data<Tag__::basic>())); d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>(logical_or(s)); } break; case 14: #line 99 "parser.yy" { set_boolean s; s.insert(rcp_static_cast<const Boolean>( d_vsp__[-2].data<Tag__::basic>())); s.insert(rcp_static_cast<const Boolean>( d_vsp__[0].data<Tag__::basic>())); d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>(logical_and(s)); } break; case 15: #line 107 "parser.yy" { vec_boolean s; s.push_back(rcp_static_cast<const Boolean>( d_vsp__[-2].data<Tag__::basic>())); s.push_back(rcp_static_cast<const Boolean>( d_vsp__[0].data<Tag__::basic>())); d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>(logical_xor(s)); } break; case 16: #line 115 "parser.yy" { d_val__.get<Tag__::basic>() = d_vsp__[-1].data<Tag__::basic>(); } break; case 17: #line 118 "parser.yy" { d_val__.get<Tag__::basic>() = neg(d_vsp__[0].data<Tag__::basic>()); } break; case 18: #line 121 "parser.yy" { d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>( logical_not(rcp_static_cast<const Boolean>( d_vsp__[0].data<Tag__::basic>()))); } break; case 19: #line 124 "parser.yy" { d_val__.get<Tag__::basic>() = rcp_static_cast<const Basic>(d_vsp__[0].data<Tag__::basic>()); } break; case 20: #line 129 "parser.yy" { d_val__.get<Tag__::basic>() = parse_identifier(d_vsp__[0].data<Tag__::string>()); } break; case 21: #line 134 "parser.yy" { auto tup = parse_implicit_mul(d_vsp__[0].data<Tag__::string>()); d_val__.get<Tag__::basic>() = mul(std::get<0>(tup), std::get<1>(tup)); } break; case 22: #line 140 "parser.yy" { d_val__.get<Tag__::basic>() = parse_numeric(d_vsp__[0].data<Tag__::string>()); } break; case 23: #line 145 "parser.yy" { d_val__.get<Tag__::basic>() = d_vsp__[0].data<Tag__::basic>(); } break; case 24: #line 152 "parser.yy" { d_val__.get<Tag__::basic>() = functionify(d_vsp__[-3].data<Tag__::string>(), d_vsp__[-1].data<Tag__::basic_vec>()); } break; case 25: #line 160 "parser.yy" { d_val__.get<Tag__::basic_vec>() = d_vsp__[-2].data<Tag__::basic_vec>(); d_val__.get<Tag__::basic_vec>().push_back( d_vsp__[0].data<Tag__::basic>()); } break; case 26: #line 166 "parser.yy" { d_val__.get<Tag__::basic_vec>() = vec_basic(1, d_vsp__[0].data<Tag__::basic>()); } break; } } catch (std::exception const &exc) { exceptionHandler__(exc); }