// This is an implementation of the MT19937 algorithm, which produces 32 bit integers.

pif_Random/Mersenne32
    var
        const
            // These constants and their names are specified by the MT19937 algorithm, so refer
            // to it for details. Pairs of the form (x1,x2) indicate a single 32 bit in broken up
            // into two groups. E.g., if x1 = 0xABCD and x2 = 0xEF01, then the original specification
            // had a single 32 bit in x = 0xABCDEF01. That is, x1 will always be the more significant
            // end, and x2 will be the least-significant one.
            w  = 32
            n  = 624
            m  = 397
            r  = 31
            
            a1 = 0x9908
            a2 = 0xB0DF
            
            u  = 11
            // d1 = 0xFFFF        (x & ((d1 << 16) | d2)) == x, so this step won't be performed.
            // d2 = 0xFFFF
            
            s  = 7
            b1 = 0x9D2C
            b2 = 0x5680
            
            t  = 15
            c1 = 0xEFC6
            c2 = 0x0000
            
            l  = 18
            
            f1 = 0x6C07
            f2 = 0x8965
            
            // lower_mask = (1 << r) - 1
            lower_mask1 = 0x7FFF
            lower_mask2 = 0xFFFF
            
            // upper_mask = lowest w bits of ~( (lower_mask1 << 16) || lower_mask2)
            upper_mask1 = 0x8000
            upper_mask2 = 0x0000

        index = n
        list/MT // Stores the state of the PRNG.

        pif_LongInt/Unsigned32/Int

    New(...)
        // Takes arguments in the pif_Arithmetic format. This argument is passed directly to
        // the Int object, which will process it instead of this method.

        MT = new
        MT.len = 1248 // 2n = 2*624. We do this, because the array will store a pair of 16 bit integers that
                      // are combineod for the Int object to use.

// This macro will store the blocks of Integer in List at the positions specified. This allows us to pretend like
// we're dealing with a list of 624 elements, even though it's actually twice as long.
#define pRMT_Store(List, pos, b1, b2)   List[(2*(pos))-1] = b1; List[2*(pos)] = b2;

        Int = new(arglist(args))
        Int.SetModeFlag(Int.NEW_OBJECT, 0) // Int will always modify itself, rather than create a new Unsigned32 object.
        
        var
            // Blocks of the previous element.
            prev_block1 = Int._GetBlock(1) // Least significant.
            prev_block2 = Int._GetBlock(2) // Most significant.
        
        pRMT_Store(MT, 1, prev_block1, prev_block2)
            
        // Now start filling up MT.
        for(var/i = 2, i <= n, i ++)
            // MT[i] := lowest w bits of (f * (MT[i-1] xor (MT[i-1] >> (w-2))) + i)
            // Note that the description of the algorithm I'm using assuming indexing starts at 0, so we have to add
            // i-1 to account for this.
        
            Int.BitshiftRight(w - 2)
            Int.BitwiseXor(prev_block2, prev_block1)
            Int.Multiply(f1, f2)
            Int.Add(i-1)
            
            prev_block1 = Int._GetBlock(1)
            prev_block2 = Int._GetBlock(2)

            pRMT_Store(MT, i, prev_block1, prev_block2)