normal

Builtin index · Statistics & ML

result = normal(mu, sigma, [rows], [cols], [seed=])

Input: mu, sigma, rows, cols, seed · Output: result

What it is

Draws from a Gaussian. mu (number) is the mean; sigma (number) is the standard deviation; rows and cols (numbers, optional) give the shape of the draw, one number for a vector and two for a matrix; seed= (number, optional) makes the draw repeatable.

Overloads

One call shape — this function is not overloaded.

Code	Input	Output	Description
`result = normal(mu, sigma, [rows], [cols], [seed=])`	`mu` number`mu` (number) is the mean. `sigma` number`sigma` (number) is the standard deviation. `rows` number, vector, or matrix, optional`rows` and `cols` (numbers, optional) give the shape of the draw, one number for a vector and two for a matrix. `cols` number, vector, or matrix, optional`rows` and `cols` (numbers, optional) give the shape of the draw, one number for a vector and two for a matrix. `seed` number, optional`seed=` (number, optional) makes the draw repeatable.	`result` number, vector, or matrix	Returns a number, vector, or `(rows, cols)` matrix.

Examples

From the documentation, and run by the build -- the output and the figure below are what the engine actually produced. Simplest first.

u = uniform(10, 20, 5)          # 5 draws, continuous uniform on [10, 20)

g = normal(5, 2, 1000, seed=1)  # 1000 draws, mean 5, std 2 — randn is mu=0/sigma=1

d = randi(1, 6, 10)             # 10 dice rolls, inclusive both ends

k = poisson(4, 500)             # 500 draws from Poisson(lambda=4)

t = exponential(2, 500)         # 500 draws, rate=2 (mean = 1/rate = 0.5)

b = binomial(20, 0.3, 500)      # 500 draws, 20 trials at p=0.3 each

from numerics-dsp

draws = normal(10, 2, 4000, seed = 77)
print("mean {round(mean(draws), 3)}, std {round(std(draws), 3)}")
hist(draws, bins = 40, color = "#4169e1")
title("normal(mu = 10, sigma = 2), 4000 draws")
xlabel("value")

output

mean 9.982, std 1.993
· hist: figure 15 (4000 points, 40 bins)

from statistics-ml

n_per_class = 60
c0x = normal(0, 0.6, n_per_class, seed=1)
c0y = normal(0, 0.6, n_per_class, seed=2)
c1x = normal(4, 0.6, n_per_class, seed=3)
c1y = normal(4, 0.6, n_per_class, seed=4)

Xc0 = hstack(reshape(c0x, n_per_class, 1), reshape(c0y, n_per_class, 1))
Xc1 = hstack(reshape(c1x, n_per_class, 1), reshape(c1y, n_per_class, 1))
Xc = vstack(Xc0, Xc1)             # (120, 2)


n = 2 * n_per_class
idx = 0 to n - 1
y = floor(idx / n_per_class)      # 0 for the first 60 rows, 1 for the last 60


function one_hot(labels, rows, k)
    m = zeros(rows, k)
    for i = 0 to rows - 1
        m[i, labels[i]] = 1
    end for
    return m
end function

Y = one_hot(y, n, 2)

net = mlp_classifier(2, [8], 2, seed=42)
trained = net.fit(Xc, Y, epochs=200, lr=0.1, loss="cross_entropy")

function accuracy(model, X, Ytrue, rows)
    logits = model.predict(X)
    correct = 0
    for i = 0 to rows - 1
        if argmax(logits[i, :]) == argmax(Ytrue[i, :]) then
            correct = correct + 1
        end if
    end for
    return correct / rows
end function

acc = accuracy(trained, Xc, Y, n)
print("training accuracy = {acc:.4f}")

output

training accuracy = 1.0000

from quickstart

How it works

normal(mu, sigma, ...) — randn is this distribution's mu=0, sigma=1 special case.

From the note above this builtin in the interpreter, where the reasoning was written down as it was built.