Port math/rand to gno

[dragosroua]

Description

Following the steps described here.

[irreverentsimplicity]

there is a working implementation of the math/rand, but it's a bit hacky. I'm using this in flippando, with relatively good results.

I'm pasting the relevant code for review here (you can ignore it, use it as a starting point in your own approach, or even ask me to do a PR, if you think it will cut it, for now).

this is located in p/math_rand/rand.gno in this repo https://github.com/irreverentsimplicity/gno/tree/feat/flippando

line 394 onward:

func (r *Rand) NormFloat64() float64 {
	z := r.Float64()*2 - 1 + r.Float64()*2 - 1
	radius := z*z
	for radius >= 1 || radius == 0 {
		z = r.Float64()*2 - 1 + r.Float64()*2 - 1
		radius = z*z
	}
	return z * (-2 * ln(radius) / radius)
}

// while not having access to math package at all
func ln(x float64) float64 {
    const negativeInfinity = -1e308
    const NaN = -99999.0

    if x == 0 {
        return negativeInfinity // Return a very large negative value for ln(0)
    }
    if x < 0 {
        return NaN // Return a special value for negative values
    }

    // Adjust large values into a suitable range for Maclaurin series
    if x > 2 {
        return -ln(1/x)
    }

    // Maclaurin series for ln(1 + x) around 0
    x -= 1 // Adjust x for the expansion around 1
    result := 0.0
    term := x
    for i := 1; i < 100; i++ { // Use 100 terms. You can adjust this for more accuracy.
        if i%2 == 1 {
            result += term / float64(i)
        } else {
            result -= term / float64(i)
        }
        term *= x
    }

    return result
}