Timeout for inverse-lamdp-update

Specification

Math

\[\frac{\left(\left(\left(xy\_x + xy\_y \cdot \frac{s}{xj}\right) - a2 \cdot \sin \left(2 \cdot lamdp\right)\right) - a4 \cdot \sin \left(4 \cdot lamdp\right)\right) - \frac{s}{xj} \cdot \left(c1 \cdot \sin lamdp + c3 \cdot \sin \left(3 \cdot lamdp\right)\right)}{b} \]

FPCore

(FPCore (lamdp xy_x xy_y s xj a2 a4 c1 c3 b)
  :precision binary64
  :pre TRUE
  (/
 (-
  (-
   (- (+ xy_x (* xy_y (/ s xj))) (* a2 (sin (* 2.0 lamdp))))
   (* a4 (sin (* 4.0 lamdp))))
  (* (/ s xj) (+ (* c1 (sin lamdp)) (* c3 (sin (* 3.0 lamdp))))))
 b))

C

double code(double lamdp, double xy_x, double xy_y, double s, double xj, double a2, double a4, double c1, double c3, double b) {
	return ((((xy_x + (xy_y * (s / xj))) - (a2 * sin((2.0 * lamdp)))) - (a4 * sin((4.0 * lamdp)))) - ((s / xj) * ((c1 * sin(lamdp)) + (c3 * sin((3.0 * lamdp)))))) / b;
}

Fortran

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

Java

public static double code(double lamdp, double xy_x, double xy_y, double s, double xj, double a2, double a4, double c1, double c3, double b) {
	return ((((xy_x + (xy_y * (s / xj))) - (a2 * Math.sin((2.0 * lamdp)))) - (a4 * Math.sin((4.0 * lamdp)))) - ((s / xj) * ((c1 * Math.sin(lamdp)) + (c3 * Math.sin((3.0 * lamdp)))))) / b;
}

Python

def code(lamdp, xy_x, xy_y, s, xj, a2, a4, c1, c3, b):
	return ((((xy_x + (xy_y * (s / xj))) - (a2 * math.sin((2.0 * lamdp)))) - (a4 * math.sin((4.0 * lamdp)))) - ((s / xj) * ((c1 * math.sin(lamdp)) + (c3 * math.sin((3.0 * lamdp)))))) / b

Julia

function code(lamdp, xy_x, xy_y, s, xj, a2, a4, c1, c3, b)
	return Float64(Float64(Float64(Float64(Float64(xy_x + Float64(xy_y * Float64(s / xj))) - Float64(a2 * sin(Float64(2.0 * lamdp)))) - Float64(a4 * sin(Float64(4.0 * lamdp)))) - Float64(Float64(s / xj) * Float64(Float64(c1 * sin(lamdp)) + Float64(c3 * sin(Float64(3.0 * lamdp)))))) / b)
end

MATLAB

function tmp = code(lamdp, xy_x, xy_y, s, xj, a2, a4, c1, c3, b)
	tmp = ((((xy_x + (xy_y * (s / xj))) - (a2 * sin((2.0 * lamdp)))) - (a4 * sin((4.0 * lamdp)))) - ((s / xj) * ((c1 * sin(lamdp)) + (c3 * sin((3.0 * lamdp)))))) / b;
end

Wolfram

code[lamdp_, xy$95$x_, xy$95$y_, s_, xj_, a2_, a4_, c1_, c3_, b_] := N[(N[(N[(N[(N[(xy$95$x + N[(xy$95$y * N[(s / xj), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(a2 * N[Sin[N[(2.0 * lamdp), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(a4 * N[Sin[N[(4.0 * lamdp), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(s / xj), $MachinePrecision] * N[(N[(c1 * N[Sin[lamdp], $MachinePrecision]), $MachinePrecision] + N[(c3 * N[Sin[N[(3.0 * lamdp), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / b), $MachinePrecision]

ReFlow

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