I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Pseudorandom number generator image

Pseudorandom number generator image is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
Task

Write a program that creates an image from a Pseudorandom Number Generator (PRNG) algorithm's output. The image can have the following dimensions:

1. 250px by 250px : If the algorithm requires the use of prime numbers, use 8-15 bit primes.
2. 500px by 500px : If the algorithm requires the use of prime numbers, use 8-15 bit primes.
3. 1000px by 1000px : If the algorithm requires the use of prime numbers, use 8-32 bit primes.
4. 1500px by 1500px : If the algorithm requires the use of prime numbers, use 16-64 bit primes.
Possible Output
See also
•   Blum Blum Shub [1].
•   Blum-Micali Algorithm: [2].
•   Linear congruential generator [3].

## Delphi

` program Pseudorandom_number_generator_image; {\$APPTYPE CONSOLE} uses  System.SysUtils,  vcl.Graphics,  Vcl.Imaging.PngImage; type  TRGBTriple = packed record    b: Byte;    g: Byte;    r: Byte;  end;   PRGBTripleArray = ^TRGBTripleArray;   TRGBTripleArray = array[0..999] of TRGBTriple; function Noise(cWidth, cHeight: Integer; Color: boolean = True): TBitmap;const  Seed = 2147483647;var  Pixels: PRGBTripleArray;begin  RandSeed := Seed;  Result := TBitmap.Create;  with Result do  begin    SetSize(cWidth, cHeight);    PixelFormat := pf24bit;    for var row := 0 to cHeight - 1 do    begin      Pixels := ScanLine[row];      for var col := 0 to cWidth - 1 do      begin        if Color then        begin          Pixels[col].r := random(255);          Pixels[col].g := random(255);          Pixels[col].b := random(255);        end        else        begin          var Gray := Round((0.299 * random(255)) + (0.587 * random(255)) + (0.114            * random(255)));          Pixels[col].r := Gray;          Pixels[col].g := Gray;          Pixels[col].b := Gray;        end;      end;    end;  end;end; const  cWidth = 1000;  cHeight = 1000; begin  // Color noise  var bmp := Noise(cWidth, cHeight);  bmp.SaveToFile('randbitmap-rdo.bmp');   // to Png  with TPngImage.create do  begin    Assign(bmp);    SaveToFile('randbitmap-rdo.png');    free;  end;  bmp.Free;   // Gray noise  bmp := Noise(cWidth, cHeight, False);  bmp.SaveToFile('randbitmap-rdo_g.bmp');   // to Png  with TPngImage.create do  begin    Assign(bmp);    SaveToFile('randbitmap-rdo_g.png');    free;  end;  bmp.Free; end.`
Output:

## Factor

Factor's default PRNG is Mersenne Twister, but it can be easily swapped out for others like Drand, Xoroshiro, Blum Blum Shub, lagged Fibonnaci, system RNGs, and more.

Works with: Factor version 0.99 2021-02-05
`USING: accessors images.testing images.viewer literals mathrandom sequences ; CONSTANT: size 500 <rgb-image>  \${ size size } >>dim  size sq 3 * [ 256 random ] B{ } replicate-as >>bitmapimage-window`

## Forth

Works with: gforth version 0.7.3

Uses gforth random generator to create PBM portable pixmap image file.

`require random.fs: prngimageoutfile-id >rs" prngimage.pbm" w/o create-file throw to outfile-ids\" P1\n500 500\n" type500 0 do  500 0 do    2 random 48 + emit  loop  #lf emitloopoutfile-id close-file throwr> to outfile-id ; prngimage`

## FreeBASIC

`Windowtitle "Pseudorandom number generator image"Dim As Integer w = 500, h = w, x, yScreenres w, h, 16 For x = 0 To w-1    For y = 0 To h-1        Pset(x, y), Rgb(Rnd * 255, Rnd * 255, Rnd * 255)    Next yNext x Bsave "Pseudo-Random-Algorithm.bmp",0`

image500.png (sample image, offsite)

## Go

The math/rand package uses a custom algorithm attributed to D.P.Mitchell and J.A.Reeds. It doesn't need to be seeded by a prime number. Typically (as here) the seed is generated from the current time.

The image is saved to a .png file which can then be viewed with a utility such as EOG.

`package main import (    "image"    "image/color"    "image/png"    "log"    "math/rand"    "os"    "time") func main() {    rand.Seed(time.Now().UnixNano())    img := image.NewNRGBA(image.Rect(0, 0, 1000, 1000))    for x := 0; x < 1000; x++ {        for y := 0; y < 1000; y++ {            col := color.RGBA{uint8(rand.Intn(256)), uint8(rand.Intn(256)), uint8(rand.Intn(256)), 255}            img.Set(x, y, col)        }    }    fileName := "pseudorandom_number_generator.png"    imgFile, err := os.Create(fileName)    if err != nil {        log.Fatal(err)    }    defer imgFile.Close()     if err := png.Encode(imgFile, img); err != nil {        imgFile.Close()        log.Fatal(err)    }}`

## Java

Following implementation generates images from java.util.Random(uses linear congruential generator [4].) and Blum Blum Shub Algorithm with least significant bit method and even bit parity method[5].

