Munching squares

Render a graphical pattern where each pixel is colored by the value of 'x xor y' from an arbitrary color table.

Action!

<lang Action!>PROC PutBigPixel(BYTE x,y,c)

 BYTE i

 Color=c
 x=x*3+16
 y=y*12
 FOR i=0 TO 11
 DO
   Plot(x,y+i)
   DrawTo(x+2,y+i)
 OD

RETURN

PROC Main()

 BYTE
   CH=$02FC, ;Internal hardware value for last key pressed
   x,y

 Graphics(9)

 FOR y=0 TO 15
 DO
   FOR x=0 TO 15
   DO
     PutBigPixel(x,y,x!y)
   OD
 OD

 DO UNTIL CH#$FF OD
 CH=$FF

RETURN</lang>

Output:

Screenshot from Atari 8-bit computer

Befunge

Writes the image to stdout using the PPM format.

Burlesque

<lang burlesque> blsq ) 0 25r@{0 25r@\/{$$Sh2' P[}\/+]m[}m[sp

0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
1  0  3  2  5  4  7  6  9  8 11 10 13 12 15 14 17 16 19 18 21 20 23 22 25 24
2  3  0  1  6  7  4  5 10 11  8  9 14 15 12 13 18 19 16 17 22 23 20 21 26 27
3  2  1  0  7  6  5  4 11 10  9  8 15 14 13 12 19 18 17 16 23 22 21 20 27 26
4  5  6  7  0  1  2  3 12 13 14 15  8  9 10 11 20 21 22 23 16 17 18 19 28 29
5  4  7  6  1  0  3  2 13 12 15 14  9  8 11 10 21 20 23 22 17 16 19 18 29 28
6  7  4  5  2  3  0  1 14 15 12 13 10 11  8  9 22 23 20 21 18 19 16 17 30 31
7  6  5  4  3  2  1  0 15 14 13 12 11 10  9  8 23 22 21 20 19 18 17 16 31 30
8  9 10 11 12 13 14 15  0  1  2  3  4  5  6  7 24 25 26 27 28 29 30 31 16 17
9  8 11 10 13 12 15 14  1  0  3  2  5  4  7  6 25 24 27 26 29 28 31 30 17 16

10 11 8 9 14 15 12 13 2 3 0 1 6 7 4 5 26 27 24 25 30 31 28 29 18 19 11 10 9 8 15 14 13 12 3 2 1 0 7 6 5 4 27 26 25 24 31 30 29 28 19 18 12 13 14 15 8 9 10 11 4 5 6 7 0 1 2 3 28 29 30 31 24 25 26 27 20 21 13 12 15 14 9 8 11 10 5 4 7 6 1 0 3 2 29 28 31 30 25 24 27 26 21 20 14 15 12 13 10 11 8 9 6 7 4 5 2 3 0 1 30 31 28 29 26 27 24 25 22 23 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 31 30 29 28 27 26 25 24 23 22 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 0 1 2 3 4 5 6 7 8 9 17 16 19 18 21 20 23 22 25 24 27 26 29 28 31 30 1 0 3 2 5 4 7 6 9 8 18 19 16 17 22 23 20 21 26 27 24 25 30 31 28 29 2 3 0 1 6 7 4 5 10 11 19 18 17 16 23 22 21 20 27 26 25 24 31 30 29 28 3 2 1 0 7 6 5 4 11 10 20 21 22 23 16 17 18 19 28 29 30 31 24 25 26 27 4 5 6 7 0 1 2 3 12 13 21 20 23 22 17 16 19 18 29 28 31 30 25 24 27 26 5 4 7 6 1 0 3 2 13 12 22 23 20 21 18 19 16 17 30 31 28 29 26 27 24 25 6 7 4 5 2 3 0 1 14 15 23 22 21 20 19 18 17 16 31 30 29 28 27 26 25 24 7 6 5 4 3 2 1 0 15 14 24 25 26 27 28 29 30 31 16 17 18 19 20 21 22 23 8 9 10 11 12 13 14 15 0 1 25 24 27 26 29 28 31 30 17 16 19 18 21 20 23 22 9 8 11 10 13 12 15 14 1 0 </lang>

Must be converted to an image with a seperate program.

C

<lang c>#include <stdlib.h>

include <stdio.h>
include <math.h>
include <string.h>

void hue_to_rgb(double hue, double sat, unsigned char *p) { double x; int c = 255 * sat; hue /= 60; x = (1 - fabs(fmod(hue, 2) - 1)) * 255;

switch((int)hue) { case 0: p[0] = c; p[1] = x; p[2] = 0; return; case 1: p[0] = x; p[1] = c; p[2] = 0; return; case 2: p[0] = 0; p[1] = c; p[2] = x; return; case 3: p[0] = 0; p[1] = x; p[2] = c; return; case 4: p[0] = x; p[1] = 0; p[2] = c; return; case 5: p[0] = c; p[1] = 0; p[2] = x; return; } }

int main(void) { const int size = 512; int i, j; unsigned char *colors = malloc(size * 3); unsigned char *pix = malloc(size * size * 3), *p; FILE *fp;

for (i = 0; i < size; i++) hue_to_rgb(i * 240. / size, i * 1. / size, colors + 3 * i);

for (i = 0, p = pix; i < size; i++) for (j = 0; j < size; j++, p += 3) memcpy(p, colors + (i ^ j) * 3, 3);

fp = fopen("xor.ppm", "wb"); fprintf(fp, "P6\n%d %d\n255\n", size, size); fwrite(pix, size * size * 3, 1, fp); fclose(fp);

return 0; }</lang>

Output:

C#

<lang csharp>using System.Drawing; using System.Drawing.Imaging; using System.Linq;

class XORPattern {

   static void Main()
   {
       var size = 0x100;
       var black = Color.Black.ToArgb();
       var palette = Enumerable.Range(black, size).Select(Color.FromArgb).ToArray();
       using (var image = new Bitmap(size, size))
       {
           for (var x = 0; x < size; x++)
           {
               for (var y = 0; y < size; y++)
               {
                   image.SetPixel(x, y, palette[x ^ y]);
               }
           }
           image.Save("XORPatternCSharp.png", ImageFormat.Png);
       }
   }

}</lang>

Output:

C++

include <windows.h>
include <string>

//-------------------------------------------------------------------------------------------------- using namespace std;

//-------------------------------------------------------------------------------------------------- const int BMP_SIZE = 512;

//-------------------------------------------------------------------------------------------------- class myBitmap { public:

   myBitmap() : pen( NULL ), brush( NULL ), clr( 0 ), wid( 1 ) {}
   ~myBitmap()
   {

DeleteObject( pen ); DeleteObject( brush ); DeleteDC( hdc ); DeleteObject( bmp );

   }

   bool create( int w, int h )
   {

BITMAPINFO bi; ZeroMemory( &bi, sizeof( bi ) ); bi.bmiHeader.biSize = sizeof( bi.bmiHeader ); bi.bmiHeader.biBitCount = sizeof( DWORD ) * 8; bi.bmiHeader.biCompression = BI_RGB; bi.bmiHeader.biPlanes = 1; bi.bmiHeader.biWidth = w; bi.bmiHeader.biHeight = -h;

HDC dc = GetDC( GetConsoleWindow() ); bmp = CreateDIBSection( dc, &bi, DIB_RGB_COLORS, &pBits, NULL, 0 ); if( !bmp ) return false;

hdc = CreateCompatibleDC( dc ); SelectObject( hdc, bmp ); ReleaseDC( GetConsoleWindow(), dc );

width = w; height = h; return true;

   }

   void clear( BYTE clr = 0 )
   {

memset( pBits, clr, width * height * sizeof( DWORD ) );

   }

   void setBrushColor( DWORD bClr )
   {

if( brush ) DeleteObject( brush ); brush = CreateSolidBrush( bClr ); SelectObject( hdc, brush );

   }

   void setPenColor( DWORD c ) { clr = c; createPen(); }

   void setPenWidth( int w )   { wid = w; createPen(); }

   void saveBitmap( string path )
   {

BITMAPFILEHEADER fileheader; BITMAPINFO infoheader; BITMAP bitmap; DWORD wb;

GetObject( bmp, sizeof( bitmap ), &bitmap ); DWORD* dwpBits = new DWORD[bitmap.bmWidth * bitmap.bmHeight];

ZeroMemory( dwpBits, bitmap.bmWidth * bitmap.bmHeight * sizeof( DWORD ) ); ZeroMemory( &infoheader, sizeof( BITMAPINFO ) ); ZeroMemory( &fileheader, sizeof( BITMAPFILEHEADER ) );

infoheader.bmiHeader.biBitCount = sizeof( DWORD ) * 8; infoheader.bmiHeader.biCompression = BI_RGB; infoheader.bmiHeader.biPlanes = 1; infoheader.bmiHeader.biSize = sizeof( infoheader.bmiHeader ); infoheader.bmiHeader.biHeight = bitmap.bmHeight; infoheader.bmiHeader.biWidth = bitmap.bmWidth; infoheader.bmiHeader.biSizeImage = bitmap.bmWidth * bitmap.bmHeight * sizeof( DWORD );

fileheader.bfType = 0x4D42; fileheader.bfOffBits = sizeof( infoheader.bmiHeader ) + sizeof( BITMAPFILEHEADER ); fileheader.bfSize = fileheader.bfOffBits + infoheader.bmiHeader.biSizeImage;

GetDIBits( hdc, bmp, 0, height, ( LPVOID )dwpBits, &infoheader, DIB_RGB_COLORS );

HANDLE file = CreateFile( path.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ); WriteFile( file, &fileheader, sizeof( BITMAPFILEHEADER ), &wb, NULL ); WriteFile( file, &infoheader.bmiHeader, sizeof( infoheader.bmiHeader ), &wb, NULL ); WriteFile( file, dwpBits, bitmap.bmWidth * bitmap.bmHeight * 4, &wb, NULL ); CloseHandle( file );

delete [] dwpBits;

   }

   HDC getDC() const     { return hdc; }
   int getWidth() const  { return width; }
   int getHeight() const { return height; }

private:

   void createPen()
   {

if( pen ) DeleteObject( pen ); pen = CreatePen( PS_SOLID, wid, clr ); SelectObject( hdc, pen );

   }

   HBITMAP bmp;
   HDC     hdc;
   HPEN    pen;
   HBRUSH  brush;
   void    *pBits;
   int     width, height, wid;
   DWORD   clr;

}; //-------------------------------------------------------------------------------------------------- class mSquares { public:

   mSquares()
   {
       bmp.create( BMP_SIZE, BMP_SIZE );
       createPallete();
   }

   void draw()
   {

HDC dc = bmp.getDC(); for( int y = 0; y < BMP_SIZE; y++ ) for( int x = 0; x < BMP_SIZE; x++ ) { int c = ( x ^ y ) % 256; SetPixel( dc, x, y, clrs[c] ); }

BitBlt( GetDC( GetConsoleWindow() ), 30, 30, BMP_SIZE, BMP_SIZE, dc, 0, 0, SRCCOPY ); //bmp.saveBitmap( "f:\\rc\\msquares_cpp.bmp" );

private:

   void createPallete()
   {

for( int x = 0; x < 256; x++ ) clrs[x] = RGB( x<<1, x, x<<2 );//rand() % 180 + 50, rand() % 200 + 50, rand() % 180 + 50 );

   unsigned int clrs[256];
   myBitmap bmp;

}; //-------------------------------------------------------------------------------------------------- int main( int argc, char* argv[] ) {

   ShowWindow( GetConsoleWindow(), SW_MAXIMIZE );
   srand( GetTickCount() );
   mSquares s; s.draw();
   return system( "pause" );

} //-------------------------------------------------------------------------------------------------- </lang>

Commodore BASIC

Works with: Commodore BASIC version 4.0

The TED machines (C-16, Plus/4) are the only Commodore 8-bits with a large- or structured- enough color palette to make this interesting. Here's an extremely low-res version (40x25 character-sized "pixels"):

<lang basic>100 FOR I=0 TO 24 110 : Y=INT(I*127/24) 120 : FOR J=0 TO 39 130 : X=INT(J*127/39) 140 : HL = (X OR Y) AND NOT (X AND Y) 150 : H = INT(HL / 8) 160 : L = HL - 8 * H 170 : POKE 2048+I*40+J,L*16+H 180 : POKE 3072+I*40+J,160 190 : NEXT J 210 NEXT I 220 GETKEY K$</lang>

Output:

Screenshot.

D

<lang d>void main() {

   import std.stdio;

   enum width = 512, height = 512;

   auto f = File("xor_pattern.ppm", "wb");
   f.writefln("P6\n%d %d\n255", width, height);
   foreach (immutable y; 0 .. height)
       foreach (immutable x; 0 .. width) {
           immutable c = (x ^ y) & ubyte.max;
           immutable ubyte[3] u3 = [255 - c, c / 2, c];
           f.rawWrite(u3);
       }

}</lang>

EchoLisp

Use the plot library, hsv->rgb ((x xor y) modulo m) as color table, and see the nice results here : http://www.echolalie.org/echolisp/help.html#bit-map . <lang scheme> (lib 'types) (lib 'plot) (plot-size 512 512) ;; for example

use m = 16, 32, 44, .. to change the definition (number of losanges)

(define (plot-munch (m 256)) (define PIX (pixels->int32-vector)) ;; get canvas image (define (pcolor x y) ;; color at (x,y) (hsv->rgb (// (bitwise-xor (modulo x m) (modulo y m)) m) 0.9 0.9)) (pixels-map pcolor PIX) (vector->pixels PIX)) ;; draw canvas image

(plot-much) ;; ESC to see tge drawing </lang>

Factor

<lang factor>USING: accessors images images.loader kernel math sequences ; IN: rosetta-code.munching-squares

img-data ( -- seq ) 256 sq [ B{ 0 0 0 255 } ] replicate ;

(munching) ( elt index -- elt' )

   256 /mod bitxor [ rest ] dip prefix ;

munching ( -- seq )

   img-data [ (munching) ] map-index B{ } concat-as ;

<munching-img> ( -- img )

   <image>
   { 256 256 }      >>dim
   BGRA             >>component-order
   ubyte-components >>component-type
   munching         >>bitmap ;

main ( -- ) <munching-img> "munching.png" save-graphic-image ;

MAIN: main</lang> Output image is identical to the Racket version.

Output:

FreeBASIC

<lang freebasic>' version 03-11-2016 ' compile with: fbc -s gui

Dim As ULong x, y, r, w = 256

ScreenRes w, w, 32

For x = 0 To w -1

   For y = 0 To w -1
       r =(x Xor y) And 255
       PSet(x, y), RGB(r, r , r)         ' gray scale
       ' PSet(x, y), RGB(r, 255 - r, 0)  ' red + green
       ' PSet(x, y), RGB(r, 0, 0)        ' red
   Next

Fōrmulæ

Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation —i.e. XML, JSON— they are intended for storage and transfer purposes more than visualization and edition.

Programs in Fōrmulæ are created/edited online in its website, However they run on execution servers. By default remote servers are used, but they are limited in memory and processing power, since they are intended for demonstration and casual use. A local server can be downloaded and installed, it has no limitations (it runs in your own computer). Because of that, example programs can be fully visualized and edited, but some of them will not run if they require a moderate or heavy computation/memory resources, and no local server is being used.

In this page you can see the program(s) related to this task and their results.

GLSL

This is an example that will work directly on shadertoy.com, Example [1] <lang GLSL>vec3 color; float c,p; vec2 b;

void main(void) { vec2 uv = gl_FragCoord.xy / iResolution.xy; float scale = iResolution.x / iResolution.y; uv = uv-0.5; uv.y/=scale;

b = uv*256.0+256.0; c = 0.0;

for(float i=16.0;i>=1.0;i-=1.0) { p = pow(2.0,i);

if((p < b.x) ^^ (p < b.y)) { c += p; }

if(p < b.x) { b.x -= p; }

if(p < b.y) { b.y -= p; }

}

c=mod(c/128.0,1.0);

color = vec3(sin(c+uv.x*cos(uv.y*1.2)), tan(c+uv.y-0.3)*1.1, cos(c-uv.y+0.9));

gl_FragColor = vec4(color,1.0); }</lang>

Gnuplot

<lang gnuplot>set pm3d map set size square set isosamples 255,255 splot [0:255][0:255]-(floor(x)^floor(y))</lang>

Output:

Go

<lang go>package main

import (

   "image"
   "image/png"
   "os"

)

func main() {

   g := image.NewGray(image.Rect(0, 0, 256, 256))
   for i := range g.Pix {
       g.Pix[i] = uint8(i>>8 ^ i)
   }
   f, _ := os.Create("xor.png")
   png.Encode(f, g)
   f.Close()

}</lang>

Haskell

<lang haskell>import qualified Data.ByteString as BY (writeFile, pack)

import Data.Bits (xor)

main :: IO () main =

 BY.writeFile
   "out.pgm"
   (BY.pack
      (fmap (fromIntegral . fromEnum) "P5\n256 256\n256\n" ++
       [ x `xor` y
       | x <- [0 .. 255] 
       , y <- [0 .. 255] ]))</lang>

Icon and Unicon

<lang Icon>link printf

procedure main(A) #: XOR graphic

  wsize := 512
  cmax  := 32768
  wparms := ["Xmas Xor Graphic","g",sprintf("size=%d,%d",wsize),"bg=black"]
  &window := open!wparms | stop("Unable to open window")

  every y := 0 to wsize - 1 do
     every x := 0 to wsize - 1 do {
        c := cmax/wsize * iand(wsize-1,ixor(x,y))
        Fg(sprintf("%d,%d,%d",c,cmax-c,0))
        DrawPoint(x,y)
        }

 until Event() == &lpress     # wait for left button to quit
 close(&window)

end</lang>

Library: Icon Programming Library

printf.icn provides formatting

J

<lang J> require 'viewmat'

  viewmat ~:"1/&.#: ~ i.256</lang>

Java

Library: Swing

This example will repeat the pattern if you expand the window. <lang java>import java.awt.Color; import java.awt.Graphics;

import javax.swing.JFrame; import javax.swing.JPanel;

public class XorPattern extends JFrame{

   private JPanel xorPanel;

   public XorPattern(){
       xorPanel = new JPanel(){
           @Override
           public void paint(Graphics g) {
               for(int y = 0; y < getHeight();y++){
                   for(int x = 0; x < getWidth();x++){
                       g.setColor(new Color(0, (x ^ y) % 256, 0));
                       g.drawLine(x, y, x, y);
                   }
               }
           }
       };
       add(xorPanel);
       setSize(300, 300);
       setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
       setVisible(true);
   }

   public static void main(String[] args){
       new XorPattern();
   }

}</lang>

jq

Works with: jq version 1.4

The following is an adaptation of the Ruby entry, but generates an SVG image file: <lang sh>jq -n -r -f Munching_squares.jq > Munching_squares.svg</lang> Part 1: Infrastructure <lang jq># Convert the input integer to an array of bits with lsb first def integer_to_lsb:

 [recurse(if . > 0 then ./2|floor else empty end) | . % 2] ;

input array of bits (with lsb first) is converted to an integer

def lsb_to_integer:

 reduce .[] as $bit
   # state: [power, ans]
   ([1,0]; (.[0] * 2) as $b | [$b, .[1] + (.[0] * $bit)])
 | .[1];

def xor(x;y):

  def lxor(a;b):  # a and/or b may be null
    if a == 1 then if b==1 then 0 else 1 end
    elif b==1 then if a==1 then 0 else 1 end
    else 0
    end;
  (x|integer_to_lsb) as $s
  | (y|integer_to_lsb) as $t
  | ([$s|length, $t|length] | max) as $length
  | reduce range(0;$length) as $i
     ([]; . + [ lxor($s[$i]; $t[$i]) ] )
  | lsb_to_integer;</lang>

Part 2: SVG <lang jq>def rgb2rgb:

 def p: (. + 0.5) | floor;  # to nearest integer
 "rgb(\(.red|p),\(.green|p),\(.blue|p))";

def svg(width; height):

 "<svg width='\(width // "100%")' height='\(height // "100%")'
          xmlns='http://www.w3.org/2000/svg'>";

def pixel(x; y; color):

 (color | if type == "string" then . else rgb2rgb end) as $c
 | "<circle r='1' cx='\(x)' cy='\(y)' fill='\($c)' />";</lang>

Part 3: xor pattern <lang jq># rgb is a JSON object: { "red": _, "green": _, "blue": _}

def xor_pattern(width; height; rgb1; rgb2):

   # create colour table
   256 as $size 
   | (reduce range(0;$size) as $i
       ([]; . + [ 
       {"red":   (rgb1.red + (rgb2.red - rgb1.red) * $i / $size), 
        "green": (rgb1.green + (rgb2.green - rgb1.green) * $i / $size), 
        "blue":  (rgb1.blue + (rgb2.blue - rgb1.blue) * $i / $size) }])
     )  as $colours
   # create the image
   | svg(width; height),
     ( (range(0;width) as $x
       | range(0;height) as $y
       |   pixel($x; $y; $colours[ xor($x; $y) % $size] ) ) ),
    "</svg>" ;</lang>

Part 4: Example <lang jq>def black: { "red": 0, "green": 0, "blue": 0}; def red: black + { "red": 255 }; def yellow: red + { "green": 255 };

xor_pattern(384; 384; red; yellow)</lang>

Julia

<lang julia>using Gtk, Colors, PerceptualColourMaps

function munchingsquares(ctx, w, h)

   extent = min(max(w, h), 256)
   colors = cmap("R1", N=extent)
   for i in 1:2:w-2, j in 1:2:h-2
       rectangle(ctx, i, j, i + 2, j + 2)
       c = colors[((UInt(i) ^ UInt(j)) % extent) + 1]
       set_source_rgb(ctx, red(c), blue(c), green(c))
       fill(ctx)
   end

end

const can = @GtkCanvas() const win = GtkWindow(can, "Munching Squares", 720, 360)

@guarded draw(can) do widget

   ctx = getgc(can)
   h = height(can)
   w = width(can)
   munchingsquares(ctx, w, h)

end

show(can) const cond = Condition() endit(w) = notify(cond) signal_connect(endit, win, :destroy) wait(cond) </lang>

Kotlin

<lang scala>// version 1.1.4-3

import javax.swing.JFrame import javax.swing.JPanel import java.awt.Graphics import java.awt.Graphics2D import java.awt.Color import java.awt.Dimension import java.awt.BorderLayout import java.awt.RenderingHints import javax.swing.SwingUtilities

class XorPattern : JPanel() {

   init {
       preferredSize = Dimension(256, 256)
       background = Color.white
   }

   override fun paint(gg: Graphics) {
       super.paintComponent(gg)
       val g = gg as Graphics2D
       g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, 
                          RenderingHints.VALUE_ANTIALIAS_ON)
       for (y in 0 until width) {
           for (x in 0 until height) {
               g.color = Color(0, (x xor y) % 256, 255)
               g.drawLine(x, y, x, y)
           }
       }
   }

}

fun main(args: Array<String>) {

   SwingUtilities.invokeLater {
       val f = JFrame()
       with (f) {
           defaultCloseOperation = JFrame.EXIT_ON_CLOSE
           title = "Munching squares"
           isResizable = false
           add(XorPattern(), BorderLayout.CENTER)
           pack()
           setLocationRelativeTo(null)
           isVisible = true
       }
   }

}</lang>

Liberty BASIC

   nomainwin

   w =512
   '   allow for title bar and window border
   WindowWidth  =w +2
   WindowHeight =w +34

   open "XOR Pattern" for graphics_nsb_nf as #w

   #w "trapclose quit"

   #w "down"

   for x =0 to w -1
       for y =0 to w -1
           b =( x xor y) and 255
           print b
           #w "color "; 255 -b; " "; b /2; " "; b
           #w "set "; x; " "; w -y -1
           scan
       next y
   next x

   #w "flush"

   wait

   sub quit j$
   close #w
   end
   end sub

</lang> Image available at [[2]]

Lua

Works with: LÖVE version 11.0 or higher

<lang lua>local clr = {} function drawMSquares() local points = {} for y = 0, hei-1 do for x = 0, wid-1 do local idx = bit.bxor(x, y)%256 local r, g, b = clr[idx][1], clr[idx][2], clr[idx][3] local point = {x+1, y+1, r/255, g/255, b/255, 1} table.insert (points, point) end end love.graphics.points(points) end

function createPalette() for i = 0, 255 do clr[i] = {i*2.8%256, i*3.2%256, i*1.5%256} end end

function love.load() wid, hei = 256, 256 love.window.setMode(wid, hei) canvas = love.graphics.newCanvas() love.graphics.setCanvas(canvas) createPalette() drawMSquares() love.graphics.setCanvas() end

function love.draw() love.graphics.setColor(1,1,1) love.graphics.draw(canvas) end</lang>

Mathematica/Wolfram Language

<lang Mathematica>ListDensityPlot[

Table[Table[
  FromDigits[BitXor[IntegerDigits[x, 2, 8], IntegerDigits[y, 2, 8]], 
   2], {x, 0, 255}], {y, 0, 255}]]</lang>

Output #1:

<lang Mathematica>ArrayPlot[Array[BitXor, {511, 511}]]</lang>

Output #2:

MATLAB

<lang matlab>size = 256; [x,y] = meshgrid([0:size-1]);

c = bitxor(x,y);

colormap bone(size); image(c); axis equal;</lang>

Output:

Microsoft Small Basic

<lang smallbasic>' Munching squares - smallbasic - 27/07/2018

 size=256
 GraphicsWindow.Width=size
 GraphicsWindow.Height=size
 For i=0 To size-1
   For j=0 To size-1
     BitXor() 'color=i Xor j
     GraphicsWindow.SetPixel(i,j,GraphicsWindow.GetColorFromRGB(0,color,color))
   EndFor
 EndFor

Sub BitXor '(i,j)->color

 n=i
 Int2Bit()
 ib=ret
 n=j
 Int2Bit()
 jb=ret
 color=0
 For k=1 to 8
   ki=Text.GetSubText(ib,k,1)
   kj=Text.GetSubText(jb,k,1)
   If ki="1" Or kj="1" Then
     kk="1"
   Else
     kk="0"
   EndIf
   If ki="1" And kj="1" Then
     kk="0"
   EndIf
   color=2*color+kk
 EndFor

EndSub

Sub Int2Bit 'n->ret

 x=n
 ret=""
 For k=1 to 8
   t=Math.Floor(x/2)
   r=Math.Remainder(x,2)
   ret=Text.Append(r,ret)
   x=t
 EndFor

EndSub </lang>

Output:

Munching squares - SmallBasic

MiniScript

This version runs in Mini Micro (for the graphics). Note that because MiniScript does not currently have any bit operations (all numbers are floating-point), we have to implement an xor function the hard way.

<lang MiniScript>xor = function(a, b) result = 0 bit = 1 while a > 0 or b > 0 if (a%2 == 0) != (b%2 == 0) then result = result + bit bit = bit * 2 a = floor(a/2) b = floor(b/2) end while return result end function

for x in range(0,255) for y in range(0,255) gfx.setPixel x, y, color.rgb(0, xor(x,y), 0) end for end for</lang>

Output:

Nim

Library: imageman

<lang Nim>import random import imageman

randomize()

Build a color table.

var colors: array[256, ColorRGBU] for color in colors.mitems:

 color = ColorRGBU [byte rand(255), byte rand(255), byte rand(255)]

var image = initImage[ColorRGBU](256, 256)

for i in 0..255:

 for j in 0..255:
   image[i, j] = colors[i xor j]

image.savePNG("munching_squares.png")</lang>

OCaml

<lang ocaml>open Graphics

let () =

 open_graph "";
 resize_window 256 256;
 for y = 0 to pred (size_y()) do
   for x = 0 to pred (size_x()) do
     let v = (x lxor y) land 0xFF in
     set_color (rgb v (255 - v) 0);
     plot x y
   done;
 done;
 ignore(read_key())</lang>

Run with:

$ ocaml graphics.cma xor_pattern.ml

Output:

Octave

<lang Octave>size = 256; [x,y] = meshgrid([0:size-1]);

c = bitxor(x,y);

colormap(jet(size)); image(c); axis equal;</lang>

Output:

Perl

<lang perl>use GD;

my $img = new GD::Image(256, 256, 1);

for my $y(0..255) {

       for my $x(0..255) {
               my $color = $img->colorAllocate( abs(255 - $x - $y),  (255-$x) ^ $y , $x ^ (255-$y));
               $img->setPixel($x, $y, $color);
       }

}

print $img->png</lang>

Output:

Phix

Library: Phix/pGUI

Library: Phix/online

You can run this online here.

--
-- demo\rosetta\Munching_squares.exw
-- =================================
--
with javascript_semantics
include pGUI.e

Ihandle dlg, canvas
cdCanvas cddbuffer, cdcanvas

function redraw_cb(Ihandle /*ih*/, integer /*posx*/, /*posy*/)
integer {width, height} = IupGetIntInt(canvas, "DRAWSIZE")
    cdCanvasActivate(cddbuffer)
    for y=0 to height-1 do
        for x=0 to width-1 do
            cdCanvasPixel(cddbuffer, x, y, xor_bits(x,y))
        end for
    end for
    cdCanvasFlush(cddbuffer)
    return IUP_DEFAULT
end function

function map_cb(Ihandle ih)
    cdcanvas = cdCreateCanvas(CD_IUP, ih)
    cddbuffer = cdCreateCanvas(CD_DBUFFER, cdcanvas)
    cdCanvasSetBackground(cddbuffer, CD_WHITE)
    cdCanvasSetForeground(cddbuffer, CD_RED)
    return IUP_DEFAULT
end function

procedure main()
    IupOpen()
    canvas = IupCanvas("RASTERSIZE=250x250")
    IupSetCallbacks(canvas, {"MAP_CB", Icallback("map_cb"),
                             "ACTION", Icallback("redraw_cb")})
    dlg = IupDialog(canvas, `TITLE="Munching squares",RESIZE=NO`)
    IupShow(dlg)
    if platform()!=JS then
        IupMainLoop()
        IupClose()
    end if
end procedure

main()

PHP

<lang php>header("Content-Type: image/png");

$w = 256; $h = 256;

$im = imagecreate($w, $h)

   or die("Cannot Initialize new GD image stream");

$color = array(); for($i=0;$i<256;$i++) {

       array_push($color,imagecolorallocate($im,sin(($i)*(2*3.14/256))*128+128,$i/2,$i));

}

for($i=0;$i<$w;$i++) {

       for($j=0;$j<$h;$j++)
       {
               imagesetpixel($im,$i,$j,$color[$i^$j]);
       }

}

imagepng($im); imagedestroy($im);</lang>

Output:

PL/I

<lang PL/I>munch: procedure options (main); /* 21 May 2014 */

  declare screen (0:255, 0:255) bit(24) aligned;
  declare b bit(8) aligned;
  declare (x, y) unsigned fixed binary (8);

  do x = 0 upthru hbound(screen,2);
     do y = 0 upthru hbound(screen,1);
        b = unspec(x) ^ unspec(y);
        screen(x,y) = b;
     end;
  end;
  call writeppm(screen);

end munch;</lang>

Processing

Renders grayscale image, the larger the window the more the squares will repeat along the main diagonal from top left to bottom right.

<lang java> //Aamrun, 26th June 2022

size(1200,720);

loadPixels();

for(int i=0;i<height;i++){

 for(int j=0;j<width;j++){
   pixels[j + i*width] = color(i^j);
 }

}

updatePixels(); </lang>

Prolog

Works with SWI-Prolog and his GUI XPCE. <lang Prolog>xor_pattern :- new(D, window('XOR Pattern')), send(D, size, size(512,512)), new(Img, image(@nil, width := 512, height := 512 , kind := pixmap)),

forall(between(0,511, I), ( forall(between(0,511, J), ( V is I xor J, R is (V * 1024) mod 65536, G is (65536 - V * 1024) mod 65536, ( V mod 2 =:= 0 -> B is (V * 4096) mod 65536 ; B is (65536 - (V * 4096)) mod 65536), send(Img, pixel(I, J, colour(@default, R, G, B))))))),

new(Bmp, bitmap(Img)), send(D, display, Bmp, point(0,0)), send(D, open). </lang>

PureBasic

<lang purebasic>#palletteSize = 128 Procedure.f XorPattern(x, y) ;compute the gradient value from the pixel values

 Protected result = x ! y
 ProcedureReturn Mod(result, #palletteSize) / #palletteSize

EndProcedure

Procedure drawPattern()

 StartDrawing(ImageOutput(0))
   DrawingMode(#PB_2DDrawing_Gradient)
   CustomGradient(@XorPattern())
   ;specify a gradient pallette from which only specific indexes will be used
   For i = 1 To #palletteSize 
     GradientColor(1 / i, i * $BACE9B) ; or alternatively use $BEEFDEAD
   Next 
   Box(0, 0, ImageWidth(0), ImageHeight(0))
 StopDrawing()

EndProcedure

If OpenWindow(0, 0, 0, 128, 128, "XOR Pattern", #PB_Window_SystemMenu)

 CreateImage(0, WindowWidth(0), WindowHeight(0))
 drawPattern()
 ImageGadget(0, 0, 0, ImageWidth(0), ImageHeight(0), ImageID(0))
 Repeat
   event = WaitWindowEvent(20)
 Until event = #PB_Event_CloseWindow

EndIf</lang>

Python

Library: PIL

<lang Python>import Image, ImageDraw

image = Image.new("RGB", (256, 256)) drawingTool = ImageDraw.Draw(image)

for x in range(256):

   for y in range(256):
       drawingTool.point((x, y), (0, x^y, 0))

del drawingTool image.save("xorpic.png", "PNG")</lang>

QBasic

<lang qbasic>w = 254

SCREEN 13 VIEW (0, 0)-(w / 2, w / 2), , 0

FOR x = 0 TO w

   FOR y = 0 TO w
       COLOR ((x XOR y) AND 255)
       PSET (x, y)
   NEXT y

NEXT x</lang>

Racket

lang racket

(require racket/draw) (define palette (for/vector ([x 256]) (make-object color% 0 0 x))) (define bm (make-object bitmap% 256 256)) (define dc (new bitmap-dc% [bitmap bm])) (for* ([x 256] [y 256])

 (define c (vector-ref palette (bitwise-xor x y)))
 (send dc set-pixel x y c))

bm </lang>

Raku

(formerly Perl 6)

Here's one simple way:

<lang perl6>my $ppm = open("munching0.ppm", :w) orelse .die;

$ppm.print(q :to 'EOT'); P3 256 256 255 EOT

for 0 .. 255 -> $row {

   for 0 .. 255 -> $col {
       my $color = $row +^ $col;
       $ppm.print("0 $color 0 ");
   }
   $ppm.say();

}

$ppm.close(); </lang>

Another way:

<lang perl6>my @colors = map -> $r, $g, $b { Buf.new: $r, $g, $b }, map -> $x { floor ($x/256) ** 3 * 256 }, (flat (0...255) Z (255...0) Z flat (0,2...254),(254,252...0));

my $PPM = open "munching1.ppm", :w orelse .die;

$PPM.print: qq:to/EOH/;

   P6
   # munching.pgm
   256 256 
   255
   EOH

$PPM.write: @colors[$_] for ^256 X+^ ^256;

$PPM.close;</lang>

REXX

Translation of: Burlesque

<lang rexx>/*REXX program renders a graphical pattern by coloring each pixel with x XOR y */ /*───────────────────────────────────────── from an arbitrary constructed color table. */ rows= 2 /*the number of rows in the color table*/ cols= 5 /* " " " cols " " " " */

       do row  =0  for rows*3                   /*construct a color table, size  25x50.*/
         do col=0  for cols*3
                             $= (row+col) // 255
         @.row.col= x2b( d2x($+0, 2) )  ||,     /*ensure $ is converted──►2 hex nibbles*/
                    x2b( d2x($+1, 2) )  ||,
                    x2b( d2x($+2, 2) )
         end   /*col*/                          /* [↑]  construct a three-byte pixel.  */
       end     /*row*/

       do   x=0  for cols                       /*create a graphical pattern with XORs.*/
         do y=0  for rows
         @.x.y= bitxor(@.x, @.y)                /*renders 3 bytes (a pixel) at a time. */
         end   /*y*/
       end     /*x*/                            /*stick a fork in it,  we're all done. */</lang>

Must be converted to an image with a separate program.

Ring

Project : Munching squares

load "guilib.ring"

paint = null

new qapp

       {
       win1 = new qwidget() {
                 setwindowtitle("Archimedean spiral")
                 setgeometry(100,100,500,600)
                 label1 = new qlabel(win1) {
                             setgeometry(10,10,400,400)
                             settext("")
                 }
                 new qpushbutton(win1) {
                         setgeometry(150,500,100,30)
                         settext("draw")
                         setclickevent("draw()")
                 }
                 show()
       }
       exec()
       }

func draw

       p1 = new qpicture()
              color = new qcolor() {
              setrgb(0,0,255,255)
       }
       pen = new qpen() {
                setcolor(color)
                setwidth(1)
       }
       paint = new qpainter() {
                 begin(p1)
                 setpen(pen)

       w = 100
       for x = 0 to w
            for y = 0 to w
                  b = (x ^ y)
                  color = new qcolor()
                  color.setrgb(255 -b,b /2,b,255)
                  pen.setcolor(color) 
                  setpen(pen)    
                  drawpoint(x,w -y -1)
            next
        next

       endpaint()
       }
       label1 { setpicture(p1) show() }
       return

</lang> Output:

https://www.dropbox.com/s/wvdqyihtxralviz/Squares.jpg?dl=0

Ruby

Uses Raster graphics operations/Ruby

<lang ruby>load 'raster_graphics.rb'

class Pixmap

 def self.xor_pattern(width, height, rgb1, rgb2)
   # create colour table
   size = 256
   colours = Array.new(size) do |i|
     RGBColour.new(
       (rgb1.red + (rgb2.red - rgb1.red) * i / size), 
       (rgb1.green + (rgb2.green - rgb1.green) * i / size), 
       (rgb1.blue + (rgb2.blue - rgb1.blue) * i / size), 
     )
   end

   # create the image
   pixmap = new(width, height)
   pixmap.each_pixel do |x, y|
     pixmap[x,y] = colours[(x^y)%size]
   end
   pixmap
 end

end

img = Pixmap.xor_pattern(384, 384, RGBColour::RED, RGBColour::YELLOW) img.save_as_png('xorpattern.png')</lang>

Run BASIC

<lang runbasic>w = 100 graphic #g, w,w for x = 0 to w

 for y = 0 to w
   b = (x xor y) and 255
   #g color(255 -b,b /2,b)
   #g "set "; x; " "; w -y -1
 next y

next x render #g

g "flush"</lang>

Rust

<lang rust>extern crate image;

use image::{ImageBuffer, Pixel, Rgb};

fn main() {

   let mut img = ImageBuffer::new(256, 256);

   for x in 0..256 {
       for y in 0..256 {
           let pixel = Rgb::from_channels(0, x as u8 ^ y as u8, 0, 0);
           img.put_pixel(x, y, pixel);
       }
   }

   let _ = img.save("output.png");

}</lang>

Scala

Scala Swing

Library: org.scala-lang.modules scala-swing

<lang Scala>import scala.swing.Swing.pair2Dimension import scala.swing.{Color, Graphics2D, MainFrame, Panel, SimpleSwingApplication}

object XorPattern extends SimpleSwingApplication {

 def top = new MainFrame {
   preferredSize = (300, 300)
   title = "Rosetta Code >>> Task: Munching squares | Language: Scala"
   contents = new Panel {

     protected override def paintComponent(g: Graphics2D) = {
       super.paintComponent(g)
       for {
         y <- 0 until size.getHeight.toInt
         x <- 0 until size.getWidth.toInt
       } {
         g.setColor(new Color(0, (x ^ y) % 256, 0))
         g.drawLine(x, y, x, y)
       }
     }
   }

   centerOnScreen()
 }

}</lang>

Sidef

Translation of: Perl

<lang ruby>require('Imager')

var img = %O<Imager>.new(xsize => 256, ysize => 256)

for y=(^256), x=(^256) {

   var rgb = [(255 - x - y).abs, (255-x)^y, x^(255-y)]
   img.setpixel(x => x, y => y, color => rgb)

}

img.write(file => 'xor.png')</lang> Output image: Munching squares

Tcl

Library: Tk

<lang tcl>package require Tk

proc xorImage {img table} {

   set data {}
   set h [image height $img]
   set w [image width $img]
   for {set y 0} {$y < $h} {incr y} {

set row {} for {set x 0} {$x < $w} {incr x} { lappend row [lindex $table [expr {($x^$y) % [llength $table]}]] } lappend data $row

   }
   $img put $data

} proc inRange {i f t} {expr {$f + ($t-$f)*$i/255}} proc mkTable {rf rt gf gt bf bt} {

   for {set i 0} {$i < 256} {incr i} {

lappend tbl [format "#%02x%02x%02x" \ [inRange $i $rf $rt] [inRange $i $gf $gt] [inRange $i $bf $bt]]

   }
   return $tbl

}

set img [image create photo -width 512 -height 512] xorImage $img [mkTable 0 255 64 192 255 0] pack [label .l -image $img]</lang>

TI-83 BASIC

Due to the TI-83's 1 bit black and white display, this program uses the home screen and a gradient of characters. Since the TI-83 does not use a standard encoding, the first Sto→ to Str1 may be subjectively interpreted.

<lang ti-83b>PROGRAM:XORPATT " •.-,+-°-1+o*:πOX"→Str1

ClrHome

{0,0,0,0}→L1 {0,0,0,0)→L2

For(I,1,8,1) For(J,1,16,1) J→A I→B

If A>8 Then A-8→A 1→L1(1) Else 0→L1(1) End

If A>4 Then A-4→A 1→L1(2) Else 0→L1(2) End

If A>2 Then A-2→A 1→L1(3) Else 0→L1(3) End

If A>1 Then 1→L1(4) Else 0→L1(4) End

0→L2(1)

If B>4 Then B-4→B 1→L2(2) Else 0→L2(2) End

If B>2 Then B-2→B 1→L2(3) Else 0→L2(3) End

If B>1 Then 1→L2(4) Else 0→L2(4) End

L1≠L2→L3 8L3(1)+4L3(2)+2L3(3)+L3(4)→C Output(I,J,sub(Str1,C+1,1))

End End Pause </lang>

Visual Basic .NET

Works with: Visual Basic .NET version 2011

<lang vbnet>' Munching squares - 27/07/2018 Public Class MunchingSquares

   Const xsize = 256
   Dim BMP As New Drawing.Bitmap(xsize, xsize)
   Dim GFX As Graphics = Graphics.FromImage(BMP)

   Private Sub MunchingSquares_Paint(sender As Object, e As PaintEventArgs) Handles Me.Paint
       'draw
       Dim MyGraph As Graphics = Me.CreateGraphics
       Dim nColor As Color
       Dim i, j, cp As Integer
       xPictureBox.Image = BMP
       For i = 0 To xsize - 1
           For j = 0 To xsize - 1
               cp = i Xor j
               nColor = Color.FromArgb(cp, 0, cp)
               BMP.SetPixel(i, j, nColor)
           Next j
       Next i
   End Sub 'Paint

End Class </lang>

Output:

Munching squares - vbnet

Wren

Translation of: D

Library: DOME

<lang ecmascript>import "graphics" for Canvas, Color import "dome" for Window

class Game {

   static init() {
       Window.title = "Munching squares"
       var w = 512
       var h = 512
       Window.resize(w, h)
       Canvas.resize(w, h)
       for (x in 0...w) {
           for (y in 0...h) {
               var c = (x ^ y) & 255
               Canvas.pset(x, y, Color.rgb(255-c, (c/2).floor, c))
           }
       }
   }

   static update() {}

   static draw(alpha) {}

}</lang>

XPL0

<lang XPL0>include c:\cxpl\codes; \intrinsic 'code' declarations int X, Y; [SetVid($101); \set 640x480 graphics with 8-bit color port($3C8):= 0; \set color registers with beautiful shades for X:= 0 to 256-1 do

       [port($3C9):= X>>1;     \red
        port($3C9):= X>>3;     \green
        port($3C9):= X;        \blue
        ];

for Y:= 0 to 256-1 do \"color table" is array of 256 registers

   for X:= 0 to 256-1 do
       Point(X, Y, X|Y);       \"|" = XOR, not OR which is "!"

X:= ChIn(1); \wait for keystroke SetVid(3); \restore normal text mode ]</lang>

Output:

Yabasic

Translation of: FreeBASIC

<lang Yabasic>w = 256

open window w, w

For x = 0 To w-1

   For y = 0 To w-1
       r =and(xor(x, y), 255)
       color r, and(r*2, 255), and(r*3, 255)
       dot x, y
   Next

Next</lang>

zkl

Uses the PPM class from http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#zkl

Translation of: XPL0

For a kaleidoscopic image, play with coolness. <lang zkl>fcn muncher{

  bitmap:=PPM(256,256);
  coolness:=(1).random(0x10000);  // 55379, 18180, 40, 51950, 57619, 43514, 65465
  foreach y,x in ([0 .. 255],[0 .. 255]){
     b:=x.bitXor(y);	// shades of blue

// rgb:=b*coolness; // kaleidoscopic image // rgb:=(b*coolness + b)*coolness + b; // more coolness

     rgb:=(b*0x10000 + b)*0x10000 + b;  // copy ADA image
     bitmap[x,y]=rgb;
  }
  bitmap.write(File("foo.ppm","wb"));

}();</lang> For a cheap slide show (on Linux): <lang zkl>while(1){ muncher(); Atomic.sleep(3); }</lang> run ImageViewer on foo.ppm and watch it [auto] update as the image changes.

Output:

Same as the ADA image: