Hickerson series of almost integers: Difference between revisions

 

=={{header|Ada}}==

with Ada.Numerics.Generic_Elementary_Functions;

 

end;

end loop;

 

{{out}}

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

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

# The Hickerson number n is defined by: h(n) = n! / ( 2 * ( (ln 2)^(n+1) ) ) #

# so: h(1) = 1 / ( 2 * ( ( ln 2 ) ^ 2 ) #

)

)

{{out}}

<pre>

 

=={{header|AWK}}==

# syntax: GAWK -M -f HICKERSON_SERIES_OF_ALMOST_INTEGERS.AWK

# using GNU Awk 4.1.0, API: 1.0 (GNU MPFR 3.1.2, GNU MP 5.1.2)

return(out)

}

<p>Output:</p>

<pre>

17 130370767029135900.45799 almost integer: false

</pre>

 

=={{header|Bracmat}}==

and a decimal part (using a string operation) before outputting.

& 1:?fac

& whl

)

)

{{out}}

<pre>h(1) = 1.041 is an almost-integer.

=={{header|C}}==

{{libheader|MPFR}}

#include <mpfr.h>

 

 

return 0;

{{out}}

<pre>

16: 5315654681981354.5131 N

17: 130370767029135900.4580 N

</pre>

 

=={{header|C++}}==

{{libheader|Boost|1.53 or later}}

#include <iomanip>

#include <boost/multiprecision/cpp_dec_float.hpp>

}

}

{{out}}

<pre>

In order to get enough precision, the natural logarithm of 2 had to be entered manually; the BigDecimal implementation does not have a high-precision logarithm function.

 

"Hickerson number, calculated with BigDecimals and manually-entered high-precision value for ln(2)."

[n]

(if (almost-integer? h)

"almost integer"

{{out}}

<pre>1 1.04068 almost integer

=={{header|COBOL}}==

{{works with|GNU Cobol|2.0}}

IDENTIFICATION DIVISION.

PROGRAM-ID. hickerson-series.

END-PERFORM

.

 

{{out}}

=={{header|Crystal}}==

{{trans|Ruby}}

LN2 = Math.log(2).to_big_f

puts "n:%3i h: %s\t%s" % [n, h, str]

end

{{out}}

<pre>

=={{header|D}}==

The D <code>real</code> type has enough precision for this task.

import std.stdio, std.algorithm, std.mathspecial;

 

tenths.among!(0, 9) ? "" : "NOT ");

}

<pre>H( 1)= 1.04 is nearly integer.

H( 2)= 3.00 is nearly integer.

 

=={{header|Factor}}==

math.ranges sequences ;

IN: rosetta-code.hickerson

] each ;

 

{{out}}

<pre>

{{works with|4tH v3.64.0}}

4tH has two different floating point libraries. This version works with both of them.

include lib/zenfprox.4th \ for F~

include lib/zenround.4th \ for FROUND

include lib/zenfln.4th \ for FLN

[ELSE]

include lib/flnflog.4th \ for FLN

[THEN]

 

float array ln2 2 s>f fln latest f! \ precalculate ln(2)

\ integer exponentiation

: integer? if ." TRUE " else ." FALSE" then space ;

\ is it an integer?

;

 

{{out}}

<pre>

 

=={{header|Fortran}}==

implicit none

integer, parameter :: q = selected_real_kind(30)

end do

1 format('h(',I2,') = ',F23.3,' is',A,' an almost-integer')

 

{{out}}

=={{header|FreeBASIC}}==

{{libheader|GMP}}

' compile with: fbc -s gui

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>h(1) = 1.04068 is a almost integer

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

 

import (

i, &w, d[1:], d[2] == '0' || d[2] == '9')

}

{{out}}

<pre>

 

=={{header|Haskell}}==

 

import qualified Data.Number.CReal as C

 

 

{{out}}

<pre style="font-size:80%">

Definitions:

 

 

Implementation (1 in initial column indicates an almost integer, results displayed to 3 digits after the decimal point):

 

1 1.041

1 3.003

1 230283190977853.037

0 5315654681981354.513

 

In other words, multiply the fractional part of h by ten, find the largest integer not greater than this result, and check if it's in the set {0,9}. Then format the result of h along with this set membership result.

 

=={{header|Java}}==

 

public class Hickerson {

return c.toString().matches("0|9");

}

 

