Physics.ForceLayout:coulombForce from force-layout-0.4.0.2

Percentage Accurate: 88.4% → 99.8%

Time: 12.1s

Alternatives: 3

Speedup: 1.0×

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

Specification

Math

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

FPCore

(FPCore (x y) :precision binary64 (/ x (* y y)))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 88.4% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y) :precision binary64 (/ x (* y y)))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 99.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{\frac{x}{y}}{y} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

function code(x, y)
	return Float64(Float64(x / y) / y)
end

MATLAB

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

Wolfram

code[x_, y_] := N[(N[(x / y), $MachinePrecision] / y), $MachinePrecision]

Derivation

1. Initial program 87.8%

   \[\frac{x}{y \cdot y} \]
2. Add Preprocessing
3. Step-by-step derivation

   1. associate-/r* N/A

      \[\leadsto \frac{\frac{x}{y}}{\color{blue}{y}} \]

   2. /-lowering-/.f64 N/A

      \[\leadsto \mathsf{/.f64}\left(\left(\frac{x}{y}\right), \color{blue}{y}\right) \]

   3. /-lowering-/.f64 99.8%

      \[\leadsto \mathsf{/.f64}\left(\mathsf{/.f64}\left(x, y\right), y\right) \]

4. Applied egg-rr 99.8%

   \[\leadsto \color{blue}{\frac{\frac{x}{y}}{y}} \]
5. Add Preprocessing

Alternative 2: 88.4% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (x y) :precision binary64 (/ x (* y y)))

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 87.8%

   \[\frac{x}{y \cdot y} \]
2. Add Preprocessing
3. Add Preprocessing

Alternative 3: 4.9% accurate, 5.0× speedup

Math

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

FPCore

(FPCore (x y) :precision binary64 x)

C

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

Fortran

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

Java

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

Python

def code(x, y):
	return x

Julia

function code(x, y)
	return x
end

MATLAB

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

Wolfram

code[x_, y_] := x

Derivation

1. Initial program 87.8%

   \[\frac{x}{y \cdot y} \]
2. Add Preprocessing
3. Step-by-step derivation

   1. associate-/r* N/A

      \[\leadsto \frac{\frac{x}{y}}{\color{blue}{y}} \]

   2. /-lowering-/.f64 N/A

      \[\leadsto \mathsf{/.f64}\left(\left(\frac{x}{y}\right), \color{blue}{y}\right) \]

   3. /-lowering-/.f64 99.8%

      \[\leadsto \mathsf{/.f64}\left(\mathsf{/.f64}\left(x, y\right), y\right) \]

4. Applied egg-rr 99.8%

   \[\leadsto \color{blue}{\frac{\frac{x}{y}}{y}} \]
