Hashtron inference
You are encouraged to solve this task according to the task description, using any language you may know.
Hashtron classifier inference
Description
This task involves implementing a Hashtron classifier inference function. Hashtron classifier program can be machine learned to calculate arbitrary finite computable functions or sets (Given enough CPU time and RAM). The Hashtron classifier takes a command and a number of bits to infer, using a provided program configuration. The inference function for the test will generate a pseudo-random n-bits output. The inference function for the square root demo will generate a square root of a command in range: 0 <= command < 256.
Examples
Test demo
Given the following program configuration and input command:
Program configuration:
Input command:
42
Number of bits:
64
Program:
[[0,2]]
The inference function should process the input and generate the following 64-bit output:
14106184687260844995
Square root demo
Given the following program configuration and input command:
Program configuration:
Input command: A byte (integer) to take square root of.
Number of bits:
4
Program:
[[8776,79884], [12638,1259], [9953,1242], [4658,1228], [5197,1210], [12043,1201], [6892,1183], [7096,1168], [10924,1149], [5551,1136], [5580,1123], [3735,1107], [3652,1091], [12191,1076], [14214,1062], [13056,1045], [14816,1031], [15205,1017], [10736,1001], [9804,989], [13081,974], [6706,960], [13698,944], [14369,928], [16806,917], [9599,906], [9395,897], [4885,883], [10237,870], [10676,858], [18518,845], [2619,833], [13715,822], [11065,810], [9590,799], [5747,785], [2627,776], [8962,764], [5575,750], [3448,738], [5731,725], [9434,714], [3163,703], [3307,690], [3248,678], [3259,667], [3425,657], [3506,648], [3270,639], [3634,627], [3077,617], [3511,606], [27159,597], [27770,589], [28496,580], [28481,571], [29358,562], [31027,552], [30240,543], [30643,534], [31351,527], [31993,519], [32853,510], [33078,502], [33688,495], [29732,487], [29898,480], [29878,474], [26046,468], [26549,461], [28792,453], [26101,446], [32971,439], [29704,432], [23193,426], [29509,421], [27079,415], [32453,409], [24737,404], [25725,400], [23755,395], [52538,393], [53242,386], [19609,380], [26492,377], [24566,358], [31163,368], [57174,363], [26639,364], [31365,357], [60918,350], [21235,338], [28072,322], [28811,314], [27571,320], [17635,309], [51968,169], [54367,323], [60541,254], [26732,270], [52457,157], [27181,276], [19874,227], [22797,320], [59346,271], [25496,260], [54265,231], [22281,250], [42977,318], [26008,240], [87604,142], [94647,314], [52292,157], [20999,216], [89253,316], [22746,29], [68338,312], [22557,317], [110904,104], [70975,285], [51835,277], [51871,313], [132221,228], [18522,290], [68512,285], [118816,302], [150865,268], [68871,273], [68139,290], [84984,285], [150693,266], [396047,272], [84923,269], [215562,258], [68015,248], [247689,235], [214471,229], [264395,221], [263287,212], [280193,201], [108065,194], [263616,187], [148609,176], [263143,173], [378205,162], [312547,154], [50400,147], [328927,140], [279217,132], [181111,127], [672098,118], [657196,113], [459383,111], [833281,105], [520281,102], [755397,95], [787994,91], [492444,82], [1016592,77], [656147,71], [819893,66], [165531,61], [886503,57], [1016551,54], [3547827,49], [14398170,43], [395900,41], [4950628,37], [11481175,33], [100014881,30], [8955328,31], [11313984,27], [13640855,23], [528553762,21], [63483027,17], [952477,8], [950580,4], [918378,2], [918471,1]]
The inference function should process the input and generate the square root of the input byte.
FreeBASIC
Function hash(n As Ulongint, s As Ulongint, max As Ulongint) As Ulongint
Dim As Ulongint k = &hFFFFFFFF
' Mixing stage, mix input with salt using subtraction
Dim As Ulongint m = (n - s) And k
' Hashing stage, use xor shift with prime coefficients
m Xor= ((m Shl 2) And k)
m Xor= ((m Shl 3) And k)
m Xor= ((m Shr 5) And k)
m Xor= ((m Shr 7) And k)
m Xor= ((m Shl 11) And k)
m Xor= ((m Shl 13) And k)
m Xor= ((m Shr 17) And k)
m Xor= ((m Shl 19) And k)
' Mixing stage 2, mix input with salt using addition
m = (m + s) And k
' Modular stage using Lemire's fast alternative to modulo reduction
Return ((m * max) Shr 32) And k
End Function
Function inference(comando As Ulongint, bits As Integer, program() As Ulong) As Ulongint
Dim As Ulongint salida = 0
' Check if the program is empty
If Ubound(program) = -1 Then Return salida
' Iterate over the bits
For j As Integer = 0 To bits - 1
Dim As Ulongint entrada = comando Or (j Shl 16)
Dim As Ulongint ss = program(0)
Dim As Ulongint maxx = program(1)
entrada = hash(entrada, ss, maxx)
For i As Integer = 1 To Ubound(program)
Dim As Ulongint s = program(i)
Dim As Ulongint max = program(i + 1)
maxx -= max
entrada = hash(entrada, s, maxx)
Next i
entrada And= 1
If entrada <> 0 Then salida Or= (1 Shl j)
Next j
Return salida
End Function
Dim As Ulong program(1) = {0, 2}
Print "Test demo:"
Print inference(42, 64, program())
Sleep
Go
package main
func Inference(command uint32, bits byte, program [][2]uint32) (out uint64) {
// Check if the program is empty
if len(program) == 0 {
return
}
// Iterate over the bits
for j := byte(0); j < bits; j++ {
var input = command | (uint32(j) << 16)
var ss, maxx = program[0][0], program[0][1]
input = Hash(input, ss, maxx)
for i := 1; i < len(program); i++ {
var s, max = program[i][0], program[i][1]
maxx -= max
input = Hash(input, s, maxx)
}
input &= 1
if input != 0 {
out |= 1 << j
}
}
return
}
func Hash(n uint32, s uint32, max uint32) uint32 {
// Mixing stage, mix input with salt using subtraction
var m = n - s
// Hashing stage, use xor shift with prime coefficients
m ^= m << 2
m ^= m << 3
m ^= m >> 5
m ^= m >> 7
m ^= m << 11
m ^= m << 13
m ^= m >> 17
m ^= m << 19
// Mixing stage 2, mix input with salt using addition
m += s
// Modular stage using Lemire's fast alternative to modulo reduction
return uint32((uint64(m) * uint64(max)) >> 32)
}
func main() {
println(Inference(42, 64, [][2]uint32{{0, 2}}))
}
https://go.dev/play/p/AsmOzKWx7jB
Java
public class Main {
public static long inference(long command, long bits, long[][] program) {
long out = 0;
// Check if the program is empty
if (program.length == 0) {
return out;
}
// Iterate over the bits
for (long j = 0; j < bits; j++) {
long input = (command & 0xFFFFFFFF) | (((long)j & 0xFF) << (long)16);
long ss = program[0][0];
long maxx = program[0][1];
input = hash(input, ss, maxx);
for (long i = 1; i < program.length; i++) {
long s = program[(int)i][0];
long max = program[(int)i][1];
maxx -= max;
input = hash(input, s, maxx);
}
input &= 1;
if (input != 0) {
out |= (long)1 << (long) j;
}
}
return out;
}
public static long hash(long n, long s, long max_val) {
// Mixing stage, mix input with salt using subtraction
long m = (n - s) & 0xFFFFFFFFL;
// Hashing stage, use xor shift with prime coefficients
m ^= (m << 2) & 0xFFFFFFFFL;
m ^= (m << 3) & 0xFFFFFFFFL;
m ^= (m >> 5) & 0xFFFFFFFFL;
m ^= (m >> 7) & 0xFFFFFFFFL;
m ^= (m << 11) & 0xFFFFFFFFL;
m ^= (m << 13) & 0xFFFFFFFFL;
m ^= (m >> 17) & 0xFFFFFFFFL;
m ^= (m << 19) & 0xFFFFFFFFL;
// Mixing stage 2, mix input with salt using addition
m += s;
m &= 0xFFFFFFFFL;
// Modular stage using Lemire's fast alternative to modulo reduction
return ((m * max_val) >>> 32) & 0xFFFFFFFFL;
}
public static void main(String[] args) {
long command = 42;
long[][] program = {{0,2}}; // Example program
long bits = 64;
long result = inference(command, bits, program);
System.out.println(Long.toUnsignedString(result));
}
}
Julia
function hash(n, s, max_val)
# Mixing stage, mix input with salt using subtraction
m = (n - s) & 0xFFFFFFFF
# Hashing stage, use xor shift with prime coefficients
m ⊻= (m << 2) & 0xFFFFFFFF
m ⊻= (m << 3) & 0xFFFFFFFF
m ⊻= (m >> 5) & 0xFFFFFFFF
m ⊻= (m >> 7) & 0xFFFFFFFF
m ⊻= (m << 11) & 0xFFFFFFFF
m ⊻= (m << 13) & 0xFFFFFFFF
m ⊻= (m >> 17) & 0xFFFFFFFF
m ⊻= (m << 19) & 0xFFFFFFFF
# Mixing stage 2, mix input with salt using addition
m += s
m &= 0xFFFFFFFF
# Modular stage using Lemire's fast alternative to modulo reduction
return ((m * max_val) >> 32) & 0xFFFFFFFF
end
function inference(command, bits, program)
out = UInt(0)
# Check if the program is empty
length(program) == 0 && return out
# Iterate over the bits
for j in 0:bits-1
input_val = command | (j << 16)
ss, maxx = program[begin]
input_val = hash(input_val, ss, maxx)
for i in firstindex(program)+1:lastindex(program)
s, max_val = program[i]
maxx -= max_val
input_val = hash(input_val, s, maxx)
end
if isodd(input_val)
out |= 1 << j
end
end
return out
end
println(inference(42, 64, [[0, 2]]))
for i in 0x0:0xff
println(i, " ", inference(i, 4, [
[8776, 79884], [12638, 1259], [9953, 1242], [4658, 1228], [5197, 1210], [12043, 1201],
[6892, 1183], [7096, 1168], [10924, 1149], [5551, 1136], [5580, 1123], [3735, 1107],
[3652, 1091], [12191, 1076], [14214, 1062], [13056, 1045], [14816, 1031], [15205, 1017],
[10736, 1001], [9804, 989], [13081, 974], [6706, 960], [13698, 944], [14369, 928],
[16806, 917], [9599, 906], [9395, 897], [4885, 883], [10237, 870], [10676, 858],
[18518, 845], [2619, 833], [13715, 822], [11065, 810], [9590, 799], [5747, 785],
[2627, 776], [8962, 764], [5575, 750], [3448, 738], [5731, 725], [9434, 714],
[3163, 703], [3307, 690], [3248, 678], [3259, 667], [3425, 657], [3506, 648],
[3270, 639], [3634, 627], [3077, 617], [3511, 606], [27159, 597], [27770, 589],
[28496, 580], [28481, 571], [29358, 562], [31027, 552], [30240, 543], [30643, 534],
[31351, 527], [31993, 519], [32853, 510], [33078, 502], [33688, 495], [29732, 487],
[29898, 480], [29878, 474], [26046, 468], [26549, 461], [28792, 453], [26101, 446],
[32971, 439], [29704, 432], [23193, 426], [29509, 421], [27079, 415], [32453, 409],
[24737, 404], [25725, 400], [23755, 395], [52538, 393], [53242, 386], [19609, 380],
[26492, 377], [24566, 358], [31163, 368], [57174, 363], [26639, 364], [31365, 357],
[60918, 350], [21235, 338], [28072, 322], [28811, 314], [27571, 320], [17635, 309],
[51968, 169], [54367, 323], [60541, 254], [26732, 270], [52457, 157], [27181, 276],
[19874, 227], [22797, 320], [59346, 271], [25496, 260], [54265, 231], [22281, 250],
[42977, 318], [26008, 240], [87604, 142], [94647, 314], [52292, 157], [20999, 216],
[89253, 316], [22746, 29], [68338, 312], [22557, 317], [110904, 104], [70975, 285],
[51835, 277], [51871, 313], [132221, 228], [18522, 290], [68512, 285], [118816, 302],
[150865, 268], [68871, 273], [68139, 290], [84984, 285], [150693, 266], [396047, 272],
[84923, 269], [215562, 258], [68015, 248], [247689, 235], [214471, 229], [264395, 221],
[263287, 212], [280193, 201], [108065, 194], [263616, 187], [148609, 176], [263143, 173],
[378205, 162], [312547, 154], [50400, 147], [328927, 140], [279217, 132], [181111, 127],
[672098, 118], [657196, 113], [459383, 111], [833281, 105], [520281, 102], [755397, 95],
[787994, 91], [492444, 82], [1016592, 77], [656147, 71], [819893, 66], [165531, 61],
[886503, 57], [1016551, 54], [3547827, 49], [14398170, 43], [395900, 41], [4950628, 37],
[11481175, 33], [100014881, 30], [8955328, 31], [11313984, 27], [13640855, 23],
[528553762, 21], [63483027, 17], [952477, 8], [950580, 4], [918378, 2], [918471, 1],
]))
end
- Output:
Same as Go example.
Phix
This sort of thing is generally quite painful in Phix, since it will insist on things like zero minus one being -1 rather than some huge positive number... you certainly have to take some care it always uses unsigned masking.
requires(64)
constant U32 = #FFFFFFFF
function hashtron(integer n, s, mx)
// Mixing stage, mix input with salt using subtraction
atom m = and_bitsu(n-s,U32)
// Hashing stage, use xor shift with prime coefficients
for p in {-2,-3,+5,+7,-11,-13,+17,-19} do
m = xor_bitsu(m,and_bitsu(shift_bits(m,p),U32))
end for
// Mixing stage 2, mix input with salt using addition
m = and_bitsu(m+s,U32)
// Modular stage using Lemire's fast alternative to modulo reduction
return (m * mx) >> 32
end function
function inference(integer command, bits, sequence program)
atom out = 0
if length(program) then
for j=0 to bits-1 do
integer input = or_bitsu(command,j<<16),
{ss, maxx} = program[1]
input = hashtron(input, ss, maxx,1)
for p in program from 2 do
integer {s, mx} = p
maxx -= mx
input = hashtron(input, s, maxx,0)
end for
if odd(input) then
out = or_bitsu(out,1<<j)
end if
end for
end if
return out
end function
constant program = {
{8776,79884}, {12638,1259}, {9953,1242}, {4658,1228}, {5197,1210}, {12043,1201},
{6892,1183}, {7096,1168}, {10924,1149}, {5551,1136}, {5580,1123}, {3735,1107},
{3652,1091}, {12191,1076}, {14214,1062}, {13056,1045}, {14816,1031}, {15205,1017},
{10736,1001}, {9804,989}, {13081,974}, {6706,960}, {13698,944}, {14369,928},
{16806,917}, {9599,906}, {9395,897}, {4885,883}, {10237,870}, {10676,858},
{18518,845}, {2619,833}, {13715,822}, {11065,810}, {9590,799}, {5747,785},
{2627,776}, {8962,764}, {5575,750}, {3448,738}, {5731,725}, {9434,714},
{3163,703}, {3307,690}, {3248,678}, {3259,667}, {3425,657}, {3506,648},
{3270,639}, {3634,627}, {3077,617}, {3511,606}, {27159,597}, {27770,589},
{28496,580}, {28481,571}, {29358,562}, {31027,552}, {30240,543}, {30643,534},
{31351,527}, {31993,519}, {32853,510}, {33078,502}, {33688,495}, {29732,487},
{29898,480}, {29878,474}, {26046,468}, {26549,461}, {28792,453}, {26101,446},
{32971,439}, {29704,432}, {23193,426}, {29509,421}, {27079,415}, {32453,409},
{24737,404}, {25725,400}, {23755,395}, {52538,393}, {53242,386}, {19609,380},
{26492,377}, {24566,358}, {31163,368}, {57174,363}, {26639,364}, {31365,357},
{60918,350}, {21235,338}, {28072,322}, {28811,314}, {27571,320}, {17635,309},
{51968,169}, {54367,323}, {60541,254}, {26732,270}, {52457,157}, {27181,276},
{19874,227}, {22797,320}, {59346,271}, {25496,260}, {54265,231}, {22281,250},
{42977,318}, {26008,240}, {87604,142}, {94647,314}, {52292,157}, {20999,216},
{89253,316}, {22746,29}, {68338,312}, {22557,317}, {110904,104}, {70975,285},
{51835,277}, {51871,313}, {132221,228}, {18522,290}, {68512,285}, {118816,302},
{150865,268}, {68871,273}, {68139,290}, {84984,285}, {150693,266}, {396047,272},
{84923,269}, {215562,258}, {68015,248}, {247689,235}, {214471,229}, {264395,221},
{263287,212}, {280193,201}, {108065,194}, {263616,187}, {148609,176}, {263143,173},
{378205,162}, {312547,154}, {50400,147}, {328927,140}, {279217,132}, {181111,127},
{672098,118}, {657196,113}, {459383,111}, {833281,105}, {520281,102}, {755397,95},
{787994,91}, {492444,82}, {1016592,77}, {656147,71}, {819893,66}, {165531,61},
{886503,57}, {1016551,54}, {3547827,49}, {14398170,43}, {395900,41}, {4950628,37},
{11481175,33}, {100014881,30}, {8955328,31}, {11313984,27}, {13640855,23},
{528553762,21}, {63483027,17}, {952477,8}, {950580,4}, {918378,2}, {918471,1}
}
printf(1,"Test demo:\n")
printf(1,"%d\n\n",inference(42, 64, {{0, 2}}))
sequence res = apply(true,inference,{tagset(255,0),4,{program}})
res = join_by(res,1,16," ",fmt:="%2d")
printf(1,"Square root demo for commands in [0, 255]:\n%s",res)
- Output:
Test demo: 14106184687260844995 Square root demo for commands in [0, 255]: 0 1 1 1 2 2 2 2 2 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 6 6 6 6 6 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15
PHP
// define hashtron hash
$hash = function($n, $s, $max) {
// Ensure the inputs are treated as unsigned 32-bit integers
$n = $n & 0xFFFFFFFF;
$s = $s & 0xFFFFFFFF;
$max = $max & 0xFFFFFFFF;
// Mixing stage, mix input with salt using subtraction
$m = ($n - $s) & 0xFFFFFFFF;
// Hashing stage, use xor shift with prime coefficients
$m ^= ($m << 2) & 0xFFFFFFFF;
$m ^= ($m << 3) & 0xFFFFFFFF;
$m ^= ($m >> 5) & 0xFFFFFFFF;
$m ^= ($m >> 7) & 0xFFFFFFFF;
$m ^= ($m << 11) & 0xFFFFFFFF;
$m ^= ($m << 13) & 0xFFFFFFFF;
$m ^= ($m >> 17) & 0xFFFFFFFF;
$m ^= ($m << 19) & 0xFFFFFFFF;
// Mixing stage 2, mix input with salt using addition
$m = ($m + $s) & 0xFFFFFFFF;
// Modular stage using multiply-shift trick
// Cast to 64-bit integer for multiplication
$result = ((($m & 0xFFFFFFFF) * ($max & 0xFFFFFFFF)) >> 32) & 0xFFFFFFFF;
return $result;
};
// define hashtron inference
$infer = function($command, $bits, $program) {
global $hash;
$out = 0;
$programLength = count($program);
if ($programLength == 0) {
return $out;
}
for ($j = 0; $j < $bits; $j++) {
$input = ($command & 0xFFFFFFFF) | (($j & 0xFF) << 16);
$ss = $program[0][0];
$maxx = $program[0][1];
$input = $hash($input, $ss, $maxx);
for ($i = 1; $i < $programLength; $i++) {
$s = $program[$i][0];
$max = $program[$i][1];
$maxx -= $max;
$input = $hash($input, $s, $maxx);
}
$input &= 1;
if ($input != 0) {
$out |= 1 << $j;
}
}
return $out;
};
Python
def hash(n, s, max_val):
# Mixing stage, mix input with salt using subtraction
m = (n - s) & 0xFFFFFFFF
# Hashing stage, use xor shift with prime coefficients
m ^= (m << 2) & 0xFFFFFFFF
m ^= (m << 3) & 0xFFFFFFFF
m ^= (m >> 5) & 0xFFFFFFFF
m ^= (m >> 7) & 0xFFFFFFFF
m ^= (m << 11) & 0xFFFFFFFF
m ^= (m << 13) & 0xFFFFFFFF
m ^= (m >> 17) & 0xFFFFFFFF
m ^= (m << 19) & 0xFFFFFFFF
# Mixing stage 2, mix input with salt using addition
m += s
m &= 0xFFFFFFFF
# Modular stage using Lemire's fast alternative to modulo reduction
return ((m * max_val) >> 32) & 0xFFFFFFFF
def inference(command, bits, program):
out = 0
# Check if the program is empty
if len(program) == 0:
return out
# Iterate over the bits
for j in range(bits):
input_val = command | (j << 16)
ss, maxx = program[0]
input_val = hash(input_val, ss, maxx)
for i in range(1, len(program)):
s, max_val = program[i]
maxx -= max_val
input_val = hash(input_val, s, maxx)
input_val &= 1
if input_val != 0:
out |= 1 << j
return out
print(inference(42,64,[[0,2]]))
Wren
import "./long" for ULong
import "./fmt" for Fmt
var hash = Fn.new { |n, s, max|
// 32 bit mask
var k = 0xFFFFFFFF
// Mixing stage, mix input with salt using subtraction
var m = (n - s) & k
// Hashing stage, use xor shift with prime coefficients
m = m ^ ((m << 2) & k)
m = m ^ ((m << 3) & k)
m = m ^ ((m >> 5) & k)
m = m ^ ((m >> 7) & k)
m = m ^ ((m << 11) & k)
m = m ^ ((m << 13) & k)
m = m ^ ((m >> 17) & k)
m = m ^ ((m << 19) & k)
// Mixing stage 2, mix input with salt using addition
m = (m + s) & k
// Modular stage using Lemire's fast alternative to modulo reduction
return ((ULong.new(m) * ULong.new(max)) >> 32).toSmall & k
}
var inference = Fn.new { |command, bits, program|
var out = ULong.zero
// Check if the program is empty
if (program.count == 0) return out
// Iterate over the bits
for (j in 0...bits) {
var input = command | (j << 16)
var ss = program[0][0]
var maxx = program [0][1]
input = hash.call(input, ss, maxx)
for (i in 1...program.count) {
var s = program[i][0]
var max = program[i][1]
maxx = maxx - max
input = hash.call(input, s, maxx)
}
input = input & 1
if (input != 0) out = out | (ULong.one << j)
}
return out
}
System.print("Test demo:")
var program = [[0, 2]]
System.print(inference.call(42, 64, program))
program = [
[8776,79884], [12638,1259], [9953,1242], [4658,1228], [5197,1210], [12043,1201],
[6892,1183], [7096,1168], [10924,1149], [5551,1136], [5580,1123], [3735,1107],
[3652,1091], [12191,1076], [14214,1062], [13056,1045], [14816,1031], [15205,1017],
[10736,1001], [9804,989], [13081,974], [6706,960], [13698,944], [14369,928],
[16806,917], [9599,906], [9395,897], [4885,883], [10237,870], [10676,858],
[18518,845], [2619,833], [13715,822], [11065,810], [9590,799], [5747,785],
[2627,776], [8962,764], [5575,750], [3448,738], [5731,725], [9434,714],
[3163,703], [3307,690], [3248,678], [3259,667], [3425,657], [3506,648],
[3270,639], [3634,627], [3077,617], [3511,606], [27159,597], [27770,589],
[28496,580], [28481,571], [29358,562], [31027,552], [30240,543], [30643,534],
[31351,527], [31993,519], [32853,510], [33078,502], [33688,495], [29732,487],
[29898,480], [29878,474], [26046,468], [26549,461], [28792,453], [26101,446],
[32971,439], [29704,432], [23193,426], [29509,421], [27079,415], [32453,409],
[24737,404], [25725,400], [23755,395], [52538,393], [53242,386], [19609,380],
[26492,377], [24566,358], [31163,368], [57174,363], [26639,364], [31365,357],
[60918,350], [21235,338], [28072,322], [28811,314], [27571,320], [17635,309],
[51968,169], [54367,323], [60541,254], [26732,270], [52457,157], [27181,276],
[19874,227], [22797,320], [59346,271], [25496,260], [54265,231], [22281,250],
[42977,318], [26008,240], [87604,142], [94647,314], [52292,157], [20999,216],
[89253,316], [22746,29], [68338,312], [22557,317], [110904,104], [70975,285],
[51835,277], [51871,313], [132221,228], [18522,290], [68512,285], [118816,302],
[150865,268], [68871,273], [68139,290], [84984,285], [150693,266], [396047,272],
[84923,269], [215562,258], [68015,248], [247689,235], [214471,229], [264395,221],
[263287,212], [280193,201], [108065,194], [263616,187], [148609,176], [263143,173],
[378205,162], [312547,154], [50400,147], [328927,140], [279217,132], [181111,127],
[672098,118], [657196,113], [459383,111], [833281,105], [520281,102], [755397,95],
[787994,91], [492444,82], [1016592,77], [656147,71], [819893,66], [165531,61],
[886503,57], [1016551,54], [3547827,49], [14398170,43], [395900,41], [4950628,37],
[11481175,33], [100014881,30], [8955328,31], [11313984,27], [13640855,23],
[528553762,21], [63483027,17], [952477,8], [950580,4], [918378,2], [918471,1]
]
System.print("\nSquare root demo for commands in [0, 255]:")
Fmt.tprint("$2i", (0..255).map { |i| inference.call(i, 4, program) }, 16)
- Output:
Test demo: 14106184687260844995 Square root demo for commands in [0, 255]: 0 1 1 1 2 2 2 2 2 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 5 6 6 6 6 6 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 11 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 12 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 13 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 14 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 15