Test integerness: Difference between revisions

 

<hr>

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release 2.8.3.win32}}

Uses LONG LONG values which in Algol 68 have a programmer specifiable number of digits. As with the C version, we need only handle the complex case directly, as Algol 68 will automatically coerce integer and real values to complex as required.

# "PR precision n PR" if required #

PR precision 24 PR

test is int( 4.0 I 0 );

test is int( 123456789012345678901234 )

{{out}}

<pre>

+1.2345678901234567890123400000000000e +23_+0.0000000000000000000000000000000000e +0 is integral

</pre>

 

=={{header|C}}==

The main function that checks a numeric value is actually quite short. Because of C's weak types and implicit casting we can get away with making a function which checks long double complex types only.

 

#include <stdio.h>

#include <complex.h>

printf("Test 4 (0+1.2i) = %s\n", isint(test4) ? "true" : "false");

}

 

{{out}}

</pre>

 

 

 

 

 

namespace Test_integerness

{

}

 

{{out| Program Input and Output :}}

<pre>

Another test < Y /N > . . .

 

</pre>

 

=={{header|COBOL}}==

COBOL likes to work with fixed-point decimal numbers. For the sake of argument, this program tests the "integerness" of values that have up to nine digits before the decimal point and up to nine digits after. It can therefore be "tricked", as in the third of the four tests below, by computing a result that differs from an integer by less than 0.000000001; if there is any likelihood of such results arising, it would be a good idea to allow more digits of precision after the decimal point. Support for complex numbers (in a sense) is included, because the specification calls for it—but it adds little of interest.

PROGRAM-ID. INTEGERNESS-PROGRAM.

DATA DIVISION.

ELSE DISPLAY POSSIBLE-INTEGER ' IS NOT AN INTEGER.'.

COMPLEX-PARAGRAPH.

{{out}}

<pre>-000000004.000000000 IS AN INTEGER.

 

=={{header|D}}==

import std.math;

import std.meta;

 

assert(isInteger(0.00009i, 0.0001));

 

{{out}}

Is 5+0i an integer? true

Is 5-5i an integer? false</pre>

 

=={{header|Elixir}}==

def integer?(n) when n == trunc(n), do: true

def integer?(_), do: false