` import javax.imageio.ImageIO;import java.awt.*;import java.awt.image.BufferedImage;import java.io.File;import java.io.IOException;import java.math.BigInteger;import java.security.SecureRandom;import java.util.Random;import java.util.Scanner;/** Numbers to try:* p = 11 or BigInteger.probablePrime(BIT1_LENGTH, rand)* q = 23 or BigInteger.probablePrime(BIT_LENGTH, rand)* seed = 3 or BigInteger.probablePrime(BIT_LENGTH,rand)* */ public class csprngBBS {    public static Scanner input = new Scanner(System.in);    private static final String fileformat = "png";    private static String bitsStri = "";    private static String parityEven = "";    private static String leastSig = "";    private static String randomJavaUtil = "";    private static int width = 0;    private static int BIT_LENGTH = 0;    private static final Random rand = new SecureRandom();    private static BigInteger p = null; // 11    private static BigInteger q = null; // 23    private static BigInteger m = null;    private static BigInteger seed = null; // 3    private static BigInteger seedFinal = null;    private static final Random randMathUtil = new SecureRandom();    public static void main(String[] args) throws IOException {        System.out.print("Width: ");        width = input.nextInt();        System.out.print("Bit-Length: ");        BIT_LENGTH = input.nextInt();        System.out.print("Generator format: ");        String useGenerator = input.next();        p = BigInteger.probablePrime(BIT_LENGTH, rand);        q = BigInteger.probablePrime(BIT_LENGTH, rand);        m = p.multiply(q);        seed = BigInteger.probablePrime(BIT_LENGTH,rand);        seedFinal = seed.add(BigInteger.ZERO);        if(useGenerator.contains("parity") && useGenerator.contains("significant")) {            findLeastSignificant();            findBitParityEven();            createImage(parityEven, "parityEven");            createImage(leastSig, "significant");        }         if(useGenerator.contains("parity") && !useGenerator.contains("significant")){            findBitParityEven();        }         if(useGenerator.contains("significant") && !useGenerator.contains("parity")){            findLeastSignificant();            createImage(leastSig, "significant");        }         if(useGenerator.contains("util")){            findRandomJava(randMathUtil);            createImage(randomJavaUtil, "randomUtilJava");        }    }    public static void findRandomJava(Random random){        for(int x = 1; x <= Math.pow(width, 2); x++){            randomJavaUtil += random.nextInt(2);        }    }     public static void findBitParityEven(){        for(int x = 1; x <= Math.pow(width, 2); x++) {            seed = seed.pow(2).mod(m);            bitsStri = convertBinary(seed);            char[] bits = bitsStri.toCharArray();            int counter = 0;            for (char bit : bits) {                if (bit == '1') {                    counter++;                }            }            if (counter % 2 != 0) {                parityEven += "1";            } else {                parityEven += "0";            }        }    }     public static void findLeastSignificant(){        seed = seedFinal;        for(int x = 1; x <= Math.pow(width, 2); x++){            seed = seed.pow(2).mod(m);            leastSig += bitsStri.substring(bitsStri.length() - 1);        }    }     public static String convertBinary(BigInteger value){        StringBuilder total = new StringBuilder();        BigInteger two = BigInteger.TWO;        while(value.compareTo(BigInteger.ZERO) > 0){            total.append(value.mod(two));            value = value.divide(two);        }        return total.reverse().toString();    }     public static void createImage(String useThis, String fileName) throws IOException {        int length = csprngBBS.width;        // Constructs a BufferedImage of one of the predefined image types.        BufferedImage bufferedImage = new BufferedImage(length, length, 1/*BufferedImage.TYPE_INT_RGB*/);        // Create a graphics which can be used to draw into the buffered image        Graphics2D g2d = bufferedImage.createGraphics();        for (int y = 1; y <= length; y++) {            for (int x = 1; x <= length; x++) {                if (useThis.startsWith("1")) {                    useThis = useThis.substring(1);                    g2d.setColor(Color.BLACK);                    g2d.fillRect(x, y, 1, 1);                } else if (useThis.startsWith("0")) {                    useThis = useThis.substring(1);                    g2d.setColor(Color.WHITE);                    g2d.fillRect(x, y, 1, 1);                }            }            System.out.print(y + "\t");        }        // Disposes of this graphics context and releases any system resources that it is using.        g2d.dispose();        // Save as file        File file = new File("REPLACEFILEPATHHERE" + fileName + "." + fileformat);        ImageIO.write(bufferedImage, fileformat, file);    }} `

## Julia

Julia uses the Mersenne Twister algorithm for its default rand() function. That algorithm uses over 600 32-bit ints to represent its internal state, rather than just a product of two or three primes.

`using FileIO, ImageIO save("randombw.png", rand(Float16, 1000, 1000)) `

## Lua

Lua uses the `xoroshiro256**` algorithm.

