aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Data commit

Browse source
This commit is contained in:
Ingy döt Net 2023-07-01 11:58:00 -04:00
parent 7387c8f97b
commit cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

5
Task/Munching-squares/00-META.yaml Normal file
View file

@ -0,0 +1,5 @@
---
category:
- Graphics algorithms
from: http://rosettacode.org/wiki/Munching_squares
note: Raster graphics operations

2
Task/Munching-squares/00-TASK.txt Normal file
View file

@ -0,0 +1,2 @@
Render a graphical pattern where each pixel is colored by the value of 'x xor y' from an arbitrary [[wp:color table|color table]].

102
Task/Munching-squares/ATS/munching-squares.ats Normal file
View file

@ -0,0 +1,102 @@
#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

17
Task/Munching-squares/AWK/munching-squares.awk Normal file
View file

@ -0,0 +1,17 @@
BEGIN {
# square size
s = 256
# the PPM image header needs 3 lines:
# P3
# width height
# max colors number (per channel)
print("P3\n", s, s, "\n", s - 1)
# and now we generate pixels as a RGB pair in a relaxed
# form "R G B\n"
for (x = 0; x < s; x++) {
for (y = 0; y < s; y++) {
p = xor(x, y)
print(0, p, p)
}
}
}

31
Task/Munching-squares/Action-/munching-squares.action Normal file
View file

@ -0,0 +1,31 @@
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

21
Task/Munching-squares/Ada/munching-squares.ada Normal file
View file

@ -0,0 +1,21 @@
with Cairo; use Cairo;
with Cairo.Png; use Cairo.Png;
with Cairo.Image_Surface; use Cairo.Image_Surface;
procedure XorPattern is
type xorable is mod 256;
Surface : Cairo_Surface;
Data : RGB24_Array_Access;
Status : Cairo_Status;
Num : Byte;
begin
Data := new RGB24_Array(0..256*256-1);
for x in Natural range 0..255 loop
for y in Natural range 0..255 loop
Num := Byte(xorable(x) xor xorable(y));
Data(x+256*y) := RGB24_Data'(Num,0,Num);
end loop;
end loop;
Surface := Create_For_Data_RGB24(Data, 256, 256);
Status := Write_To_Png (Surface, "AdaXorPattern.png");
pragma Assert (Status = Cairo_Status_Success);
end XorPattern;

25
Task/Munching-squares/Applesoft-BASIC/munching-squares.basic Normal file
View file

@ -0,0 +1,25 @@
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

20
Task/Munching-squares/BBC-BASIC/munching-squares.basic Normal file
View file

@ -0,0 +1,20 @@
size% = 256
VDU 23,22,size%;size%;8,8,16,0
OFF
DIM coltab%(size%-1)
FOR I% = 0 TO size%-1
coltab%(I%) = ((I% AND &FF) * &010101) EOR &FF0000
NEXT
GCOL 1
FOR I% = 0 TO size%-1
FOR J% = 0 TO size%-1
C% = coltab%(I% EOR J%)
COLOUR 1, C%, C%>>8, C%>>16
PLOT I%*2, J%*2
NEXT
NEXT I%
REPEAT WAIT 1 : UNTIL FALSE

3
Task/Munching-squares/Befunge/munching-squares.bf Normal file
View file