Enum.each([2, 2.0, 2.5, 2.000000000000001, 1.23e300, 1.0e-300, "123", '123', :"123"], fn n ->

IO.puts "#{inspect n} is integer?: #{Test.integer?(n)}"

 

{{out}}

:"123" is integer?: false

</pre>

=={{header|Fortran}}==

===Straightforward===

 

The MODULE protocol of F90 is used, merely to save on the need to define the types of the function in each routine that uses them, since there is no default type for LOGICAL. Otherwise, this is F77 style.

CONTAINS

LOGICAL FUNCTION ISINTEGRAL(X) !A whole number?

Z = DCMPLX(-3D0,4*ATAN(1D0))

WRITE (6,*) ISINTEGRALZ(Z),Z

<pre>

See if some numbers are integral...

The argument is the same with binary (or base 4, 8 or 16), but, you have to know what base is used to prepare the proper boundary value, similarly you must ascertain just how many digits of precision are in use, remembering that in binary the leading one of normalised numbers may be represented implicitly, or it may be explicitly present. One would have to devise probing routines with delicate calculations that may be disrupted by various compiler optimisation tricks and unanticipated details of the arithmetic mill. For instance, the Intel 8087 floating-point co-processor and its descendants use an implicit leading-one bit for 32- and 64-bit floating-point numbers, but ''not'' for 80-bit floating-point numbers. So if your compiler offers a REAL*10 type, such variables will enjoy a slightly different style of arithmetic. Further, ''during'' a calculation (add, subtract, multiply, divide) a further three guard bits (with special meanings) are employed. Calculations are done with full 83-bit precision to yield an 80-bit result; it is only when values are stored that they are converted to single or double precision format in storage - the register retains full precision. On top of that, the arithmetic can employ "denormalised" numbers during underflow towards zero. Chapter 6 of ''The I8087 Numeric Data Processor'', page 219, remarks "At least some of the generalised numerical solutions to common mathematical procedures have coding that is so involved and tricky in order to take care of all possible roundoff contingencies that they have been termed 'pornographic algorithms'". So a probe routine that worked for one design will likely need tweaking when tried on another system.

 

10 X = X*BASE

Y = X + 1

D = Y - X

Or alternatively, compare 1 + ''eps'' to 1, successively dividing ''eps'' by BASE.

 

 

Despite the attempt at generality, there will be difficulties on systems whose word sizes are not multiples of eight bits so that the REAL*4 scheme falters. Still, it is preferable to a blizzard of terms such as small int, int, long int, long long int. A decimal computer would be quite different in its size specifications, and there have been rumours of a Russian computer that worked in base three...

MODULE ZERMELO !Approach the foundations of mathematics.

INTERFACE ISINTEGRAL !And obscure them with computerese.

WRITE (6,*) ISINTEGRAL(Z),Z

END

 

<pre>

F (-3.00000000000000,3.14159265358979)

</pre>

 

=={{header|Go}}==

 

import (

show("12345/5")

show(new(customIntegerType))

{{out}}

<pre>

 

Some imports for additional number types

import Data.Ratio

 

Haskell is statically typed, so in order to get universal integerness test we define a class of numbers, which may contain integers:

 

Laws for this class are simple:

 

Integral numbers:

 

Real fractional numbers:

isIntegerF x = x == fromInteger (truncate x)

 

instance ContainsInteger Double where isInteger = isIntegerF

instance Integral i => ContainsInteger (DecimalRaw i) where isInteger = isIntegerF

 

Complex numbers:

 

'''Extra credit'''

 

Approximate integerness for fractional numbers:

 

almostInteger :: RealFrac a => a -> a -> Bool

 

almostIntegerC :: RealFrac a => a -> Complex a -> Bool

 

'''Testing'''

[ isInteger (5 :: Integer)

, isInteger (5.0 :: Decimal)

, not $ almostInteger 0.01 2.02

, almostIntegerC 0.001 (5.999999 :+ 0.000001)

 

'''Possible use'''

Effective definition of Pithagorean triangles:

 

pithagoreanTriangles =

[ [a, b, round c] | b <- [1..]

, a <- [1..b]

, let c = sqrt (fromInteger (a^2 + b^2))

<pre>λ> take 7 pithagoreanTriangles

[[3,4,5],[6,8,10],[5,12,13],[9,12,15],[8,15,17],[12,16,20],[15,20,25]]

 

=={{header|J}}==

 

=={{header|Java}}==

{{trans|Kotlin}}

import java.util.List;

 

}

}

{{out}}

<pre>25.000000 is an integer

we shall also identify the rational numbers p/q with JSON objects that have the form:

{"type": "rational", "p": p, "q": q}.

if type == "number" then . == floor

elif type == "array" then

and (.q | is_integral)

and ((.p / .q) | is_integral)

'''Example''':

0, -1, [3,0], {"p": 4, "q": 2, "type": "rational"},

1.1, -1.1, [3,1], {"p": 5, "q": 2, "type": "rational"}

{{out}}

0 => integral

-1 => integral

-1.1 =>

[3,1] =>

 

=={{header|Julia}}==

 

@show isinteger(25.000000)

@show isinteger(complex(5.0, 0.0))

@show isinteger(complex(5, 5))

 

{{out}}

=={{header|Kotlin}}==

As Kotlin doesn't have built in rational or complex number classes, we create 'bare bones' classes for the purposes of this task:

 

import java.math.BigInteger

println("$r is ${if (exact) "an" else "not an"} integer")

}

 

{{out}}

 

=={{header|Lua}}==

 

print("Value\tInteger?")

print("=====\t========")

local testCases = {2, 0, -1, 3.5, "String!", true}

{{out}}

<pre>Value Integer?

String! false

true false</pre>

 

=={{header|ooRexx}}==

* 22.06.2014 Walter Pachl using a complex data class

* ooRexx Distribution contains an elaborate complex class

* parts of which are used here

*--------------------------------------------------------------------*/

Numeric Digits 1000

::method string /* format as a string value */

expose real imaginary /* get the state info */

'''output'''

<pre>1E+12+0i is an integer

3+0i is an integer</pre>

 

=={{header|PARI/GP}}==

 

The operator <code>==</code> does what we want here, comparing a number mathematically regardless of how it's stored. <code>===</code> checks literal equivalence instead.

 

{{out}}

<pre>%1 = [1, 1, 0, 1, 1]</pre>

=={{header|Perl}}==

 

 

sub is_int {

for (5, 4.1, sqrt(2), sqrt(4), 1.1e10, 3.0-0.0*i, 4-3*i, 5.6+0*i) {

printf "%20s is%s an integer\n", $_, (is_int($_) ? "" : " NOT");

 

{{out}}

</pre>

 

 

 

 

 

 

 

 

 

By default the inverted precision of round is 1, and that does exactly what you'd expect.

Technically though, -2.1e120 is way past precision limits, as next, so declaring it integer is deeply flawed...

It is not only way too big to fit in an integer, but also simply too big to actually have a fractional part.

Obviously using bigatoms would "solve" this, as long as I was prepared to wait for it to wade through the 120+

digits of precision needed, that is compared to the mere 19 or so that the raw physical hardware can manage.

 

=={{header|PicoLisp}}==

Pico Lisp scaled fixed-point numbers. Every number is stored an an Integer and a Non-integer only relative to the scale applied. For this example we assume that all numbers are generated with the same scale. This is the common case.

(de int? (N)

(= N (* 1.0 (/ N 1.0)))) #returns T or NIL

(int? "RE") #-> "RE" -- Number expected

(int? (*/ 2.0 1.0 3.0)) #-> NIL # 6667 is not an integer of the scale of 4, use of */ because of the scale

 

=={{header|PowerShell}}==

function Test-Integer ($Number)

{

}

}

Test-Integer 9

Test-Integer 9.9

Test-Integer (New-Object System.Numerics.Complex(14,56))

Test-Integer "abc"

{{Out}}

<pre>

=={{header|Python}}==

 

return complex(f).imag == 0 and complex(f).real.is_integer()

 

>>> isint(5-5j)

False

 

=={{header|Racket}}==

See [http://docs.racket-lang.org/reference/number-types.html?q=integer%3F#%28def._%28%28quote._~23~25kernel%29._integer~3f%29%29 documentation for <code>integer?</code>]

 

(require tests/eli-tester)

 

(integer? pi) => #f

)

All tests pass.

 

=={{header|REXX}}==

===version 1===

* 20.06.2014 Walter Pachl

* 22.06.2014 WP add complex numbers such as 13-12j etc.

imag=imag_sign||imag_v

 

'''output'''

<pre>3.14 isn't an integer

j is not an integer (imaginary part is not zero)

0003-00.0j is an integer</pre>

 

===version 2===

 

Also, most REXXes have a limit on the minimum/maximum value of the power in exponentiated numbers.

numeric digits 3000 /*be able to handle gihugic integers. */

parse arg #s /*obtain optional numbers list from CL.*/

x= left(x, e+s) /* " " " real " " " */

if isInt(z) then if z\=0 then x=. /*Not imaginary part=0? Not an integer.*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

would be considered an integer &nbsp; (extra blanks were added to show the number with more clarity).

numeric digits 3000 /*be able to handle gihugic integers. */

unaB= '++ -- -+ +-' /*a list of unary operators.*/

x= left(x, e+s) /* " " " real " " " */

if isInt(z) then if z\=0 then x=. /*Not imaginary part=0? Not an integer.*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

 

Testing for integerness of floats, rationals and complex numbers:

class Numeric

def to_i?

ar.each{|num| puts "#{num} integer? #{num.to_i?}" }

{{out}}

<pre>

sash[r7rs]> (integer? 1e120)

#t

</pre>

 

The simplest way is to test whether the value is (numerically) equal to itself cast as an integer. entier() performs this cast without imposing any word-size limits (as int() or wide() would).

 

expr {$x == entier($x)}

}

foreach x {1e100 3.14 7 1.000000000000001 1000000000000000000000 -22.7 -123.000} {

puts [format "%s: %s" $x [expr {[isNumberIntegral $x] ? "yes" : "no"}]]

{{out}}

<pre>

Note that 1.0000000000000001 will pass this integer test, because its difference from 1.0 is beyond the precision of an IEEE binary64 float. This discrepancy will be visible in other languages, but perhaps more obvious in Tcl as such a value's string representation will persist:

 

1.0000000000000001

% expr $a

1

% puts $a

 

compare Python:

 

>>> a

1.0

>>> 1.0 == 1.0000000000000001

 

.. this is a fairly benign illustration of why comparing floating point values with == is usually a bad idea.

 

=={{header|zkl}}==

No complex type.

{{out}}<pre>L(True,False,False,False,False)</pre>

All is not golden as BigInts (lib GMP) don't consider themselves to be integers so the above test would fail. For that case:

var BN=Import("zklBigNum");

{{out}}<pre>L(True,True,False,False,False,True)</pre>

Note that the first float is now considered to have an integer equivalent.