1/256 sin(-2 PI n k / 256) (-sin(n/256 (2 PI) + 2 PI))

(FPCore (n k)
  :precision binary64
  (*
 (/ 1.0 256.0)
 (*
  (sin (* (- 2.0) (* PI (* n (/ k 256.0)))))
  (- (sin (+ (* (/ n 256.0) (* 2.0 PI)) (* 2.0 PI)))))))

double code(double n, double k) {
	return (1.0 / 256.0) * (sin((-2.0 * (((double) M_PI) * (n * (k / 256.0))))) * -sin((((n / 256.0) * (2.0 * ((double) M_PI))) + (2.0 * ((double) M_PI)))));
}

public static double code(double n, double k) {
	return (1.0 / 256.0) * (Math.sin((-2.0 * (Math.PI * (n * (k / 256.0))))) * -Math.sin((((n / 256.0) * (2.0 * Math.PI)) + (2.0 * Math.PI))));
}

def code(n, k):
	return (1.0 / 256.0) * (math.sin((-2.0 * (math.pi * (n * (k / 256.0))))) * -math.sin((((n / 256.0) * (2.0 * math.pi)) + (2.0 * math.pi))))

function code(n, k)
	return Float64(Float64(1.0 / 256.0) * Float64(sin(Float64(Float64(-2.0) * Float64(pi * Float64(n * Float64(k / 256.0))))) * Float64(-sin(Float64(Float64(Float64(n / 256.0) * Float64(2.0 * pi)) + Float64(2.0 * pi))))))
end

function tmp = code(n, k)
	tmp = (1.0 / 256.0) * (sin((-2.0 * (pi * (n * (k / 256.0))))) * -sin((((n / 256.0) * (2.0 * pi)) + (2.0 * pi))));
end