@ -0,0 +1,3 @@
55+::"3P",,,28*:*::..\,:.\,:v
>2%*28*:**-2/\1-:v<:8:-1<_@ v
^\-1*2%2/*:*82::\_$0.0..:^:*<

27
Task/Munching-squares/Burlesque/munching-squares.blq Normal file
View file

@ -0,0 +1,27 @@
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

161
Task/Munching-squares/C++/munching-squares.cpp Normal file
View file

@ -0,0 +1,161 @@
#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" );
}
//--------------------------------------------------------------------------------------------------

24
Task/Munching-squares/C-sharp/munching-squares.cs Normal file
View file

@ -0,0 +1,24 @@
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);
}
}
}

44
Task/Munching-squares/C/munching-squares.c Normal file
View file

@ -0,0 +1,44 @@
#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;
}

10
Task/Munching-squares/Clojure/munching-squares.clj Normal file
View file

@ -0,0 +1,10 @@
(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)))))

12
Task/Munching-squares/Commodore-BASIC/munching-squares.basic Normal file
View file

@ -0,0 +1,12 @@
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$

15
Task/Munching-squares/Craft-Basic/munching-squares.basic Normal file
View file

@ -0,0 +1,15 @@
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

14
Task/Munching-squares/D/munching-squares.d Normal file
View file

@ -0,0 +1,14 @@
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);
}
}

12
Task/Munching-squares/Delphi/munching-squares.delphi Normal file
View file

@ -0,0 +1,12 @@
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;

10
Task/Munching-squares/EasyLang/munching-squares.easy Normal file
View file

@ -0,0 +1,10 @@
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
.
.

16
Task/Munching-squares/EchoLisp/munching-squares.l Normal file
View file

@ -0,0 +1,16 @@
(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

21
Task/Munching-squares/Factor/munching-squares.factor Normal file
View file

@ -0,0 +1,21 @@
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

21
Task/Munching-squares/FreeBASIC/munching-squares.basic Normal file
View file

@ -0,0 +1,21 @@
' 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

43
Task/Munching-squares/GLSL/munching-squares.glsl Normal file
View file

@ -0,0 +1,43 @@
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);
}

4
Task/Munching-squares/Gnuplot/munching-squares.gnuplot Normal file
View file

@ -0,0 +1,4 @@
set pm3d map
set size square
set isosamples 255,255
splot [0:255][0:255]-(floor(x)^floor(y))

17
Task/Munching-squares/Go/munching-squares.go Normal file
View file

@ -0,0 +1,17 @@
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()
}

13
Task/Munching-squares/Haskell/munching-squares.hs Normal file
View file

@ -0,0 +1,13 @@
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] ]))

18
Task/Munching-squares/Icon/munching-squares.icon Normal file
View file

@ -0,0 +1,18 @@
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

2
Task/Munching-squares/J/munching-squares.j Normal file
View file

@ -0,0 +1,2 @@
require 'viewmat'
viewmat ~:"1/&.#: ~ i.256

31
Task/Munching-squares/Java/munching-squares.java Normal file
View file

@ -0,0 +1,31 @@
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();
}
}

1
Task/Munching-squares/Jq/munching-squares-1.jq Normal file
View file

@ -0,0 +1 @@
jq -n -r -f Munching_squares.jq > Munching_squares.svg

23
Task/Munching-squares/Jq/munching-squares-2.jq Normal file
View file

@ -0,0 +1,23 @@
# 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;

11
Task/Munching-squares/Jq/munching-squares-3.jq Normal file
View file

@ -0,0 +1,11 @@
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)' />";

17
Task/Munching-squares/Jq/munching-squares-4.jq Normal file
View file

@ -0,0 +1,17 @@
# 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>" ;

5
Task/Munching-squares/Jq/munching-squares-5.jq Normal file
View file

@ -0,0 +1,5 @@
def black: { "red": 0, "green": 0, "blue": 0};
def red: black + { "red": 255 };
def yellow: red + { "green": 255 };
xor_pattern(384; 384; red; yellow)

19
Task/Munching-squares/Julia/munching-squares.julia Normal file
View file

@ -0,0 +1,19 @@
using Gtk, Cairo
const can = @GtkCanvas()
const win = GtkWindow(can, "Munching Squares", 512, 512)
@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)
circle(ctx, 2x, 2y, 2)
fill(ctx)
end
end
show(can)
const cond = Condition()
endit(w) = notify(cond)
signal_connect(endit, win, :destroy)
wait(cond)

47
Task/Munching-squares/Kotlin/munching-squares.kotlin Normal file
View file

@ -0,0 +1,47 @@
// 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
}
}
}

31
Task/Munching-squares/Liberty-BASIC/munching-squares.basic Normal file
View file

@ -0,0 +1,31 @@
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

34
Task/Munching-squares/Lua/munching-squares.lua Normal file
View file

@ -0,0 +1,34 @@
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

8
Task/Munching-squares/MATLAB/munching-squares.m Normal file
View file

@ -0,0 +1,8 @@
size = 256;
[x,y] = meshgrid([0:size-1]);
c = bitxor(x,y);
colormap bone(size);
image(c);
axis equal;

4
Task/Munching-squares/Mathematica/munching-squares-1.math Normal file
View file

@ -0,0 +1,4 @@
ListDensityPlot[
Table[Table[
FromDigits[BitXor[IntegerDigits[x, 2, 8], IntegerDigits[y, 2, 8]],
2], {x, 0, 255}], {y, 0, 255}]]

1
Task/Munching-squares/Mathematica/munching-squares-2.math Normal file
View file

@ -0,0 +1 @@
ArrayPlot[Array[BitXor, {511, 511}]]

44
Task/Munching-squares/Microsoft-Small-Basic/munching-squares.basic Normal file
View file

@ -0,0 +1,44 @@
' 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

5
Task/Munching-squares/MiniScript/munching-squares.mini Normal file
View file

@ -0,0 +1,5 @@
for x in range(0,255)
for y in range(0,255)
gfx.setPixel x, y, color.rgb(0, bitXor(x,y), 0)
end for
end for

18
Task/Munching-squares/Nim/munching-squares.nim Normal file
View file

@ -0,0 +1,18 @@
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")

13
Task/Munching-squares/OCaml/munching-squares.ocaml Normal file
View file

@ -0,0 +1,13 @@
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())

8
Task/Munching-squares/Octave/munching-squares.octave Normal file
View file

@ -0,0 +1,8 @@
size = 256;
[x,y] = meshgrid([0:size-1]);
c = bitxor(x,y);
colormap(jet(size));
image(c);
axis equal;

24
Task/Munching-squares/PHP/munching-squares.php Normal file
View file

@ -0,0 +1,24 @@
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);

14
Task/Munching-squares/PL-I/munching-squares.pli Normal file
View file

@ -0,0 +1,14 @@
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;

12
Task/Munching-squares/Perl/munching-squares.pl Normal file
View file

@ -0,0 +1,12 @@
use GD;
my $img = GD::Image->new(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

46
Task/Munching-squares/Phix/munching-squares.phix Normal file
View file

@ -0,0 +1,46 @@
(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>
<!--

13
Task/Munching-squares/Processing/munching-squares.processing Normal file
View file

@ -0,0 +1,13 @@
//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();

18
Task/Munching-squares/Prolog/munching-squares.pro Normal file
View file

@ -0,0 +1,18 @@
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).

26
Task/Munching-squares/PureBasic/munching-squares.basic Normal file
View file

@ -0,0 +1,26 @@
#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

11
Task/Munching-squares/Python/munching-squares.py Normal file
View file

@ -0,0 +1,11 @@
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")

11
Task/Munching-squares/QBasic/munching-squares.basic Normal file
View file

@ -0,0 +1,11 @@
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

18
Task/Munching-squares/REXX/munching-squares.rexx Normal file
View file

@ -0,0 +1,18 @@
/*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. */

