Graphics.Rendering.Plot.Render.Plot.Axis:tickPosition from plot-0.2.3.4

Percentage Accurate: 97.7% → 97.7%

Time: 2.9s

Alternatives: 6

Speedup: 1.0×

• 74.9% of points produce a very large (infinite) output. You may want to add a precondition.

Specification

Math

\[x + \left(y - x\right) \cdot \frac{z}{t} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (+ x (* (- y x) (/ z t))))

C

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

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = x + ((y - x) * (z / t))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	x + ((y - x) * (z / t))
END code

Initial Program: 97.7% accurate, 1.0× speedup

Math

\[x + \left(y - x\right) \cdot \frac{z}{t} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (+ x (* (- y x) (/ z t))))

C

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

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = x + ((y - x) * (z / t))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	x + ((y - x) * (z / t))
END code

Alternative 1: 97.7% accurate, 1.0× speedup

Math

\[\mathsf{fma}\left(y - x, \frac{z}{t}, x\right) \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (fma (- y x) (/ z t) x))

C

double code(double x, double y, double z, double t) {
	return fma((y - x), (z / t), x);
}

Julia

function code(x, y, z, t)
	return fma(Float64(y - x), Float64(z / t), x)
end

Wolfram

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

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	((y - x) * (z / t)) + x
END code

Derivation

1. Initial program 97.7%

   \[x + \left(y - x\right) \cdot \frac{z}{t} \]
2. Step-by-step derivation

3. Applied rewrites 97.7%

   \[\leadsto \mathsf{fma}\left(y - x, \frac{z}{t}, x\right) \]
4. Add Preprocessing

Alternative 2: 94.4% accurate, 0.5× speedup

Math

