complex_long_double /*{ ret - Complex fraction }*/ cdivd ( complex_long_double a, /*{ (i) - Complex input `a` }*/ complex_long_double b /*{ (i) - Complex input `b` }*/ ) { complex_long_double c; long double fractio, denum; /* To prevent avoidable overflows, underflow or loss of precision, the following alternative algorithm is used: If |b.re| >= |b.im| c.re = (a.re + a.im * (b.im / b.re)) / (b.re + b.im * (b.im / b.re)); c.im = (a.im - a.re * (b.im / b.re)) / (b.re + b.im * (b.im / b.re)); Else // |b.re| < |b.im| c.re = (a.re * (b.re / b.im) + a.im) / (b.re * (b.re / b.im) + b.im); c.im = (a.im * (b.re / b.im) - a.re) / (b.re * (b.re / b.im) + b.im); */ if( (b.re == 0) && (b.im == 0) ) { /* return +Inf */ plus_inf.a[1] = 0x7FF00000; plus_inf.a[0] = 0x00000000; c.re = plus_inf.x; c.im = plus_inf.x; } else if (b.re == 0) { c.re = a.im / b.im; c.im = -(a.re / b.im); } else if (b.im == 0) { c.re = a.re / b.re; c.im = a.im / b.re; } else if( fabsd(b.re) >= fabsd(b.im) ) { fractio = b.im / b.re; denum = 1.0L / (b.re + b.im * fractio); c.re = (a.re + a.im * fractio) * denum; c.im = (a.im - a.re * fractio) * denum; } else { fractio = b.re / b.im; denum = 1.0L / (b.re * fractio + b.im); c.re = (a.re * fractio + a.im) * denum; c.im = (a.im * fractio - a.re) * denum; } return (c); }
void AdaptivePaddedAverage::sample(float new_sample) { // Compute new adaptive weighted average based on new sample. AdaptiveWeightedAverage::sample(new_sample); // Now update the deviation and the padded average. float new_avg = average(); float new_dev = compute_adaptive_average(fabsd(new_sample - new_avg), deviation()); set_deviation(new_dev); set_padded_average(new_avg + padding() * new_dev); _last_sample = new_sample; }
void AdaptivePaddedAverage::sample(double new_sample) { // Compute our parent classes sample information AdaptiveWeightedAverage::sample(new_sample); // Now compute the deviation and the new padded sample float new_avg = average(); float new_dev = compute_adaptive_average(fabsd(new_sample - new_avg), deviation()); set_deviation(new_dev); set_padded_average(new_avg + padding() * new_dev); _last_sample = new_sample; }
void AdaptivePaddedNoZeroDevAverage::sample(float new_sample) { // Compute our parent classes sample information AdaptiveWeightedAverage::sample(new_sample); float new_avg = average(); if (new_sample != 0) { // We only create a new deviation if the sample is non-zero float new_dev = compute_adaptive_average(fabsd(new_sample - new_avg), deviation()); set_deviation(new_dev); } set_padded_average(new_avg + padding() * deviation()); _last_sample = new_sample; }
address InterpreterGenerator::generate_math_entry(AbstractInterpreter::MethodKind kind) { // rmethod: Method* // r13: sender sp // esp: args if (!InlineIntrinsics) return NULL; // Generate a vanilla entry // These don't need a safepoint check because they aren't virtually // callable. We won't enter these intrinsics from compiled code. // If in the future we added an intrinsic which was virtually callable // we'd have to worry about how to safepoint so that this code is used. // mathematical functions inlined by compiler // (interpreter must provide identical implementation // in order to avoid monotonicity bugs when switching // from interpreter to compiler in the middle of some // computation) // // stack: // [ arg ] <-- esp // [ arg ] // retaddr in lr address entry_point = NULL; Register continuation = lr; switch (kind) { case Interpreter::java_lang_math_abs: entry_point = __ pc(); __ ldrd(v0, Address(esp)); __ fabsd(v0, v0); __ mov(sp, r13); // Restore caller's SP break; case Interpreter::java_lang_math_sqrt: entry_point = __ pc(); __ ldrd(v0, Address(esp)); __ fsqrtd(v0, v0); __ mov(sp, r13); break; case Interpreter::java_lang_math_sin : case Interpreter::java_lang_math_cos : case Interpreter::java_lang_math_tan : case Interpreter::java_lang_math_log : case Interpreter::java_lang_math_log10 : case Interpreter::java_lang_math_exp : entry_point = __ pc(); __ ldrd(v0, Address(esp)); __ mov(sp, r13); __ mov(r19, lr); continuation = r19; // The first callee-saved register generate_transcendental_entry(kind, 1); break; case Interpreter::java_lang_math_pow : entry_point = __ pc(); __ mov(r19, lr); continuation = r19; __ ldrd(v0, Address(esp, 2 * Interpreter::stackElementSize)); __ ldrd(v1, Address(esp)); __ mov(sp, r13); generate_transcendental_entry(kind, 2); break; default: ; } if (entry_point) { __ br(continuation); } return entry_point; }