Quotient of products

Percentage Accurate: 85.7% → 89.4%

Time: 3.0s

Alternatives: 5

Speedup: 1.0×

Specification

Math

\[\begin{array}{l} \\ \frac{a1 \cdot a2}{b1 \cdot b2} \end{array} \]

FPCore

(FPCore (a1 a2 b1 b2) :precision binary64 (/ (* a1 a2) (* b1 b2)))

C

double code(double a1, double a2, double b1, double b2) {
	return (a1 * a2) / (b1 * b2);
}

Fortran

real(8) function code(a1, a2, b1, b2)
    real(8), intent (in) :: a1
    real(8), intent (in) :: a2
    real(8), intent (in) :: b1
    real(8), intent (in) :: b2
    code = (a1 * a2) / (b1 * b2)
end function

Java

public static double code(double a1, double a2, double b1, double b2) {
	return (a1 * a2) / (b1 * b2);
}

Python

def code(a1, a2, b1, b2):
	return (a1 * a2) / (b1 * b2)

Julia

function code(a1, a2, b1, b2)
	return Float64(Float64(a1 * a2) / Float64(b1 * b2))
end

MATLAB

function tmp = code(a1, a2, b1, b2)
	tmp = (a1 * a2) / (b1 * b2);
end

Wolfram

code[a1_, a2_, b1_, b2_] := N[(N[(a1 * a2), $MachinePrecision] / N[(b1 * b2), $MachinePrecision]), $MachinePrecision]

Initial Program: 85.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{a1 \cdot a2}{b1 \cdot b2} \end{array} \]

FPCore

(FPCore (a1 a2 b1 b2) :precision binary64 (/ (* a1 a2) (* b1 b2)))

C

double code(double a1, double a2, double b1, double b2) {
	return (a1 * a2) / (b1 * b2);
}

Fortran

real(8) function code(a1, a2, b1, b2)
    real(8), intent (in) :: a1
    real(8), intent (in) :: a2
    real(8), intent (in) :: b1
    real(8), intent (in) :: b2
    code = (a1 * a2) / (b1 * b2)
end function

Java

public static double code(double a1, double a2, double b1, double b2) {
	return (a1 * a2) / (b1 * b2);
}

Python

def code(a1, a2, b1, b2):
	return (a1 * a2) / (b1 * b2)

Julia

function code(a1, a2, b1, b2)
	return Float64(Float64(a1 * a2) / Float64(b1 * b2))
end

MATLAB

function tmp = code(a1, a2, b1, b2)
	tmp = (a1 * a2) / (b1 * b2);
end

Wolfram

code[a1_, a2_, b1_, b2_] := N[(N[(a1 * a2), $MachinePrecision] / N[(b1 * b2), $MachinePrecision]), $MachinePrecision]

Alternative 1: 89.4% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;a1 \cdot a2 \leq 4 \cdot 10^{-235}:\\ \;\;\;\;\frac{a2}{\frac{b1}{a1} \cdot b2}\\ \mathbf{elif}\;a1 \cdot a2 \leq 5 \cdot 10^{+128}:\\ \;\;\;\;\frac{a1 \cdot a2}{b1 \cdot b2}\\ \mathbf{else}:\\ \;\;\;\;\frac{a1}{b1 \cdot \frac{b2}{a2}}\\ \end{array} \end{array} \]

FPCore

(FPCore (a1 a2 b1 b2)
 :precision binary64
 (if (<= (* a1 a2) 4e-235)
   (/ a2 (* (/ b1 a1) b2))
   (if (<= (* a1 a2) 5e+128) (/ (* a1 a2) (* b1 b2)) (/ a1 (* b1 (/ b2 a2))))))

C

double code(double a1, double a2, double b1, double b2) {
	double tmp;
	if ((a1 * a2) <= 4e-235) {
		tmp = a2 / ((b1 / a1) * b2);
	} else if ((a1 * a2) <= 5e+128) {
		tmp = (a1 * a2) / (b1 * b2);
	} else {
		tmp = a1 / (b1 * (b2 / a2));
	}
	return tmp;
}

Fortran

