x / sqrt(1 + pow(x, 2))

(FPCore (x) :precision binary64 (/ x (sqrt (+ 1.0 (pow x 2.0)))))

double code(double x) {
	return x / sqrt((1.0 + pow(x, 2.0)));
}

real(8) function code(x)
    real(8), intent (in) :: x
    code = x / sqrt((1.0d0 + (x ** 2.0d0)))
end function

public static double code(double x) {
	return x / Math.sqrt((1.0 + Math.pow(x, 2.0)));
}

def code(x):
	return x / math.sqrt((1.0 + math.pow(x, 2.0)))

function code(x)
	return Float64(x / sqrt(Float64(1.0 + (x ^ 2.0))))
end

function tmp = code(x)
	tmp = x / sqrt((1.0 + (x ^ 2.0)));
end

code[x_] := N[(x / N[Sqrt[N[(1.0 + N[Power[x, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

\begin{array}{l}

\\
\frac{x}{\sqrt{1 + {x}^{2}}}
\end{array}

(FPCore (x) :precision binary64 (sqrt (* (/ x (fma x x 1.0)) x)))

double code(double x) {
	return sqrt(((x / fma(x, x, 1.0)) * x));
}

function code(x)
	return sqrt(Float64(Float64(x / fma(x, x, 1.0)) * x))
end

code[x_] := N[Sqrt[N[(N[(x / N[(x * x + 1.0), $MachinePrecision]), $MachinePrecision] * x), $MachinePrecision]], $MachinePrecision]

\begin{array}{l}

\\
\sqrt{\frac{x}{\mathsf{fma}\left(x, x, 1\right)} \cdot x}
\end{array}

(FPCore (x) :precision binary64 (/ x (sqrt (fma x x 1.0))))

double code(double x) {
	return x / sqrt(fma(x, x, 1.0));
}

function code(x)
	return Float64(x / sqrt(fma(x, x, 1.0)))
end

code[x_] := N[(x / N[Sqrt[N[(x * x + 1.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]

\begin{array}{l}

\\
\frac{x}{\sqrt{\mathsf{fma}\left(x, x, 1\right)}}
\end{array}

(FPCore (x) :precision binary64 (/ x (- x (/ -0.5 x))))

double code(double x) {
	return x / (x - (-0.5 / x));
}

real(8) function code(x)
    real(8), intent (in) :: x
    code = x / (x - ((-0.5d0) / x))
end function

public static double code(double x) {
	return x / (x - (-0.5 / x));
}

def code(x):
	return x / (x - (-0.5 / x))

function code(x)
	return Float64(x / Float64(x - Float64(-0.5 / x)))
end

function tmp = code(x)
	tmp = x / (x - (-0.5 / x));
end

code[x_] := N[(x / N[(x - N[(-0.5 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

\begin{array}{l}

\\
\frac{x}{x - \frac{-0.5}{x}}
\end{array}

(FPCore (x) :precision binary64 (- 1.0 (/ 0.5 (* x x))))

double code(double x) {
	return 1.0 - (0.5 / (x * x));
}

real(8) function code(x)
    real(8), intent (in) :: x
    code = 1.0d0 - (0.5d0 / (x * x))
end function

public static double code(double x) {
	return 1.0 - (0.5 / (x * x));
}

def code(x):
	return 1.0 - (0.5 / (x * x))

function code(x)
	return Float64(1.0 - Float64(0.5 / Float64(x * x)))
end

function tmp = code(x)
	tmp = 1.0 - (0.5 / (x * x));
end

code[x_] := N[(1.0 - N[(0.5 / N[(x * x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

\begin{array}{l}

\\
1 - \frac{0.5}{x \cdot x}
\end{array}

(FPCore (x) :precision binary64 (* (/ -1.0 x) (- x)))

double code(double x) {
	return (-1.0 / x) * -x;
}

real(8) function code(x)
    real(8), intent (in) :: x
    code = ((-1.0d0) / x) * -x
end function

public static double code(double x) {
	return (-1.0 / x) * -x;
}

def code(x):
	return (-1.0 / x) * -x

function code(x)
	return Float64(Float64(-1.0 / x) * Float64(-x))
end

function tmp = code(x)
	tmp = (-1.0 / x) * -x;
end

code[x_] := N[(N[(-1.0 / x), $MachinePrecision] * (-x)), $MachinePrecision]

\begin{array}{l}

\\
\frac{-1}{x} \cdot \left(-x\right)
\end{array}

(FPCore (x) :precision binary64 (* -1.0 (- x)))

double code(double x) {
	return -1.0 * -x;
}

real(8) function code(x)
    real(8), intent (in) :: x
    code = (-1.0d0) * -x
end function

public static double code(double x) {
	return -1.0 * -x;
}

def code(x):
	return -1.0 * -x

function code(x)
	return Float64(-1.0 * Float64(-x))
end

function tmp = code(x)
	tmp = -1.0 * -x;
end

code[x_] := N[(-1.0 * (-x)), $MachinePrecision]

\begin{array}{l}

\\
-1 \cdot \left(-x\right)
\end{array}

(FPCore (x) :precision binary64 -1.0)

double code(double x) {
	return -1.0;
}

real(8) function code(x)
    real(8), intent (in) :: x
    code = -1.0d0
end function

public static double code(double x) {
	return -1.0;
}

def code(x):
	return -1.0

function code(x)
	return -1.0
end

function tmp = code(x)
	tmp = -1.0;
end

code[x_] := -1.0

\begin{array}{l}

\\
-1
\end{array}