Munching squares: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
m (Updated description and link for Fōrmulæ solution) |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
(32 intermediate revisions by 21 users not shown) | |||
Line 4:
{{omit from|Lilypond}}
Render a graphical pattern where each pixel is colored by the value of 'x xor y' from an arbitrary [[wp:color table|color table]].
=={{header|Action!}}==
<syntaxhighlight 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</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Munching_squares.png Screenshot from Atari 8-bit computer]
=={{header|Ada}}==
{{libheader|GtkAda}}
Uses the Cairo component of GtkAda to create and save as png
<
with Cairo.Png; use Cairo.Png;
with Cairo.Image_Surface; use Cairo.Image_Surface;
Line 28 ⟶ 63:
Status := Write_To_Png (Surface, "AdaXorPattern.png");
pragma Assert (Status = Cairo_Status_Success);
end XorPattern;</
{{out}} [[Image:AdaXorPattern.png|Ada Output|200px]]
=={{header|ATS}}==
<syntaxhighlight lang="ats">
#include "share/atspre_staload.hats"
(* uint2uchar0 seems to have a definition in the prelude, but no
implementation. Such incompletenesses are common, but usually
easily overcome. Here I simply redefine uint2uchar0 locally,
letting C do the casting. *)
extern castfn uint2uchar0 : uint -<> uchar
(* write_pam writes a Portable Arbitrary Map to standard output. It
XORs the positions of colors in a palette of size equal to a power
of two, containing RGB colors in the usual hex format. The palette
is otherwise arbitrary. *)
fn
write_pam {expnt : nat}
{numcolors : nat}
(* The palette size must be proven to be a power of two. *)
(pf : EXP2 (expnt, numcolors) |
palette : &array (uint, numcolors),
numcolors : uint numcolors) : void =
let
fun
loop {x, y : nat | x <= numcolors; y <= numcolors}
.<numcolors - y, numcolors - x>.
(palette : &array (uint, numcolors),
x : uint x,
y : uint y) : void =
if y = numcolors then
()
else if x = numcolors then
loop (palette, 0u, succ y)
else
let
val i = g1ofg0 (x lxor y)
(* Prove that the index is non-negative. *)
prval () = lemma_g1uint_param i
(* Test that the index is not out of bounds high. This could
be proven without a runtime check, but doing that is left
as an exercise for an advanced reader. For one thing, you
will need a more complicated version of lxor. Then you
will need to prove, or provide as an axiom, that the XOR
of two numbers of the same number of significant bits is
itself restricted to that number of bits. *)
val () = assertloc (i < numcolors)
val color = palette[i]
val r = uint2uchar0 (color >> 16)
and g = uint2uchar0 ((color >> 8) land 0xFFu)
and b = uint2uchar0 (color land 0xFFu)
in
print! (r, g, b);
loop (palette, succ x, y)
end
in
println! ("P7");
println! ("WIDTH ", numcolors);
println! ("HEIGHT ", numcolors);
println! ("DEPTH 3");
println! ("MAXVAL 255");
println! ("TUPLTYPE RGB");
println! ("ENDHDR");
loop (palette, 0u, 0u)
end
prfn (* Produces a proof that 2**7 = 128. *)
exp2_of_7_is_128 () :<prf> EXP2 (7, 128) =
EXP2ind (EXP2ind (EXP2ind (EXP2ind
(EXP2ind (EXP2ind (EXP2ind (EXP2bas ())))))))
implement
main0 () =
let
(* 128 RGB colors borrowed from
https://github.com/yeun/open-color *)
var palette : array (uint, 128) =
@[uint][128]
(0xe9ecefu, 0xdee2e6u, 0xced4dau, 0xadb5bdu, 0x868e96u, 0x495057u,
0x343a40u, 0x212529u, 0xfff5f5u, 0xffe3e3u, 0xffc9c9u, 0xffa8a8u,
0xff8787u, 0xff6b6bu, 0xfa5252u, 0xf03e3eu, 0xe03131u, 0xc92a2au,
0xfff0f6u, 0xffdeebu, 0xfcc2d7u, 0xfaa2c1u, 0xf783acu, 0xf06595u,
0xe64980u, 0xd6336cu, 0xc2255cu, 0xa61e4du, 0xf8f0fcu, 0xf3d9fau,
0xeebefau, 0xe599f7u, 0xda77f2u, 0xcc5de8u, 0xbe4bdbu, 0xae3ec9u,
0x9c36b5u, 0x862e9cu, 0xf3f0ffu, 0xe5dbffu, 0xd0bfffu, 0xb197fcu,
0x9775fau, 0x845ef7u, 0x7950f2u, 0x7048e8u, 0x6741d9u, 0x5f3dc4u,
0xedf2ffu, 0xdbe4ffu, 0xbac8ffu, 0x91a7ffu, 0x748ffcu, 0x5c7cfau,
0x4c6ef5u, 0x4263ebu, 0x3b5bdbu, 0x364fc7u, 0xe7f5ffu, 0xd0ebffu,
0xa5d8ffu, 0x74c0fcu, 0x4dabf7u, 0x339af0u, 0x228be6u, 0x1c7ed6u,
0x1971c2u, 0x1864abu, 0xe3fafcu, 0xc5f6fau, 0x99e9f2u, 0x66d9e8u,
0x3bc9dbu, 0x22b8cfu, 0x15aabfu, 0x1098adu, 0x0c8599u, 0x0b7285u,
0xe6fcf5u, 0xc3fae8u, 0x96f2d7u, 0x63e6beu, 0x38d9a9u, 0x20c997u,
0x12b886u, 0x0ca678u, 0x099268u, 0x087f5bu, 0xebfbeeu, 0xd3f9d8u,
0xb2f2bbu, 0x8ce99au, 0x69db7cu, 0x51cf66u, 0x40c057u, 0x37b24du,
0x2f9e44u, 0x2b8a3eu, 0xf4fce3u, 0xe9fac8u, 0xd8f5a2u, 0xc0eb75u,
0xa9e34bu, 0x94d82du, 0x82c91eu, 0x74b816u, 0x66a80fu, 0x5c940du,
0xfff9dbu, 0xfff3bfu, 0xffec99u, 0xffe066u, 0xffd43bu, 0xfcc419u,
0xfab005u, 0xf59f00u, 0xf08c00u, 0xe67700u, 0xfff4e6u, 0xffe8ccu,
0xffd8a8u, 0xffc078u, 0xffa94du, 0xff922bu, 0xfd7e14u, 0xf76707u,
0xe8590cu, 0xd9480fu)
in
write_pam (exp2_of_7_is_128 () | palette, 128u)
end
</syntaxhighlight>
Here I use Netpbm to make a PNG, but you could use, for instance, ImageMagick instead. (Then I generally run my PNGs through optipng before posting them.)
<pre>patscc -std=gnu2x -g -O2 munching_squares.dats && ./a.out | pamtopng > image.png</pre>
{{out}}
[[File:Munching squares ATS.png|alt=A geometric mosaic in 128 arbitrarily chosen colors.]]
=={{header|AWK}}==
{{works with|gawk}}
This program generates a PPM image, that you can view/convert using The GIMP or ImageMagick
<
BEGIN {
# square size
Line 52 ⟶ 199:
}
}
</syntaxhighlight>
=={{header|
==={{header|Applesoft BASIC}}===
<syntaxhighlight lang="gwbasic"> 100 DATA 0,2, 6,10,5, 6, 7,15
110 DATA 0,1, 3,10,5, 3,11,15
120 DATA 0,8, 9,10,5, 9,13,15
130 DATA 0,4,12,10,5,12,14,15
140 LET C = 7
150 POKE 768,169: REM LDA #
160 POKE 770,073: REM EOR #
170 POKE 772,133: REM STA
180 POKE 773,235: REM $EB
190 POKE 774,096: REM RTS
200 GR
210 FOR H = 0 TO 1
220 FOR W = 0 TO 1
230 FOR S = 0 TO C
240 READ C(S)
250 NEXT S
260 FOR Y = 0 TO C
270 POKE 769,Y
280 LET Y1 = H * S * 2 + Y * 2
290 FOR X = 0 TO C
300 POKE 771,X
310 CALL 768
320 COLOR= C( PEEK (235))
330 VLIN Y1,Y1 + 1 AT W * S + X
340 NEXT X,Y,W,H</syntaxhighlight>
==={{header|BBC BASIC}}===
{{works with|BBC BASIC for Windows}}
<
VDU 23,22,size%;size%;8,8,16,0
Line 76 ⟶ 252:
REPEAT WAIT 1 : UNTIL FALSE
</syntaxhighlight>
==={{header|
{{works with|Commodore BASIC|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"):
<syntaxhighlight 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$</syntaxhighlight>
{{Out}}
[https://imgur.com/a/pjl2Pd4 Screenshot.]
==={{header|Craft Basic}}===
<syntaxhighlight lang="basic">let s = 255
for y = 0 to s
for x = 0 to s
let r = x ~ y
fgcolor r, r * 2, r * 3
dot x, y
wait
next x
next y</syntaxhighlight>
==={{header|FreeBASIC}}===
<syntaxhighlight 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
Next
' empty keyboard buffer
While Inkey <> "" : Wend
WindowTitle "Close window or hit any key to end program"
Sleep
End</syntaxhighlight>
==={{header|Liberty BASIC}}===
<syntaxhighlight lang="lb">
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
</syntaxhighlight>
Image available at [[http://www.diga.me.uk/xorRC.gif]]
==={{header|Microsoft Small Basic}}===
<syntaxhighlight 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 </syntaxhighlight>
{{out}}
[https://github.com/Pat-Garrett/RC/blob/master/Munching%20squares%20-%20vbnet.jpg Munching squares - SmallBasic]
==={{header|PureBasic}}===
<syntaxhighlight 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</syntaxhighlight>
[[File:PureBasic_XOR_Pattern.png|Sample display of PureBasic solution|200px]]
==={{header|QBasic}}===
<syntaxhighlight 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</syntaxhighlight>
==={{header|RapidQ}}===
{{trans|FreeBASIC}}
<syntaxhighlight lang="rapidq">
'Munching squares
DECLARE SUB PaintCanvas
CREATE Form AS QForm
ClientWidth = 256
ClientHeight = 256
CREATE Canvas AS QCanvas
Height = Form.ClientHeight
Width = Form.ClientWidth
OnPaint = PaintCanvas
END CREATE
END CREATE
SUB PaintCanvas
FOR X = 0 TO Canvas.Width - 1
FOR Y = 0 TO Canvas.Width - 1
R = (X XOR Y) AND 255
Canvas.Pset(X, Y, RGB(R, R, R)) ' gray scale
'Canvas.Pset(X, Y, RGB(R, 255 - R, 0)) ' red + green
'Canvas.Pset(X, Y, RGB(R, 0, 0)) ' red
NEXT Y
NEXT X
END SUB
Form.ShowModal
</syntaxhighlight>
==={{header|Run BASIC}}===
<syntaxhighlight 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"</syntaxhighlight>
==={{header|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.
<syntaxhighlight 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
</syntaxhighlight>
==={{header|Visual Basic .NET}}===
{{works with|Visual Basic .NET|2011}}
<syntaxhighlight 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 </syntaxhighlight>
{{out}}
[https://github.com/Pat-Garrett/RC/blob/7e9842513d361a5b4241bc6bb28f9985c2bfe161/Munching%20squares%20-%20vbnet.jpg Munching squares - vbnet]
==={{header|Yabasic}}===
{{trans|FreeBASIC}}
<syntaxhighlight 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</syntaxhighlight>
=={{header|Befunge}}==
Writes the image to stdout using the PPM format.
<syntaxhighlight lang="befunge">55+::"3P",,,28*:*::..\,:.\,:v
>2%*28*:**-2/\1-:v<:8:-1<_@ v
^\-1*2%2/*:*82::\_$0.0..:^:*<</
=={{header|BQN}}==
Outputs a string that represents a PPM image.
BQN uses the <code>•bit</code> namespace for native bitwise operations, including casting. An input bit width and output bit width have to be given.
<syntaxhighlight lang="bqn">nl←@+10
XORppm ← {
g←⥊(0∾∾˜)¨((↕𝕩)16‿16•bit._xor⊢)˘↕𝕩
s←•Repr 𝕩
h←"P3"∾nl∾s∾" "∾s∾nl∾(•Repr 𝕩-1)∾nl
h∾∾∾⟜nl¨{¯1↓∾∾⟜' '¨•Repr¨𝕩}¨g
}</syntaxhighlight>
Example usage:
<syntaxhighlight lang="bqn">"xor.ppm" •FChars XORppm 256</syntaxhighlight>
=={{header|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
Line 116 ⟶ 653:
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
</syntaxhighlight>
Must be converted to an image with a seperate program.
=={{header|C}}==
<
#include <stdio.h>
#include <math.h>
Line 164 ⟶ 701:
return 0;
}</
{{out}} [[Image:Xor_pattern_c.png|C output|200px]]
=={{header|C sharp}}==
<
using System.Drawing.Imaging;
using System.Linq;
Line 191 ⟶ 728:
}
}
}</
{{out}}
[[File:XORPatternCSharp.png|XORPatternCSharp.png]]
Line 197 ⟶ 734:
=={{header|C++}}==
[[File:msquares_cpp2.png|300px]]
<
#include <windows.h>
#include <string>
Line 359 ⟶ 896:
}
//--------------------------------------------------------------------------------------------------
</syntaxhighlight>
=={{header|Clojure}}==
The fun part of munching squares isn't color tables, it's watching them munch:
<syntaxhighlight lang="clojure">(let [n 16]
(loop [i 0]
(print "\033[0;0f\033[2J")
(doseq [y (range n)]
(doseq [x (range n)]
(print (if (< (bit-xor x y) i) "█" " ")))
(print "\n"))
(flush)
(Thread/sleep 150)
(recur (mod (inc i) (inc n)))))
</syntaxhighlight>
=={{header|Evaldraw}}==
Since all variables in Evaldraw are doubles, convert to binary and do a custom per bit xor operation.
[[File:Evaldraw xor squares.gif|thumb|alt=xor pattern where color is the result of xor(x,y) over values x from 0 to 128 and y to 128|Coloring the xor munching squares pattern over time]]
<syntaxhighlight lang="c">enum{NUMBITS=7, MAXNUMS=3}
static binary[MAXNUMS][NUMBITS];
() {
cls(0);
t = 100*klock();
for(y = 0; y < 128; y++) {
decToBin(y,1);
for(x = 0; x < 128; x++) {
decToBin(x,0);
xor(0,1,2);
c = binToDec(2);
setcol(hsv_to_rgb( (t+c*1)%360,.8,1) );
setpix(x,y);
}
}
}
binToDec(id) {
num = 0;
for(i=0; i<NUMBITS; i++) {
if( binary[id][i] == 1) {
num += 2^(NUMBITS-i-1);
}
}
return num;
}
decToBin(num,id) {
for(i=0; i<NUMBITS; i++) binary[id][i] = 0;
bitpos = NUMBITS-1;
while( num > 0 && bitpos >= 0) {
binary[id][bitpos] = num % 2 == 1;
bitpos--; // ready for next bit
num = int(num/2);
}
}
xor(num1,num2,store) {
for(i=0; i<NUMBITS; i++)
if(binary[num1][i] == binary[num2][i]) binary[store][i] = 0; else binary[store][i] = 1;
}</syntaxhighlight>
=={{header|D}}==
<
import std.stdio;
Line 375 ⟶ 975:
f.rawWrite(u3);
}
}</
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|Windows,Types,ExtCtrls,Graphics}}
<syntaxhighlight lang="Delphi">
procedure MunchingSquares(Image: TImage);
{XOR's X and Y to select an RGB level}
var W,H,X,Y: integer;
begin
W:=Image.Width;
H:=Image.Height;
for Y:=0 to Image.Height-1 do
for X:=0 to Image.Width-1 do
begin
Image.Canvas.Pixels[X,Y]:=RGB(0,X xor Y,0);
end;
end;
</syntaxhighlight>
{{out}}
[[File:DelphiMunchingSquares.png|thumb|none]]
<pre>
</pre>
=={{header|EasyLang}}==
[https://easylang.dev/show/#cod=VYxLCoAwDET3PcWsFWqL4s7DaK0f0BZSEb29iRTBZDHJG2aSQwdrDCq0jZoi4QL1YfZGfgCC7j/iWTg1rEcfRpHrjd1o62xL6SKVH4hbpJo5b0Z7PD2nCiTHUZFskHeHwBJG2+8QUyutHg== Run it]
<syntaxhighlight lang="easylang">
sc = 100 / 64
for x range0 64
for y range0 64
h = bitand bitxor x y 63
c = h / 63
color3 c c c
move x * sc y * sc
rect sc + 0.1 sc + 0.1
.
.
</syntaxhighlight>
=={{header|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 .
<
(lib 'types)
(lib 'plot)
Line 396 ⟶ 1,039:
(plot-much) ;; ESC to see tge drawing
</syntaxhighlight>
=={{header|Factor}}==
<
IN: rosetta-code.munching-squares
Line 419 ⟶ 1,062:
: main ( -- ) <munching-img> "munching.png" save-graphic-image ;
MAIN: main</
Output image is identical to the Racket version.
{{out}}
[[File:munching-racket.png]]
=={{header|
{{FormulaeEntry|page=https://formulae.org/?script=examples/Munching_squares}}
'''Solution'''
[[File:Fōrmulæ - Munching squares 01.png]]
'''Test case'''
[[File:Fōrmulæ - Munching squares 02.png]]
[[File:Fōrmulæ - Munching squares 03.png]]
=={{header|GLSL}}==
This is an example that will work directly on shadertoy.com, Example [https://www.shadertoy.com/view/Mss3Rs]
<
float c,p;
vec2 b;
Line 499 ⟶ 1,125:
gl_FragColor = vec4(color,1.0);
}</
=={{header|Gnuplot}}==
<
set size square
set isosamples 255,255
splot [0:255][0:255]-(floor(x)^floor(y))</
{{out}} [[Image:gnuplot_xor.png|Gnuplot output|200px]]
=={{header|Go}}==
<
import (
Line 526 ⟶ 1,152:
png.Encode(f, g)
f.Close()
}</
=={{header|Haskell}}==
<
import Data.Bits (xor)
Line 541 ⟶ 1,167:
[ x `xor` y
| x <- [0 .. 255]
, y <- [0 .. 255] ]))</
=={{header|Icon}} and {{header|Unicon}}==
[[File:XORimage-unicon-GR512.png|thumb|right|512x512 bit green and red]]
<
procedure main(A) #: XOR graphic
Line 562 ⟶ 1,188:
until Event() == &lpress # wait for left button to quit
close(&window)
end</
{{libheader|Icon Programming Library}}
Line 568 ⟶ 1,194:
=={{header|J}}==
<
viewmat ~:"1/&.#: ~ i.256</
=={{header|Java}}==
{{libheader|Swing}}
This example will repeat the pattern if you expand the window.
<
import java.awt.Graphics;
Line 604 ⟶ 1,230:
new XorPattern();
}
}</
[[Image:Xor pattern Java.png|200px]]
Line 610 ⟶ 1,236:
{{works with|jq|1.4}}
The following is an adaptation of the Ruby entry, but generates an SVG image file:
<
'''Part 1: Infrastructure'''
<
def integer_to_lsb:
[recurse(if . > 0 then ./2|floor else empty end) | . % 2] ;
Line 634 ⟶ 1,260:
| reduce range(0;$length) as $i
([]; . + [ lxor($s[$i]; $t[$i]) ] )
| lsb_to_integer;</
'''Part 2: SVG'''
<
def p: (. + 0.5) | floor; # to nearest integer
"rgb(\(.red|p),\(.green|p),\(.blue|p))";
Line 646 ⟶ 1,272:
def pixel(x; y; color):
(color | if type == "string" then . else rgb2rgb end) as $c
| "<circle r='1' cx='\(x)' cy='\(y)' fill='\($c)' />";</
'''Part 3: xor pattern'''
<
def xor_pattern(width; height; rgb1; rgb2):
Line 664 ⟶ 1,290:
| range(0;height) as $y
| pixel($x; $y; $colours[ xor($x; $y) % $size] ) ) ),
"</svg>" ;</
'''Part 4: Example'''
<
def red: black + { "red": 255 };
def yellow: red + { "green": 255 };
xor_pattern(384; 384; red; yellow)</
=={{header|Julia}}==
<syntaxhighlight lang
const can = @GtkCanvas()
const win = GtkWindow(can, "Munching Squares",
@guarded draw(can) do widget
ctx = getgc(can)
for x in 0:255, y in 0:255
set_source_rgb(ctx, abs(255 - x - y) / 255, ((255 - x) ⊻ y) / 255, (x ⊻ (255 - y)) / 255)
fill(ctx)
end
end
show(can)
const cond = Condition()
Line 701 ⟶ 1,318:
signal_connect(endit, win, :destroy)
wait(cond)
</syntaxhighlight>
=={{header|Kotlin}}==
<
import javax.swing.JFrame
Line 750 ⟶ 1,367:
}
}
}</
=={{header|Lua}}==
{{works with|LÖVE|11.0 or higher}}
<syntaxhighlight lang="lua">local clr = {}
function drawMSquares()
local r, g,
local point = {x+1, y+1, r/255, g/255, b/255, 1}
table.insert (points, point)
end
love.graphics.points(points)
end
function createPalette()
end
function love.load()
wid, hei = 256, 256
drawMSquares()
love.graphics.setCanvas()
end
function love.draw()
love.graphics.draw(canvas)
end</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
Table[Table[
FromDigits[BitXor[IntegerDigits[x, 2, 8], IntegerDigits[y, 2, 8]],
2], {x, 0, 255}], {y, 0, 255}]]</
{{out|Output #1}}
[[File:xorpattern3.png|Mathematica output #1|200px]]
<
{{out|Output #2}}
[[File:xorpattern4.png|Mathematica output #2|200px]]
=={{header|MATLAB}}==
<
[x,y] = meshgrid([0:size-1]);
Line 840 ⟶ 1,426:
colormap bone(size);
image(c);
axis equal;</
{{out}} [[File:matlab_xor.png|MATLAB output|200px]]
=={{header|MiniScript}}==
This version runs in Mini Micro (for the graphics
<syntaxhighlight lang="miniscript">for x in range(0,255)
for y in range(0,255)
gfx.setPixel x, y, color.rgb(0,
end for
end for</
{{out}}
Line 917 ⟶ 1,443:
=={{header|Nim}}==
{{libheader|imageman}}
<
import imageman
Line 934 ⟶ 1,460:
image[i, j] = colors[i xor j]
image.savePNG("munching_squares.png")</
=={{header|OCaml}}==
<
let () =
Line 950 ⟶ 1,476:
done;
done;
ignore(read_key())</
Run with:
Line 959 ⟶ 1,485:
=={{header|Octave}}==
<
[x,y] = meshgrid([0:size-1]);
Line 966 ⟶ 1,492:
colormap(jet(size));
image(c);
axis equal;</
{{out}} [[File:Xor_pattern_octave.png|Octave output|320px]]
=={{header|Perl}}==
<
my $img =
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);
Line 981 ⟶ 1,507:
}
print $img->png</
{{out}} [[File:perl_xor_pattern.png|Perl output|200px]]
=={{header|Phix}}==
{{libheader|Phix/pGUI}}
{{libheader|Phix/online}}
You can run this online [http://phix.x10.mx/p2js/Munching_squares.htm here].
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #000080;font-style:italic;">--
-- demo\rosetta\Munching_squares.exw
-- =================================
--</span>
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">include</span> <span style="color: #000000;">pGUI</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #004080;">Ihandle</span> <span style="color: #000000;">dlg</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">canvas</span>
<span style="color: #004080;">cdCanvas</span> <span style="color: #000000;">cddbuffer</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">cdcanvas</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">redraw_cb</span><span style="color: #0000FF;">(</span><span style="color: #004080;">Ihandle</span> <span style="color: #000080;font-style:italic;">/*ih*/</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000080;font-style:italic;">/*posx*/</span><span style="color: #0000FF;">,</span> <span style="color: #000080;font-style:italic;">/*posy*/</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">width</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">height</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupGetIntInt</span><span style="color: #0000FF;">(</span><span style="color: #000000;">canvas</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">"DRAWSIZE"</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">cdCanvasActivate</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cddbuffer</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">y</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">to</span> <span style="color: #000000;">height</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">x</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span> <span style="color: #008080;">to</span> <span style="color: #000000;">width</span><span style="color: #0000FF;">-</span><span style="color: #000000;">1</span> <span style="color: #008080;">do</span>
<span style="color: #7060A8;">cdCanvasPixel</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cddbuffer</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">x</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">y</span><span style="color: #0000FF;">,</span> <span style="color: #7060A8;">xor_bits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">x</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y</span><span style="color: #0000FF;">))</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">cdCanvasFlush</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cddbuffer</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #004600;">IUP_DEFAULT</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">map_cb</span><span style="color: #0000FF;">(</span><span style="color: #004080;">Ihandle</span> <span style="color: #000000;">ih</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">cdcanvas</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">cdCreateCanvas</span><span style="color: #0000FF;">(</span><span style="color: #004600;">CD_IUP</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">ih</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">cddbuffer</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">cdCreateCanvas</span><span style="color: #0000FF;">(</span><span style="color: #004600;">CD_DBUFFER</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">cdcanvas</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">cdCanvasSetBackground</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cddbuffer</span><span style="color: #0000FF;">,</span> <span style="color: #004600;">CD_WHITE</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">cdCanvasSetForeground</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cddbuffer</span><span style="color: #0000FF;">,</span> <span style="color: #004600;">CD_RED</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #004600;">IUP_DEFAULT</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>
<span style="color: #7060A8;">IupOpen</span><span style="color: #0000FF;">()</span>
<span style="color: #000000;">canvas</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupCanvas</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"RASTERSIZE=250x250"</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">IupSetCallbacks</span><span style="color: #0000FF;">(</span><span style="color: #000000;">canvas</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"MAP_CB"</span><span style="color: #0000FF;">,</span> <span style="color: #7060A8;">Icallback</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"map_cb"</span><span style="color: #0000FF;">),</span>
<span style="color: #008000;">"ACTION"</span><span style="color: #0000FF;">,</span> <span style="color: #7060A8;">Icallback</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"redraw_cb"</span><span style="color: #0000FF;">)})</span>
<span style="color: #000000;">dlg</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">IupDialog</span><span style="color: #0000FF;">(</span><span style="color: #000000;">canvas</span><span style="color: #0000FF;">,</span> <span style="color: #008000;">`TITLE="Munching squares",RESIZE=NO`</span><span style="color: #0000FF;">)</span>
<span style="color: #7060A8;">IupShow</span><span style="color: #0000FF;">(</span><span style="color: #000000;">dlg</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">platform</span><span style="color: #0000FF;">()!=</span><span style="color: #004600;">JS</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">IupMainLoop</span><span style="color: #0000FF;">()</span>
<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>
<!--</syntaxhighlight>-->
=={{header|PHP}}==
<
$w = 256;
Line 1,056 ⟶ 1,585:
imagepng($im);
imagedestroy($im);</
{{out}}
[[File:xor_pattern_php.png|PHP output|200px]]
=={{header|PL/I}}==
<
declare screen (0:255, 0:255) bit(24) aligned;
Line 1,074 ⟶ 1,603:
end;
call writeppm(screen);
end munch;</
=={{header|Processing}}==
Renders grayscale image, the larger the window the more the squares will repeat along the main diagonal from top left to bottom right.
<syntaxhighlight 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();
</syntaxhighlight>
=={{header|Prolog}}==
Works with SWI-Prolog and his GUI XPCE.
<
new(D, window('XOR Pattern')),
send(D, size, size(512,512)),
Line 1,096 ⟶ 1,644:
send(D, display, Bmp, point(0,0)),
send(D, open).
</syntaxhighlight>
[[File:Prolog_xor_pattern.png|200px]]
=={{header|Python}}==
{{libheader|PIL}}
<
image = Image.new("RGB", (256, 256))
Line 1,140 ⟶ 1,659:
del drawingTool
image.save("xorpic.png", "PNG")</
[[File:PythonXORPic.png|Sample produced by the above code|200px]]
=={{header|Racket}}==
[[File:munching-racket.png|thumb|right]]
<
#lang racket
(require racket/draw)
Line 1,155 ⟶ 1,674:
(send dc set-pixel x y c))
bm
</syntaxhighlight>
=={{header|Raku}}==
Line 1,162 ⟶ 1,681:
Here's one simple way:
<syntaxhighlight lang="raku"
$ppm.print(q :to 'EOT');
Line 1,179 ⟶ 1,698:
$ppm.close();
</syntaxhighlight>
Another way:
<syntaxhighlight lang="raku"
map -> $x { floor ($x/256) ** 3 * 256 },
(flat (0...255) Z
Line 1,201 ⟶ 1,720:
$PPM.write: @colors[$_] for ^256 X+^ ^256;
$PPM.close;</
[[File:perl_6_xor_pattern.png|Raku output|200px]]
=={{header|REXX}}==
{{trans|Burlesque}}
<
/*───────────────────────────────────────── from an arbitrary constructed color table. */
rows= 2 /*the number of rows in the color table*/
Line 1,223 ⟶ 1,742:
@.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. */</
Must be converted to an image with a separate program. <br><br>
=={{header|Ring}}==
<
# Project : Munching squares
Line 1,282 ⟶ 1,801:
label1 { setpicture(p1) show() }
return
</syntaxhighlight>
Output:
Line 1,290 ⟶ 1,809:
Uses [[Raster graphics operations/Ruby]]
[[File:xorpattern_rb.png|thumb|right|Sample output from Ruby program]]
<
class Pixmap
Line 1,314 ⟶ 1,833:
img = Pixmap.xor_pattern(384, 384, RGBColour::RED, RGBColour::YELLOW)
img.save_as_png('xorpattern.png')</
=={{header|Rust}}==
<
use image::{ImageBuffer, Pixel, Rgb};
Line 1,345 ⟶ 1,851:
let _ = img.save("output.png");
}</
=={{header|Scala}}==
===Scala Swing===
{{libheader|org.scala-lang.modules scala-swing}}
<
import scala.swing.{Color, Graphics2D, MainFrame, Panel, SimpleSwingApplication}
Line 1,374 ⟶ 1,880:
centerOnScreen()
}
}</
=={{header|Sidef}}==
{{trans|Perl}}
<
var img = %O<Imager>.new(xsize => 256, ysize => 256)
Line 1,387 ⟶ 1,893:
}
img.write(file => 'xor.png')</
Output image: [https://github.com/trizen/rc/blob/master/img/munching-squares-sidef.png Munching squares]
=={{header|Tcl}}==
{{libheader|Tk}}<
proc xorImage {img table} {
Line 1,417 ⟶ 1,923:
set img [image create photo -width 512 -height 512]
xorImage $img [mkTable 0 255 64 192 255 0]
pack [label .l -image $img]</
=={{header|Wren}}==
{{trans|D}}
{{libheader|DOME}}
<
import "dome" for Window
Line 1,554 ⟶ 1,949:
static draw(alpha) {}
}</
=={{header|XPL0}}==
<
int X, Y;
[SetVid($101); \set 640x480 graphics with 8-bit color
Line 1,571 ⟶ 1,966:
X:= ChIn(1); \wait for keystroke
SetVid(3); \restore normal text mode
]</
{{out}} [[File:MunchXPL0.png]]
=={{header|zkl}}==
Line 1,592 ⟶ 1,973:
{{trans|XPL0}}
For a kaleidoscopic image, play with coolness.
<
bitmap:=PPM(256,256);
coolness:=(1).random(0x10000); // 55379, 18180, 40, 51950, 57619, 43514, 65465
Line 1,603 ⟶ 1,984:
}
bitmap.write(File("foo.ppm","wb"));
}();</
For a cheap slide show (on Linux):
<
run ImageViewer on foo.ppm and watch it [auto] update as the image changes.
{{out}}
|