real(8) function code(a1, a2, b1, b2)
    real(8), intent (in) :: a1
    real(8), intent (in) :: a2
    real(8), intent (in) :: b1
    real(8), intent (in) :: b2
    real(8) :: tmp
    if ((a1 * a2) <= 4d-235) then
        tmp = a2 / ((b1 / a1) * b2)
    else if ((a1 * a2) <= 5d+128) then
        tmp = (a1 * a2) / (b1 * b2)
    else
        tmp = a1 / (b1 * (b2 / a2))
    end if
    code = tmp
end function

Java

public static double code(double a1, double a2, double b1, double b2) {
	double tmp;
	if ((a1 * a2) <= 4e-235) {
		tmp = a2 / ((b1 / a1) * b2);
	} else if ((a1 * a2) <= 5e+128) {
		tmp = (a1 * a2) / (b1 * b2);
	} else {
		tmp = a1 / (b1 * (b2 / a2));
	}
	return tmp;
}

Python

def code(a1, a2, b1, b2):
	tmp = 0
	if (a1 * a2) <= 4e-235:
		tmp = a2 / ((b1 / a1) * b2)
	elif (a1 * a2) <= 5e+128:
		tmp = (a1 * a2) / (b1 * b2)
	else:
		tmp = a1 / (b1 * (b2 / a2))
	return tmp

Julia

