本文整理汇总了C++中Sign::Positive方法的典型用法代码示例。如果您正苦于以下问题：C++ Sign::Positive方法的具体用法？C++ Sign::Positive怎么用？C++ Sign::Positive使用的例子？那么, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类Sign的用法示例。
在下文中一共展示了Sign::Positive方法的1个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: Sign
void SymplecticRungeKuttaNyströmIntegrator<Position, order, time_reversible,
evaluations, composition>::Solve(
IntegrationProblem<ODE> const& problem,
Time const& step) const {
using Displacement = typename ODE::Displacement;
using Velocity = typename ODE::Velocity;
using Acceleration = typename ODE::Acceleration;
// Argument checks.
CHECK_NOTNULL(problem.initial_state);
int const dimension = problem.initial_state->positions.size();
CHECK_EQ(dimension, problem.initial_state->velocities.size());
CHECK_NE(Time(), step);
Sign const integration_direction = Sign(step);
if (integration_direction.Positive()) {
// Integrating forward.
CHECK_LT(problem.initial_state->time.value, problem.t_final);
} else {
// Integrating backward.
CHECK_GT(problem.initial_state->time.value, problem.t_final);
}
typename ODE::SystemState current_state = *problem.initial_state;
// Time step.
Time const& h = step;
Time const abs_h = integration_direction * h;
// Current time. This is a non-const reference whose purpose is to make the
// equations more readable.
DoublePrecision<Instant>& t = current_state.time;
// Position increment.
std::vector<Displacement> Δq(dimension);
// Velocity increment.
std::vector<Velocity> Δv(dimension);
// Current position. This is a non-const reference whose purpose is to make
// the equations more readable.
std::vector<DoublePrecision<Position>>& q = current_state.positions;
// Current velocity. This is a non-const reference whose purpose is to make
// the equations more readable.
std::vector<DoublePrecision<Velocity>>& v = current_state.velocities;
// Current Runge-Kutta-Nyström stage.
std::vector<Position> q_stage(dimension);
// Accelerations at the current stage.
std::vector<Acceleration> g(dimension);
// The first full stage of the step, i.e. the first stage where
// exp(bᵢ h B) exp(aᵢ h A) must be entirely computed.
// Always 0 in the non-FSAL kBA case, always 1 in the kABA case since b₀ = 0,
// means the first stage is only exp(a₀ h A), and 1 after the first step
// in the kBAB case, since the last right-hand-side evaluation can be used for
// exp(bᵢ h B).
int first_stage = composition == kABA ? 1 : 0;
while (abs_h <= Abs((problem.t_final - t.value) - t.error)) {
std::fill(Δq.begin(), Δq.end(), Displacement{});
std::fill(Δv.begin(), Δv.end(), Velocity{});
if (first_stage == 1) {
for (int k = 0; k < dimension; ++k) {
if (composition == kBAB) {
// exp(b₀ h B)
Δv[k] += h * b_[0] * g[k];
}
// exp(a₀ h A)
Δq[k] += h * a_[0] * (v[k].value + Δv[k]);
}
}
for (int i = first_stage; i < stages_; ++i) {
for (int k = 0; k < dimension; ++k) {
q_stage[k] = q[k].value + Δq[k];
}
problem.equation.compute_acceleration(t.value + c_[i] * h, q_stage, &g);
for (int k = 0; k < dimension; ++k) {
// exp(bᵢ h B)
Δv[k] += h * b_[i] * g[k];
// exp(aᵢ h A)
Δq[k] += h * a_[i] * (v[k].value + Δv[k]);
}
}
if (composition == kBAB) {
first_stage = 1;
}
// Increment the solution.
t.Increment(h);
for (int k = 0; k < dimension; ++k) {
q[k].Increment(Δq[k]);
v[k].Increment(Δv[k]);
}
problem.append_state(current_state);
}
}