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

Percentage Accurate: 99.8% → 99.8%

Time: 1.4s

Alternatives: 5

Speedup: 1.0×

Specification

\[\mathsf{TRUE}\left(\right)\]

Math

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

FPCore

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

C

double code(double x, double y, double z) {
	return (x * cos(y)) - (z * sin(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 * cos(y)) - (z * sin(y))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 99.8% accurate, 1.0× speedup

Math

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

FPCore

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

C

double code(double x, double y, double z) {
	return (x * cos(y)) - (z * sin(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 * cos(y)) - (z * sin(y))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 99.8% accurate, 1.0× speedup

Math

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

FPCore

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

C

double code(double x, double y, double z) {
	return (x * cos(y)) - (z * sin(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 * cos(y)) - (z * sin(y))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 99.8%

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

Alternative 2: 71.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \cos y - z \cdot \sin y\\ \mathbf{if}\;z \leq -4.1 \cdot 10^{+58}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;z \leq 2.1 \cdot 10^{+133}:\\ \;\;\;\;x \cdot \cos y\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (x y z)
 :precision binary64
 (let* ((t_0 (- (cos y) (* z (sin y)))))
   (if (<= z -4.1e+58) t_0 (if (<= z 2.1e+133) (* x (cos y)) t_0))))

C

double code(double x, double y, double z) {
	double t_0 = cos(y) - (z * sin(y));
	double tmp;
	if (z <= -4.1e+58) {
		tmp = t_0;
	} else if (z <= 2.1e+133) {
		tmp = x * 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 = cos(y) - (z * sin(y))
    if (z <= (-4.1d+58)) then
        tmp = t_0
    else if (z <= 2.1d+133) then
        tmp = x * 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 = Math.cos(y) - (z * Math.sin(y));
	double tmp;
	if (z <= -4.1e+58) {
		tmp = t_0;
	} else if (z <= 2.1e+133) {
		tmp = x * Math.cos(y);
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(x, y, z):
	t_0 = math.cos(y) - (z * math.sin(y))
	tmp = 0
	if z <= -4.1e+58:
		tmp = t_0
	elif z <= 2.1e+133:
		tmp = x * math.cos(y)
	else:
		tmp = t_0
	return tmp

Julia

function code(x, y, z)
	t_0 = Float64(cos(y) - Float64(z * sin(y)))
	tmp = 0.0
	if (z <= -4.1e+58)
		tmp = t_0;
	elseif (z <= 2.1e+133)
		tmp = Float64(x * cos(y));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(x, y, z)
	t_0 = cos(y) - (z * sin(y));
	tmp = 0.0;
	if (z <= -4.1e+58)
		tmp = t_0;
	elseif (z <= 2.1e+133)
		tmp = x * cos(y);
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[x_, y_, z_] := Block[{t$95$0 = N[(N[Cos[y], $MachinePrecision] - N[(z * N[Sin[y], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[z, -4.1e+58], t$95$0, If[LessEqual[z, 2.1e+133], N[(x * N[Cos[y], $MachinePrecision]), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if z < -4.1e58 or 2.1e133 < z

   1. Initial program 99.8%

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

   3. Taylor expanded in x around 0

      \[\leadsto \color{blue}{x \cdot \cos y} - z \cdot \sin y \]

   5. Applied rewrites 70.2%

      \[\leadsto \color{blue}{\cos y} - z \cdot \sin y \]

   if -4.1e58 < z < 2.1e133

   1. Initial program 99.9%

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

   3. Taylor expanded in x around 0

      \[\leadsto \color{blue}{x \cdot \cos y - z \cdot \sin y} \]

   5. Applied rewrites 80.5%

      \[\leadsto \color{blue}{x \cdot \cos y} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 3: 60.1% accurate, 2.0× speedup

Math

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

FPCore

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

C

double code(double x, double y, double z) {
	return x * 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 * cos(y)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 99.8%

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

3. Taylor expanded in x around 0

   \[\leadsto \color{blue}{x \cdot \cos y - z \cdot \sin y} \]

5. Applied rewrites 60.9%

   \[\leadsto \color{blue}{x \cdot \cos y} \]
6. Add Preprocessing

Alternative 4: 3.4% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \sin y \end{array} \]

FPCore

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

C

double code(double x, double y, double z) {
	return sin(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 = sin(y)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_] := N[Sin[y], $MachinePrecision]

Derivation

1. Initial program 99.8%

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

3. Taylor expanded in x around -inf

   \[\leadsto \color{blue}{-1 \cdot \left(x \cdot \left(-1 \cdot \cos y + \frac{z \cdot \sin y}{x}\right)\right)} \]

5. Applied rewrites 3.3%

   \[\leadsto \color{blue}{\sin y} \]
6. Add Preprocessing

Alternative 5: 3.5% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \cos y \end{array} \]

FPCore

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

C

double code(double x, double y, double z) {
	return 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 = cos(y)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_] := N[Cos[y], $MachinePrecision]

Derivation

1. Initial program 99.8%

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

3. Taylor expanded in x around -inf

   \[\leadsto \color{blue}{-1 \cdot \left(x \cdot \left(-1 \cdot \cos y + \frac{z \cdot \sin y}{x}\right)\right)} \]

5. Applied rewrites 3.3%

   \[\leadsto \color{blue}{\sin y} \]

6. Taylor expanded in x around -inf

   \[\leadsto \color{blue}{-1 \cdot \left(x \cdot \left(-1 \cdot \cos y + \frac{z \cdot \sin y}{x}\right)\right)} \]

8. Applied rewrites 3.3%

   \[\leadsto \color{blue}{\cos y} \]
9. Add Preprocessing

Reproduce

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