function code(a1, a2, b1, b2)
	tmp = 0.0
	if (Float64(a1 * a2) <= 4e-235)
		tmp = Float64(a2 / Float64(Float64(b1 / a1) * b2));
	elseif (Float64(a1 * a2) <= 5e+128)
		tmp = Float64(Float64(a1 * a2) / Float64(b1 * b2));
	else
		tmp = Float64(a1 / Float64(b1 * Float64(b2 / a2)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a1, a2, b1, b2)
	tmp = 0.0;
	if ((a1 * a2) <= 4e-235)
		tmp = a2 / ((b1 / a1) * b2);
	elseif ((a1 * a2) <= 5e+128)
		tmp = (a1 * a2) / (b1 * b2);
	else
		tmp = a1 / (b1 * (b2 / a2));
	end
	tmp_2 = tmp;
end

Wolfram

code[a1_, a2_, b1_, b2_] := If[LessEqual[N[(a1 * a2), $MachinePrecision], 4e-235], N[(a2 / N[(N[(b1 / a1), $MachinePrecision] * b2), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(a1 * a2), $MachinePrecision], 5e+128], N[(N[(a1 * a2), $MachinePrecision] / N[(b1 * b2), $MachinePrecision]), $MachinePrecision], N[(a1 / N[(b1 * N[(b2 / a2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if (*.f64 a1 a2) < 3.9999999999999998e-235

   1. Initial program 85.1%

      \[\frac{a1 \cdot a2}{b1 \cdot b2} \]
   2. Step-by-step derivation

      1. times-frac 90.4%

         \[\leadsto \color{blue}{\frac{a1}{b1} \cdot \frac{a2}{b2}} \]

      2. *-commutative 90.4%

         \[\leadsto \color{blue}{\frac{a2}{b2} \cdot \frac{a1}{b1}} \]

   3. Simplified 90.4%

      \[\leadsto \color{blue}{\frac{a2}{b2} \cdot \frac{a1}{b1}} \]
   4. Step-by-step derivation

      1. *-commutative 90.4%

         \[\leadsto \color{blue}{\frac{a1}{b1} \cdot \frac{a2}{b2}} \]

      2. clear-num 90.4%

         \[\leadsto \color{blue}{\frac{1}{\frac{b1}{a1}}} \cdot \frac{a2}{b2} \]

      3. frac-times 96.6%

         \[\leadsto \color{blue}{\frac{1 \cdot a2}{\frac{b1}{a1} \cdot b2}} \]

      4. *-un-lft-identity 96.6%

         \[\leadsto \frac{\color{blue}{a2}}{\frac{b1}{a1} \cdot b2} \]

   5. Applied egg-rr 96.6%

      \[\leadsto \color{blue}{\frac{a2}{\frac{b1}{a1} \cdot b2}} \]

   if 3.9999999999999998e-235 < (*.f64 a1 a2) < 5e128

   1. Initial program 95.5%

      \[\frac{a1 \cdot a2}{b1 \cdot b2} \]

   if 5e128 < (*.f64 a1 a2)

   1. Initial program 78.6%

      \[\frac{a1 \cdot a2}{b1 \cdot b2} \]
   2. Step-by-step derivation

      1. times-frac 91.4%

         \[\leadsto \color{blue}{\frac{a1}{b1} \cdot \frac{a2}{b2}} \]

      2. *-commutative 91.4%

         \[\leadsto \color{blue}{\frac{a2}{b2} \cdot \frac{a1}{b1}} \]

   3. Simplified 91.4%

      \[\leadsto \color{blue}{\frac{a2}{b2} \cdot \frac{a1}{b1}} \]
   4. Step-by-step derivation

      1. clear-num 91.5%

         \[\leadsto \color{blue}{\frac{1}{\frac{b2}{a2}}} \cdot \frac{a1}{b1} \]

      2. frac-times 97.7%

         \[\leadsto \color{blue}{\frac{1 \cdot a1}{\frac{b2}{a2} \cdot b1}} \]

      3. *-un-lft-identity 97.7%

         \[\leadsto \frac{\color{blue}{a1}}{\frac{b2}{a2} \cdot b1} \]

   5. Applied egg-rr 97.7%

      \[\leadsto \color{blue}{\frac{a1}{\frac{b2}{a2} \cdot b1}} \]
3. Recombined 3 regimes into one program.

4. Final simplification 96.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a1 \cdot a2 \leq 4 \cdot 10^{-235}:\\ \;\;\;\;\frac{a2}{\frac{b1}{a1} \cdot b2}\\ \mathbf{elif}\;a1 \cdot a2 \leq 5 \cdot 10^{+128}:\\ \;\;\;\;\frac{a1 \cdot a2}{b1 \cdot b2}\\ \mathbf{else}:\\ \;\;\;\;\frac{a1}{b1 \cdot \frac{b2}{a2}}\\ \end{array} \]

Alternative 2: 86.2% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;b1 \leq 1.55 \cdot 10^{-130}:\\ \;\;\;\;\frac{a2}{\frac{b1 \cdot b2}{a1}}\\ \mathbf{else}:\\ \;\;\;\;\frac{a1}{b1 \cdot \frac{b2}{a2}}\\ \end{array} \end{array} \]

FPCore

(FPCore (a1 a2 b1 b2)
 :precision binary64
 (if (<= b1 1.55e-130) (/ a2 (/ (* b1 b2) a1)) (/ a1 (* b1 (/ b2 a2)))))

C

double code(double a1, double a2, double b1, double b2) {
	double tmp;
	if (b1 <= 1.55e-130) {
		tmp = a2 / ((b1 * b2) / a1);
	} else {
		tmp = a1 / (b1 * (b2 / a2));
	}
	return tmp;
}

Fortran

real(8) function code(a1, a2, b1, b2)
    real(8), intent (in) :: a1
    real(8), intent (in) :: a2
    real(8), intent (in) :: b1
    real(8), intent (in) :: b2
    real(8) :: tmp
    if (b1 <= 1.55d-130) then
        tmp = a2 / ((b1 * b2) / a1)
    else
        tmp = a1 / (b1 * (b2 / a2))
    end if
    code = tmp
end function

Java

public static double code(double a1, double a2, double b1, double b2) {
	double tmp;
	if (b1 <= 1.55e-130) {
		tmp = a2 / ((b1 * b2) / a1);
	} else {
		tmp = a1 / (b1 * (b2 / a2));
	}
	return tmp;
}

Python

def code(a1, a2, b1, b2):
	tmp = 0
	if b1 <= 1.55e-130:
		tmp = a2 / ((b1 * b2) / a1)
	else:
		tmp = a1 / (b1 * (b2 / a2))
	return tmp

Julia

function code(a1, a2, b1, b2)
	tmp = 0.0
	if (b1 <= 1.55e-130)
		tmp = Float64(a2 / Float64(Float64(b1 * b2) / a1));
	else
		tmp = Float64(a1 / Float64(b1 * Float64(b2 / a2)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a1, a2, b1, b2)
	tmp = 0.0;
	if (b1 <= 1.55e-130)
		tmp = a2 / ((b1 * b2) / a1);
	else
		tmp = a1 / (b1 * (b2 / a2));
	end
	tmp_2 = tmp;
end

Wolfram

code[a1_, a2_, b1_, b2_] := If[LessEqual[b1, 1.55e-130], N[(a2 / N[(N[(b1 * b2), $MachinePrecision] / a1), $MachinePrecision]), $MachinePrecision], N[(a1 / N[(b1 * N[(b2 / a2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if b1 < 1.55000000000000005e-130

   1. Initial program 88.6%

      \[\frac{a1 \cdot a2}{b1 \cdot b2} \]
   2. Step-by-step derivation

      1. times-frac 87.6%

         \[\leadsto \color{blue}{\frac{a1}{b1} \cdot \frac{a2}{b2}} \]

      2. *-commutative 87.6%

         \[\leadsto \color{blue}{\frac{a2}{b2} \cdot \frac{a1}{b1}} \]

   3. Simplified 87.6%

      \[\leadsto \color{blue}{\frac{a2}{b2} \cdot \frac{a1}{b1}} \]
   4. Step-by-step derivation

      1. frac-times 88.6%

         \[\leadsto \color{blue}{\frac{a2 \cdot a1}{b2 \cdot b1}} \]

      2. *-commutative 88.6%

         \[\leadsto \frac{a2 \cdot a1}{\color{blue}{b1 \cdot b2}} \]

      3. associate-/l* 92.1%

         \[\leadsto \color{blue}{\frac{a2}{\frac{b1 \cdot b2}{a1}}} \]

      4. *-commutative 92.1%

         \[\leadsto \frac{a2}{\frac{\color{blue}{b2 \cdot b1}}{a1}} \]

   5. Applied egg-rr 92.1%

      \[\leadsto \color{blue}{\frac{a2}{\frac{b2 \cdot b1}{a1}}} \]

   if 1.55000000000000005e-130 < b1

   1. Initial program 82.3%

      \[\frac{a1 \cdot a2}{b1 \cdot b2} \]
   2. Step-by-step derivation

      1. times-frac 90.1%

         \[\leadsto \color{blue}{\frac{a1}{b1} \cdot \frac{a2}{b2}} \]

      2. *-commutative 90.1%

         \[\leadsto \color{blue}{\frac{a2}{b2} \cdot \frac{a1}{b1}} \]

   3. Simplified 90.1%

      \[\leadsto \color{blue}{\frac{a2}{b2} \cdot \frac{a1}{b1}} \]
   4. Step-by-step derivation

      1. clear-num 90.0%

         \[\leadsto \color{blue}{\frac{1}{\frac{b2}{a2}}} \cdot \frac{a1}{b1} \]

      2. frac-times 93.2%

         \[\leadsto \color{blue}{\frac{1 \cdot a1}{\frac{b2}{a2} \cdot b1}} \]

      3. *-un-lft-identity 93.2%

         \[\leadsto \frac{\color{blue}{a1}}{\frac{b2}{a2} \cdot b1} \]

   5. Applied egg-rr 93.2%

      \[\leadsto \color{blue}{\frac{a1}{\frac{b2}{a2} \cdot b1}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 92.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;b1 \leq 1.55 \cdot 10^{-130}:\\ \;\;\;\;\frac{a2}{\frac{b1 \cdot b2}{a1}}\\ \mathbf{else}:\\ \;\;\;\;\frac{a1}{b1 \cdot \frac{b2}{a2}}\\ \end{array} \]

Alternative 3: 85.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{a2}{b2} \cdot \frac{a1}{b1} \end{array} \]

FPCore

(FPCore (a1 a2 b1 b2) :precision binary64 (* (/ a2 b2) (/ a1 b1)))

C

double code(double a1, double a2, double b1, double b2) {
	return (a2 / b2) * (a1 / b1);
}

Fortran

real(8) function code(a1, a2, b1, b2)
    real(8), intent (in) :: a1
    real(8), intent (in) :: a2
    real(8), intent (in) :: b1
    real(8), intent (in) :: b2
    code = (a2 / b2) * (a1 / b1)
end function

Java

public static double code(double a1, double a2, double b1, double b2) {
	return (a2 / b2) * (a1 / b1);
}

Python

def code(a1, a2, b1, b2):
	return (a2 / b2) * (a1 / b1)

Julia

function code(a1, a2, b1, b2)
	return Float64(Float64(a2 / b2) * Float64(a1 / b1))
end

MATLAB

function tmp = code(a1, a2, b1, b2)
	tmp = (a2 / b2) * (a1 / b1);
end

Wolfram

code[a1_, a2_, b1_, b2_] := N[(N[(a2 / b2), $MachinePrecision] * N[(a1 / b1), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 86.4%

   \[\frac{a1 \cdot a2}{b1 \cdot b2} \]
2. Step-by-step derivation

   1. times-frac 88.5%

      \[\leadsto \color{blue}{\frac{a1}{b1} \cdot \frac{a2}{b2}} \]

   2. *-commutative 88.5%

      \[\leadsto \color{blue}{\frac{a2}{b2} \cdot \frac{a1}{b1}} \]

3. Simplified 88.5%

   \[\leadsto \color{blue}{\frac{a2}{b2} \cdot \frac{a1}{b1}} \]

4. Final simplification 88.5%

   \[\leadsto \frac{a2}{b2} \cdot \frac{a1}{b1} \]

Alternative 4: 85.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{a1}{b1 \cdot \frac{b2}{a2}} \end{array} \]

FPCore

(FPCore (a1 a2 b1 b2) :precision binary64 (/ a1 (* b1 (/ b2 a2))))

C

double code(double a1, double a2, double b1, double b2) {
	return a1 / (b1 * (b2 / a2));
}

Fortran

real(8) function code(a1, a2, b1, b2)
    real(8), intent (in) :: a1
    real(8), intent (in) :: a2
    real(8), intent (in) :: b1
    real(8), intent (in) :: b2
    code = a1 / (b1 * (b2 / a2))
end function

Java

public static double code(double a1, double a2, double b1, double b2) {
	return a1 / (b1 * (b2 / a2));
}

Python

def code(a1, a2, b1, b2):
	return a1 / (b1 * (b2 / a2))

Julia

function code(a1, a2, b1, b2)
	return Float64(a1 / Float64(b1 * Float64(b2 / a2)))
end

MATLAB

function tmp = code(a1, a2, b1, b2)
	tmp = a1 / (b1 * (b2 / a2));
end

Wolfram

code[a1_, a2_, b1_, b2_] := N[(a1 / N[(b1 * N[(b2 / a2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 86.4%

   \[\frac{a1 \cdot a2}{b1 \cdot b2} \]
2. Step-by-step derivation

   1. times-frac 88.5%

      \[\leadsto \color{blue}{\frac{a1}{b1} \cdot \frac{a2}{b2}} \]

   2. *-commutative 88.5%

      \[\leadsto \color{blue}{\frac{a2}{b2} \cdot \frac{a1}{b1}} \]

3. Simplified 88.5%

   \[\leadsto \color{blue}{\frac{a2}{b2} \cdot \frac{a1}{b1}} \]
4. Step-by-step derivation

   1. clear-num 88.2%

      \[\leadsto \color{blue}{\frac{1}{\frac{b2}{a2}}} \cdot \frac{a1}{b1} \]

   2. frac-times 88.7%

      \[\leadsto \color{blue}{\frac{1 \cdot a1}{\frac{b2}{a2} \cdot b1}} \]

   3. *-un-lft-identity 88.7%

      \[\leadsto \frac{\color{blue}{a1}}{\frac{b2}{a2} \cdot b1} \]

5. Applied egg-rr 88.7%

   \[\leadsto \color{blue}{\frac{a1}{\frac{b2}{a2} \cdot b1}} \]

6. Final simplification 88.7%

   \[\leadsto \frac{a1}{b1 \cdot \frac{b2}{a2}} \]

Alternative 5: 86.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{a2}{\frac{b1}{a1} \cdot b2} \end{array} \]

FPCore

(FPCore (a1 a2 b1 b2) :precision binary64 (/ a2 (* (/ b1 a1) b2)))

C

double code(double a1, double a2, double b1, double b2) {
	return a2 / ((b1 / a1) * b2);
}

Fortran

real(8) function code(a1, a2, b1, b2)
    real(8), intent (in) :: a1
    real(8), intent (in) :: a2
    real(8), intent (in) :: b1
    real(8), intent (in) :: b2
    code = a2 / ((b1 / a1) * b2)
end function

Java

public static double code(double a1, double a2, double b1, double b2) {
	return a2 / ((b1 / a1) * b2);
}

Python

def code(a1, a2, b1, b2):
	return a2 / ((b1 / a1) * b2)

Julia

function code(a1, a2, b1, b2)
	return Float64(a2 / Float64(Float64(b1 / a1) * b2))
end

MATLAB

function tmp = code(a1, a2, b1, b2)
	tmp = a2 / ((b1 / a1) * b2);
end

Wolfram

code[a1_, a2_, b1_, b2_] := N[(a2 / N[(N[(b1 / a1), $MachinePrecision] * b2), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 86.4%

   \[\frac{a1 \cdot a2}{b1 \cdot b2} \]
2. Step-by-step derivation

   1. times-frac 88.5%

      \[\leadsto \color{blue}{\frac{a1}{b1} \cdot \frac{a2}{b2}} \]

   2. *-commutative 88.5%

      \[\leadsto \color{blue}{\frac{a2}{b2} \cdot \frac{a1}{b1}} \]

3. Simplified 88.5%

   \[\leadsto \color{blue}{\frac{a2}{b2} \cdot \frac{a1}{b1}} \]
4. Step-by-step derivation

   1. *-commutative 88.5%

      \[\leadsto \color{blue}{\frac{a1}{b1} \cdot \frac{a2}{b2}} \]

   2. clear-num 88.2%

      \[\leadsto \color{blue}{\frac{1}{\frac{b1}{a1}}} \cdot \frac{a2}{b2} \]

   3. frac-times 90.5%

      \[\leadsto \color{blue}{\frac{1 \cdot a2}{\frac{b1}{a1} \cdot b2}} \]

   4. *-un-lft-identity 90.5%

      \[\leadsto \frac{\color{blue}{a2}}{\frac{b1}{a1} \cdot b2} \]

5. Applied egg-rr 90.5%

   \[\leadsto \color{blue}{\frac{a2}{\frac{b1}{a1} \cdot b2}} \]

6. Final simplification 90.5%

   \[\leadsto \frac{a2}{\frac{b1}{a1} \cdot b2} \]

Developer target: 85.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{a1}{b1} \cdot \frac{a2}{b2} \end{array} \]

FPCore

(FPCore (a1 a2 b1 b2) :precision binary64 (* (/ a1 b1) (/ a2 b2)))

C

double code(double a1, double a2, double b1, double b2) {
	return (a1 / b1) * (a2 / b2);
}

Fortran

real(8) function code(a1, a2, b1, b2)
    real(8), intent (in) :: a1
    real(8), intent (in) :: a2
    real(8), intent (in) :: b1
    real(8), intent (in) :: b2
    code = (a1 / b1) * (a2 / b2)
end function

Java

public static double code(double a1, double a2, double b1, double b2) {
	return (a1 / b1) * (a2 / b2);
}

Python

def code(a1, a2, b1, b2):
	return (a1 / b1) * (a2 / b2)

Julia

function code(a1, a2, b1, b2)
	return Float64(Float64(a1 / b1) * Float64(a2 / b2))
end

MATLAB

function tmp = code(a1, a2, b1, b2)
	tmp = (a1 / b1) * (a2 / b2);
end

Wolfram

code[a1_, a2_, b1_, b2_] := N[(N[(a1 / b1), $MachinePrecision] * N[(a2 / b2), $MachinePrecision]), $MachinePrecision]

Reproduce

herbie shell --seed 2023293 
(FPCore (a1 a2 b1 b2)
  :name "Quotient of products"
  :precision binary64

  :herbie-target
  (* (/ a1 b1) (/ a2 b2))

  (/ (* a1 a2) (* b1 b2)))