Timeout for forward-xy-x

Specification

Math

\[b \cdot lamdp + \left(a2 \cdot \sin \left(2 \cdot lamdp\right) + \left(a4 \cdot \sin \left(4 \cdot lamdp\right) + \left(-tanph \cdot \frac{s}{\sqrt{xj \cdot xj + s \cdot s}}\right)\right)\right) \]

FPCore

(FPCore (lamdp b a2 a4 tanph s xj)
  :precision binary64
  :pre TRUE
  (+
 (* b lamdp)
 (+
  (* a2 (sin (* 2.0 lamdp)))
  (+
   (* a4 (sin (* 4.0 lamdp)))
   (- (* tanph (/ s (sqrt (+ (* xj xj) (* s s))))))))))

C

double code(double lamdp, double b, double a2, double a4, double tanph, double s, double xj) {
	return (b * lamdp) + ((a2 * sin((2.0 * lamdp))) + ((a4 * sin((4.0 * lamdp))) + -(tanph * (s / sqrt(((xj * xj) + (s * s)))))));
}

Fortran

real(8) function code(lamdp, b, a2, a4, tanph, s, xj)
use fmin_fmax_functions
    real(8), intent (in) :: lamdp
    real(8), intent (in) :: b
    real(8), intent (in) :: a2
    real(8), intent (in) :: a4
    real(8), intent (in) :: tanph
    real(8), intent (in) :: s
    real(8), intent (in) :: xj
    code = (b * lamdp) + ((a2 * sin((2.0d0 * lamdp))) + ((a4 * sin((4.0d0 * lamdp))) + -(tanph * (s / sqrt(((xj * xj) + (s * s)))))))
end function

Java

public static double code(double lamdp, double b, double a2, double a4, double tanph, double s, double xj) {
	return (b * lamdp) + ((a2 * Math.sin((2.0 * lamdp))) + ((a4 * Math.sin((4.0 * lamdp))) + -(tanph * (s / Math.sqrt(((xj * xj) + (s * s)))))));
}

Python

def code(lamdp, b, a2, a4, tanph, s, xj):
	return (b * lamdp) + ((a2 * math.sin((2.0 * lamdp))) + ((a4 * math.sin((4.0 * lamdp))) + -(tanph * (s / math.sqrt(((xj * xj) + (s * s)))))))

Julia

function code(lamdp, b, a2, a4, tanph, s, xj)
	return Float64(Float64(b * lamdp) + Float64(Float64(a2 * sin(Float64(2.0 * lamdp))) + Float64(Float64(a4 * sin(Float64(4.0 * lamdp))) + Float64(-Float64(tanph * Float64(s / sqrt(Float64(Float64(xj * xj) + Float64(s * s)))))))))
end

MATLAB

function tmp = code(lamdp, b, a2, a4, tanph, s, xj)
	tmp = (b * lamdp) + ((a2 * sin((2.0 * lamdp))) + ((a4 * sin((4.0 * lamdp))) + -(tanph * (s / sqrt(((xj * xj) + (s * s)))))));
end

Wolfram

code[lamdp_, b_, a2_, a4_, tanph_, s_, xj_] := N[(N[(b * lamdp), $MachinePrecision] + N[(N[(a2 * N[Sin[N[(2.0 * lamdp), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + N[(N[(a4 * N[Sin[N[(4.0 * lamdp), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + (-N[(tanph * N[(s / N[Sqrt[N[(N[(xj * xj), $MachinePrecision] + N[(s * s), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision])), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

ReFlow

f(lamdp, b, a2, a4, tanph, s, xj):
	lamdp in [-inf, +inf],
	b in [-inf, +inf],
	a2 in [-inf, +inf],
	a4 in [-inf, +inf],
	tanph in [-inf, +inf],
	s in [-inf, +inf],
	xj in [-inf, +inf]
code: THEORY
BEGIN
f(lamdp, b, a2, a4, tanph, s, xj: real): real =
	(b * lamdp) + ((a2 * (sin(((2) * lamdp)))) + ((a4 * (sin(((4) * lamdp)))) + (- (tanph * (s / (sqrt(((xj * xj) + (s * s)))))))))
END code