9
Task/Munching-squares/Racket/munching-squares.rkt Normal file
View file

@ -0,0 +1,9 @@
#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

17
Task/Munching-squares/Raku/munching-squares-1.raku Normal file
View file

@ -0,0 +1,17 @@
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();

19
Task/Munching-squares/Raku/munching-squares-2.raku Normal file
View file

@ -0,0 +1,19 @@
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;

25
Task/Munching-squares/RapidQ/munching-squares.rapidq Normal file
View file

@ -0,0 +1,25 @@
'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

54
Task/Munching-squares/Ring/munching-squares.ring Normal file
View file

@ -0,0 +1,54 @@
# 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

25
Task/Munching-squares/Ruby/munching-squares.rb Normal file
View file

@ -0,0 +1,25 @@
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')

11
Task/Munching-squares/Run-BASIC/munching-squares.basic Normal file
View file

@ -0,0 +1,11 @@
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"

16
Task/Munching-squares/Rust/munching-squares.rust Normal file
View file

@ -0,0 +1,16 @@
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");
}

25
Task/Munching-squares/Scala/munching-squares.scala Normal file
View file

@ -0,0 +1,25 @@
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()
}
}

10
Task/Munching-squares/Sidef/munching-squares.sidef Normal file
View file

@ -0,0 +1,10 @@
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')

76
Task/Munching-squares/TI-83-BASIC/munching-squares.basic Normal file
View file

@ -0,0 +1,76 @@
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

27
Task/Munching-squares/Tcl/munching-squares.tcl Normal file
View file

@ -0,0 +1,27 @@
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]

22
Task/Munching-squares/Visual-Basic-.NET/munching-squares.vb Normal file
View file

@ -0,0 +1,22 @@
' 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

22
Task/Munching-squares/Wren/munching-squares.wren Normal file
View file

@ -0,0 +1,22 @@
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) {}
}

15
Task/Munching-squares/XPL0/munching-squares.xpl0 Normal file
View file

@ -0,0 +1,15 @@
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
]

11
Task/Munching-squares/Yabasic/munching-squares.basic Normal file
View file

@ -0,0 +1,11 @@
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

12
Task/Munching-squares/Zkl/munching-squares-1.zkl Normal file
View file

@ -0,0 +1,12 @@
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"));
}();

1
Task/Munching-squares/Zkl/munching-squares-2.zkl Normal file
View file

@ -0,0 +1 @@
while(1){ muncher(); Atomic.sleep(3); }