code[n_, k_] := N[(N[(1.0 / 256.0), $MachinePrecision] * N[(N[Sin[N[((-2.0) * N[(Pi * N[(n * N[(k / 256.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * (-N[Sin[N[(N[(N[(n / 256.0), $MachinePrecision] * N[(2.0 * Pi), $MachinePrecision]), $MachinePrecision] + N[(2.0 * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision])), $MachinePrecision]), $MachinePrecision]

\frac{1}{256} \cdot \left(\sin \left(\left(-2\right) \cdot \left(\pi \cdot \left(n \cdot \frac{k}{256}\right)\right)\right) \cdot \left(-\sin \left(\frac{n}{256} \cdot \left(2 \cdot \pi\right) + 2 \cdot \pi\right)\right)\right)

(FPCore (n k)
  :precision binary64
  (* (* (* 3.0517578125e-5 k) (* (sin (* (* 0.0078125 n) PI)) PI)) n))

double code(double n, double k) {
	return ((3.0517578125e-5 * k) * (sin(((0.0078125 * n) * ((double) M_PI))) * ((double) M_PI))) * n;
}

public static double code(double n, double k) {
	return ((3.0517578125e-5 * k) * (Math.sin(((0.0078125 * n) * Math.PI)) * Math.PI)) * n;
}

def code(n, k):
	return ((3.0517578125e-5 * k) * (math.sin(((0.0078125 * n) * math.pi)) * math.pi)) * n

function code(n, k)
	return Float64(Float64(Float64(3.0517578125e-5 * k) * Float64(sin(Float64(Float64(0.0078125 * n) * pi)) * pi)) * n)
end

function tmp = code(n, k)
	tmp = ((3.0517578125e-5 * k) * (sin(((0.0078125 * n) * pi)) * pi)) * n;
end

code[n_, k_] := N[(N[(N[(3.0517578125e-5 * k), $MachinePrecision] * N[(N[Sin[N[(N[(0.0078125 * n), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision] * n), $MachinePrecision]

\left(\left(3.0517578125 \cdot 10^{-5} \cdot k\right) \cdot \left(\sin \left(\left(0.0078125 \cdot n\right) \cdot \pi\right) \cdot \pi\right)\right) \cdot n

(FPCore (n k)
  :precision binary64
  (* (* (* 3.0517578125e-5 k) PI) (* (sin (* (* PI n) 0.0078125)) n)))

double code(double n, double k) {
	return ((3.0517578125e-5 * k) * ((double) M_PI)) * (sin(((((double) M_PI) * n) * 0.0078125)) * n);
}

public static double code(double n, double k) {
	return ((3.0517578125e-5 * k) * Math.PI) * (Math.sin(((Math.PI * n) * 0.0078125)) * n);
}

def code(n, k):
	return ((3.0517578125e-5 * k) * math.pi) * (math.sin(((math.pi * n) * 0.0078125)) * n)

function code(n, k)
	return Float64(Float64(Float64(3.0517578125e-5 * k) * pi) * Float64(sin(Float64(Float64(pi * n) * 0.0078125)) * n))
end

function tmp = code(n, k)
	tmp = ((3.0517578125e-5 * k) * pi) * (sin(((pi * n) * 0.0078125)) * n);
end

code[n_, k_] := N[(N[(N[(3.0517578125e-5 * k), $MachinePrecision] * Pi), $MachinePrecision] * N[(N[Sin[N[(N[(Pi * n), $MachinePrecision] * 0.0078125), $MachinePrecision]], $MachinePrecision] * n), $MachinePrecision]), $MachinePrecision]

\left(\left(3.0517578125 \cdot 10^{-5} \cdot k\right) \cdot \pi\right) \cdot \left(\sin \left(\left(\pi \cdot n\right) \cdot 0.0078125\right) \cdot n\right)

(FPCore (n k)
  :precision binary64
  (* 3.0517578125e-5 (* (* (* k n) (sin (* (* 0.0078125 n) PI))) PI)))

double code(double n, double k) {
	return 3.0517578125e-5 * (((k * n) * sin(((0.0078125 * n) * ((double) M_PI)))) * ((double) M_PI));
}

public static double code(double n, double k) {
	return 3.0517578125e-5 * (((k * n) * Math.sin(((0.0078125 * n) * Math.PI))) * Math.PI);
}

def code(n, k):
	return 3.0517578125e-5 * (((k * n) * math.sin(((0.0078125 * n) * math.pi))) * math.pi)

function code(n, k)
	return Float64(3.0517578125e-5 * Float64(Float64(Float64(k * n) * sin(Float64(Float64(0.0078125 * n) * pi))) * pi))
end

function tmp = code(n, k)
	tmp = 3.0517578125e-5 * (((k * n) * sin(((0.0078125 * n) * pi))) * pi);
end

code[n_, k_] := N[(3.0517578125e-5 * N[(N[(N[(k * n), $MachinePrecision] * N[Sin[N[(N[(0.0078125 * n), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]

3.0517578125 \cdot 10^{-5} \cdot \left(\left(\left(k \cdot n\right) \cdot \sin \left(\left(0.0078125 \cdot n\right) \cdot \pi\right)\right) \cdot \pi\right)

(FPCore (n k)
  :precision binary64
  (* 3.0517578125e-5 (* k (* n (* PI (sin (* 0.0078125 (* n PI))))))))

double code(double n, double k) {
	return 3.0517578125e-5 * (k * (n * (((double) M_PI) * sin((0.0078125 * (n * ((double) M_PI)))))));
}

public static double code(double n, double k) {
	return 3.0517578125e-5 * (k * (n * (Math.PI * Math.sin((0.0078125 * (n * Math.PI))))));
}

def code(n, k):
	return 3.0517578125e-5 * (k * (n * (math.pi * math.sin((0.0078125 * (n * math.pi))))))

function code(n, k)
	return Float64(3.0517578125e-5 * Float64(k * Float64(n * Float64(pi * sin(Float64(0.0078125 * Float64(n * pi)))))))
end

function tmp = code(n, k)
	tmp = 3.0517578125e-5 * (k * (n * (pi * sin((0.0078125 * (n * pi))))));
end

code[n_, k_] := N[(3.0517578125e-5 * N[(k * N[(n * N[(Pi * N[Sin[N[(0.0078125 * N[(n * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

3.0517578125 \cdot 10^{-5} \cdot \left(k \cdot \left(n \cdot \left(\pi \cdot \sin \left(0.0078125 \cdot \left(n \cdot \pi\right)\right)\right)\right)\right)

(FPCore (n k)
  :precision binary64
  (* (* (* PI PI) n) (* n (* 2.384185791015625e-7 k))))

double code(double n, double k) {
	return ((((double) M_PI) * ((double) M_PI)) * n) * (n * (2.384185791015625e-7 * k));
}

public static double code(double n, double k) {
	return ((Math.PI * Math.PI) * n) * (n * (2.384185791015625e-7 * k));
}

def code(n, k):
	return ((math.pi * math.pi) * n) * (n * (2.384185791015625e-7 * k))

function code(n, k)
	return Float64(Float64(Float64(pi * pi) * n) * Float64(n * Float64(2.384185791015625e-7 * k)))
end

function tmp = code(n, k)
	tmp = ((pi * pi) * n) * (n * (2.384185791015625e-7 * k));
end

code[n_, k_] := N[(N[(N[(Pi * Pi), $MachinePrecision] * n), $MachinePrecision] * N[(n * N[(2.384185791015625e-7 * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

\left(\left(\pi \cdot \pi\right) \cdot n\right) \cdot \left(n \cdot \left(2.384185791015625 \cdot 10^{-7} \cdot k\right)\right)

(FPCore (n k)
  :precision binary64
  (* 2.384185791015625e-7 (* n (* n (* (* PI PI) k)))))

double code(double n, double k) {
	return 2.384185791015625e-7 * (n * (n * ((((double) M_PI) * ((double) M_PI)) * k)));
}

public static double code(double n, double k) {
	return 2.384185791015625e-7 * (n * (n * ((Math.PI * Math.PI) * k)));
}

def code(n, k):
	return 2.384185791015625e-7 * (n * (n * ((math.pi * math.pi) * k)))

function code(n, k)
	return Float64(2.384185791015625e-7 * Float64(n * Float64(n * Float64(Float64(pi * pi) * k))))
end

function tmp = code(n, k)
	tmp = 2.384185791015625e-7 * (n * (n * ((pi * pi) * k)));
end

code[n_, k_] := N[(2.384185791015625e-7 * N[(n * N[(n * N[(N[(Pi * Pi), $MachinePrecision] * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

2.384185791015625 \cdot 10^{-7} \cdot \left(n \cdot \left(n \cdot \left(\left(\pi \cdot \pi\right) \cdot k\right)\right)\right)

(FPCore (n k)
  :precision binary64
  (* 2.384185791015625e-7 (* k (* (* PI n) (* PI n)))))

double code(double n, double k) {
	return 2.384185791015625e-7 * (k * ((((double) M_PI) * n) * (((double) M_PI) * n)));
}

public static double code(double n, double k) {
	return 2.384185791015625e-7 * (k * ((Math.PI * n) * (Math.PI * n)));
}

def code(n, k):
	return 2.384185791015625e-7 * (k * ((math.pi * n) * (math.pi * n)))

function code(n, k)
	return Float64(2.384185791015625e-7 * Float64(k * Float64(Float64(pi * n) * Float64(pi * n))))
end

function tmp = code(n, k)
	tmp = 2.384185791015625e-7 * (k * ((pi * n) * (pi * n)));
end

code[n_, k_] := N[(2.384185791015625e-7 * N[(k * N[(N[(Pi * n), $MachinePrecision] * N[(Pi * n), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

2.384185791015625 \cdot 10^{-7} \cdot \left(k \cdot \left(\left(\pi \cdot n\right) \cdot \left(\pi \cdot n\right)\right)\right)

(FPCore (n k)
  :precision binary64
  0.0)

double code(double n, double k) {
	return 0.0;
}

real(8) function code(n, k)
    real(8), intent (in) :: n
    real(8), intent (in) :: k
    code = 0.0d0
end function

public static double code(double n, double k) {
	return 0.0;
}

def code(n, k):
	return 0.0

function code(n, k)
	return 0.0
end

function tmp = code(n, k)
	tmp = 0.0;
end

code[n_, k_] := 0.0

0