`size = 500math.randomseed(os.time()) -- Writes a 256-bit grayscale PGM image file:function writePgm(data, fn, comment)  local rows = #data  local cols = #data[1]  local file = io.open(fn, "wb")   -- Write header in ASCII  file:write("P5", "\n")  if comment ~= nil then    file:write("# ", comment, "\n")  end  file:write(cols, " ", rows, "\n")  file:write("255", "\n")  -- Write data in raw bytes  for _, r in ipairs(data) do    file:write(string.char(unpack(r)))  end  file:close()end img = {}for r = 1, size do  img[r] = {}  for c = 1, size do    img[r][c] = math.random(0,255)  endend writePgm(img, "prng_img.pgm", string.format("PRNG Image (%d x %d)", size, size))`

## Nim

Nim standard PRNG is an implementation of the `xoroshiro128+` (xor/rotate/shift/rotate) algorithm which is extremely fast. The standard library provides a Mersenne Twister implementation too. For this task, we used the first one.

`import randomimport imageman const Size = 500 randomize()var image = initImage[ColorRGBU](Size, Size)for x in 0..<Size:  for y in 0..<Size:    let color = ColorRGBU([rand(255).byte, rand(255).byte, rand(255).byte])    image[x, y] = color image.savePNG("prng_image.png", compression = 9)`

## Perl

Perl unified the PRNG with its own internal drand48() implementation on all platforms since v5.20.0. Without a manual srand, Perl by default source the seed from "/dev/urandom" if it is available so there shouldn't be any prime prerequisite.

`use strict;use warnings;use GD; my \$img = new GD::Image(500, 500, 1); for my \$y(0..500) {        for my \$x(0..500) {                my \$color = \$img->colorAllocate(rand 256, rand 256, rand 256);                \$img->setPixel(\$x, \$y, \$color);        }} open  F, "image500.png";print F  \$img->png;`

image500.png (sample image, offsite)

## Phix

Library: Phix/pGUI
```-- demo\rosetta\Pseudorandom_number_generator_image.exw
without js -- IupSaveImage(), not possible from within a browser (though a "save" button might be?)
include pGUI.e

IupOpen()
integer w=250, h=w
sequence bw = repeat(0,w*h)
for x=0 to w-1 do
for y=0 to h-1 do
if rand(2)=2 then bw[x*h+y+1] = 255 end if
end for
end for
Ihandle image = IupImage(w,h,bw)
object res = IupSaveImage(image,"bw.png","PNG")
IupClose()
```

## PicoLisp

`(seed (in "/dev/urandom" (rd 8)))(out "image.pbm"   (prinl "P1")   (prinl 500 " " 500)   (do 500      (do 500         (prin (if (rand T) 1 0)) )      (prinl) ) )`

## Raku

MoarVM uses Mersenne Twister as its PRNG but a prime seeder is not mandatory.

`# 20200818 Raku programming solution use Image::PNG::Portable; srand 2⁶³ - 25; # greatest prime smaller than 2⁶³ and the max my system can take my @data = < 250 500 1000 1500 >; @data.map: {   my \$o = Image::PNG::Portable.new: :width(\$_), :height(\$_);   for ^\$_ X ^\$_ -> @pixel { # about 40% slower if split to (\$x,\$y) or (\x,\y)      \$o.set: @pixel[0], @pixel[1], 256.rand.Int, 256.rand.Int, 256.rand.Int   }   \$o.write: "image\$_.png" or die;}`
Output:
```file image*.png
image1000.png: PNG image data, 1000 x 1000, 8-bit/color RGBA, non-interlaced
image1500.png: PNG image data, 1500 x 1500, 8-bit/color RGBA, non-interlaced
image250.png:  PNG image data, 250 x 250, 8-bit/color RGBA, non-interlaced
image500.png:  PNG image data, 500 x 500, 8-bit/color RGBA, non-interlaced
```

image500.png (sample image, offsite)

## Sidef

Translation of: Perl
`require('GD') var img = %O<GD::Image>.new(500, 500, 1) for y in (0..500), x in (0..500) {    var color = img.colorAllocate(255.irand, 255.irand, 255.irand)    img.setPixel(x, y, color)} File("image500.png").write(img.png, :raw)`

## Wren

Library: DOME

Wren's 'random' module uses the 'Well equidistributed long-period linear' (WELL512a) PRNG which doesn't need to be seeded with a prime number. It is in fact seeded from a sequence of 16 numbers but, if less are provided, the others are generated automatically. Typically (as here) the seed is generated from the current time.

`import "dome" for Windowimport "graphics" for Canvas, Colorimport "random" for Random class Game {    static init() {        Window.title = "Pseudorandom Number Generator Image"        Window.resize(1000, 1000)        Canvas.resize(1000, 1000)        var r = Random.new() // generates seed from current time        for (x in 0...1000) {            for (y in 0...1000) {                var c = Color.rgb(r.int(256), r.int(256), r.int(256))                Canvas.pset(x, y, c)            }        }    }     static update() {}     static draw(dt) {}}`

## XPL0

The PRNG is linear congruential and is built-in. It's seeded with the time-of-day.

`int X, Y;[SetVid(\$11B);  \VESA 1280x1024x24for Y:= 0 to 1000-1 do    for X:= 0 to 1000-1 do        Point(X, Y, Ran(\$100_0000));]`
Output:
```Essentially the same as Delphi's image.
```