5. Step-by-step derivation

   1. clear-num N/A

      \[\leadsto \frac{\frac{1}{\frac{y}{x}}}{y} \]

   2. associate-/l/ N/A

      \[\leadsto \frac{1}{\color{blue}{y \cdot \frac{y}{x}}} \]

   3. associate-/r* N/A

      \[\leadsto \frac{\frac{1}{y}}{\color{blue}{\frac{y}{x}}} \]

   4. inv-pow N/A

      \[\leadsto \frac{{y}^{-1}}{\frac{\color{blue}{y}}{x}} \]

   5. sqr-pow N/A

      \[\leadsto \frac{{y}^{\left(\frac{-1}{2}\right)} \cdot {y}^{\left(\frac{-1}{2}\right)}}{\frac{\color{blue}{y}}{x}} \]

   6. associate-/l* N/A

      \[\leadsto {y}^{\left(\frac{-1}{2}\right)} \cdot \color{blue}{\frac{{y}^{\left(\frac{-1}{2}\right)}}{\frac{y}{x}}} \]

   7. *-lowering-*.f64 N/A

      \[\leadsto \mathsf{*.f64}\left(\left({y}^{\left(\frac{-1}{2}\right)}\right), \color{blue}{\left(\frac{{y}^{\left(\frac{-1}{2}\right)}}{\frac{y}{x}}\right)}\right) \]

   8. pow-lowering-pow.f64 N/A

      \[\leadsto \mathsf{*.f64}\left(\mathsf{pow.f64}\left(y, \left(\frac{-1}{2}\right)\right), \left(\frac{\color{blue}{{y}^{\left(\frac{-1}{2}\right)}}}{\frac{y}{x}}\right)\right) \]

   9. metadata-eval N/A

      \[\leadsto \mathsf{*.f64}\left(\mathsf{pow.f64}\left(y, \frac{-1}{2}\right), \left(\frac{{y}^{\color{blue}{\left(\frac{-1}{2}\right)}}}{\frac{y}{x}}\right)\right) \]

   10. div-inv N/A

       \[\leadsto \mathsf{*.f64}\left(\mathsf{pow.f64}\left(y, \frac{-1}{2}\right), \left({y}^{\left(\frac{-1}{2}\right)} \cdot \color{blue}{\frac{1}{\frac{y}{x}}}\right)\right) \]

   11. div-inv N/A

       \[\leadsto \mathsf{*.f64}\left(\mathsf{pow.f64}\left(y, \frac{-1}{2}\right), \left({y}^{\left(\frac{-1}{2}\right)} \cdot \frac{1}{y \cdot \color{blue}{\frac{1}{x}}}\right)\right) \]

   12. associate-/r* N/A

       \[\leadsto \mathsf{*.f64}\left(\mathsf{pow.f64}\left(y, \frac{-1}{2}\right), \left({y}^{\left(\frac{-1}{2}\right)} \cdot \frac{\frac{1}{y}}{\color{blue}{\frac{1}{x}}}\right)\right) \]

   13. associate-*r/ N/A

       \[\leadsto \mathsf{*.f64}\left(\mathsf{pow.f64}\left(y, \frac{-1}{2}\right), \left(\frac{{y}^{\left(\frac{-1}{2}\right)} \cdot \frac{1}{y}}{\color{blue}{\frac{1}{x}}}\right)\right) \]

   14. inv-pow N/A

       \[\leadsto \mathsf{*.f64}\left(\mathsf{pow.f64}\left(y, \frac{-1}{2}\right), \left(\frac{{y}^{\left(\frac{-1}{2}\right)} \cdot {y}^{-1}}{\frac{1}{x}}\right)\right) \]

   15. sqr-pow N/A

       \[\leadsto \mathsf{*.f64}\left(\mathsf{pow.f64}\left(y, \frac{-1}{2}\right), \left(\frac{{y}^{\left(\frac{-1}{2}\right)} \cdot \left({y}^{\left(\frac{-1}{2}\right)} \cdot {y}^{\left(\frac{-1}{2}\right)}\right)}{\frac{1}{x}}\right)\right) \]

   16. cube-unmult N/A

       \[\leadsto \mathsf{*.f64}\left(\mathsf{pow.f64}\left(y, \frac{-1}{2}\right), \left(\frac{{\left({y}^{\left(\frac{-1}{2}\right)}\right)}^{3}}{\frac{\color{blue}{1}}{x}}\right)\right) \]

   17. /-lowering-/.f64 N/A

       \[\leadsto \mathsf{*.f64}\left(\mathsf{pow.f64}\left(y, \frac{-1}{2}\right), \mathsf{/.f64}\left(\left({\left({y}^{\left(\frac{-1}{2}\right)}\right)}^{3}\right), \color{blue}{\left(\frac{1}{x}\right)}\right)\right) \]

6. Applied egg-rr 47.3%

   \[\leadsto \color{blue}{{y}^{-0.5} \cdot \frac{{y}^{-1.5}}{\frac{1}{x}}} \]
7. Step-by-step derivation

   1. associate-/r/ N/A

      \[\leadsto \mathsf{*.f64}\left(\mathsf{pow.f64}\left(y, \frac{-1}{2}\right), \left(\frac{{y}^{\frac{-3}{2}}}{1} \cdot \color{blue}{x}\right)\right) \]

   2. /-rgt-identity N/A

      \[\leadsto \mathsf{*.f64}\left(\mathsf{pow.f64}\left(y, \frac{-1}{2}\right), \left({y}^{\frac{-3}{2}} \cdot x\right)\right) \]

   3. *-lowering-*.f64 N/A

      \[\leadsto \mathsf{*.f64}\left(\mathsf{pow.f64}\left(y, \frac{-1}{2}\right), \mathsf{*.f64}\left(\left({y}^{\frac{-3}{2}}\right), \color{blue}{x}\right)\right) \]

   4. pow-lowering-pow.f64 47.3%

      \[\leadsto \mathsf{*.f64}\left(\mathsf{pow.f64}\left(y, \frac{-1}{2}\right), \mathsf{*.f64}\left(\mathsf{pow.f64}\left(y, \frac{-3}{2}\right), x\right)\right) \]

8. Applied egg-rr 47.3%

   \[\leadsto {y}^{-0.5} \cdot \color{blue}{\left({y}^{-1.5} \cdot x\right)} \]

10. Applied egg-rr 4.8%

    \[\leadsto \color{blue}{\frac{x}{1}} \]

11. Final simplification 4.8%

    \[\leadsto x \]
12. Add Preprocessing

Developer Target 1: 99.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{\frac{x}{y}}{y} \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

function code(x, y)
	return Float64(Float64(x / y) / y)
end

MATLAB

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

Wolfram

code[x_, y_] := N[(N[(x / y), $MachinePrecision] / y), $MachinePrecision]

Reproduce

herbie shell --seed 2024161 
(FPCore (x y)
  :name "Physics.ForceLayout:coulombForce from force-layout-0.4.0.2"
  :precision binary64

  :alt
  (! :herbie-platform default (/ (/ x y) y))

  (/ x (* y y)))