<pre> 1 is almost integer: true

{{works with|jq|1.4}}

jq currently uses IEEE 754 64-bit numbers, and therefore the built-in arithmetic functions lack adequate precision to solve the task completely. In the following, therefore, we include a check for adequate precision.

. as $n

| (2|log) as $log2

end

else "insufficient precision for hickerson(\($i))"

{{out}}

hickerson(1) is 1.0406844905028039 -- almost an integer

hickerson(2) is 3.0027807071569055 -- almost an integer

hickerson(15) is 230283190977853.06 -- almost an integer

insufficient precision for hickerson(16)

 

=={{header|Julia}}==

This solution implements its Hickerson Series function as a closure. It explores the effects of datatype precision, implementing a rather conservative "guard number" scheme to identify when the results may have inadequate precision. One can not be confident of the 64-bit floating point results beyond <tt>n=13</tt>, but the 256-bit precision floating point results are easily precise enough for the entire calculation to <tt>n=17</tt>. (A slight variant of this calculation, not shown here, indicates that these extended precision numbers are adequate to <tt>n=50</tt>.)

function makehickerson{T<:Real}(x::T)

n = 0

a = log(2.0)

reporthickerson(a, 17)

 

{{out}}

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.math.BigDecimal

fun main(args: Array<String>) {

for (n in 1..17) println("${"%2d".format(n)} is almost integer: ${Hickerson.almostInteger(n)}")

 

{{out}}

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

firstdecimal[x_] := Floor[10 x] - 10 Floor[x];

almostIntegerQ[x_] := firstdecimal[x] == 0 || firstdecimal[x] == 9;

{{out}}

<pre>1 1.04068 True

=={{header|ML}}==

==={{header|mLite}}===

fun log (n, k, last = sum, sum) = sum

| (n, k, last, sum) = log (n, k + 1, sum, sum + ( 1 / (k * n ^ k)))

;

foreach show ` iota 17;

Output

<pre>(1, 1.04068449050280389893479080186749587, true)

For big values, it is not possible to keep enough precision while converting a rational to a float, so we compute only the fractional part of h(n), which is sufficient to decide whether the number if nearly an integer or not.

 

import bignum

 

let s = if int(10 * f) in {0, 9}: "" else: "not "

echo &"Fractional part of h({i}) is {f:.5f}..., so h({i}) is {s}nearly an integer."

 

{{out}}

 

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

almost(x)=abs(x-round(x))<.1

select(n->almost(h(n)),[1..17])

{{out}}

<pre>%1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]</pre>

calculate the inverse of the natural log of 2, and then compute a running value of h.

 

use warnings;

use Math::BigFloat;

$n, $s, ($s =~ /\.[09]/ ? "" : " NOT");

}

{{out}}

<pre>h( 1) = 1.041 is almost an integer.

 

=={{header|Phix}}==

{{out}}

<pre>

=={{header|PicoLisp}}==

PicoLisp does not have floating point, but does have library functions to make fixed-point math easier. I use a scale factor of 25 to ensure that there is enough precision.

(load "@lib/misc.l")

 

(prinl "h(" (align 2 I) ") = " (fmt4 H))))

(bye)

{{Out}}

<pre>

 

=={{header|PL/I}}==

declare s float (18), (i, n) fixed binary;

declare is fixed decimal (30);

end;

 

{{out}}

<pre>

</pre>

Using extended precision available by software:

do n = 1 to 18;

s = divide( float(0.5), float(0.693147180559945309417232121458) );

put edit (' is not a near integer') (A);

end;

{{out}} Results:

<pre>

This uses Pythons [http://docs.python.org/2/library/decimal.html decimal module] of fixed precision decimal floating point calculations.

 

import math

 

if 'E' not in norm and ('.0' in norm or '.9' in norm)

else ' NOT nearly integer!')

 

{{out}}

=={{header|Racket}}==

{{trans|Python}}

(require math/bigfloat)

 

(~r n #:min-width 2)

(bigfloat->string hickerson-n)

{{out}}

<pre> 0: 0.7213475204444817036799623405009460687136 is not Nearly integer!

We'll use [http://doc.raku.org/type/FatRat FatRat] values, and a series for an [http://mathworld.wolfram.com/NaturalLogarithmof2.html approximation of ln(2)].

 

constant h = [\*] 1/2, |(1..*) X/ ln2;

 

for h[1..17] {

ok m/'.'<[09]>/, .round(0.001)

{{out}}

<pre>ok 1 - 1.041

=={{header|REXX}}==

===version 1===

* 04.01.2014 Walter Pachl - using a rather aged ln function of mine

* with probably unreasonably high precision

fact=fact*i

End

{{out}}

<pre> 1 1.0406844905 almost an integer

 

This version supports up to &nbsp; '''507''' &nbsp; decimal digits.

numeric digits length(ln2())-length(.) /*be able to calculate big factorials. */

parse arg N . /*get optional number of values to use.*/

|| 3501153644979552391204751726815749320651555247341395258829504530070953263666426541042391578149520437404,

|| 3038550080194417064167151864471283996817178454695702627163106454615025720740248163777338963855069526066,

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 197 </tt>}}

<pre style="height:91ex">

===version 3===

This REXX version takes advantage that the Hickerson series are computed in order, so that the factorials need not be (re-)computed from scratch.

numeric digits length(ln2())-length(.) /*be able to calculate big factorials. */

parse arg N . /*get optional number of values to use.*/

|| 3501153644979552391204751726815749320651555247341395258829504530070953263666426541042391578149520437404,

|| 3038550080194417064167151864471283996817178454695702627163106454615025720740248163777338963855069526066,

{{out|output|text=&nbsp; is identical to the 2^nd REXX version.}}<br><br>

 

=={{header|Ring}}==

n = 12

hick = 0

else return 0 ok

return sub

 

=={{header|Ruby}}==

Using the BigDecimal standard library:

 

LN2 = BigMath::log(2,16) #Use LN2 = Math::log(2) to see the difference with floats

str = nearly_int?(h) ? "nearly integer" : "NOT nearly integer"

puts "n:%3i h: %s\t%s" % [n, h.to_s('F')[0,25], str] #increase the 25 to print more digits, there are 856 of them

{{out}}

<pre>

 

=={{header|Rust}}==

use decimal::d128;

use factorial::Factorial;

}

}

{{out}}

<pre>

=={{header|Scala}}==

===Functional Programming ♫===

 

object Hickerson extends App {

println(s"While h(n) gives NOT an almost integer with a n of ${aa.filter(!_._2).map(_._1).mkString(", ")}.")

 

{{Out}}See it in running in your browser by [https://scalafiddle.io/sf/tNNk9jB/2 ScalaFiddle (JavaScript executed in browser)]

or by [https://scastie.scala-lang.org/aX6X59zrTkWpEbCOXmpmAg Scastie (remote JVM)].

 

=={{header|Seed7}}==

include "bigrat.s7i";

 

stri[succ(pos(stri, '.'))] in {'0', '9'});

end for;

 

{{out}}

 

=={{header|Sidef}}==

n! / (2 * pow(2.log, n+1))

}

"h(%2d) = %22s is%s almost an integer.\n".printf(

n, var hn = h(n).round(-3), hn.to_s ~~ /\.[09]/ ? '' : ' NOT')

{{out}}

<pre>h( 1) = 1.041 is almost an integer.

=={{header|Tcl}}==

{{tcllib|math::bigfloat}}

namespace import math::bigfloat::*

 

set almost [regexp {\.[09]} $h]

puts [format "h(%d) = %s (%salmost integer)" $n $h [expr {$almost ? "" : "not "}]]

{{out}}

<pre>

 

=={{header|TI-83 BASIC}}==

N!/(2ln(2)^(N+1→H

Disp N,H,"IS

Disp "NOT

Disp "ALMOST INTEGER

(untested)

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

{{libheader|Wren-big}}

 

var hickerson = Fn.new { |n|

}

 

System.print("Values of h(n), truncated to 1 dp, and whether 'almost integers' or not:")

for (i in 1..17) {

var ai = (h[k] == "0" || h[k] == "9")

 

{{out}}

17: 130370767029135900.4 false

</pre>

 

=={{header|zkl}}==

Uses lib GMP (integer) and some fiddling to fake up the floating point math.

X =BN("1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),

ln2X=BN("693147180559945309417232121458176568075500134360255254120680009493393621969694715605863326996418687")

;

hs,ld,isH:=hickerson(n).toString(),hs[-1],"90".holds(ld);

println("h(%2d)=%s.%s almost integer: %b".fmt(n,hs[0,-1],ld,isH));

{{out}}

<pre>