I'm using a "programming language" that only allows basic operations: addition, subtraction, multiplication, and division.
Is it possible to emulate a floor function (i.e. drop the decimals a number) by using only those operators? I'm only interested in positive numbers
Edit: This is a mathematics forum so avoid answers that are specific to CSS, especially since it now has a native round() function.
Let $$f_1(x)=x+c_1$$ $$f_2(x)=x\cdot c_2$$ where $c_1,c_2$ are some constants, and $f_1$ represents addition and subtraction, and $f_2$ represents multiplication and division. Functions $f_1$ and $f_2$ have inverse function, but $\lfloor{x}\rfloor$ does not have an inverse function. So, if we assume it is possible to find $\lfloor{x}\rfloor$ from $x$ using $f_1$ and $f_2$, then it is possible to find $x$ from $\lfloor{x}\rfloor$. Contradiction.
The floor function has jump discontinuities.
A function obtained with elementary arithmetic is a rational function and those can only have pole (or infinite) discontinuities.
Yes it is possible, but depends on the available arithmetic and the rounding mode. With IEEE-double you can round a double $x$ to the nearest integer with this:
$c=2^{52};$
$x = x + c; \mathrm{round} = x - c$ for $x\ge 0\;$ and
$x = x - c; \mathrm{round} = x + c$ for $x<0.$
With the rounding to the next integer you can implement floor.
calc(2.9999px + 9007199254740992px - 9007199254740992px) actually produces 2px in Chrome ($c=2^{53}$)! As @hvd said this is likely to depend on the implementation but I can run some tests. Worst case scenario I cause the browser to crash /s
$\endgroup$
If you can use a loop and extra variables, you can repeatedly subtract one until left with only the decimal part.
Something like:
floor(x):
floor = 0
While x >= 1
floor += 1
x -= 1
End While
Not the greatest, and will take a long time for large numbers, but it could be tweaked.
It also won't work for negative values, but that's easily fixed.
You can do integer division using complex arithmetic, but there's a different function for each divisor. For example,
$$\left\lfloor \frac{x}{2} \right\rfloor = \frac{x}{2} - \frac{1 - (-1)^x}{4} $$
for $x$ an integer. For higher $k$ you'll use $k$th roots of unity.
For overkill, if you also have sine you can use the Fourier expansion:
$$\lfloor x \rfloor = x- \frac{1}{2} + \frac{1}{\pi} \sum_{k=1}^{\infty} \frac{\sin 2 \pi k x}{k}$$
(except when $x$ is already an integer, I think). If you don't have sine you can build that up using a Taylor's series. Also $\pi$.
Programming languages typically use floating-point arithmetic defined by the IEEE 754 standard. Roughly speaking, if the exact result of an operation calculated using mathematical real arithmetic has an absolute value $2^k ≤ x < 2^{k+1}$, then x will be rounded to the nearest integer multiple of $2^{k-52}$. The exception is the case where x is exactly between the two nearest integer multiples of $2^{k-52}$, in which case x will be rounded to the even multiple.
If the absolute value x is between $2^{52} ≤ x < 2^{53}$, then x will be rounded to the nearest integer or the nearest even integer if x is exactly between two integers. Any floating-point numbers with an absolute value $x ≥ 2^{52}$ are actually integers. And any floating-point operation where the exact result is an integer with $-2^{53} ≤ x ≤ 2^{53}$ will give the exact result.
This gives a simple implementation: If the absolute value of x is $2^{52}$ or greater then x is an integer and floor (x) = x. Otherwise; first add then subtract $2^{52}$ from x if x >= 0, but first subtract then add $2^{52}$ to x if x < 0. This rounds x to one of the two nearest integers. If the result is greater than the original value of x, subtract 1.
I think this is quite close to the implementation that is typically used by current compilers.
try modulo 1 : x=x-(x mod 1) It works with both + and - numbers.
mod is not among the available operations
$\endgroup$
I know I'm a little late to this party but thought it was worth noting that given a basic round function you can find the floor by doing round(x - .5)
round() is not among the available operations
$\endgroup$
Depending on how the limitations of your code you can use the below function:
$f(x)=x-\frac{\sin(2\pi x)}{x}$
by using the Taylor expansion of sine and expansions for pi.
Applying the function with itself under composition (with initial input $x-\frac{1}{2}$) makes it converge quickly to the floor function. You just have to apply it enough times for the computer itself to round it (assuming it doesn't do arbitrary precision).
floor,ceiland many more besides. $\endgroup$