Rosetta Code

Hashtron inference: Difference between revisions

Page Discussion

Hashtron inference (view source)

Revision as of 19:58, 17 June 2024

3,424 bytes added ,  13 days ago
removed error message
m (Reposted a corrected program.)
(removed error message)
 
(One intermediate revision by one other user not shown)
Line 353:
 
=={{header|FreeBASIC}}==
<syntaxhighlight lang="vbnet">Function hashHashtron(n As Ulongint, s As Ulongint, max As Ulongint) As Ulongint▼
{{incomplete|FreeBASIC|output missing}}
Dim As Ulongint kU32 = &hFFFFFFFF▼
▲<syntaxhighlight lang="vbnet">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 kU32
' Hashing stage, use xor shift with prime coefficients
m Xor= ((m Shl 2) And kU32)
m Xor= ((m Shl 3) And kU32)
m Xor= ((m Shr 5) And kU32)
m Xor= ((m Shr 7) And kU32)
m Xor= ((m Shl 11) And kU32)
m Xor= ((m Shl 13) And kU32)
m Xor= ((m Shr 17) And kU32)
m Xor= ((m Shl 19) And kU32)
' Mixing stage 2, mix input with salt using addition
m = (m + s) And kU32
' Modular stage using Lemire's fast alternative to modulo reduction
Return ((m * max) Shr 32) 'And kU32
End Function
 
Function inferenceInference(comandocmd As UlongintInteger, 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 UlongintInteger entradass = comando Or program(j Shl0, 160)
Dim As UlongintInteger ssmaxx = program(0, 1)
Dim As UlongintInteger maxxentrada = programcmd Or (1j Shl 16)
entrada = hashHashtron(entrada, ss, maxx)
For i As Integer = 1 To Ubound(program, 1)
Dim As Ulongint s maxx -= program(i+1)
Dim As Ulongint max entrada = Hashtron(entrada, program(i), + 1maxx)
maxxNext -= maxi
If entrada Mod 2 <> 0 Then salida Or= hash(entrada,1 s,Shl maxxj)
Next ij
NextEnd jIf▼
entrada And= 1
If entrada <> 0 Then salida Or= (1 Shl j)
▲ Next j
Return salida
End Function
Line 397 ⟶ 398:
Dim As Ulong program(1) = {0, 2}
Print "Test demo:"
Print inferenceInference(42, 64, program())
 
Dim As Ulong program2(255, 1) = { _
{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} }
 
Print !"\nSquare root demo for commands in (0, 255):"
Dim As Ulong results(255)
For i As Uinteger = 0 To 255
results(i) = Inference(i, 4, program2())
Next i
 
For i As Uinteger = 0 To 255
Print Using "###"; Inference(i, 4, program2());
If (i+1) Mod 16 = 0 Then Print
Next i
 
Sleep</syntaxhighlight>
{{out}}
<pre>Test demo:
14106184687260844995
 
Square root demo for commands in (0, 255):
0 0 10 15 7 0 5 10 2 9 5 10 7 10 4 14
14 13 13 13 10 9 5 4 14 3 5 15 10 5 4 4
12 13 1 12 8 0 8 15 5 10 4 9 11 10 15 2
14 7 7 13 8 11 4 14 2 10 10 9 9 6 4 13
13 7 13 8 6 9 15 15 5 11 7 13 11 3 15 5
1 0 6 3 12 14 13 9 10 11 14 13 8 4 5 3
13 10 8 14 14 3 8 4 9 12 8 3 6 6 1 10
15 6 10 6 9 6 3 10 5 7 10 6 13 6 3 1
7 11 1 9 13 15 7 15 12 1 7 7 4 13 15 9
15 8 2 5 7 10 3 11 0 9 10 11 9 10 14 15
4 10 3 13 3 11 9 10 7 14 11 15 7 9 10 5
8 15 3 5 15 8 5 10 12 15 15 7 13 14 10 14
1 1 9 14 10 6 5 14 1 15 15 9 14 9 2 10
11 13 7 12 15 1 7 3 15 15 4 9 2 5 7 1
15 14 14 10 15 1 13 10 6 9 5 0 11 14 9 1
13 6 6 6 8 13 13 8 13 10 14 14 15 1 7 10</pre>
 
=={{header|Go}}==
Line 718 ⟶ 783:
 
=={{header|Java}}==
<syntaxhighlight lang="java" line>▼
{{incorrect|Java|output should be 14106184687260844995, not 18446744073709551615 which is 2^64-1}}
▲<syntaxhighlight lang="java" line>
public class Main {
public static long inference(longint command, longint bits, longint[][] program) {
long out = 0;
 
// Check if the program is empty
if ( program.length == 0 ) {
return out;
}
 
// Iterate over the bits
for (long int j = 0; j < bits; j++ ) {
longint input = (command & 0xFFFFFFFF) | (((long) j & 0xFF) << (long)16);
longint ss = program[0][0];
longint maxx = program[0][1];
input = hash(input, ss, maxx);
for (long int i = 1; i < program.length; i++ ) {
longint s = program[(int)i][0];
longint max = program[(int)i][1];
maxx -= max;
input = hash(input, s, maxx);
Line 743 ⟶ 808:
input &= 1;
if (input != 0) {
out |= (long)1 << (long) j;
}
}
return out;
}
public static longint hash(longint n, longint s, longint max_val) {
// Mixing stage, mix input with salt using subtraction
long m = (n - s) & 0xFFFFFFFFL;
Line 767 ⟶ 833:
// Modular stage using Lemire's fast alternative to modulo reduction
return (int) ( ( ( m * max_val ) >>> 32 ) & 0xFFFFFFFFL );
}
 
public static void main(String[] args) {
int command = 42;
 
longint[][] commandprogram = 42{ { 0, 2 } }; // Example program
longint bits = 64;▼
long[][] program = {{0,2}}; // Example program
▲ long bits = 64;
long result = inference(command, bits, program);
System.out.println(Long.toUnsignedString(result));
 
}
}
}</syntaxhighlight>
 
===Both Demos===
Jjuanhdez
2,169

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/365166...365485"