\[\begin{array}{l} \mathbf{if}\;\frac{z}{t} \leq -1 \cdot 10^{-8}:\\ \;\;\;\;\mathsf{fma}\left(z, \frac{y - x}{t}, x\right)\\ \mathbf{elif}\;\frac{z}{t} \leq 5 \cdot 10^{-10}:\\ \;\;\;\;\mathsf{fma}\left(y, \frac{z}{t}, x\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{z \cdot \left(y - x\right)}{t}\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (if (<= (/ z t) -1e-8)
  (fma z (/ (- y x) t) x)
  (if (<= (/ z t) 5e-10) (fma y (/ z t) x) (/ (* z (- y x)) t))))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((z / t) <= -1e-8) {
		tmp = fma(z, ((y - x) / t), x);
	} else if ((z / t) <= 5e-10) {
		tmp = fma(y, (z / t), x);
	} else {
		tmp = (z * (y - x)) / t;
	}
	return tmp;
}

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (Float64(z / t) <= -1e-8)
		tmp = fma(z, Float64(Float64(y - x) / t), x);
	elseif (Float64(z / t) <= 5e-10)
		tmp = fma(y, Float64(z / t), x);
	else
		tmp = Float64(Float64(z * Float64(y - x)) / t);
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[N[(z / t), $MachinePrecision], -1e-8], N[(z * N[(N[(y - x), $MachinePrecision] / t), $MachinePrecision] + x), $MachinePrecision], If[LessEqual[N[(z / t), $MachinePrecision], 5e-10], N[(y * N[(z / t), $MachinePrecision] + x), $MachinePrecision], N[(N[(z * N[(y - x), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET tmp_1 = IF ((z / t) <= (50000000000000003114079572888992820944853434639298939146101474761962890625e-83)) THEN ((y * (z / t)) + x) ELSE ((z * (y - x)) / t) ENDIF IN
	LET tmp = IF ((z / t) <= (-10000000000000000209225608301284726753266340892878361046314239501953125e-78)) THEN ((z * ((y - x) / t)) + x) ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 3 regimes

2. if (/.f64 z t) < -1e-8

   1. Initial program 97.7%

      \[x + \left(y - x\right) \cdot \frac{z}{t} \]
   2. Step-by-step derivation

   3. Applied rewrites 92.4%

      \[\leadsto \mathsf{fma}\left(z, \frac{y - x}{t}, x\right) \]

   if -1e-8 < (/.f64 z t) < 5.0000000000000003e-10

   1. Initial program 97.7%

      \[x + \left(y - x\right) \cdot \frac{z}{t} \]
   2. Step-by-step derivation

   3. Applied rewrites 97.7%

      \[\leadsto \mathsf{fma}\left(y - x, \frac{z}{t}, x\right) \]

   4. Taylor expanded in x around 0

      \[\leadsto \mathsf{fma}\left(y, \frac{z}{t}, x\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 76.4%

      \[\leadsto \mathsf{fma}\left(y, \frac{z}{t}, x\right) \]

   if 5.0000000000000003e-10 < (/.f64 z t)

   1. Initial program 97.7%

      \[x + \left(y - x\right) \cdot \frac{z}{t} \]

   2. Taylor expanded in x around 0

      \[\leadsto x + y \cdot \frac{z}{t} \]
   3. Step-by-step derivation

   4. Applied rewrites 76.4%

      \[\leadsto x + y \cdot \frac{z}{t} \]

   5. Taylor expanded in undef-var around zero

      \[\leadsto 0 + y \cdot \frac{z}{t} \]
   6. Step-by-step derivation

   7. Applied rewrites 40.6%

      \[\leadsto 0 + y \cdot \frac{z}{t} \]
   8. Step-by-step derivation

   9. Applied rewrites 40.6%

      \[\leadsto \mathsf{fma}\left(y, \frac{z}{t}, 0\right) \]

   10. Taylor expanded in z around -inf

       \[\leadsto \frac{z \cdot \left(y - x\right)}{t} \]
   11. Step-by-step derivation

   12. Applied rewrites 58.0%

       \[\leadsto \frac{z \cdot \left(y - x\right)}{t} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 3: 94.0% accurate, 0.5× speedup

Math

\[\begin{array}{l} t_1 := \frac{z \cdot \left(y - x\right)}{t}\\ \mathbf{if}\;\frac{z}{t} \leq -1 \cdot 10^{+28}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;\frac{z}{t} \leq 5 \cdot 10^{-10}:\\ \;\;\;\;\mathsf{fma}\left(y, \frac{z}{t}, x\right)\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (let* ((t_1 (/ (* z (- y x)) t)))
  (if (<= (/ z t) -1e+28)
    t_1
    (if (<= (/ z t) 5e-10) (fma y (/ z t) x) t_1))))

C

double code(double x, double y, double z, double t) {
	double t_1 = (z * (y - x)) / t;
	double tmp;
	if ((z / t) <= -1e+28) {
		tmp = t_1;
	} else if ((z / t) <= 5e-10) {
		tmp = fma(y, (z / t), x);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Julia

function code(x, y, z, t)
	t_1 = Float64(Float64(z * Float64(y - x)) / t)
	tmp = 0.0
	if (Float64(z / t) <= -1e+28)
		tmp = t_1;
	elseif (Float64(z / t) <= 5e-10)
		tmp = fma(y, Float64(z / t), x);
	else
		tmp = t_1;
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_] := Block[{t$95$1 = N[(N[(z * N[(y - x), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]}, If[LessEqual[N[(z / t), $MachinePrecision], -1e+28], t$95$1, If[LessEqual[N[(z / t), $MachinePrecision], 5e-10], N[(y * N[(z / t), $MachinePrecision] + x), $MachinePrecision], t$95$1]]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET t_1 = ((z * (y - x)) / t) IN
		LET tmp_1 = IF ((z / t) <= (50000000000000003114079572888992820944853434639298939146101474761962890625e-83)) THEN ((y * (z / t)) + x) ELSE t_1 ENDIF IN
		LET tmp = IF ((z / t) <= (-9999999999999999583119736832)) THEN t_1 ELSE tmp_1 ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if (/.f64 z t) < -9.9999999999999996e27 or 5.0000000000000003e-10 < (/.f64 z t)

   1. Initial program 97.7%

      \[x + \left(y - x\right) \cdot \frac{z}{t} \]

   2. Taylor expanded in x around 0

      \[\leadsto x + y \cdot \frac{z}{t} \]
   3. Step-by-step derivation

   4. Applied rewrites 76.4%

      \[\leadsto x + y \cdot \frac{z}{t} \]

   5. Taylor expanded in undef-var around zero

      \[\leadsto 0 + y \cdot \frac{z}{t} \]
   6. Step-by-step derivation

   7. Applied rewrites 40.6%

      \[\leadsto 0 + y \cdot \frac{z}{t} \]
   8. Step-by-step derivation

   9. Applied rewrites 40.6%

      \[\leadsto \mathsf{fma}\left(y, \frac{z}{t}, 0\right) \]

   10. Taylor expanded in z around -inf

       \[\leadsto \frac{z \cdot \left(y - x\right)}{t} \]
   11. Step-by-step derivation

   12. Applied rewrites 58.0%

       \[\leadsto \frac{z \cdot \left(y - x\right)}{t} \]

   if -9.9999999999999996e27 < (/.f64 z t) < 5.0000000000000003e-10

   1. Initial program 97.7%

      \[x + \left(y - x\right) \cdot \frac{z}{t} \]
   2. Step-by-step derivation

   3. Applied rewrites 97.7%

      \[\leadsto \mathsf{fma}\left(y - x, \frac{z}{t}, x\right) \]

   4. Taylor expanded in x around 0

      \[\leadsto \mathsf{fma}\left(y, \frac{z}{t}, x\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 76.4%

      \[\leadsto \mathsf{fma}\left(y, \frac{z}{t}, x\right) \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 4: 76.4% accurate, 1.3× speedup

Math

\[\mathsf{fma}\left(y, \frac{z}{t}, x\right) \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (fma y (/ z t) x))

C

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

Julia

function code(x, y, z, t)
	return fma(y, Float64(z / t), x)
end

Wolfram

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

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	(y * (z / t)) + x
END code

Derivation

1. Initial program 97.7%

   \[x + \left(y - x\right) \cdot \frac{z}{t} \]
2. Step-by-step derivation

3. Applied rewrites 97.7%

   \[\leadsto \mathsf{fma}\left(y - x, \frac{z}{t}, x\right) \]

4. Taylor expanded in x around 0

   \[\leadsto \mathsf{fma}\left(y, \frac{z}{t}, x\right) \]
5. Step-by-step derivation

6. Applied rewrites 76.4%

   \[\leadsto \mathsf{fma}\left(y, \frac{z}{t}, x\right) \]
7. Add Preprocessing

Alternative 5: 71.7% accurate, 0.7× speedup

Math

\[\begin{array}{l} \mathbf{if}\;\frac{z}{t} \leq 2 \cdot 10^{-39}:\\ \;\;\;\;\mathsf{fma}\left(z, \frac{y}{t}, x\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{y \cdot z}{t}\\ \end{array} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (if (<= (/ z t) 2e-39) (fma z (/ y t) x) (/ (* y z) t)))

C

double code(double x, double y, double z, double t) {
	double tmp;
	if ((z / t) <= 2e-39) {
		tmp = fma(z, (y / t), x);
	} else {
		tmp = (y * z) / t;
	}
	return tmp;
}

Julia

function code(x, y, z, t)
	tmp = 0.0
	if (Float64(z / t) <= 2e-39)
		tmp = fma(z, Float64(y / t), x);
	else
		tmp = Float64(Float64(y * z) / t);
	end
	return tmp
end

Wolfram

code[x_, y_, z_, t_] := If[LessEqual[N[(z / t), $MachinePrecision], 2e-39], N[(z * N[(y / t), $MachinePrecision] + x), $MachinePrecision], N[(N[(y * z), $MachinePrecision] / t), $MachinePrecision]]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	LET tmp = IF ((z / t) <= (19999999999999998585857587997602900046612902381239473479626644444638600999022172123081953005438153743965334907528585972613655030727386474609375e-181)) THEN ((z * (y / t)) + x) ELSE ((y * z) / t) ENDIF IN
	tmp
END code

Derivation

1. Split input into 2 regimes

2. if (/.f64 z t) < 1.9999999999999999e-39

   1. Initial program 97.7%

      \[x + \left(y - x\right) \cdot \frac{z}{t} \]
   2. Step-by-step derivation

   3. Applied rewrites 92.4%

      \[\leadsto \mathsf{fma}\left(z, \frac{y - x}{t}, x\right) \]

   4. Taylor expanded in x around 0

      \[\leadsto \mathsf{fma}\left(z, \frac{y}{t}, x\right) \]
   5. Step-by-step derivation

   6. Applied rewrites 72.8%

      \[\leadsto \mathsf{fma}\left(z, \frac{y}{t}, x\right) \]

   if 1.9999999999999999e-39 < (/.f64 z t)

   1. Initial program 97.7%

      \[x + \left(y - x\right) \cdot \frac{z}{t} \]

   2. Taylor expanded in x around 0

      \[\leadsto x + y \cdot \frac{z}{t} \]
   3. Step-by-step derivation

   4. Applied rewrites 76.4%

      \[\leadsto x + y \cdot \frac{z}{t} \]

   5. Taylor expanded in undef-var around zero

      \[\leadsto 0 + y \cdot \frac{z}{t} \]
   6. Step-by-step derivation

   7. Applied rewrites 40.6%

      \[\leadsto 0 + y \cdot \frac{z}{t} \]
   8. Step-by-step derivation

   9. Applied rewrites 40.6%

      \[\leadsto \mathsf{fma}\left(y, \frac{z}{t}, 0\right) \]

   10. Taylor expanded in x around 0

       \[\leadsto \frac{y \cdot z}{t} \]
   11. Step-by-step derivation

   12. Applied rewrites 37.6%

       \[\leadsto \frac{y \cdot z}{t} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 6: 37.6% accurate, 1.7× speedup

Math

\[\frac{y \cdot z}{t} \]

FPCore

(FPCore (x y z t)
  :precision binary64
  :pre TRUE
  (/ (* y z) t))

C

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

Fortran

real(8) function code(x, y, z, t)
use fmin_fmax_functions
    real(8), intent (in) :: x
    real(8), intent (in) :: y
    real(8), intent (in) :: z
    real(8), intent (in) :: t
    code = (y * z) / t
end function

Java

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

Python

def code(x, y, z, t):
	return (y * z) / t

Julia

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

MATLAB

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

Wolfram

code[x_, y_, z_, t_] := N[(N[(y * z), $MachinePrecision] / t), $MachinePrecision]

ReFlow

f(x, y, z, t):
	x in [-inf, +inf],
	y in [-inf, +inf],
	z in [-inf, +inf],
	t in [-inf, +inf]
code: THEORY
BEGIN
f(x, y, z, t: real): real =
	(y * z) / t
END code

Derivation

1. Initial program 97.7%

   \[x + \left(y - x\right) \cdot \frac{z}{t} \]

2. Taylor expanded in x around 0

   \[\leadsto x + y \cdot \frac{z}{t} \]
3. Step-by-step derivation

4. Applied rewrites 76.4%

   \[\leadsto x + y \cdot \frac{z}{t} \]

5. Taylor expanded in undef-var around zero

   \[\leadsto 0 + y \cdot \frac{z}{t} \]
6. Step-by-step derivation

7. Applied rewrites 40.6%

   \[\leadsto 0 + y \cdot \frac{z}{t} \]
8. Step-by-step derivation

9. Applied rewrites 40.6%

   \[\leadsto \mathsf{fma}\left(y, \frac{z}{t}, 0\right) \]

10. Taylor expanded in x around 0

    \[\leadsto \frac{y \cdot z}{t} \]
11. Step-by-step derivation

12. Applied rewrites 37.6%

    \[\leadsto \frac{y \cdot z}{t} \]
13. Add Preprocessing

Reproduce

herbie shell --seed 2026092 
(FPCore (x y z t)
  :name "Graphics.Rendering.Plot.Render.Plot.Axis:tickPosition from plot-0.2.3.4"
  :precision binary64
  (+ x (* (- y x) (/ z t))))