Hickerson series of almost integers: Difference between revisions
Hickerson series of almost integers (view source)
Revision as of 08:21, 10 February 2024
, 3 months agoAdd C# implementation
(→{{header|Perl 6}}: fixing issue with printf) |
(Add C# implementation) |
||
| (134 intermediate revisions by 53 users not shown) | |||
Line 1:
{{
The following function, due to D. Hickerson, is said to generate "Almost integers" by the
<br>[http://mathworld.wolfram.com/AlmostInteger.html "Almost Integer" page of Wolfram MathWorld], (December 31 2013). (See formula numbered '''51'''.)
The function is: <math>h(n) = {\operatorname{n}!\over2(\
It is said to produce "almost integers" for '''n''' between '''1''' and '''17'''.
The purpose of the task is to verify this assertion.
Assume that an "almost integer" has '''either a nine or a zero as its first digit after the decimal point''' of its decimal string representation
;Task:
Calculate all values of the function checking and stating which are "almost integers".
Note: Use extended/arbitrary precision numbers in your calculation if necessary to ensure you have adequate precision of results as for example:
h(18) = 3385534663256845326.39...
<br><br>
=={{header|Ada}}==
<syntaxhighlight lang="ada">with Ada.Text_IO;
with Ada.Numerics.Generic_Elementary_Functions;
procedure Almost_Integers is
type Real is new Long_Long_Float;
package Real_IO is
new Ada.Text_IO.Float_IO (Real);
package Integer_IO is
new Ada.Text_IO.Integer_IO (Integer);
function Faculty (N : in Long_Long_Integer) return Long_Long_Integer is
(if N < 2 then N else N * Faculty (N - 1));
function Hickerson (N : in Integer) return Real
is
package Math is
new Ada.Numerics.Generic_Elementary_Functions (Real);
LN2 : constant Real := Math.Log (2.0, Base => Ada.Numerics.E);
Numerator : constant Real := Real (Faculty (Long_Long_Integer (N)));
Denominator : constant Real := 2.0 * LN2 ** (N + 1);
begin
return Numerator / Denominator;
end Hickerson;
function Is_Almost_Integer (N : Real) return Boolean is
Image : String (1 .. 100);
begin
Real_IO.Put (Image, N, Exp => 0, Aft => 2);
pragma Assert (Image (Image'Last - 2) = '.');
case Image (Image'Last - 1) is
when '0' | '9' => return True;
when others => return False;
end case;
end Is_Almost_Integer;
use Ada.Text_IO;
Placeholder : String := " n h(n) almost";
Image_N : String renames Placeholder ( 1 .. 2);
Image_H : String renames Placeholder ( 4 .. 31);
Image_A : String renames Placeholder (34 .. 39);
begin
Put_Line (Placeholder);
Image_N := (others => '-');
Image_H := (others => '-');
Image_A := (others => '-');
Put_Line (Placeholder);
for N in 1 .. 17 loop
declare
H : constant Real := Hickerson (N);
I : constant Boolean := Is_Almost_Integer (H);
begin
Integer_IO.Put (Image_N, N);
Real_IO.Put (Image_H, H, Exp => 0, Aft => 4);
Image_A := (if I then "TRUE " else "FALSE");
Put_Line (Placeholder);
end;
end loop;
end Almost_Integers;</syntaxhighlight>
{{out}}
<pre> n h(n) almost
-- ---------------------------- ------
1 1.0407 TRUE
2 3.0028 TRUE
3 12.9963 TRUE
4 74.9987 TRUE
5 541.0015 TRUE
6 4683.0012 TRUE
7 47292.9987 TRUE
8 545834.9979 TRUE
9 7087261.0016 TRUE
10 102247563.0053 TRUE
11 1622632572.9976 TRUE
12 28091567594.9816 TRUE
13 526858348381.0012 TRUE
14 10641342970443.0845 TRUE
15 230283190977853.0370 TRUE
16 5315654681981354.5100 FALSE
17 130370767029135900.0000 TRUE</pre>
=={{header|ALGOL 68}}==
{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}
<syntaxhighlight lang="algol68"># determine whether the first few Hickerson numbers really are "near integers" #
# The Hickerson number n is defined by: h(n) = n! / ( 2 * ( (ln 2)^(n+1) ) ) #
# so: h(1) = 1 / ( 2 * ( ( ln 2 ) ^ 2 ) #
# and: h(n) = ( n / ln 2 ) * h(n-1) #
# set the precision of LONG LONG numbers #
PR precision 100 PR
# calculate the Hickerson numbers #
LONG LONG REAL ln2 = long long ln( 2 );
[ 1 : 18 ]LONG LONG REAL h;
h[ 1 ] := 0.5 / ( ln2 * ln2 );
FOR n FROM 2 TO UPB h
DO
h[ n ] := ( n * h[ n - 1 ] ) / ln2
OD;
# determine the first digit after the point in each h(n) - if it is 0 or 9 #
# the number is a "near integer" #
FOR n TO UPB h
DO
INT first decimal = SHORTEN SHORTEN ( ( ENTIER ( h[ n ] * 10 ) ) MOD 10 );
print( ( whole( n, -4 )
, " "
, fixed( h[ n ], 40, 4 )
, IF first decimal = 0 OR first decimal = 9
THEN
" a near integer"
ELSE
" NOT a near integer"
FI
, newline
)
)
OD</syntaxhighlight>
{{out}}
<pre>
1 +1.0407 a near integer
2 +3.0028 a near integer
3 +12.9963 a near integer
4 +74.9987 a near integer
5 +541.0015 a near integer
6 +4683.0012 a near integer
7 +47292.9987 a near integer
8 +545834.9979 a near integer
9 +7087261.0016 a near integer
10 +102247563.0053 a near integer
11 +1622632572.9976 a near integer
12 +28091567594.9816 a near integer
13 +526858348381.0012 a near integer
14 +10641342970443.0845 a near integer
15 +230283190977853.0374 a near integer
16 +5315654681981354.5131 NOT a near integer
17 +130370767029135900.4580 NOT a near integer
18 +3385534663256845326.3903 NOT a near integer
</pre>
=={{header|AWK}}==
<syntaxhighlight lang="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)
BEGIN {
PREC = 100
for (i=1; i<=17; i++) {
h = sprintf("%25.5f",factorial(i) / (2 * log(2) ^ (i + 1)))
msg = (h ~ /\.[09]/) ? "true" : "false"
printf("%2d %s almost integer: %s\n",i,h,msg)
}
exit(0)
}
function factorial(n, i,out) {
out = 1
for (i=2; i<=n; i++) {
out *= i
}
return(out)
}
</syntaxhighlight>
<p>Output:</p>
<pre>
1 1.04068 almost integer: true
2 3.00278 almost integer: true
3 12.99629 almost integer: true
4 74.99874 almost integer: true
5 541.00152 almost integer: true
6 4683.00125 almost integer: true
7 47292.99873 almost integer: true
8 545834.99791 almost integer: true
9 7087261.00162 almost integer: true
10 102247563.00527 almost integer: true
11 1622632572.99755 almost integer: true
12 28091567594.98157 almost integer: true
13 526858348381.00125 almost integer: true
14 10641342970443.08453 almost integer: true
15 230283190977853.03744 almost integer: true
16 5315654681981354.51308 almost integer: false
17 130370767029135900.45799 almost integer: false
</pre>
=={{header|BBC BASIC}}==
We use the native 80 bit floats precision.
{{works with|BBC BASIC for Windows}}
<syntaxhighlight lang="bbcbasic"> Fac=1
FOR I%=1 TO 17
Fac*=I%
@%=&1420300
Hick$=RIGHT$(STRING$(17, " ") + STR$(Fac / (2 * LN2 ^ (I% + 1))), 22)
@%=2
PRINT "H(" I% ") = " Hick$ " which is ";
IF MID$(Hick$, 20, 1) <> "0" IF MID$(Hick$, 20, 1) <> "9" PRINT "NOT ";
PRINT "an almost integer."
NEXT</syntaxhighlight>
{{out}}
<pre>H( 1) = 1.041 which is an almost integer.
H( 2) = 3.003 which is an almost integer.
H( 3) = 12.996 which is an almost integer.
H( 4) = 74.999 which is an almost integer.
H( 5) = 541.002 which is an almost integer.
H( 6) = 4683.001 which is an almost integer.
H( 7) = 47292.999 which is an almost integer.
H( 8) = 545834.998 which is an almost integer.
H( 9) = 7087261.002 which is an almost integer.
H(10) = 102247563.005 which is an almost integer.
H(11) = 1622632572.998 which is an almost integer.
H(12) = 28091567594.982 which is an almost integer.
H(13) = 526858348381.001 which is an almost integer.
H(14) = 10641342970443.085 which is an almost integer.
H(15) = 230283190977853.037 which is an almost integer.
H(16) = 5315654681981354.511 which is NOT an almost integer.
H(17) = 130370767029135900.410 which is NOT an almost integer.</pre>
=={{header|Bracmat}}==
This solution approximates <math>\log_e{2}</math>
with enough terms to make the first two decimals right with high likelyhood.
(It stops adding more terms when the first three decimals in two consecutive approximations are the same.)
See [https://en.wikipedia.org/wiki/Natural_logarithm_of_2 Natural logarithm of 2]
Bracmat has no built in support for fixed point notation of rational numbers.
Therefore each Hickerson number is split in an integer part (using integer division)
and a decimal part (using a string operation) before outputting.
<syntaxhighlight lang="bracmat">( 0:?n
& 1:?fac
& whl
' ( 1+!n:~>17:?n
& !n*!fac:?fac
& -1:?k
& 0:?L2
& 0:?oldN
& whl
' ( 1+!k:?k
& ((2*!k+1)*9^!k)^-1+!L2:?L2
& !fac*1/2*(2/3*!L2)^(-1*(!n+1)):?N
& div$(1000*!N+1/2.1):?newN
& !newN:~!oldN:?oldN
)
& out
$ ( str$("h(" !n ") =")
( div$(!newN.1000):?intpart
& @(!newN:!intpart ?decimalpart)
& str$(!intpart "." !decimalpart)
)
( @(!decimalpart:(0|9) ?)
& "is an almost-integer."
| "is NOT an almost-integer."
)
)
)
);</syntaxhighlight>
{{out}}
<pre>h(1) = 1.041 is an almost-integer.
h(2) = 3.003 is an almost-integer.
h(3) = 12.996 is an almost-integer.
h(4) = 74.999 is an almost-integer.
h(5) = 541.002 is an almost-integer.
h(6) = 4683.001 is an almost-integer.
h(7) = 47292.999 is an almost-integer.
h(8) = 545834.998 is an almost-integer.
h(9) = 7087261.002 is an almost-integer.
h(10) = 102247563.005 is an almost-integer.
h(11) = 1622632572.998 is an almost-integer.
h(12) = 28091567594.982 is an almost-integer.
h(13) = 526858348381.001 is an almost-integer.
h(14) = 10641342970443.085 is an almost-integer.
h(15) = 230283190977853.038 is an almost-integer.
h(16) = 5315654681981354.513 is NOT an almost-integer.
h(17) = 130370767029135900.458 is NOT an almost-integer.</pre>
=={{header|C}}==
{{libheader|MPFR}}
<syntaxhighlight lang="c">#include <stdio.h>
#include <mpfr.h>
void h(int n)
{
MPFR_DECL_INIT(a, 200);
MPFR_DECL_INIT(b, 200);
mpfr_fac_ui(a, n, MPFR_RNDD); // a = n!
mpfr_set_ui(b, 2, MPFR_RNDD); // b = 2
mpfr_log(b, b, MPFR_RNDD); // b = log(b)
mpfr_pow_ui(b, b, n + 1, MPFR_RNDD); // b = b^(n+1)
mpfr_div(a, a, b, MPFR_RNDD); // a = a / b
mpfr_div_ui(a, a, 2, MPFR_RNDD); // a = a / 2
mpfr_frac(b, a, MPFR_RNDD); // b = a - [a]
mpfr_printf("%2d: %23.4Rf %c\n", n, a,
mpfr_cmp_d(b, .1) * mpfr_cmp_d(b, .9) > 0 ? 'Y' : 'N');
}
int main(void)
{
int n;
for (n = 1; n <= 17; n++) h(n);
return 0;
}</syntaxhighlight>
{{out}}
<pre>
1: 1.0407 Y
2: 3.0028 Y
3: 12.9963 Y
4: 74.9987 Y
5: 541.0015 Y
6: 4683.0012 Y
7: 47292.9987 Y
8: 545834.9979 Y
9: 7087261.0016 Y
10: 102247563.0053 Y
11: 1622632572.9976 Y
12: 28091567594.9816 Y
13: 526858348381.0012 Y
14: 10641342970443.0845 Y
15: 230283190977853.0374 Y
16: 5315654681981354.5131 N
17: 130370767029135900.4580 N
</pre>
=={{header|C#}}==
{{trans|Go}}
<syntaxhighlight lang="C#">
using System;
using System.Numerics;
public class Program
{
public static void Main(string[] args)
{
decimal ln2 = 0.6931471805599453094172m;
decimal h = 0.5m / ln2;
BigInteger w = new BigInteger();
decimal f = 0;
for (long i = 1; i <= 17; i++)
{
h = h * i / ln2;
w = (BigInteger)h;
f = h - (decimal)w;
double y = (double)f;
string d = y.ToString("0.000");
Console.WriteLine($"n: {i,2} h: {w}{d.Substring(1)} Nearly integer: {d[2] == '0' || d[2] == '9'}");
}
}
}
</syntaxhighlight>
{{out}}
<pre>
n: 1 h: 1.041 Nearly integer: True
n: 2 h: 3.003 Nearly integer: True
n: 3 h: 12.996 Nearly integer: True
n: 4 h: 74.999 Nearly integer: True
n: 5 h: 541.002 Nearly integer: True
n: 6 h: 4683.001 Nearly integer: True
n: 7 h: 47292.999 Nearly integer: True
n: 8 h: 545834.998 Nearly integer: True
n: 9 h: 7087261.002 Nearly integer: True
n: 10 h: 102247563.005 Nearly integer: True
n: 11 h: 1622632572.998 Nearly integer: True
n: 12 h: 28091567594.982 Nearly integer: True
n: 13 h: 526858348381.001 Nearly integer: True
n: 14 h: 10641342970443.085 Nearly integer: True
n: 15 h: 230283190977853.037 Nearly integer: True
n: 16 h: 5315654681981354.513 Nearly integer: False
n: 17 h: 130370767029135900.458 Nearly integer: False
</pre>
=={{header|C++}}==
{{libheader|Boost|1.53 or later}}
<syntaxhighlight lang="cpp">#include <iostream>
#include <iomanip>
#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/math/constants/constants.hpp>
typedef boost::multiprecision::cpp_dec_float_50 decfloat;
int main()
{
const decfloat ln_two = boost::math::constants::ln_two<decfloat>();
decfloat numerator = 1, denominator = ln_two;
for(int n = 1; n <= 17; n++) {
decfloat h = (numerator *= n) / (denominator *= ln_two) / 2;
decfloat tenths_dig = floor((h - floor(h)) * 10);
std::cout << "h(" << std::setw(2) << n << ") = " << std::setw(25) << std::fixed << h <<
(tenths_dig == 0 || tenths_dig == 9 ? " is " : " is NOT ") << "an almost-integer.\n";
}
}
</syntaxhighlight>
{{out}}
<pre>
h( 1) = 1.040684 is an almost-integer.
h( 2) = 3.002781 is an almost-integer.
h( 3) = 12.996291 is an almost-integer.
h( 4) = 74.998735 is an almost-integer.
h( 5) = 541.001519 is an almost-integer.
h( 6) = 4683.001247 is an almost-integer.
h( 7) = 47292.998731 is an almost-integer.
h( 8) = 545834.997907 is an almost-integer.
h( 9) = 7087261.001623 is an almost-integer.
h(10) = 102247563.005271 is an almost-integer.
h(11) = 1622632572.997550 is an almost-integer.
h(12) = 28091567594.981572 is an almost-integer.
h(13) = 526858348381.001248 is an almost-integer.
h(14) = 10641342970443.084532 is an almost-integer.
h(15) = 230283190977853.037436 is an almost-integer.
h(16) = 5315654681981354.513077 is NOT an almost-integer.
h(17) = 130370767029135900.457985 is NOT an almost-integer.
</pre>
=={{header|Clojure}}==
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.
<syntaxhighlight lang="clojure">(defn hickerson
"Hickerson number, calculated with BigDecimals and manually-entered high-precision value for ln(2)."
[n]
(let [n! (apply *' (range 1M (inc n)))]
(.divide n! (*' 2 (.pow 0.693147180559945309417232121458M (inc n)))
30 BigDecimal/ROUND_HALF_UP)))
(defn almost-integer?
"Tests whether the first digit after the decimal is 0 or 9."
[x]
(let [first-digit (int (mod (.divide (*' x 10) 1.0M 0 BigDecimal/ROUND_DOWN)
10))]
(or (= 0 first-digit) (= 9 first-digit))))
; Execute for side effects
(doseq [n (range 1 18) :let [h (hickerson n)]]
(println (format "%2d %24.5f" n h)
(if (almost-integer? h)
"almost integer"
"NOT almost integer")))</syntaxhighlight>
{{out}}
<pre>1 1.04068 almost integer
2 3.00278 almost integer
3 12.99629 almost integer
4 74.99874 almost integer
5 541.00152 almost integer
6 4683.00125 almost integer
7 47292.99873 almost integer
8 545834.99791 almost integer
9 7087261.00162 almost integer
10 102247563.00527 almost integer
11 1622632572.99755 almost integer
12 28091567594.98157 almost integer
13 526858348381.00125 almost integer
14 10641342970443.08453 almost integer
15 230283190977853.03744 almost integer
16 5315654681981354.51308 NOT almost integer
17 130370767029135900.45799 NOT almost integer</pre>
=={{header|COBOL}}==
{{works with|GNU Cobol|2.0}}
<
IDENTIFICATION DIVISION.
PROGRAM-ID. hickerson-series.
Line 46 ⟶ 514:
END-PERFORM
.
END PROGRAM hickerson-series.</
{{out}}
Line 70 ⟶ 538:
</pre>
=={{header|
{{trans|Ruby}}
<syntaxhighlight lang="ruby">require "big"
LN2 = Math.log(2).to_big_f
FACTORIALS = Hash(Int32, Float64).new{|h,k| h[k] = k * h[k-1]}
FACTORIALS[0] = 1
def hickerson(n)
end
def nearly_int?(n)
(int - 0.1..int + 0.1).includes? n
end
1.upto(17) do |n|
h = hickerson(n)
str = nearly_int?(h) ? "nearly integer" : "NOT nearly integer"
puts "n:%3i h: %s\t%s" % [n, h, str]
end
</syntaxhighlight>
{{out}}
<pre>
</pre>
=={{header|D}}==
The D <code>real</code> type has enough precision for this task.
<syntaxhighlight lang="d">void main() {
import std.stdio, std.algorithm, std.mathspecial;
foreach (immutable n; 1 .. 18) {
immutable x = gamma(n + 1) / (2 * LN2 ^^ (n + 1)),
tenths = cast(int)floor((x - x.floor) * 10);
writefln("H(%2d)=%22.2f is %snearly integer.", n, x,
tenths.among!(0, 9) ? "" : "NOT ");
}
}</syntaxhighlight>
<pre>H( 1)= 1.04 is nearly integer.
H( 2)= 3.00 is nearly integer.
H( 3)= 13.00 is nearly integer.
H( 4)= 75.00 is nearly integer.
H( 5)= 541.00 is nearly integer.
H( 6)= 4683.00 is nearly integer.
H( 7)= 47293.00 is nearly integer.
H( 8)= 545835.00 is nearly integer.
H( 9)= 7087261.00 is nearly integer.
H(10)= 102247563.01 is nearly integer.
H(11)= 1622632573.00 is nearly integer.
H(12)= 28091567594.98 is nearly integer.
H(13)= 526858348381.00 is nearly integer.
H(14)= 10641342970443.08 is nearly integer.
H(15)= 230283190977853.04 is nearly integer.
H(16)= 5315654681981354.51 is NOT nearly integer.
H(17)= 130370767029135900.50 is NOT nearly integer.</pre>
=={{header|Factor}}==
<syntaxhighlight lang="factor">USING: formatting kernel math math.factorials math.functions
math.ranges sequences ;
IN: rosetta-code.hickerson
: ln2 ( -- x )
99 [1,b] [ [ 2 swap ^ ] [ * ] bi recip ] map-sum ;
: hickerson ( n -- x ) [ n! ] [ 1 + ln2 swap ^ 2 * ] bi / ;
: almost-int? ( x -- ? ) 10 * truncate 10 mod { 0 9 } member? ;
: hickerson-demo ( -- )
18 [1,b] [
dup hickerson dup almost-int?
"h(%02d) = %23.3f almost integer? %u\n" printf
] each ;
MAIN: hickerson-demo</syntaxhighlight>
{{out}}
<pre>
h(01) = 1.041 almost integer? t
h(02) = 3.003 almost integer? t
h(03) = 12.996 almost integer? t
h(04) = 74.999 almost integer? t
h(05) = 541.002 almost integer? t
h(06) = 4683.001 almost integer? t
h(07) = 47292.999 almost integer? t
h(08) = 545834.998 almost integer? t
h(09) = 7087261.002 almost integer? t
h(10) = 102247563.005 almost integer? t
h(11) = 1622632572.998 almost integer? t
h(12) = 28091567594.982 almost integer? t
h(13) = 526858348381.001 almost integer? t
h(14) = 10641342970443.085 almost integer? t
h(15) = 230283190977853.037 almost integer? t
h(16) = 5315654681981354.513 almost integer? f
h(17) = 130370767029135900.458 almost integer? f
h(18) = 3385534663256845326.390 almost integer? f
</pre>
=={{header|Forth}}==
{{works with|4tH v3.64.0}}
4tH has two different floating point libraries. This version works with both of them.
<syntaxhighlight lang="forth">[UNDEFINED] ANS [IF]
include lib/fp1.4th \ Zen float version
include lib/zenfprox.4th \ for F~
include lib/zenround.4th \ for FROUND
include lib/zenfln.4th \ for FLN
include lib/zenfpow.4th \ for FPOW
[ELSE]
include lib/fp3.4th \ ANS float version
include lib/flnflog.4th \ for FLN
include lib/fpow.4th \ for FPOW
[THEN]
include lib/fast-fac.4th \ for FACTORIAL
fclear \ initialize floating point
float array ln2 2 s>f fln latest f! \ precalculate ln(2)
\ integer exponentiation
: hickerson dup >r factorial s>f ln2 f@ r> 1+ fpow fdup f+ f/ ;
: integer? if ." TRUE " else ." FALSE" then space ;
\ is it an integer?
: first17
18 1 do \ test hickerson 1-17
i hickerson i 2 .r space fdup fdup fround
s" 1e-1" s>float f~ integer? f. cr
loop \ within 0.1 absolute error
;
first17</syntaxhighlight>
{{out}}
<pre>
1 TRUE 1.040684490502803898935311338275660267
2 TRUE 3.002780707156905443502020333103288357
3 TRUE 12.99629050527696646223788568296556096
4 TRUE 74.99873544766160012772833377667325825
5 TRUE 541.0015185164235075700145797037460679
6 TRUE 4683.001247262257437188665462676039563
7 TRUE 47292.99873131462390491745677950570536
8 TRUE 545834.9979074851670685196268094270956
9 TRUE 7087261.001622899120996912279845689616
10 TRUE 102247563.0052710420113696743135681269
11 TRUE 1622632572.997550049857744575227371627
12 TRUE 28091567594.98157244080652083799015398
13 TRUE 526858348381.0012482880251816804368039
14 TRUE 10641342970443.08453196701499663939019
15 TRUE 230283190977853.0374369606024567600908
16 FALSE 5315654681981354.513099343419112934817
17 FALSE 130370767029135900.4585722365605854515
</pre>
=={{header|Fortran}}==
<syntaxhighlight lang="fortran">program hickerson
implicit none
integer, parameter :: q = selected_real_kind(30)
integer, parameter :: l = selected_int_kind(15)
real(q) :: s, l2
integer :: i, n, k
l2 = log(2.0_q)
do n = 1, 17
s = 0.5_q / l2
do i = 1, n
s = (s * i) / l2
end do
k = floor((s - floor(s, l)) * 10)
if (k == 0 .or. k == 9) then
print 1, n, s, ""
else
print 1, n, s, " NOT"
endif
end do
1 format('h(',I2,') = ',F23.3,' is',A,' an almost-integer')
end program</syntaxhighlight>
{{out}}
<pre>
h( 1) = 1.041 is an almost-integer
h( 2) = 3.003 is an almost-integer
h( 3) = 12.996 is an almost-integer
h( 4) = 74.999 is an almost-integer
h( 5) = 541.002 is an almost-integer
h( 6) = 4683.001 is an almost-integer
h( 7) = 47292.999 is an almost-integer
h( 8) = 545834.998 is an almost-integer
h( 9) = 7087261.002 is an almost-integer
h(10) = 102247563.005 is an almost-integer
h(11) = 1622632572.998 is an almost-integer
h(12) = 28091567594.982 is an almost-integer
h(13) = 526858348381.001 is an almost-integer
h(14) = 10641342970443.085 is an almost-integer
h(15) = 230283190977853.037 is an almost-integer
h(16) = 5315654681981354.513 is NOT an almost-integer
h(17) = 130370767029135900.458 is NOT an almost-integer
</pre>
=={{header|FreeBASIC}}==
{{libheader|GMP}}
<syntaxhighlight lang="freebasic">' version 08-10-2016
' compile with: fbc -s gui
#Include Once "gmp.bi"
#Macro init_float_size (big_float ,size)
Dim As Mpf_ptr big_float = Allocate( Len( __mpf_struct))
Mpf_init2( big_float,size)
#EndMacro
#Macro mpf_remove(big_float)
Mpf_clear(big_float)
DeAllocate (big_float)
#EndMacro
Screen 20
init_float_size(tmp,1024)
init_float_size(ln2,1024)
init_float_size(pow_ln2,2048)
init_float_size(answer,2048)
Dim As UInteger n, num
Dim As String st
Dim As ZString Ptr text
text = Allocate (1500) ' size 1500 char.
' need to calculate ln(2)
' x 1 1 1 1
' ln --- = - + ------ + ------ ... + ------
' x-1 x 2x^2 3x^3 nx^n
Mpf_set_ui(answer, 1)
Mpf_div_ui(answer, answer, 2) ' answer = 1/2
For n = 2 To 1024
Mpf_set_ui(tmp, 2) ' tmp = x = 2
Mpf_pow_ui(tmp, tmp, n) ' tmp = x ^ n
Mpf_mul_ui(tmp, tmp, n) ' tmp = n * (x ^ n)
Mpf_ui_div(tmp, 1, tmp) ' tmp = 1 / (n * (x ^ n))
Mpf_add(answer, answer, tmp) ' answer += tmp
Next
/' remove this line if you want to print ln(2)
Gmp_sprintf(text,!"ln(2) =\t %2.100Ff ", answer)
Print *text
Print
'/
Mpf_set_ui(tmp, 1)
Mpf_set(ln2, answer )
Mpf_set(pow_ln2, ln2)
Print
For n = 1 To 40
Mpf_mul_ui(tmp, tmp, n) ' n!
Mpf_mul(pow_ln2, pow_ln2, ln2) ' ln(2)^(n+1)
Mpf_div_ui(answer, tmp , 2) ' / 2
Mpf_div(answer, answer, pow_ln2) ' / ln(2)^(n+1)
Gmp_sprintf(text,!"h(%i) =\t %65.5Ff ",n, answer)
st = *text
num = st[InStr(st,".")] ' get the first character after the "."
If num = Asc("0") Or num = Asc("9") Then
Color 10
Print st;" is a almost integer"
Color 15
Else
Color 12
Print st;" not close enough"
Color 15
End If
Next
mpf_remove(answer) 'cleanup
mpf_remove(pow_ln2)
mpf_remove(ln2)
mpf_remove(tmp)
DeAllocate (text)
' empty keyboard buffer
While Inkey <> "" : Wend
Print : Print "hit any key to end program"
Sleep
End</syntaxhighlight>
{{out}}
<pre>h(1) = 1.04068 is a almost integer
h(2) = 3.00278 is a almost integer
h(3) = 12.99629 is a almost integer
h(4) = 74.99874 is a almost integer
h(5) = 541.00152 is a almost integer
h(6) = 4683.00125 is a almost integer
h(7) = 47292.99873 is a almost integer
h(8) = 545834.99791 is a almost integer
h(9) = 7087261.00162 is a almost integer
h(10) = 102247563.00527 is a almost integer
h(11) = 1622632572.99755 is a almost integer
h(12) = 28091567594.98157 is a almost integer
h(13) = 526858348381.00125 is a almost integer
h(14) = 10641342970443.08453 is a almost integer
h(15) = 230283190977853.03744 is a almost integer
h(16) = 5315654681981354.51308 not close enough
h(17) = 130370767029135900.45799 not close enough
h(18) = 3385534663256845326.39030 not close enough
h(19) = 92801587319328411139.87379 not close enough
h(20) = 2677687796244384203087.52849 not close enough
h(21) = 81124824998504073881728.73642 not close enough
h(22) = 2574844419803190384544450.20255 not close enough
h(23) = 85438451336745709294581778.58838 not close enough
h(24) = 2958279121074145472650646597.12769 not close enough
h(25) = 106697365438475775825583475660.43285 not close enough
h(26) = 4002225759844168492486127555858.62763 not close enough
h(27) = 155897763918621623249276226664346.97380 is a almost integer
h(28) = 6297562064950066033518373935416160.57852 not close enough
h(29) = 263478385263023690020893329036314027.57946 not close enough
h(30) = 11403568794011880483742464196174527074.25258 not close enough
h(31) = 510008036574269388430841024076099269561.72065 not close enough
h(32) = 23545154085734896649184490637145314147689.71316 not close enough
h(33) = 1120959742203056268267494209293002620410998.73593 not close enough
h(34) = 54984904077825684862426868390301031843623475.17448 not close enough
h(35) = 2776425695289206002630310219593685601350868792.44731 not close enough
h(36) = 144199280951655469628360978109406918279521398522.98537 is a almost integer
h(37) = 7697316738562185268347644943000493477791292787264.22720 not close enough
h(38) = 421985466101260424678587486718115935816310614908533.21973 not close enough
h(39) = 23743057231588741419119534567705900419845239863116450.98123 is a almost integer
h(40) = 1370159636942236704917645663312384364387429049720377464.47614 not close enough</pre>
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/Hickerson_series_of_almost_integers}}
'''Solution'''
[[File:Fōrmulæ - Hickerson series of almost integers 01.png]]
[[File:Fōrmulæ - Hickerson series of almost integers 02.png]]
=={{header|Go}}==
<syntaxhighlight lang="go">package main
import (
"fmt"
"math/big"
)
func main() {
ln2, _ := new(big.Rat).SetString("0.6931471805599453094172")
h := big.NewRat(1, 2)
h.Quo(h, ln2)
var f big.Rat
var w big.Int
for i := int64(1); i <= 17; i++ {
h.Quo(h.Mul(h, f.SetInt64(i)), ln2)
w.Quo(h.Num(), h.Denom())
f.Sub(h, f.SetInt(&w))
y, _ := f.Float64()
d := fmt.Sprintf("%.3f", y)
fmt.Printf("n: %2d h: %18d%s Nearly integer: %t\n",
i, &w, d[1:], d[2] == '0' || d[2] == '9')
}
}</syntaxhighlight>
{{out}}
<pre>
n: 1 h: 1.041 Nearly integer: true
n: 2 h: 3.003 Nearly integer: true
n: 3 h: 12.996 Nearly integer: true
n: 4 h: 74.999 Nearly integer: true
n: 5 h: 541.002 Nearly integer: true
n: 6 h: 4683.001 Nearly integer: true
n: 7 h: 47292.999 Nearly integer: true
n: 8 h: 545834.998 Nearly integer: true
n: 9 h: 7087261.002 Nearly integer: true
n: 10 h: 102247563.005 Nearly integer: true
n: 11 h: 1622632572.998 Nearly integer: true
n: 12 h: 28091567594.982 Nearly integer: true
n: 13 h: 526858348381.001 Nearly integer: true
n: 14 h: 10641342970443.085 Nearly integer: true
n: 15 h: 230283190977853.037 Nearly integer: true
n: 16 h: 5315654681981354.513 Nearly integer: false
n: 17 h: 130370767029135900.458 Nearly integer: false
</pre>
=={{header|Haskell}}==
<syntaxhighlight lang="haskell">import Data.Number.CReal -- from numbers
import qualified Data.Number.CReal as C
hickerson :: Int -> C.CReal
hickerson n = (fromIntegral $ product [1..n]) / (2 * (log 2 ^ (n + 1)))
charAfter :: Char -> String -> Char
charAfter ch string = ( dropWhile (/= ch) string ) !! 1
isAlmostInteger :: C.CReal -> Bool
isAlmostInteger = (`elem` ['0', '9']) . charAfter '.' . show
checkHickerson :: Int -> String
checkHickerson n = show $ (n, hickerson n, isAlmostInteger $ hickerson n)
main :: IO ()
main = mapM_ putStrLn $ map checkHickerson [1..18]
</syntaxhighlight>
{{out}}
<pre style="font-size:80%">
(1,1.040684490502803898934790801867495712532,True)
(2,3.0027807071569054434997674072193048895102,True)
(3,12.9962905052769664622248845429643076304964,True)
(4,74.9987354476616001276345503756447016691321,True)
(5,541.0015185164235075692027746182564709468146,True)
(6,4683.0012472622574371804671524790095859510537,True)
(7,47292.9987313146239048228354877863088058057962,True)
(8,545834.9979074851670672910397944923634653083422,True)
(9,7087261.0016228991209791875159082204876452222335,True)
(10,102247563.0052710420110883885941994702319297523418,True)
(11,1622632572.9975500498528748610784990790541604568286,True)
(12,28091567594.9815724407151891760995257984907158464557,True)
(13,526858348381.0012482861804893808362085163957120038669,True)
(14,10641342970443.0845319270950701503926391962048486244252,True)
(15,230283190977853.0374360391259771068310386307484746008223,True)
(16,5315654681981354.5130767434568055779953901730514005313021,False)
(17,130370767029135900.4579853491967736302239049400128248109361,False)
(18,3385534663256845326.3903018015167499502289072143201827212596,False)
</pre>
=={{header|J}}==
Using <math>\ln 2 = \sum_{k\ge 1} \frac{1}{k2^k}.</math> to approximate the natural log of 2 (defining a function whose argument is the limit value for k).
Definitions:
<syntaxhighlight lang="j">ln2=: [: +/ 1 % [: (*2x&^) 1+i.
h=: ! % 2*(ln2 99)^>:</syntaxhighlight>
Implementation (1 in initial column indicates an almost integer, results displayed to 3 digits after the decimal point):
<syntaxhighlight lang="j"> 1 23j3": (h ,.~ 0 9 e.~ 10 <.@* 1 | h) x:1+i.17
1 1.041
1 3.003
1 12.996
1 74.999
1 541.002
1 4683.001
1 47292.999
1 545834.998
1 7087261.002
1 102247563.005
1 1622632572.998
1 28091567594.982
1 526858348381.001
1 10641342970443.085
1 230283190977853.037
0 5315654681981354.513
0 130370767029135900.458</syntaxhighlight>
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}}==
<syntaxhighlight lang="java">import java.math.*;
public class Hickerson {
final static String LN2 = "0.693147180559945309417232121458";
public static void main(String[] args) {
for (int n = 1; n <= 17; n++)
System.out.printf("%2s is almost integer: %s%n", n, almostInteger(n));
}
static boolean almostInteger(int n) {
BigDecimal a = new BigDecimal(LN2);
a = a.pow(n + 1).multiply(BigDecimal.valueOf(2));
long f = n;
while (--n > 1)
f *= n;
BigDecimal b = new BigDecimal(f);
b = b.divide(a, MathContext.DECIMAL128);
BigInteger c = b.movePointRight(1).toBigInteger().mod(BigInteger.TEN);
return c.toString().matches("0|9");
}
}</syntaxhighlight>
<pre> 1 is almost integer: true
2 is almost integer: true
3 is almost integer: true
4 is almost integer: true
5 is almost integer: true
6 is almost integer: true
7 is almost integer: true
8 is almost integer: true
9 is almost integer: true
10 is almost integer: true
11 is almost integer: true
12 is almost integer: true
13 is almost integer: true
14 is almost integer: true
15 is almost integer: true
16 is almost integer: false
17 is almost integer: false</pre>
=={{header|jq}}==
{{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.
<syntaxhighlight lang="jq">def hickerson:
. as $n
| (2|log) as $log2
| reduce range(1;$n+1) as $i ( 0.5/$log2; . * $i / $log2) ;
def precise:
(. - 0.05) as $x | . != ($x + 0.1) ;
def almost_an_integer:
tostring
| index(".") as $ix
| if $ix == null then true
else .[$ix+1:$ix+2] | (. == "9" or . == "0")
end ;
range(1;18)
| . as $i
| hickerson
| if precise then
if almost_an_integer
then "hickerson(\($i)) is \(.) -- almost an integer"
else "hickerson(\($i)) is \(.)"
end
else "insufficient precision for hickerson(\($i))"
end</syntaxhighlight>
{{out}}
<syntaxhighlight lang="sh">$ jq -M -r -n -f Hickerson_series.jq
hickerson(1) is 1.0406844905028039 -- almost an integer
hickerson(2) is 3.0027807071569055 -- almost an integer
hickerson(3) is 12.996290505276967 -- almost an integer
hickerson(4) is 74.9987354476616 -- almost an integer
hickerson(5) is 541.0015185164235 -- almost an integer
hickerson(6) is 4683.001247262258 -- almost an integer
hickerson(7) is 47292.99873131463 -- almost an integer
hickerson(8) is 545834.9979074852 -- almost an integer
hickerson(9) is 7087261.001622899 -- almost an integer
hickerson(10) is 102247563.00527105 -- almost an integer
hickerson(11) is 1622632572.9975502 -- almost an integer
hickerson(12) is 28091567594.98158 -- almost an integer
hickerson(13) is 526858348381.00134 -- almost an integer
hickerson(14) is 10641342970443.086 -- almost an integer
hickerson(15) is 230283190977853.06 -- almost an integer
insufficient precision for hickerson(16)
insufficient precision for hickerson(17)</syntaxhighlight>
=={{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>.)
<syntaxhighlight lang="julia">
function makehickerson{T<:Real}(x::T)
n = 0
h = one(T)/2x
function hickerson()
n += 1
h *= n/x
end
end
function reporthickerson{T<:Real,U<:Integer}(a::T, nmax::U)
h = makehickerson(a)
hgm = makehickerson(prevfloat(a))
hgp = makehickerson(nextfloat(a))
println()
print("Performing calculations using ", typeof(a))
println(", which has ", precision(a), "-bit precision.")
for i in 1:nmax
x = h()
xm = hgm()
xp = hgp()
y = ifloor(10x)
ym = ifloor(10xm)
yp = ifloor(10xp)
println()
println("Hickerson series result for n = ", i)
println(@sprintf(" -> %25.4f ", xm))
println(@sprintf(" 0> %25.4f ", x))
println(@sprintf(" +> %25.4f ", xp))
isprecok =
isint =
if ym == y == yp
print("The precision is adequate, ")
if digits(y)[1] in [0, 9]
println("and the result is an almost integer.")
else
println("but the result is not an almost integer.")
end
else
println("The precision is inadequate for a definite result.")
end
end
end
a = log(big(2.0))
reporthickerson(a, 17)
a = log(2.0)
reporthickerson(a, 17)
</syntaxhighlight>
{{out}}
<pre>
Performing calculations using BigFloat, which has 256-bit precision.
Hickerson series result for n = 1
-> 1.0407
0> 1.0407
+> 1.0407
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 2
-> 3.0028
0> 3.0028
+> 3.0028
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 3
-> 12.9963
0> 12.9963
+> 12.9963
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 4
-> 74.9987
0> 74.9987
+> 74.9987
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 5
-> 541.0015
0> 541.0015
+> 541.0015
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 6
-> 4683.0012
0> 4683.0012
+> 4683.0012
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 7
-> 47292.9987
0> 47292.9987
+> 47292.9987
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 8
-> 545834.9979
0> 545834.9979
+> 545834.9979
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 9
-> 7087261.0016
0> 7087261.0016
+> 7087261.0016
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 10
-> 102247563.0053
0> 102247563.0053
+> 102247563.0053
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 11
-> 1622632572.9976
0> 1622632572.9976
+> 1622632572.9976
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 12
-> 28091567594.9816
0> 28091567594.9816
+> 28091567594.9816
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 13
-> 526858348381.0012
0> 526858348381.0012
+> 526858348381.0012
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 14
-> 10641342970443.0845
0> 10641342970443.0845
+> 10641342970443.0845
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 15
-> 230283190977853.0374
0> 230283190977853.0374
+> 230283190977853.0374
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 16
-> 5315654681981354.5131
0> 5315654681981354.5131
+> 5315654681981354.5131
The precision is adequate, but the result is not an almost integer.
Hickerson series result for n = 17
-> 130370767029135900.4580
0> 130370767029135900.4580
+> 130370767029135900.4580
The precision is adequate, but the result is not an almost integer.
Performing calculations using Float64, which has 53-bit precision.
Hickerson series result for n = 1
-> 1.0407
0> 1.0407
+> 1.0407
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 2
-> 3.0028
0> 3.0028
+> 3.0028
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 3
-> 12.9963
0> 12.9963
+> 12.9963
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 4
-> 74.9987
0> 74.9987
+> 74.9987
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 5
-> 541.0015
0> 541.0015
+> 541.0015
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 6
-> 4683.0012
0> 4683.0012
+> 4683.0012
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 7
-> 47292.9987
0> 47292.9987
+> 47292.9987
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 8
-> 545834.9979
0> 545834.9979
+> 545834.9979
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 9
-> 7087261.0016
0> 7087261.0016
+> 7087261.0016
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 10
-> 102247563.0053
0> 102247563.0053
+> 102247563.0053
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 11
-> 1622632572.9976
0> 1622632572.9976
+> 1622632572.9975
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 12
-> 28091567594.9816
0> 28091567594.9816
+> 28091567594.9815
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 13
-> 526858348381.0024
0> 526858348381.0015
+> 526858348381.0003
The precision is adequate, and the result is an almost integer.
Hickerson series result for n = 14
-> 10641342970443.1094
0> 10641342970443.0898
+> 10641342970443.0645
The precision is inadequate for a definite result.
Hickerson series result for n = 15
-> 230283190977853.5938
0> 230283190977853.1563
+> 230283190977852.5625
The precision is inadequate for a definite result.
Hickerson series result for n = 16
-> 5315654681981368.0000
0> 5315654681981357.0000
+> 5315654681981343.0000
The precision is inadequate for a definite result.
Hickerson series result for n = 17
-> 130370767029136256.0000
0> 130370767029135968.0000
+> 130370767029135600.0000
The precision is inadequate for a definite result.
</pre>
=={{header|Kotlin}}==
{{trans|Java}}
<syntaxhighlight lang="kotlin">// version 1.1.4
import java.math.BigDecimal
import java.math.BigInteger
import java.math.MathContext
object Hickerson {
private const val LN2 = "0.693147180559945309417232121458"
fun almostInteger(n: Int): Boolean {
val a = BigDecimal(LN2).pow(n + 1) * BigDecimal(2)
var nn = n
var f = n.toLong()
while (--nn > 1) f *= nn
val b = BigDecimal(f).divide(a, MathContext.DECIMAL128)
val c = b.movePointRight(1).toBigInteger() % BigInteger.TEN
return c.toString().matches(Regex("[09]"))
}
}
fun main(args: Array<String>) {
for (n in 1..17) println("${"%2d".format(n)} is almost integer: ${Hickerson.almostInteger(n)}")
}</syntaxhighlight>
{{out}}
<pre>
1 is almost integer: true
2 is almost integer: true
3 is almost integer: true
4 is almost integer: true
5 is almost integer: true
6 is almost integer: true
7 is almost integer: true
8 is almost integer: true
9 is almost integer: true
10 is almost integer: true
11 is almost integer: true
12 is almost integer: true
13 is almost integer: true
14 is almost integer: true
15 is almost integer: true
16 is almost integer: false
17 is almost integer: false
</pre>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">h[n_] = n!/(2 (Log[2])^(n + 1));
firstdecimal[x_] := Floor[10 x] - 10 Floor[x];
almostIntegerQ[x_] := firstdecimal[x] == 0 || firstdecimal[x] == 9;
Table[{i, AccountingForm[N[h[i], 50], {Infinity, 5}], almostIntegerQ[N[h[i], 50]]}, {i, 1, 17}] // TableForm</syntaxhighlight>
{{out}}
<pre>1 1.04068 True
2 3.00278 True
3 12.99629 True
4 74.99874 True
5 541.00152 True
6 4683.00125 True
7 47292.99873 True
8 545834.99791 True
9 7087261.00162 True
10 102247563.00527 True
11 1622632572.99755 True
12 28091567594.98157 True
13 526858348381.00125 True
14 10641342970443.08453 True
15 230283190977853.03744 True
16 5315654681981354.51308 False
17 130370767029135900.45799 False</pre>
=={{header|ML}}==
==={{header|mLite}}===
<syntaxhighlight lang="ocaml">local
fun log (n, k, last = sum, sum) = sum
| (n, k, last, sum) = log (n, k + 1, sum, sum + ( 1 / (k * n ^ k)))
| n = log (n, 1, 1, 0);
val ln2 = log 2
in
fun hickerson n = (fold (opt *,1) ` iota n) / (2 * ln2 ^ (n+1));
fun almost_int ([]) = false
| (h :: h' :: t) where (h <> #".") = almost_int (h' :: t)
| (h :: h' :: t) = h' = #"0" or h' = #"9"
| s = almost_int (explode s)
and show (n, h) = println (n, ntos h, almost_int ` ntos ` h)
| n = show (n, hickerson n)
end
;
foreach show ` iota 17;
</syntaxhighlight>
Output
<pre>(1, 1.04068449050280389893479080186749587, true)
(2, 3.00278070715690544349976740721930557, true)
(3, 12.9962905052769664622248845429643116, true)
(4, 74.9987354476616001276345503756447306, true)
(5, 541.001518516423507569202774618256721, true)
(6, 4683.0012472622574371804671524790121, true)
(7, 47292.9987313146239048228354877863377, true)
(8, 545834.997907485167067291039794492739, true)
(9, 7087261.00162289912097918751590822596, true)
(10, 102247563.005271042011088388594199557, true)
(11, 1622632572.99755004985287486107850058, true)
(12, 28091567594.9815724407151891760995539, true)
(13, 526858348381.001248286180489380836777, true)
(14, 10641342970443.0845319270950701504049, true)
(15, 230283190977853.037436039125977107112, true)
(16, 5315654681981354.51307674345680558492, false)
(17, 130370767029135900.457985349196773809, false)
</pre>
=={{header|Nim}}==
Nim floats are limited to 64 bits which is not enough to get correct results for n greater that 14. Unfortunately, the third party "bignum" proposes only big integers and big rationals. But, using an approximation of Ln(2) as a rational, it is possible to compute the terms of the Hickerson series with enough precision, at least until n = 17.
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.
<syntaxhighlight lang="nim">import strformat
import bignum
let ln2 = newInt("693147180559945309417232121458") / newInt("1000000000000000000000000000000")
iterator hickerson(): tuple[n: int; val: Rat] =
## Yield the hickerson series values as rational numbers.
var
n = 1
num = 1
denom = 2 * ln2 * ln2
while true:
yield (n, num / denom)
inc n
num *= n
denom *= ln2
func fract(r: Rat): float =
## Return the fractional part of rational "r".
((r.num mod r.denom) / r.denom).toFloat
for i, val in hickerson():
let f = val.fract
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."
if i == 17: break</syntaxhighlight>
{{out}}
<pre>Fractional part of h(1) is 0.04068..., so h(1) is nearly an integer.
Fractional part of h(2) is 0.00278..., so h(2) is nearly an integer.
Fractional part of h(3) is 0.99629..., so h(3) is nearly an integer.
Fractional part of h(4) is 0.99874..., so h(4) is nearly an integer.
Fractional part of h(5) is 0.00152..., so h(5) is nearly an integer.
Fractional part of h(6) is 0.00125..., so h(6) is nearly an integer.
Fractional part of h(7) is 0.99873..., so h(7) is nearly an integer.
Fractional part of h(8) is 0.99791..., so h(8) is nearly an integer.
Fractional part of h(9) is 0.00162..., so h(9) is nearly an integer.
Fractional part of h(10) is 0.00527..., so h(10) is nearly an integer.
Fractional part of h(11) is 0.99755..., so h(11) is nearly an integer.
Fractional part of h(12) is 0.98157..., so h(12) is nearly an integer.
Fractional part of h(13) is 0.00125..., so h(13) is nearly an integer.
Fractional part of h(14) is 0.08453..., so h(14) is nearly an integer.
Fractional part of h(15) is 0.03744..., so h(15) is nearly an integer.
Fractional part of h(16) is 0.51308..., so h(16) is not nearly an integer.
Fractional part of h(17) is 0.45799..., so h(17) is not nearly an integer.</pre>
=={{header|PARI/GP}}==
<syntaxhighlight lang="parigp">h(n)=n!/2/log(2)^(n+1)
almost(x)=abs(x-round(x))<.1
select(n->almost(h(n)),[1..17])
</syntaxhighlight>
{{out}}
<pre>%1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]</pre>
=={{header|Perl}}==
We'll use Math::BigFloat, which comes with perl.
Conveniently, it includes a sufficiently precise logarithm function.
To avoid doing factorials or exponentiations or divisions in the loop, we first
calculate the inverse of the natural log of 2, and then compute a running value of h.
<syntaxhighlight lang="perl">use strict;
use warnings;
use Math::BigFloat;
my $iln2 = 1 / Math::BigFloat->new(2)->blog;
my $h = $iln2 / 2;
for my $n ( 1 .. 17 ) {
$h *= $iln2;
$h *= $n;
my $s = $h->copy->bfround(-3)->bstr;
printf "h(%2d) = %22s is%s almost an integer.\n",
$n, $s, ($s =~ /\.[09]/ ? "" : " NOT");
}
</syntaxhighlight>
{{out}}
<pre>h( 1) = 1.041 is almost an integer.
h( 2) = 3.003 is almost an integer.
h( 3) = 12.996 is almost an integer.
h( 4) = 74.999 is almost an integer.
h( 5) = 541.002 is almost an integer.
h( 6) = 4683.001 is almost an integer.
h( 7) = 47292.999 is almost an integer.
h( 8) = 545834.998 is almost an integer.
h( 9) = 7087261.002 is almost an integer.
h(10) = 102247563.005 is almost an integer.
h(11) = 1622632572.998 is almost an integer.
h(12) = 28091567594.982 is almost an integer.
h(13) = 526858348381.001 is almost an integer.
h(14) = 10641342970443.085 is almost an integer.
h(15) = 230283190977853.037 is almost an integer.
h(16) = 5315654681981354.513 is NOT almost an integer.
h(17) = 130370767029135900.458 is NOT almost an integer.</pre>
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(notonline)-->
<span style="color: #008080;">without</span> <span style="color: #008080;">javascript_semantics</span> <span style="color: #000080;font-style:italic;">-- (no mpfr_log() for pwa/p2js)</span>
<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.0"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (mpfr_set_default_prec[ision] renamed)</span>
<span style="color: #008080;">include</span> <span style="color: #004080;">mpfr</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #7060A8;">mpfr_set_default_precision</span><span style="color: #0000FF;">(-</span><span style="color: #000000;">23</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (found by trial/error)</span>
<span style="color: #004080;">mpfr</span> <span style="color: #000000;">ln2</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpfr_init</span><span style="color: #0000FF;">(</span><span style="color: #000000;">2</span><span style="color: #0000FF;">),</span>
<span style="color: #000000;">hn</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpfr_init</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0.5</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">mpfr_log</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ln2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ln2</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_div</span><span style="color: #0000FF;">(</span><span style="color: #000000;">hn</span><span style="color: #0000FF;">,</span><span style="color: #000000;">hn</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ln2</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">17</span> <span style="color: #008080;">do</span>
<span style="color: #7060A8;">mpfr_mul_si</span><span style="color: #0000FF;">(</span><span style="color: #000000;">hn</span><span style="color: #0000FF;">,</span><span style="color: #000000;">hn</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">mpfr_div</span><span style="color: #0000FF;">(</span><span style="color: #000000;">hn</span><span style="color: #0000FF;">,</span><span style="color: #000000;">hn</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ln2</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">n10</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpfr_sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%24.4Rf "</span><span style="color: #0000FF;">,</span><span style="color: #000000;">hn</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">n10</span> <span style="color: #0000FF;">&=</span> <span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">find</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n10</span><span style="color: #0000FF;">[</span><span style="color: #000000;">21</span><span style="color: #0000FF;">],</span><span style="color: #008000;">"09"</span><span style="color: #0000FF;">)?</span><span style="color: #008000;">"Y"</span><span style="color: #0000FF;">:</span><span style="color: #008000;">"N"</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%2d:%s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n10</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
1: 1.0407 Y
2: 3.0028 Y
3: 12.9963 Y
4: 74.9987 Y
5: 541.0015 Y
6: 4683.0012 Y
7: 47292.9987 Y
8: 545834.9979 Y
9: 7087261.0016 Y
10: 102247563.0053 Y
11: 1622632572.9976 Y
12: 28091567594.9816 Y
13: 526858348381.0012 Y
14: 10641342970443.0845 Y
15: 230283190977853.0374 Y
16: 5315654681981354.5131 N
17: 130370767029135900.4580 N
</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.
<syntaxhighlight lang="picolisp">
(load "@lib/misc.l")
(scl 25)
(setq LN2 0.69314718055994530941723212)
(de almost-int? (N)
(bool (member (% (/ N 0.1) 10) (0 9))))
(de fmt4 (N)
(format (/ N 0.0001) 4))
(de h (N)
(*/ (factorial N) `(* 1.0 1.0) (* 2 (s** LN2 (inc N)))))
(de s** (A N) # scaled integer exponentiation
(let R 1.0
(for Bit (chop (bin N))
(setq R (*/ R R 1.0))
(when (= Bit "1")
(setq R (*/ A R 1.0))))
R))
(de factorial (N)
(cond
((lt0 N) NIL)
((=0 N) 1)
(T (apply * (range 1 N)))))
(for I 18
(let H (h I)
(if (almost-int? H)
(prin "yes: ")
(prin " no: "))
(prinl "h(" (align 2 I) ") = " (fmt4 H))))
(bye)
</syntaxhighlight>
{{Out}}
<pre>
yes: h( 1) = 1.0406
yes: h( 2) = 3.0027
yes: h( 3) = 12.9962
yes: h( 4) = 74.9987
yes: h( 5) = 541.0015
yes: h( 6) = 4683.0012
yes: h( 7) = 47292.9987
yes: h( 8) = 545834.9979
yes: h( 9) = 7087261.0016
yes: h(10) = 102247563.0052
yes: h(11) = 1622632572.9975
yes: h(12) = 28091567594.9815
yes: h(13) = 526858348381.0012
yes: h(14) = 10641342970443.0845
yes: h(15) = 230283190977853.0374
no: h(16) = 5315654681981354.5130
no: h(17) = 130370767029135900.4579
no: h(18) = 3385534663256845326.3904
</pre>
=={{header|PL/I}}==
<syntaxhighlight lang="pli">Hickerson: procedure options (main); /* 12 January 2014 */
declare s float (18), (i, n) fixed binary;
declare is fixed decimal (30);
declare f fixed decimal (4,3);
do n = 1 to 16; /* 17 exceeds hardware precision */
s = 0.5Q0 / 0.693147180559945309417232121458;
do i = 1 to n;
s = (s * i) / 0.693147180559945309417232121458;
end;
is = s;
f = s-is;
is = 10*f;
put skip edit (n, s) (f(2), f(30,3));
if is = 0 | is = 9 then
put edit (' is a near integer') (A);
else
put edit (' is not a near integer') (A);
end;
end Hickerson;</syntaxhighlight>
{{out}}
<pre>
1 1.041 is a near integer
2 3.003 is a near integer
3 12.996 is a near integer
4 74.999 is a near integer
5 541.002 is a near integer
6 4683.001 is a near integer
7 47292.999 is a near integer
8 545834.998 is a near integer
9 7087261.002 is a near integer
10 102247563.005 is a near integer
11 1622632572.998 is a near integer
12 28091567594.982 is a near integer
13 526858348381.001 is a near integer
14 10641342970443.085 is a near integer
15 230283190977853.037 is a near integer
16 5315654681981354.510 is not a near integer
</pre>
Using extended precision available by software:
<syntaxhighlight lang="pli">
do n = 1 to 18;
s = divide( float(0.5), float(0.693147180559945309417232121458) );
do i = 1 to n;
s = divide ( multiply(s, float(i)), float(0.693147180559945309417232121458) );
end;
is = trunc(s);
f = subtract(s, is);
is = multiply(float(10), f);
is = trunc(is);
put skip edit (n) (f(3)); call output_fixed (s, 'F(60,4)' );
if compare(is, float(0)) = 0 | compare(is, float(9)) = 0 then
put edit (' is a near integer') (A);
else
put edit (' is not a near integer') (A);
end;
</syntaxhighlight>
{{out}} Results:
<pre>
1 1.0406 is a near integer
2 3.0027 is a near integer
3 12.9962 is a near integer
4 74.9987 is a near integer
5 541.0015 is a near integer
6 4683.0012 is a near integer
7 47292.9987 is a near integer
8 545834.9979 is a near integer
9 7087261.0016 is a near integer
10 102247563.0052 is a near integer
11 1622632572.9975 is a near integer
12 28091567594.9815 is a near integer
13 526858348381.0012 is a near integer
14 10641342970443.0845 is a near integer
15 230283190977853.0374 is a near integer
16 5315654681981354.5130 is not a near integer
17 130370767029135900.4579 is not a near integer
18 3385534663256845326.3903 is not a near integer
</pre>
=={{header|Python}}==
This uses Pythons [http://docs.python.org/2/library/decimal.html decimal module] of fixed precision decimal floating point calculations.
<
import math
Line 122 ⟶ 1,790:
if 'E' not in norm and ('.0' in norm or '.9' in norm)
else ' NOT nearly integer!')
print('n:%2i h:%s%s' % (n, norm, almostinteger))</
{{out}}
Line 145 ⟶ 1,813:
'''The range for <math>n</math> should be reduced''' to be <math>1<= n <= 15</math> for this definition of almost integer.
=={{header|Racket}}==
{{trans|Python}}
<syntaxhighlight lang="racket">#lang racket
(require math/bigfloat)
(define (hickerson n)
(bf/ (bffactorial n)
2.bf
(bfexpt (bflog 2.bf) (bf (+ n 1)))))
(for ([n (in-range 18)])
(define hickerson-n (hickerson n))
(define first-decimal
(bigfloat->integer (bftruncate (bf* 10.bf (bffrac hickerson-n)))))
(define almost-integer (if (or (= first-decimal 0) (= first-decimal 9))
"is Nearly integer"
"is not Nearly integer!"))
(printf "~a: ~a ~a\n"
(~r n #:min-width 2)
(bigfloat->string hickerson-n)
almost-integer))</syntaxhighlight>
{{out}}
<pre> 0: 0.7213475204444817036799623405009460687136 is not Nearly integer!
1: 1.040684490502803898934790801867495712535 is Nearly integer
2: 3.002780707156905443499767407219304889517 is Nearly integer
3: 12.99629050527696646222488454296430763056 is Nearly integer
4: 74.99873544766160012763455037564470166964 is Nearly integer
5: 541.0015185164235075692027746182564709501 is Nearly integer
6: 4683.001247262257437180467152479009585976 is Nearly integer
7: 47292.99873131462390482283548778630880614 is Nearly integer
8: 545834.9979074851670672910397944923634685 is Nearly integer
9: 7087261.001622899120979187515908220487726 is Nearly integer
10: 102247563.005271042011088388594199470233 is Nearly integer
11: 1622632572.997550049852874861078499079071 is Nearly integer
12: 28091567594.98157244071518917609952579893 is Nearly integer
13: 526858348381.0012482861804893808362085239 is Nearly integer
14: 10641342970443.08453192709507015039263936 is Nearly integer
15: 230283190977853.0374360391259771068310425 is Nearly integer
16: 5315654681981354.513076743456805577995494 is not Nearly integer!
17: 130370767029135900.4579853491967736302263 is not Nearly integer!</pre>
=={{header|Raku}}==
(formerly Perl 6)
{{works with|rakudo|2015-09-13}}
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)].
<syntaxhighlight lang="raku" line>constant ln2 = [+] (1/2.FatRat, */2 ... *) Z/ 1 .. 100;
constant h = [\*] 1/2, |(1..*) X/ ln2;
use Test;
plan *;
for h[1..17] {
ok m/'.'<[09]>/, .round(0.001)
}</syntaxhighlight>
{{out}}
<pre>ok 1 - 1.041
ok 2 - 3.003
ok 3 - 12.996
ok 4 - 74.999
ok 5 - 541.002
ok 6 - 4683.001
ok 7 - 47292.999
ok 8 - 545834.998
ok 9 - 7087261.002
ok 10 - 102247563.005
ok 11 - 1622632572.998
ok 12 - 28091567594.982
ok 13 - 526858348381.001
ok 14 - 10641342970443.085
ok 15 - 230283190977853.037
not ok 16 - 5315654681981354.513
# Failed test '5315654681981354.513'
# at hickerson line 8
not ok 17 - 130370767029135900.458
# Failed test '130370767029135900.458'
# at hickerson line 8</pre>
=={{header|REXX}}==
===version 1===
<syntaxhighlight lang="rexx">/* REXX ---------------------------------------------------------------
* 04.01.2014 Walter Pachl - using a rather aged ln function of mine
* with probably unreasonably high precision
* 05.01.2014 added n=18
*--------------------------------------------------------------------*/
Numeric Digits 100
Do n=1 To 18
x=format(def(),20,10)
Parse Var x '.' +1 d +1
If pos(d,'09')>0 Then
tag='almost an integer'
Else
tag=''
Say right(n,2) x tag
End
Exit
def:
x=fact(n)/(2*ln(2,200)**(n + 1))
Return x
ln: Procedure
/***********************************************************************
* Return ln(x) -- with specified precision
* Three different series are used for the ranges 0 to 0.5
* 0.5 to 1.5
* 1.5 to infinity
* 920903 Walter Pachl
***********************************************************************/
Parse Arg x,prec,b
If prec='' Then prec=9
Numeric Digits (2*prec)
Numeric Fuzz 3
Select
When x<=0 Then r='*** invalid argument ***'
When x<0.5 Then Do
z=(x-1)/(x+1)
o=z
r=z
k=1
Do i=3 By 2
ra=r
k=k+1
o=o*z*z
r=r+o/i
If r=ra Then Leave
End
r=2*r
End
When x<1.5 Then Do
z=(x-1)
o=z
r=z
k=1
Do i=2 By 1
ra=r
k=k+1
o=-o*z
r=r+o/i
If r=ra Then Leave
End
End
Otherwise /* 1.5<=x */ Do
z=(x+1)/(x-1)
o=1/z
r=o
k=1
Do i=3 By 2
ra=r
k=k+1
o=o/(z*z)
r=r+o/i
If r=ra Then Leave
End
r=2*r
End
End
If b<>'' Then
r=r/ln(b)
Numeric Digits (prec)
Return r+0
fact: Procedure
Parse Arg m
fact=1
Do i=2 To m
fact=fact*i
End
Return fact</syntaxhighlight>
{{out}}
<pre> 1 1.0406844905 almost an integer
2 3.0027807072 almost an integer
3 12.9962905053 almost an integer
4 74.9987354477 almost an integer
5 541.0015185164 almost an integer
6 4683.0012472623 almost an integer
7 47292.9987313146 almost an integer
8 545834.9979074852 almost an integer
9 7087261.0016228991 almost an integer
10 102247563.0052710420 almost an integer
11 1622632572.9975500499 almost an integer
12 28091567594.9815724407 almost an integer
13 526858348381.0012482862 almost an integer
14 10641342970443.0845319271 almost an integer
15 230283190977853.0374360391 almost an integer
16 5315654681981354.5130767435
17 130370767029135900.4579853492
18 3385534663256845326.3903018015 </pre>
===version 2===
This REXX version can calculate the Hickerson series to any number up to the length (in decimal digits)
<br>of the number returned by the '''ln2''' function.
This version supports up to '''507''' decimal digits.
<syntaxhighlight lang="rexx">/*REXX program to calculate and show the Hickerson series (are near integer). */
numeric digits length(ln2())-length(.) /*be able to calculate big factorials. */
parse arg N . /*get optional number of values to use.*/
if N=='' then N= 1 /*Not specified? Then use the default.*/
/* [↓] compute possible Hickerson #s. */
do j=1 for N; #= Hickerson(j) /*traipse thru a range of Hickerson #s.*/
?= right(# * 10 % 1, 1) /*get 1st decimal digit past dec. point*/
if ?==0 | ?==9 then _= 'almost integer' /*the number is, */
else _= ' ' /* or it ain't. */
say right(j,3) _ format(#, , 5) /*show number with 5 dec digs fraction.*/
end /*j*/
exit /*stick a fork in it, we're all done. */
/*─────────────────────────────────────────────────────────────────────────────────────────────────────────*/
!: procedure; parse arg x; !=1; do j=2 to x; != !*j; end; return ! /* ◄──compute X factorial*/
Hickerson: procedure; parse arg z; return !(z) / (2*ln2() ** (z+1))
ln2: return .69314718055994530941723212145817656807550013436025525412068000949339362196969471560586332699641,
|| 8687542001481020570685733685520235758130557032670751635075961930727570828371435190307038623891673471123,
|| 3501153644979552391204751726815749320651555247341395258829504530070953263666426541042391578149520437404,
|| 3038550080194417064167151864471283996817178454695702627163106454615025720740248163777338963855069526066,
|| 83411372738737229289564935470257626520988596932019650585547647033067936544325476327449512504060694381470</syntaxhighlight>
{{out|output|text= when using the input of: <tt> 197 </tt>}}
<pre style="height:91ex">
1 almost integer 1.04068
2 almost integer 3.00278
3 almost integer 12.99629
4 almost integer 74.99874
5 almost integer 541.00152
6 almost integer 4683.00125
7 almost integer 47292.99873
8 almost integer 545834.99791
9 almost integer 7087261.00162
10 almost integer 102247563.00527
11 almost integer 1622632572.99755
12 almost integer 28091567594.98157
13 almost integer 526858348381.00125
14 almost integer 10641342970443.08453
15 almost integer 230283190977853.03744
16 5315654681981354.51308
17 130370767029135900.45799
18 3385534663256845326.39030
19 92801587319328411139.87379
20 2677687796244384203087.52849
21 81124824998504073881728.73642
22 2574844419803190384544450.20255
23 85438451336745709294581778.58838
24 2958279121074145472650646597.12769
25 106697365438475775825583475660.43285
26 4002225759844168492486127555858.62763
27 almost integer 155897763918621623249276226664346.97380
28 6297562064950066033518373935416160.57852
29 263478385263023690020893329036314027.57946
30 11403568794011880483742464196174527074.25258
31 510008036574269388430841024076099269561.72065
32 23545154085734896649184490637145314147689.71316
33 1120959742203056268267494209293002620410998.73593
34 54984904077825684862426868390301031843623475.17448
35 2776425695289206002630310219593685601350868792.44731
36 almost integer 144199280951655469628360978109406918279521398522.98537
37 7697316738562185268347644943000493477791292787264.22720
38 421985466101260424678587486718115935816310614908533.21973
39 almost integer 23743057231588741419119534567705900419845239863116450.98123
40 1370159636942236704917645663312384364387429049720377464.47614
41 81045623051154285047127402304207782853156218361814319021.28280
42 4910812975389574954318759599939388855544732309560436182821.35633
43 304646637632091740261982544696657582136519509662728787385223.78746
44 19338536506753895707368358095646384573117827333115778939657189.34970
45 1255482482235481041484313695469155949742941813368110258119125666.54828
46 almost integer 83318804148028351409201335290659562069258599819486505697819558094.95701
47 5649570401186486930330812460375430692673276471701214788305128308192.63131
48 391229145645351175841837029639030040330277058722445073547950709497937.24947
49 27656793065414932606012896651489726461435178241054470446176414701300759.68492
50 1995015910118319790635433747742913123711612309012803454341376306544687943.66054
51 almost integer 146788177561136377730260697283316629866051820967150940915169721150316606892.05918
52 11012069943086163504795579947992458193990796847590872523330083892852015565626.28941
53 842014110931079332783532220015836831045327371743757681552681009426224153091637.23798
54 65597557438735074090994025536102763729036609801731831230533885501204932903110195.70938
55 5205049894621061289218474196429496131424689228776492621372505509295323231187794811.18045
56 almost integer 420520781550767894712366209445415465306816295045705598150082071298498563284781170169.03701
57 almost integer 34580945029640504393370721771069401074083502173524617793574204974469998047025866870097.02237
58 2893605958403939796891998166457291344321113091137014546099293839148904090004806176427638.60317
59 246300867022091084352691958585695642066952827239759473981562041651101948387611615902530101.23216
60 almost integer 21320222365165370148450725694202652367764740960338726836059360731081589392256498745759003771.01903
61 1876273323689316794552898932003548830214301148023334732450711143880068675273459337334678356510.54479
62 almost integer 167827193605207470382244239593751346592925059206583127133257042316428312353166326463498634995723.96506
63 almost integer 15253777976254320482680028798302887920587781886722393040786662312902435640815721495160588622047541.92840
64 1408419189834457368564204829523128565178390518208834734403870767459047244122454099122442802088884321.73467
65 132074759743356507265849312929567147234908587643858117900265185019357132816098895359362429954543792250.41307
66 12575877659950554472502916897483150472428551212111494310419777827319052677957994891799291825191389852999.17201
67 1215591474434076764736685372169536683582142127785487987047068194303571231853163199814716027890404260071569.88314
68 almost integer 119253489850080307228410908979332327602349548167435756238732178160360682219616027578362147289795251646339953.92335
69 almost integer 11871202870663510214658796273851712937873144830499188934497638900478929836299976837994531733424834494413388915.95250
70 1198856785762515085433047378179373006408841522298485701569549736200218795168354301822880350705072744254029177974.27548
71 122800516508452069087008691134168306922157250579355968528220277637680521063341532176649945604606722169422881949772.27313
72 12755786125344990028594343963936309999106975215043630050197141450003929225895159286410920090232666677567781668116842.80093
73 1343397785154308762546986584839633417565562502594324180627238421955041065318679414963300088378553801208008677342105129.20781
74 143420385871167038557536299613944875171590207217392651473614091977309061787666287331580822225139240178311453147278916363.35957
75 15518390959403568033551566827678607140363326576559695820270383745035406196325951714541143408200761091941463352557779137479.59341
76 almost integer 1701511231657781450488490657187463365688823186902664849351256426751462495076884249622278025237121805817453644028642475582941.04704
77 189016659826575619359816463566590900567665644326734831940281352836144822599463416848350164874138510566588334766260387690390882.63636
78 21270085026621350415799651921499346803894882526119364175378674541895973741657242545930525335438800297104058164210172490673537333.32584
79 2424213448788264179583061306089147620134038095441867764757968971686974539641887227399315328126639570887068398905864468400203147379.13428
80 279792057649852783175737713059565268313828016234531102244960765250050772031108759182312138156720330707487174908389146019680769950627.13659
81 32696023738176487003017678437152831751829536269695148312421532512438766629331326025007830371276220306319964008365309960094718678123025.72933
82 3867972086916113699289650561448774985264647530291049879502944190830421004287744690833208017718554836505317767698155032416161235799978153.55849
83 almost integer 463165244291537377407938377908509856879151672553650449432252233056386498022670707383927182825531345754093757771505246691827175409837333706.03165
84 56129320888328204336159568944138094624862468930689936507266999153981195420801200053053466593736461319060626598320474363329095816269614248570.26351
85 6883086895994794564193512707959076687449938175712429198130223275797343967727966873924934477871130478678856374089795957959702559434133276875558.36346
86 853996798453916859286707332364040151020472833921624157042891999067692861031567447908099758601565668309504205967050579936439746813730932889524110.10646
87 almost integer 107188954307613016000523311392809231433160190250667607690375475681677727720687471319593137707247355623545849957670511278864612577019674851693529129.02379
88 13608405607954695161891393427685656221057735793458790720461284212774892489827559568850855692362627497225211166876726460186939885169175550464962373899.34048
89 1747317356365160010675286089449398905752478506010237186666200281047566557280027666701240190903491017547173702078796478817511283115112530023987934885247.58668
90 almost integer 226876147639850697035498164180665227340867432554801341517337271449480622375293088050301117860485783921944898315478899240634590962769072809212926135838226.00884
91 29785491471736445918952653271075531391540819876778975402174887327425599452642406068862719850771752593361583104778259003866002872441102216080600657543852651.65325
92 3953367036977750808685756007120090736939292055073874653365943059202128556342358488546018279923077047134125498022074379841398482263974194955368267319577754995.27286
93 almost integer 530425780772737757181826423434492823619343330766440565137249239877583887700661622746755246932052806628510661960680329286085407045591157790622109718215821384486.92752
94 71932808487165612459817313420088981223441387545508285691783916644870517242503482223932321736730312940138541874552901642390084976544951541683244641434588659192963.57883
95 almost integer 9858825077756689892365727469356584444697619626867085315546360659481108594876947783837934569215103038786902497849668159869688315692702653014667407310567738222438995.92792
96 1365434692672447254549334110811913069561967885901464921338743306353836651045642292387627910698830813843896593548335731977839012531770052413043446025832262165782270740.75950
97 191080868398299691145372728810441155882257482078053536497729039741289151762976230835088279174422983509793335031628712195215374587400810640276485642254628643079607175392.85664
98 27015799282204393652757486182039839007928724239614076724115229683229744474973964185696283577921463067421150497137337005875520322135625742598745273146982124791039386353415.38534
99 almost integer 3858580405358701701178592349999764119100383919493174924234254289226946169670282634143611442423604879965913160770963193114640928490544697626354358018070202709736290269337380.08317
100 almost integer 556675481568232514984982818042190343148558399534414077721290961776960540637206877790763456361060917814220537590278336850556859288553005678671299997903793583385604976819964755.04034
101 81114408620939424986242514379582957449016424524099565267891545593328093462760476004369461266098743327042738370557610164286909371887321059005699649656712559364600524668046794528.44599
102 11936382216331169543459489823962269247340103082621860186296631343330490903201372446908668847970901657125884938029330188049336491356935287124813184542465509756888606391507242520194.23361
103 almost integer 1773717621254587807345808358381304237732498110887124158117318309098848032800262430393573334097474125584687058988428219977893011195082866094273627682650470062670514333460416907621582.90899
104 266129096076621696587457570500527320905565521509692908178076934476696035458451901526371083769423579154339533869506520423226593390860325287170949115309735105100004938678805354930046450.14803
105 40314028350330484015245036711230598747596286811487007250653044228411079693097670122719321789136650982285647520969570440822516442552260314433245938212396974979161155010282225695876805160.16471
106 6165049970603559971568615064523283028584617037618201386263234271314730434154454509949110928686550351412525867537013817108514711812479711616073350289020590644957335849472737850469615043925.64606
107 951688711078197399813808296545760872147628716236561389481424327075244763209386401065062331631986034894116821764081819058541983719890778797125461842371654127768373378615484518917157035254556.54084
108 148283631065792687061419360565375379308559840321757580470062533908445626372097828715429287981460169451241740535123834324194616768608497984202142352223761497549980831803636384122583512842707655.33220
109 23318158451015424228950671773583457159746952971274726427350763676476539678958570327282116705779386714745323345804539112039982994738995010310011179032182763747601490575140661761177951120275275414.20366
110 almost integer 3700509071593732759743387879122534531093459460019546885341496988364005534089830811680294792747194445415434375962412398953950450394440991138741768593093575004323295113512001416462649321025727206777.03051
111 592596375585171933390750659287342641654953297691010994963323859733044942221570118622885921630262738836076821004543838157482529421781108680909554473521249711877254209263603384825050196032113797263696.34724
112 almost integer 95752815458216127576890837767142061080070498026215229450388035105997326196134526961277649242964336060360357296674263698547346506504900657846222052210432065624714479019752542356577276908638116789448673.95076
113 15610058657437866646486934261623564713499145696125747834762160156265986835065327251656537539201315989971943162457656519855358769881410817736735403605534922557214764577081238208145608789268376863146495730.39713
114 2567343180290144188759052538844932809564341142956576847230230487853327344139915083551758055830823684090597642898626979213291475790727266282798189612798100442732998346450643792139372114338488731182587049563.86795
115 425947726563439456193357598283577430239944402421297999785709691652897108771516590505203130432105264038019852624481756516667266902102644075604636778483744921373972236321486367038793538738854208093492028088565.17068
116 71283470043756265773806339672676821238242181932992368764625814367671298825779365158678502776867824272395232669215251372909147291139380532044974951121123207441178223791555965821296957200406804842537713764008645.84444
117 almost integer 12032316121349644850261476325442362736118338476108342105408800024255837142801156909123609843739117921351404061777680000018958582197196407532758363447141948123030690218513263569153882064669617607059311406089315336.90537
118 2048357610244176217330259927929847195453492343074137059661813165405040134253938592377265334895794412518463666025202476107488959851932569276952996042106178781645512010209168334419132358293725616440374103949203978524.76656
119 351663488585706500220392195482117025377561436720676055038587055644194823743159881388779433156511639282333484629603694972572921812890322525081218896524486295705268021137592791746181973698521613516225076361190717472541.82289
120 60881180525317362698513562979673962450025251047234028540125599471773516387024940354882385257726476473204265820991508715368377388906337376806686459529640985898339445398031822351297800244319449448813273107679917409516460.58411
121 10627790244508272528263788704322466474482213858819073204023396314191334618336896960206146402613463406035641455746398372326998207611674498599407823545810401380537417083650327674133141270259979345581373425266938122082191401.24869
122 1870584554325943014563006390580938172260407123002591745530970502010727043208383927087458942432087733561430123492538962350460691683215234200910063673621903226072403136121459096743264021915954387839998790722854720867499522059.51197
123 almost integer 331938016391012159200939423808212256954486959317325379153498995020380297837206876083071758514294279289479655646269592221929040450657682954776842594350306680674708239162806939968379542746178247931908432124439231430446904958884.94518
124 59381780936099253900024661626072197009857295709261723604551628599957794012202410240026900090302502263389590677759710488195460998699206781872870740681011922997152790163436589714940766411485497067266525120301159315132621943217694.16327
125 10708725109458147608165205725435802215704214844760298635570819965684624486627412080715266124791151793287808468866379936761039506767764805818963962499187469108991484372520189443772190361643170492716242748101112374819071345802032878.11885
126 1946627500816957316862735389502281981716828076909629690407535950224352728592825798896739822054566370290647926964588299879354885209355036220711853610774911427147405543829607921589470255735029312123267581915647233921115103765346004441.27874
127 356665509919611012384376913461143176864132405138530009887254419313626010505703984507267604908662754612386567030614629832375793684171422171439587289040402236399944896905102473713814773343335971318810379308728487064165088061196487012629.56912
128 65863623989395992740124360717699657982839698584715608144791847453230524585085759181826949515835116573507176771403177301606042312078030471071888582685211011536060589922300265432676819051748436156504108373566950976993584687015595405959621.55179
129 12257724957877528217291429249369099757060427301862538465552411576010691795696634260205879000405735350780182127716440309555705462438537642240526383539494737345126658052456772742388107648219305834033668796254389667736167544250454255901818530.46242
130 2298940671210402418105657910981997459313944147851439632728905908873193349059129764773970832226363706618646944685899693812935317708260050606544167718707995193159757381151390336002964587250907772172802432439332278112472829320919830152236196376.77989
131 almost integer 434483810040568217159734115405472141287609929559445180855862969158818103113484334418341406739576386365148427335248295576038177978563092484396569247490348587405453357084979961639084186436157378222072543299291467575928141891356731691270881628528.02298
132 82741248228153262954057773673730030611283904675989680259962714117411595883906951844757357736952235912832587373353965463643667005832840759304445904790252558341099425225062876948903674498628150667862804330300848091618473057457502383900726307128488.77321
133 15876261669930685889440397986313869878743245523736989306112243867485545713974518175619363175944865701658783526093610246983539669560898987523270857179648987194543905850842365655707017358924167069000903325455983663525581946869138633792065926434901438.23666
134 3069216933194647468462222127254056619887822603880400428509346167460486251364431718575779562306542640246031542819774224225952518884472271550011794564583535798331098565401047954541850212839053240557469264776149843335095015280622415383162754832235136184.49124
135 almost integer 597772446605867358021397017199698115152668557436242478624117144785666140988452016755857329055183003638912539958254797455780798704347986155374919206190129972960512094944774366058552165781746481022774515984514316460920816379717172299891546839575721041339.94477
136 117286854824575260445536568550437995938000212919475892926398411117464128133471718133308608262700171765580275936647528331081654931146788619804680436984702308754700102260981947251843964607079762838591919720324600104139011044169905668080049454521018778990097.58267
137 almost integer 23181655442912357302316784788025853877080767602012790530291610199635654201205240854990983045336644322793616019066562766998722182800308745766989947927760634108987435605025929926479134421187199097791344728772227160390884825359243093524640268709056468645764314.98542
138 almost integer 4615280189897910013483874023750835748597618984464840101947048537983598920251721222529905475263687103741818933428861125367171977941831323673631467653998042626372184979884067134452552273359962896842365510099790551827599944932235750929263901833454524597688104091.02264
139 925523416076751544002917504374040362136244811470543300813668700399559505181858582214600534319716250300109073015079232639945499640345390871532302750672882246657852717054558574294189478776177176846450415429643518924627120062549889134798066077605632651756877907628.81045
140 almost integer 186934725964075902594927204560221922085969293947470908896819363007093040377758711566390296620565298857152798563564056520601988894908654597816755920667108060781261246706284370433266258089950973112115142078714251962303366015576187328097705702023541560504586724922846.07644
141 38026262098681661186384205690327525101407436854637223015330813229067707022878468254480507804768525560978262710512065180265715782489940129125971190413927951162359704963971312604258695645983663167371166091964933011768027236774790932949490442618701211855732172013564488.48496
142 7790162564970300969288691908792766839406438559991969830393442450335565202895452083886450857185816396699466683100621114038743679819061734337398353978208489150664399388232152137540785594049487420615427921277122155398735407304006474770711539288410926499056211525468617200.63357
143 1607152532728814559108151606007439999191121780095423089313359857324291486973513167190930576475618060338455999952705709410097310076733024694550833791333564258005049475138013291683942726327641970883538288927017438705420326148460298723770251017095717186949595008531997038160.70147
144 333882862404479743845147408828684693537435802265676518564307659991695421126033106303577150656155073103889598936841473799200805297702209366557994796969121996433896242382533282336596673453543702403635541030417437496472331066269319984000926983494965312020566875109448739465735.19528
145 69845216725169481850965205888599442488694626899984285216809790758005059208253039374308508998881189677965533327414382535934484130726432434071372479309566028814424037179341402341594628057353112401691656510812584932397658657822866112485400744846469835220059229342925780148422144.50109
146 14711740778685666885139261313061044455515206836997347024479132923675111701671268598677009107091025176503782114365572906090794826594499583585292716848702468215413178533754439431310017771077393718609730240524654194459140058678504038367768960672045353216264051444869472573348509080.39306
147 almost integer 3120009653245301036129556532211329257120397502374103300648918370097718733496613213116666577338957660501803703819985656436184743823798779061582697830471860305341787298433052118486970534497005167734377565171298096515927259570870366054767430105610386560634274821870433517740058206205.93043
148 666180923230878137830414241408144935088285984624081366577273304454344039776100919154846239859264419055860248552872536868249820747399404157688963013669180874255972166549677168453341797339366224910502735118393846709165723481015327996214702394425158382269122010547831246727560575803368.69243
149 almost integer 143203291227722850031155646256862209447729113591002376247444546645535989285187860008550750462141963859545911478560400362411196583026265264941713807318345977172365546177639121425603366376945925505899176677609598618757891050783857896663444352920590969295112396791145394860074070605942978.96464
150 30989801713982062792434631927766259065743852346381353424655819468138215874397172529395309518244577736192554160906706019950120882541695044517657605104205361160853936162041446040804841628479633462249454750941098914991558994800055110823193129657330134825925771119695294364934131171578277211.86520
151 6751033820885027275067272158501710820224477291596666820140278220759670988286332280849821525521779400199079747885945949717520800713168267936131470860990593270248090549037001175990610734016515324284675818324027917368764147687961521706115979211989820989673804436189131917112050203095317873851.31529
152 1480431818168203891870287804843184873937879041449750391843965961804860626346490048124930633467391764945316451110286306128085191544389725974837198845173815724740004384768959593359376561918234498793028251118274454695329622572056212519670370105062799915152080315463353822495069644198759302136867.15345
153 326779181294161401154780774576319502506058456803961724679673948298027377083365384654284835663797790769336091151633470256968508779508644550575235042937154358240044713756956859672078402919023534840148083665222263158931136898528152735474645078364080666405552992224156321545389607390847392314469898.73597
154 72602176465101694004901503616793052682855926956259480319034656717689680850314879266865240871104084097431007792109084621290271066656333360031646400142421772848790412933664796780081712665269831629025137646745379116823290861876458330127638140913114730886962821051660888766168022973464094711969060909.13190
155 16235133991311881907338032643044452802932428234787601417304166592301609929567611017874830293973748714363590084283668417308148101106520292361975061079561047469069669896906073761876358816402423087300575017384369590147797240707648375531622320896078804446154187805466344721631282144290630300483195600524.84459
156 3653886178399625243812442730999484119324407061199933147807976079375653071438899177450573129322404111005507881331131643516239447979048497158368196323256390104855469886767561507306152001636194017056103393187182141228161643495982917194676297916242749065422653559965557272297357023851601055649202917502578.65806
157 827616624719328896744907209058776918488781262156240644152032589316310497917704278573041113320597973119052610891389955361675777280300864839798359318495709104405786183612422601907783121589048096310881843679773121995685487830798002687709349322579493477773619254140840812652652469623324919939156489093831587.22972
158 188651747237894417613400784714319430164487181309579572110462632930512663014657539519344465377549109559228618759073925619411673901972744772786479386562066146971411513364087599050195564367675620465382731491389020259045701812198099022750166591979801131774098298537336944673630511186276533671731001239967223800.23746
159 almost integer 43274543491028607741803469061010767430332337084204918320429970472522761733456850206230925917936911783068676793548484810501547707312243095701424289819741084975826041304289858217729559322645951397447088012570536933829919072607637917254177914793769476183640402383097529542299702743634513731188261671332932254628.07663
160 9989115086598518803349681088519177460149178912488412410905059070244738604774689634274070344436555109402659279232110783535274490750358665151829196799179716495498826260758985902415268744476672973019520046160095133088274392471418309497263207396112897853003214776015310211027892792035832782966576587524663300243062.25586
161 2320210734527074624586011355806062683946622201634170565761132603458136065426380617916539493562484900112525539171909627978684218622477066387351352845528355000246544687019145818030193274227941652190418350735454909748123225319064463065002910202358153633808321795173996711047052884364401107319960844624662750865561963.20776
162 542271756324167059007254730978145324569124764875811981803578051577656245145879252641769859044467735573174592878116902045688747745079890277328347439794926681405621617981500180835424211252093255259903866534501865120685941658015737501895542311796479627598797326235343292210998561711225288780556898235001591216862725682.35473
163 127520242107072944009636177539130894358409589467102276260639790163371648861969709950516325279197817888285773926484472321283834216795388524136788659362779131237642675745397364042721604539976866655177493575034472745318348010012382781078243724022664220550101966613289531158142222329055683803057796155184173435861289973823.16542
164 30171542627736794724169612701427008582854369260042238387694742648058009964996834533589653680196239838317041984854026336281448496304993967416452879847212774724439333084375639673369302753662088142090325545010483165187174455160308639000197727945458754444704770401110185737095370647953529247377682732926103776720308628000488.33801
165 7182175262625963189763104517731807198163649605294105861716403612516532133687002375109909822741597959894153507370918409234589663667969892331293771579535970230044905359683702097584790839563641516580452271152663054524797454555329441341659482619876707261768739390251005189046412826383903234673140562013460009392441624262637220.51842
166 1720040313274853666827115335939091650739208250799593023794829861952587626343860099432952148698888990897295690628134387270888413342083800245117174234831381625095854557797716804813993012909304429681208415451198686479714240349038342604241143810569834775743662808633598741043340892803617600895299198196064399721817770044370505112.32434
167 414409436225151983403603852149304547581842164354292978467632632560401997303344674386242278831025612457704277528075242210607785266248344344663661851587833561570013662143232324419788688671014374221536333447219660646579022588058146410304314573551354314922876516430033902532996487838990672869313297667368392570699069082842853436153.43428
168 100441561674655809580788161810936965607189711720727416661659064246699501831104282085382730092104867454351751579064156729879126294628818833387603865089866762699959202878446326748308584017662836802828135227244735619776439091590813877717579820222829492638893857207642330137085201207594855199600919206851477807987505851278970154472451.57729
169 24489205754691544623264832329594550104750853925618866853382162849683652515715090977664067926480897235302073129364480701709338396134050340013671850496093926231108425879351359460445875226843014928838964575168673581203100915797227282539217075185492794469982160707903045326677772156317343177126999667581083264403045609175732466087110246.24208
170 6006177468592502511355791298395715124982596151228973649401523395200900647133762244772091883935027971890070865975758343168759452961489649354858915118944128747601433827214419713707475109799941113127161984233038247249072766616399402313589555085097246982564733515792318111675980988024732784902601817651552719755556317693182733797695765534.51567
171 1481729098717000725283529050885774872123071341812319576351243601747285494557142539758067809356317663991602721366785252212373620468392461313042826938754215037253953762298790184170482669666995837879660248346430492047604605587870642265092964724183636165425471369178296552024714764261444814501846303803630123301434196854497920587387583186006.24709
172 almost integer 367681514297501124448715601012426383418150674500888613542161292058441474746316292257972416503541790335661531397785637711246410802747777691146646712451135574736900873957913842341015573640963581196399239954444636805487102152839329298006952033850848583741621812385868444034816812174342274343569782647775261745518433501670112266497462622652825.08196
173 91768247433514040734886437712739826078327056113306090031027099378379697640778177531200378293326294001012074268214026085595706915762156548630348782467866354607272025890590788082362564218263450123188287557021163420246318837169541073750480646617268384295217290699246972624245520821118907213537078219699714335106753896811467034738897315692936899.58903
174 23036485614111956746027162683618244602188820378803609032834216340093032087791810103306425439855234901089463246693708577281212859686726654730377311932172439126837982309765376053643189697657268158562871152504039902114886290015033818044134122625123278803570210856199759147225205941101842897498644098638248187067196282046465293313978644913571530147.59048
175 5816059122123121680778686393841149006273979824960504151711449238828259896339226553746785362471111776362242260455372409039557066074932750066305507622517682852364746763784297116912561779957570132184065907900619877187659024982961072877956548847161227025770393481155605345571132796031195822949077909287637273416921421363974482535299551785573674582078.72344
176 almost integer 1476780738928712034890198147146225599087596218552173442905221528436311623561444583662020128478087399864056039375838911024176231719307227165874467990904946775525650858998573905129478687474298711472839349006770880844086171038332612991615888598251568768584342847973282448668573705812314159657483183512324566105008304534750188963184100605497214008671621.07247
177 377106331990304149294896872050092930132116474753599922954529326802619413622971225766742702548754608609454708009827853436034438560140180540820383942469119841599328216836126996739352417299859793224817469350629506481034280275531770417163692882611783311386501693801643067930256050022975052203140081254231931736809926089274886361570213956235894636325499176.67892
178 96840799438942516030204230592888799221679367600797051179685806535473753548848641415136212271487572370153155280101458026640117710046285694419846676046547800720261388350881018230216261724286852209164827386783490240838364598265378754342229605496863591198587321905187604954540103259350234581106261635706160273139601897912303347023476384552515588948963571021.64996
179 25008401658025028919504962351581650606718047972297435681206563234864966573472931972036844140298996719126410658861248255504209669079596565082464939724765420806656242814938544134981993550186199251246672467872316851725281753767080796912780228328476467753179298309639610719108374758363655571985655559384063598204751405597578996842966497571138748727170348735310.64768
180 6494309469466567086342579845166376654935638986889609805298460864216507262095371598194373427571474926401222709972747664258580761067238049192677039572270457032465612687641160178983698173005216905899553958944123869822741100156768013260839027819619655090511856209219523061125380814521071117015048386970255272717052892881640243860526925509274745902515782132164029.76749
181 1695844759873174877285413377396817112669976741852260874200735707930334414192385993144414320988374494074378133115407091196613356125414993181046323854465020908495904895147058337509986843627730499298353430773472189950871794159444657661392179137667734766539478680306504586964527022381980737868623219614528428801921341705267857071997284981919738882437758101800013566.23523
182 445278802183954713629674174603551191654793853953148417270972255830999255160587007015932893701984750316171858905551248455842900867393174289396318458257456649020562122497170030803606592059446271396777115344453280860683671509737991107400289350554758286057586837050548246295079508314561202637063386195384236520417911229084708300685612840401045338651700916470083111481.39278
183 117559478109449762529952441563012971701433703710113343869704738204429351330990686746535747417829590052672540165173788500956291558260467455659340936798584747326874941226279758505310846091173621461084852500063050676770262026365269184990837020957169217121928771299228077617085981609324939863489293440558300157592667251794268189151172827613899261547989348309284302129465.23738
184 31206855598351599571613896444740010235823585807731722934156408627299605903464873284476090077121160984024354654267890077886380630249203258036129476015582192583529852444687280126694739379960323785325984725662202495624155397654135410622420806707802094572556751729398572449684179554529600423613022435251636670238111014121333403517490953093478147969463086642979756276284930.41255
185 8329065525493769949290655372038740278137351458379387272349672875965256974983771970375346747860499359955301342221761168768456057562657886823790331948991674160490509197405680200830606364480811167749317168640189980434755459343147250606084552601443594914422160458120218410355324926949800092659839971905367805947579718202980213757649571918539556571055577265322074490622441712.56721
186 2235032084369650726312204826316402353778555601746014369964473249023457712114934392384632268442469841076649647640300893152103005353054229432313330332672250455274590082608407771793758050779915654193457402038846489936505607515051335018178771316058131098014777471217386823496003058312198413572725358633469583468689482568351970425927432579084454047967667131694944066288632557211.25494
187 602975834713042034565983760390962608446431303895722457995414678890188031470369266019780074929626688611457349647474497917267528648892995102545678928041346048494399199264588012170290495187441392359823534205306765303476437562787104379493419043960492139460205528325742158264624472132202641785816589155924637114889169577288885528885039064855426102173623196865078272518812522781388.18523
188 almost integer 163543126345081135602466137557749797590586206478282853905652970085911912813158883884068533840548392490115699283608583721860533629613601753080576003315822331750679238035668377926389844065259324423929794560628523358971363428091752799784920258264095085234001939293781297844267730989922619757055777459014482005577310277003828763433825158703123653048113733432476739802104790585163697.07762
189 44593200039060364402102763699797035075668618780430757051572667376752268447817349238487814866546473731608722211688933951926851146905998770106131622809571161242441299360784008808002750154987508653648044543859518823284823573194254364938185486290451148539674806392621473401832449669703857953258707619516982055147506880075692250258927074876203616210272628015827010314526899890875372763.40413
190 12223533825207164236709289628526713711069819006290621785574070251194627588208132432145236203776132867004016048262192760092224738967672588039432329243044750419905108012710044731764354402919010639476252488807281881811659391434938893283071701692564866778899674179465512541450467047465701698223156593453222314161976352369107570568436392889020183382101259313707110811949466236803131876690.59385
191 3368252841667091525336254561443385846396301564470520256678533308760465357354817346323732580835898766758914068846133814314211303682039257324794096983662063419228045403527024400705335469880788169232561608744965635532537199883362293010613618563333514597666656553765101973336837059394780382142727422589059170040675086965790207256344779802469598528724647899509576935928934277023431740544057.78753
192 almost integer 932997440857588185178900869059757369538699967004525686039278814096413151816173030647842747305719921637293430570379820797507833232778321392034195309952284583489560078533696809574016963567760015515665419179267879307962345099511334826340353301910367705105827822710052806327089212933909151983339689407897810158756292306505647881853532693367832940591380018181127870675633979870981783490894069.99807
193 259783940749855926204189267140666406648171997016362190076968024884191920478871863745049203419286917117047865500302802662670740620368419829656778308248004754077183230330662278572677059682358974922306973068691887802341833208261510955958920871771985300506145447764082200812075032916301076421225725345863862138486689778400620147987819478193432082296181248984982596711555129842753347115931149703.67529
194 72709066586347431863579495206220499035405827729562949784089657445038184675939091263524059320871387677161439172120061124957114929788756760510401924340830740894355500172745495949404576950296521181414894394095194671955046816327059445092851798945679004021616461986863451490409473076458605570450859236721071700831215540774296947468474322510928650085713992079160373287984099781702113981409085350037.17803
195 20454916909398829892752215164920989897208967508911145569541639071798681151367986151586637417168878982759356217949945115064965970993199375332927173439923870829104067936753896348357732166411910443832892811336800002927524585573115237023068345456169550408501590655925574970453057389125931654011665876389108586726951383759931974258179854734476370812870633833368156050966001274942172376159862046835677.50930
196 5784000608649156804619652565433848911508149743675643946536150725436532389116172322612741989340830339373306970661331751696655753418948276412526377712932882811326796973392139574256671911388075367805652556711180740588202536114918285200690316037231737291427576180606631821287075764855299754138094663119369564089069749821374920588257646142446777715914950624540907820274843935902766556895110704576908045.69749
197 1643876151935586248754399939921773116810182486644547522574931394691560184496243423318050284392287070630741841933378019077143506399048999971329130724719290951693185394006413229467436103698095895857668552124021504010516518577784964721473716632131171833401903867648995563495500287568657134216864406410565598048745050529812285114555953856738899125594156828764334624325053726883824339337487192462825547564.49176
</pre>
===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.
<syntaxhighlight lang="rexx">/*REXX program to calculate and show the Hickerson series (are near integer). */
numeric digits length(ln2())-length(.) /*be able to calculate big factorials. */
parse arg N . /*get optional number of values to use.*/
if N=='' then N= 1 /*Not specified? Then use the default.*/
!= 1 /* [↓] compute possible Hickerson #s. */
do j=1 for N; #= Hickerson(j) /*traipse thru a range of Hickerson #s.*/
?= right(# * 10 % 1, 1) /*get 1st decimal digit past dec. point*/
if ?==0 | ?==9 then _= 'almost integer' /*the number is, */
else _= ' ' /* or it ain't. */
say right(j,3) _ format(#, , 5) /*show number with 5 dec digs fraction.*/
end /*j*/
exit /*stick a fork in it, we're all done. */
/*─────────────────────────────────────────────────────────────────────────────────────────────────────────*/
Hickerson: parse arg z; != ! * z; return ! / (2*ln2() ** (z+1) )
ln2: return .69314718055994530941723212145817656807550013436025525412068000949339362196969471560586332699641,
|| 8687542001481020570685733685520235758130557032670751635075961930727570828371435190307038623891673471123,
|| 3501153644979552391204751726815749320651555247341395258829504530070953263666426541042391578149520437404,
|| 3038550080194417064167151864471283996817178454695702627163106454615025720740248163777338963855069526066,
|| 83411372738737229289564935470257626520988596932019650585547647033067936544325476327449512504060694381470</syntaxhighlight>
{{out|output|text= is identical to the 2<sup>nd</sup> REXX version.}}<br><br>
=={{header|Ring}}==
<syntaxhighlight lang="ring">
n = 12
hick = 0
decimals(8)
for i = 1 to n
see "h(" + string(i) + ") = "
see "" + hickersonSeries(i) + " "
if nearly(hick) = 1 see "nearly integer" + nl
else see "not nearly integer" + nl ok
next
func hickersonSeries nr
hick = fact(nr) / (2 * pow(log(2), nr+1))
return hick
func fact nr if nr = 1 return 1 else return nr * fact(nr-1) ok
func nearly nr
strNr = string(nr)
sub = substr(strNr,".")
sub2 = substr(strNr,sub+1,1)
if (sub2 = "0" or sub2="9") return 1
else return 0 ok
return sub
</syntaxhighlight>
=={{header|Ruby}}==
Using the BigDecimal standard library:
<syntaxhighlight lang="ruby">require "bigdecimal"
LN2 = BigMath::log(2,16) #Use LN2 = Math::log(2) to see the difference with floats
FACTORIALS = Hash.new{|h,k
FACTORIALS[0] = 1
Line 168 ⟶ 2,303:
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
end</syntaxhighlight>
<pre>
n: 1 h: 1.04068449050280389893479 nearly integer
Line 187 ⟶ 2,322:
n: 15 h: 230283190977853.037436039 nearly integer
n: 16 h: 5315654681981354.51307674 NOT nearly integer
n: 17 h: 130370767029135900.457985 NOT nearly integer</pre>
=={{header|Rust}}==
<syntaxhighlight lang="rust">
use decimal::d128;
use factorial::Factorial;
fn hickerson(n: u64) -> d128 {
d128::from(n.factorial()) / (d128!(2) * (d128!(2).ln().pow(d128::from(n + 1))))
}
// Some details on floating-points numbers can be found at https://cheats.rs/#basic-types
fn main() {
for i in 1..18 {
let h = hickerson(i);
let string = h.to_string();
let dec_part = string.split('.').nth(1).unwrap();
if dec_part.starts_with('0') || dec_part.starts_with('9') {
println!("{} is an almost integer.", h);
} else {
println!("{} is not an almost integer.", h);
}
}
}
</syntaxhighlight>
{{out}}
<pre>
1.040684490502803898934790801867496 is an almost integer.
3.002780707156905443499767407219304 is an almost integer.
12.99629050527696646222488454296431 is an almost integer.
74.99873544766160012763455037564470 is an almost integer.
541.0015185164235075692027746182565 is an almost integer.
4683.001247262257437180467152479008 is an almost integer.
47292.99873131462390482283548778628 is an almost integer.
545834.9979074851670672910397944921 is an almost integer.
7087261.001622899120979187515908217 is an almost integer.
102247563.0052710420110883885941994 is an almost integer.
1622632572.997550049852874861078498 is an almost integer.
28091567594.98157244071518917609951 is an almost integer.
526858348381.0012482861804893808360 is an almost integer.
10641342970443.08453192709507015038 is an almost integer.
230283190977853.0374360391259771066 is an almost integer.
5315654681981354.513076743456805575 is not an almost integer.
130370767029135900.4579853491967735 is not an almost integer.
</pre>
=={{header|Scala}}==
===Functional Programming ♫===
<syntaxhighlight lang="scala">import scala.annotation.tailrec
object Hickerson extends App {
def almostInteger(n: Int): Boolean = {
def ln2 = BigDecimal("0.69314718055994530941723212145818")
def div: BigDecimal = ln2.pow(n + 1) * 2
def factorial(num: Int): Long = {
@tailrec
def accumulated(acc: Long, n: Long): Long =
if (n <= 0) acc else accumulated(acc * n, n - 1)
accumulated(1, num)
}
((BigDecimal(factorial(n)) / div * 10).toBigInt() % 10).toString.matches("0|9")
}
val aa = (1 to 17).map(n => n -> almostInteger(n))
println(s"Function h(n) gives a almost integer with a n of ${aa.filter(_._2).map(_._1).mkString(", ")}.")
println(s"While h(n) gives NOT an almost integer with a n of ${aa.filter(!_._2).map(_._1).mkString(", ")}.")
}</syntaxhighlight>
{{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}}==
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";
include "bigrat.s7i";
const proc: main is func
local
const bigRational: ln2 is 6931471805599453094172_ / 10000000000000000000000_;
var bigRational: h is 1_ / 2_ / ln2;
var integer: n is 0;
var string: stri is "";
begin
for n range 1 to 17 do
h := h * bigRational conv n / ln2;
stri := h digits 3;
writeln(n lpad 2 <& stri lpad 23 <& " is almost integer: " <&
stri[succ(pos(stri, '.'))] in {'0', '9'});
end for;
end func;</syntaxhighlight>
{{out}}
<pre>
1 1.041 is almost integer: TRUE
2 3.003 is almost integer: TRUE
3 12.996 is almost integer: TRUE
4 74.999 is almost integer: TRUE
5 541.002 is almost integer: TRUE
6 4683.001 is almost integer: TRUE
7 47292.999 is almost integer: TRUE
8 545834.998 is almost integer: TRUE
9 7087261.002 is almost integer: TRUE
10 102247563.005 is almost integer: TRUE
11 1622632572.998 is almost integer: TRUE
12 28091567594.982 is almost integer: TRUE
13 526858348381.001 is almost integer: TRUE
14 10641342970443.085 is almost integer: TRUE
15 230283190977853.037 is almost integer: TRUE
16 5315654681981354.513 is almost integer: FALSE
17 130370767029135900.458 is almost integer: FALSE
</pre>
=={{header|Sidef}}==
<syntaxhighlight lang="ruby">func h(n) {
n! / (2 * pow(2.log, n+1))
}
{ |n|
"h(%2d) = %22s is%s almost an integer.\n".printf(
n, var hn = h(n).round(-3), hn.to_s ~~ /\.[09]/ ? '' : ' NOT')
} << 1..17</syntaxhighlight>
{{out}}
<pre>h( 1) = 1.041 is almost an integer.
h( 2) = 3.003 is almost an integer.
h( 3) = 12.996 is almost an integer.
h( 4) = 74.999 is almost an integer.
h( 5) = 541.002 is almost an integer.
h( 6) = 4683.001 is almost an integer.
h( 7) = 47292.999 is almost an integer.
h( 8) = 545834.998 is almost an integer.
h( 9) = 7087261.002 is almost an integer.
h(10) = 102247563.005 is almost an integer.
h(11) = 1622632572.998 is almost an integer.
h(12) = 28091567594.982 is almost an integer.
h(13) = 526858348381.001 is almost an integer.
h(14) = 10641342970443.085 is almost an integer.
h(15) = 230283190977853.037 is almost an integer.
h(16) = 5315654681981354.513 is NOT almost an integer.
h(17) = 130370767029135900.458 is NOT almost an integer.</pre>
=={{header|Tcl}}==
{{tcllib|math::bigfloat}}
<syntaxhighlight lang="tcl">package require math::bigfloat
namespace import math::bigfloat::*
# Precision is an arbitrary value large enough to provide clear demonstration
proc hickerson {n {precision 28}} {
set fac 1
for {set i 1} {$i <= $n} {incr i} {set fac [expr {$fac * $i}]}
set numerator [int2float $fac $precision]
set 2 [int2float 2 $precision]
set denominator [mul $2 [pow [log $2] [expr {$n + 1}]]]
return [tostr -nosci [div $numerator $denominator]]
}
for {set n 1} {$n <= 17} {incr n} {
set h [hickerson $n]
set almost [regexp {\.[09]} $h]
puts [format "h(%d) = %s (%salmost integer)" $n $h [expr {$almost ? "" : "not "}]]
}</syntaxhighlight>
{{out}}
<pre>
h(1) = 1.040684490502803898934790802 (almost integer)
h(2) = 3.00278070715690544349976741 (almost integer)
h(3) = 12.9962905052769664622248845 (almost integer)
h(4) = 74.998735447661600127634550 (almost integer)
h(5) = 541.00151851642350756920277 (almost integer)
h(6) = 4683.001247262257437180467 (almost integer)
h(7) = 47292.9987313146239048228355 (almost integer)
h(8) = 545834.99790748516706729104 (almost integer)
h(9) = 7087261.0016228991209791875 (almost integer)
h(10) = 102247563.005271042011088389 (almost integer)
h(11) = 1622632572.99755004985287486 (almost integer)
h(12) = 28091567594.981572440715189 (almost integer)
h(13) = 526858348381.00124828618049 (almost integer)
h(14) = 10641342970443.0845319270951 (almost integer)
h(15) = 230283190977853.037436039126 (almost integer)
h(16) = 5315654681981354.5130767435 (not almost integer)
h(17) = 130370767029135900.457985349 (not almost integer)
</pre>
=={{header|TI-83 BASIC}}==
<syntaxhighlight lang="ti83b">For(N,1,17
N!/(2ln(2)^(N+1→H
Disp N,H,"IS
round(H,1)-iPart(H)
If not(Ans=.9 or not(Ans
Disp "NOT
Disp "ALMOST INTEGER
End</syntaxhighlight>
(untested)
=={{header|Wren}}==
{{libheader|Wren-fmt}}
{{libheader|Wren-big}}
<syntaxhighlight lang="wren">import "./fmt" for Fmt
import "./big" for BigInt, BigDec
var hickerson = Fn.new { |n|
var fact = BigDec.fromBigInt(BigInt.factorial(n), 64)
var ln2 = BigDec.ln2 // precise to 64 decimal digits
return fact / (BigDec.two * ln2.pow(n+1))
}
System.print("Values of h(n), truncated to 1 dp, and whether 'almost integers' or not:")
for (i in 1..17) {
// truncate to 1 d.p and show final zero if any
var h = hickerson.call(i).toString(1, false, true)
var k = h.count - 1
var ai = (h[k] == "0" || h[k] == "9")
Fmt.print("$2d: $20s $s", i, h, ai)
}</syntaxhighlight>
{{out}}
<pre>
Values of h(n), truncated to 1 dp, and whether 'almost integers' or not:
1: 1.0 true
2: 3.0 true
3: 12.9 true
4: 74.9 true
5: 541.0 true
6: 4683.0 true
7: 47292.9 true
8: 545834.9 true
9: 7087261.0 true
10: 102247563.0 true
11: 1622632572.9 true
12: 28091567594.9 true
13: 526858348381.0 true
14: 10641342970443.0 true
15: 230283190977853.0 true
16: 5315654681981354.5 false
17: 130370767029135900.4 false
</pre>
=={{header|zkl}}==
Uses lib GMP (integer) and some fiddling to fake up the floating point math.
<syntaxhighlight lang="zkl">var [const] BN=Import("zklBigNum"),
X =BN("1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"),
ln2X=BN("693147180559945309417232121458176568075500134360255254120680009493393621969694715605863326996418687")
;
fcn hickerson(n){ BN(n).factorial()*X.pow(n+1)*10/2/ln2X.pow(n+1) }</syntaxhighlight>
<syntaxhighlight lang="zkl">foreach n in ([1..18]){
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));
}</syntaxhighlight>
{{out}}
<pre>
h( 1)=1.0 almost integer: True
h( 2)=3.0 almost integer: True
h( 3)=12.9 almost integer: True
h( 4)=74.9 almost integer: True
h( 5)=541.0 almost integer: True
h( 6)=4683.0 almost integer: True
h( 7)=47292.9 almost integer: True
h( 8)=545834.9 almost integer: True
h( 9)=7087261.0 almost integer: True
h(10)=102247563.0 almost integer: True
h(11)=1622632572.9 almost integer: True
h(12)=28091567594.9 almost integer: True
h(13)=526858348381.0 almost integer: True
h(14)=10641342970443.0 almost integer: True
h(15)=230283190977853.0 almost integer: True
h(16)=5315654681981354.5 almost integer: False
h(17)=130370767029135900.4 almost integer: False
h(18)=3385534663256845326.3 almost integer: False
</pre>
| |||