Diagrams.ThreeD.Transform:aboutX from diagrams-lib-1.3.0.3, B

Percentage Accurate: 99.8% → 99.8%

Time: 15.3s

Alternatives: 8

Speedup: 1.0×

Specification

Math

\[\begin{array}{l} \\ x \cdot \sin y + z \cdot \cos y \end{array} \]

FPCore

(FPCore (x y z) :precision binary64 (+ (* x (sin y)) (* z (cos y))))

C

double code(double x, double y, double z) {
	return (x * sin(y)) + (z * cos(y));
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = (x * sin(y)) + (z * cos(y))
end function

Java

public static double code(double x, double y, double z) {
	return (x * Math.sin(y)) + (z * Math.cos(y));
}

Python

def code(x, y, z):
	return (x * math.sin(y)) + (z * math.cos(y))

Julia

function code(x, y, z)
	return Float64(Float64(x * sin(y)) + Float64(z * cos(y)))
end

MATLAB

function tmp = code(x, y, z)
	tmp = (x * sin(y)) + (z * cos(y));
end

Wolfram

code[x_, y_, z_] := N[(N[(x * N[Sin[y], $MachinePrecision]), $MachinePrecision] + N[(z * N[Cos[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Initial Program: 99.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ x \cdot \sin y + z \cdot \cos y \end{array} \]

FPCore

(FPCore (x y z) :precision binary64 (+ (* x (sin y)) (* z (cos y))))

C

double code(double x, double y, double z) {
	return (x * sin(y)) + (z * cos(y));
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = (x * sin(y)) + (z * cos(y))
end function

Java

public static double code(double x, double y, double z) {
	return (x * Math.sin(y)) + (z * Math.cos(y));
}

Python

def code(x, y, z):
	return (x * math.sin(y)) + (z * math.cos(y))

Julia

function code(x, y, z)
	return Float64(Float64(x * sin(y)) + Float64(z * cos(y)))
end

MATLAB

function tmp = code(x, y, z)
	tmp = (x * sin(y)) + (z * cos(y));
end

Wolfram

code[x_, y_, z_] := N[(N[(x * N[Sin[y], $MachinePrecision]), $MachinePrecision] + N[(z * N[Cos[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Alternative 1: 99.8% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \mathsf{fma}\left(\sin y, x, z \cdot \cos y\right) \end{array} \]

FPCore

(FPCore (x y z) :precision binary64 (fma (sin y) x (* z (cos y))))

C

double code(double x, double y, double z) {
	return fma(sin(y), x, (z * cos(y)));
}

Julia

function code(x, y, z)
	return fma(sin(y), x, Float64(z * cos(y)))
end

Wolfram

code[x_, y_, z_] := N[(N[Sin[y], $MachinePrecision] * x + N[(z * N[Cos[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.8%

   \[x \cdot \sin y + z \cdot \cos y \]
2. Add Preprocessing

4. Applied egg-rr 0

   \[\leadsto expr\]
5. Add Preprocessing

Alternative 2: 99.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ x \cdot \sin y + z \cdot \cos y \end{array} \]

FPCore

(FPCore (x y z) :precision binary64 (+ (* x (sin y)) (* z (cos y))))

C

double code(double x, double y, double z) {
	return (x * sin(y)) + (z * cos(y));
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = (x * sin(y)) + (z * cos(y))
end function

Java

public static double code(double x, double y, double z) {
	return (x * Math.sin(y)) + (z * Math.cos(y));
}

Python

def code(x, y, z):
	return (x * math.sin(y)) + (z * math.cos(y))

Julia

function code(x, y, z)
	return Float64(Float64(x * sin(y)) + Float64(z * cos(y)))
end

MATLAB

function tmp = code(x, y, z)
	tmp = (x * sin(y)) + (z * cos(y));
end

Wolfram

code[x_, y_, z_] := N[(N[(x * N[Sin[y], $MachinePrecision]), $MachinePrecision] + N[(z * N[Cos[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.8%

   \[x \cdot \sin y + z \cdot \cos y \]
2. Add Preprocessing
3. Add Preprocessing

Alternative 3: 74.7% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := z \cdot \cos y\\ t_1 := x \cdot \sin y\\ \mathbf{if}\;y \leq -8.2 \cdot 10^{+89}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;y \leq -27000000:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;y \leq -7.5 \cdot 10^{-7}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;y \leq 57:\\ \;\;\;\;x \cdot \left(y \cdot \left(1 + \left(y \cdot y\right) \cdot \left(-0.16666666666666666 + \left(y \cdot y\right) \cdot \left(0.008333333333333333 + \left(y \cdot y\right) \cdot -0.0001984126984126984\right)\right)\right)\right) + z\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (* z (cos y))) (t_1 (* x (sin y))))
   (if (<= y -8.2e+89)
     t_0
     (if (<= y -27000000.0)
       t_1
       (if (<= y -7.5e-7)
         t_0
         (if (<= y 57.0)
           (+
            (*
             x
             (*
              y
              (+
               1.0
               (*
                (* y y)
                (+
                 -0.16666666666666666
                 (*
                  (* y y)
                  (+
                   0.008333333333333333
                   (* (* y y) -0.0001984126984126984))))))))
            z)
           t_1))))))

C

double code(double x, double y, double z) {
	double t_0 = z * cos(y);
	double t_1 = x * sin(y);
	double tmp;
	if (y <= -8.2e+89) {
		tmp = t_0;
	} else if (y <= -27000000.0) {
		tmp = t_1;
	} else if (y <= -7.5e-7) {
		tmp = t_0;
	} else if (y <= 57.0) {
		tmp = (x * (y * (1.0 + ((y * y) * (-0.16666666666666666 + ((y * y) * (0.008333333333333333 + ((y * y) * -0.0001984126984126984)))))))) + z;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = z * cos(y)
    t_1 = x * sin(y)
    if (y <= (-8.2d+89)) then
        tmp = t_0
    else if (y <= (-27000000.0d0)) then
        tmp = t_1
    else if (y <= (-7.5d-7)) then
        tmp = t_0
    else if (y <= 57.0d0) then
        tmp = (x * (y * (1.0d0 + ((y * y) * ((-0.16666666666666666d0) + ((y * y) * (0.008333333333333333d0 + ((y * y) * (-0.0001984126984126984d0))))))))) + z
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = z * Math.cos(y);
	double t_1 = x * Math.sin(y);
	double tmp;
	if (y <= -8.2e+89) {
		tmp = t_0;
	} else if (y <= -27000000.0) {
		tmp = t_1;
	} else if (y <= -7.5e-7) {
		tmp = t_0;
	} else if (y <= 57.0) {
		tmp = (x * (y * (1.0 + ((y * y) * (-0.16666666666666666 + ((y * y) * (0.008333333333333333 + ((y * y) * -0.0001984126984126984)))))))) + z;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = z * math.cos(y)
	t_1 = x * math.sin(y)
	tmp = 0
	if y <= -8.2e+89:
		tmp = t_0
	elif y <= -27000000.0:
		tmp = t_1
	elif y <= -7.5e-7:
		tmp = t_0
	elif y <= 57.0:
		tmp = (x * (y * (1.0 + ((y * y) * (-0.16666666666666666 + ((y * y) * (0.008333333333333333 + ((y * y) * -0.0001984126984126984)))))))) + z
	else:
		tmp = t_1
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(z * cos(y))
	t_1 = Float64(x * sin(y))
	tmp = 0.0
	if (y <= -8.2e+89)
		tmp = t_0;
	elseif (y <= -27000000.0)
		tmp = t_1;
	elseif (y <= -7.5e-7)
		tmp = t_0;
	elseif (y <= 57.0)
		tmp = Float64(Float64(x * Float64(y * Float64(1.0 + Float64(Float64(y * y) * Float64(-0.16666666666666666 + Float64(Float64(y * y) * Float64(0.008333333333333333 + Float64(Float64(y * y) * -0.0001984126984126984)))))))) + z);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = z * cos(y);
	t_1 = x * sin(y);
	tmp = 0.0;
	if (y <= -8.2e+89)
		tmp = t_0;
	elseif (y <= -27000000.0)
		tmp = t_1;
	elseif (y <= -7.5e-7)
		tmp = t_0;
	elseif (y <= 57.0)
		tmp = (x * (y * (1.0 + ((y * y) * (-0.16666666666666666 + ((y * y) * (0.008333333333333333 + ((y * y) * -0.0001984126984126984)))))))) + z;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(z * N[Cos[y], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(x * N[Sin[y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -8.2e+89], t$95$0, If[LessEqual[y, -27000000.0], t$95$1, If[LessEqual[y, -7.5e-7], t$95$0, If[LessEqual[y, 57.0], N[(N[(x * N[(y * N[(1.0 + N[(N[(y * y), $MachinePrecision] * N[(-0.16666666666666666 + N[(N[(y * y), $MachinePrecision] * N[(0.008333333333333333 + N[(N[(y * y), $MachinePrecision] * -0.0001984126984126984), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + z), $MachinePrecision], t$95$1]]]]]]

Derivation

1. Split input into 3 regimes

2. if y < -8.1999999999999997e89 or -2.7e7 < y < -7.5000000000000002e-7

   1. Initial program 99.7%

      \[x \cdot \sin y + z \cdot \cos y \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -8.1999999999999997e89 < y < -2.7e7 or 57 < y

   1. Initial program 99.6%

      \[x \cdot \sin y + z \cdot \cos y \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -7.5000000000000002e-7 < y < 57

   1. Initial program 100.0%

      \[x \cdot \sin y + z \cdot \cos y \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 4: 86.6% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x \cdot \sin y + z\\ \mathbf{if}\;x \leq -3.4 \cdot 10^{-47}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;x \leq 1.6 \cdot 10^{-50}:\\ \;\;\;\;z \cdot \cos y\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (+ (* x (sin y)) z)))
   (if (<= x -3.4e-47) t_0 (if (<= x 1.6e-50) (* z (cos y)) t_0))))

C

double code(double x, double y, double z) {
	double t_0 = (x * sin(y)) + z;
	double tmp;
	if (x <= -3.4e-47) {
		tmp = t_0;
	} else if (x <= 1.6e-50) {
		tmp = z * cos(y);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = (x * sin(y)) + z
    if (x <= (-3.4d-47)) then
        tmp = t_0
    else if (x <= 1.6d-50) then
        tmp = z * cos(y)
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = (x * Math.sin(y)) + z;
	double tmp;
	if (x <= -3.4e-47) {
		tmp = t_0;
	} else if (x <= 1.6e-50) {
		tmp = z * Math.cos(y);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = (x * math.sin(y)) + z
	tmp = 0
	if x <= -3.4e-47:
		tmp = t_0
	elif x <= 1.6e-50:
		tmp = z * math.cos(y)
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(Float64(x * sin(y)) + z)
	tmp = 0.0
	if (x <= -3.4e-47)
		tmp = t_0;
	elseif (x <= 1.6e-50)
		tmp = Float64(z * cos(y));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = (x * sin(y)) + z;
	tmp = 0.0;
	if (x <= -3.4e-47)
		tmp = t_0;
	elseif (x <= 1.6e-50)
		tmp = z * cos(y);
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(N[(x * N[Sin[y], $MachinePrecision]), $MachinePrecision] + z), $MachinePrecision]}, If[LessEqual[x, -3.4e-47], t$95$0, If[LessEqual[x, 1.6e-50], N[(z * N[Cos[y], $MachinePrecision]), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if x < -3.4000000000000002e-47 or 1.6e-50 < x

   1. Initial program 99.8%

      \[x \cdot \sin y + z \cdot \cos y \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -3.4000000000000002e-47 < x < 1.6e-50

   1. Initial program 99.8%

      \[x \cdot \sin y + z \cdot \cos y \]
   2. Add Preprocessing

   3. Taylor expanded in x around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 5: 75.1% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := x \cdot \sin y\\ \mathbf{if}\;y \leq -4000000:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;y \leq 0.036:\\ \;\;\;\;z + y \cdot \left(x + y \cdot \left(z \cdot -0.5 + \left(y \cdot x\right) \cdot -0.16666666666666666\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (* x (sin y))))
   (if (<= y -4000000.0)
     t_0
     (if (<= y 0.036)
       (+ z (* y (+ x (* y (+ (* z -0.5) (* (* y x) -0.16666666666666666))))))
       t_0))))

C

double code(double x, double y, double z) {
	double t_0 = x * sin(y);
	double tmp;
	if (y <= -4000000.0) {
		tmp = t_0;
	} else if (y <= 0.036) {
		tmp = z + (y * (x + (y * ((z * -0.5) + ((y * x) * -0.16666666666666666)))));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: t_0
    real(8) :: tmp
    t_0 = x * sin(y)
    if (y <= (-4000000.0d0)) then
        tmp = t_0
    else if (y <= 0.036d0) then
        tmp = z + (y * (x + (y * ((z * (-0.5d0)) + ((y * x) * (-0.16666666666666666d0))))))
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double t_0 = x * Math.sin(y);
	double tmp;
	if (y <= -4000000.0) {
		tmp = t_0;
	} else if (y <= 0.036) {
		tmp = z + (y * (x + (y * ((z * -0.5) + ((y * x) * -0.16666666666666666)))));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = x * math.sin(y)
	tmp = 0
	if y <= -4000000.0:
		tmp = t_0
	elif y <= 0.036:
		tmp = z + (y * (x + (y * ((z * -0.5) + ((y * x) * -0.16666666666666666)))))
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(x * sin(y))
	tmp = 0.0
	if (y <= -4000000.0)
		tmp = t_0;
	elseif (y <= 0.036)
		tmp = Float64(z + Float64(y * Float64(x + Float64(y * Float64(Float64(z * -0.5) + Float64(Float64(y * x) * -0.16666666666666666))))));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = x * sin(y);
	tmp = 0.0;
	if (y <= -4000000.0)
		tmp = t_0;
	elseif (y <= 0.036)
		tmp = z + (y * (x + (y * ((z * -0.5) + ((y * x) * -0.16666666666666666)))));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(x * N[Sin[y], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[y, -4000000.0], t$95$0, If[LessEqual[y, 0.036], N[(z + N[(y * N[(x + N[(y * N[(N[(z * -0.5), $MachinePrecision] + N[(N[(y * x), $MachinePrecision] * -0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if y < -4e6 or 0.0359999999999999973 < y

   1. Initial program 99.7%

      \[x \cdot \sin y + z \cdot \cos y \]
   2. Add Preprocessing

   3. Taylor expanded in x around inf 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if -4e6 < y < 0.0359999999999999973

   1. Initial program 99.9%

      \[x \cdot \sin y + z \cdot \cos y \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 6: 40.0% accurate, 25.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;x \leq 5 \cdot 10^{+108}:\\ \;\;\;\;z\\ \mathbf{else}:\\ \;\;\;\;x \cdot y\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z) :precision binary64 (if (<= x 5e+108) z (* x y)))

C

double code(double x, double y, double z) {
	double tmp;
	if (x <= 5e+108) {
		tmp = z;
	} else {
		tmp = x * y;
	}
	return tmp;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8) :: tmp
    if (x <= 5d+108) then
        tmp = z
    else
        tmp = x * y
    end if
    code = tmp
end function

Java

public static double code(double x, double y, double z) {
	double tmp;
	if (x <= 5e+108) {
		tmp = z;
	} else {
		tmp = x * y;
	}
	return tmp;
}

Python

def code(x, y, z):
	tmp = 0
	if x <= 5e+108:
		tmp = z
	else:
		tmp = x * y
	return tmp

Julia

function code(x, y, z)
	tmp = 0.0
	if (x <= 5e+108)
		tmp = z;
	else
		tmp = Float64(x * y);
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	tmp = 0.0;
	if (x <= 5e+108)
		tmp = z;
	else
		tmp = x * y;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := If[LessEqual[x, 5e+108], z, N[(x * y), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if x < 4.99999999999999991e108

   1. Initial program 99.8%

      \[x \cdot \sin y + z \cdot \cos y \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 4.99999999999999991e108 < x

   1. Initial program 99.9%

      \[x \cdot \sin y + z \cdot \cos y \]
   2. Add Preprocessing

   3. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in y around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in y around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 7: 52.6% accurate, 41.4× speedup

Math

\[\begin{array}{l} \\ z + y \cdot x \end{array} \]

FPCore

(FPCore (x y z) :precision binary64 (+ z (* y x)))

C

double code(double x, double y, double z) {
	return z + (y * x);
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = z + (y * x)
end function

Java

public static double code(double x, double y, double z) {
	return z + (y * x);
}

Python

def code(x, y, z):
	return z + (y * x)

Julia

function code(x, y, z)
	return Float64(z + Float64(y * x))
end

MATLAB

function tmp = code(x, y, z)
	tmp = z + (y * x);
end

Wolfram

code[x_, y_, z_] := N[(z + N[(y * x), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.8%

   \[x \cdot \sin y + z \cdot \cos y \]
2. Add Preprocessing

3. Taylor expanded in y around 0 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]
6. Add Preprocessing

Alternative 8: 38.7% accurate, 207.0× speedup

Math

\[\begin{array}{l} \\ z \end{array} \]

FPCore

(FPCore (x y z) :precision binary64 z)

C

double code(double x, double y, double z) {
	return z;
}

Fortran

real(8) function code(x, y, z)
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    code = z
end function

Java

public static double code(double x, double y, double z) {
	return z;
}

Python

def code(x, y, z):
	return z

Julia

function code(x, y, z)
	return z
end

MATLAB

function tmp = code(x, y, z)
	tmp = z;
end

Wolfram

code[x_, y_, z_] := z

Derivation

1. Initial program 99.8%

   \[x \cdot \sin y + z \cdot \cos y \]
2. Add Preprocessing

3. Taylor expanded in y around 0 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]
6. Add Preprocessing

Reproduce

herbie shell --seed 2024110 
(FPCore (x y z)
  :name "Diagrams.ThreeD.Transform:aboutX from diagrams-lib-1.3.0.3, B"
  :precision binary64
  (+ (* x (sin y)) (* z (cos y))))