# Yin and yang

Yin and yang
You are encouraged to solve this task according to the task description, using any language you may know.

One well-known symbol of the philosophy of duality known as yin and yang is the taijitu.

•   Create a function that, given a parameter representing size, generates such a symbol scaled to the requested size.
•   Generate and display the symbol for two different (small) sizes.

## 11l

Translation of: Python
F yinyang(n = 3)
V radii = [1, 3, 6].map(i -> i * @n)
V ranges = radii.map(r -> Array(-r .. r))
V squares = ranges.map(rnge -> multiloop(rnge, rnge, (x, y) -> (x, y)))
V m = Dict(squares.last, (x, y) -> ((x, y), ‘ ’))
L(x, y) circles.last
m[(x, y)] = ‘*’
L(x, y) circles.last
I x > 0
m[(x, y)] = ‘·’
L(x, y) circles[(len)-2]
m[(x, y + 3 * n)] = ‘*’
m[(x, y - 3 * n)] = ‘·’
L(x, y) circles[(len)-3]
m[(x, y + 3 * n)] = ‘·’
m[(x, y - 3 * n)] = ‘*’
R ranges.last.map(y -> reversed(@ranges.last).map(x -> @@m[(x, @y)]).join(‘’)).join("\n")

print(yinyang(2))
print(yinyang(1))
Output:
            ·
········*
···········**
·············**
········*·····***
········***····****
········*****····****
·········***····*****
···········*·····******
·················******
················*******
···············********
·············************
········***************
·······****************
······*****************
······*****·***********
·····****···*********
····****·····********
····****···********
···*****·********
··*************
··***********
·********
*
·
······*
····*··**
····***··**
·····*··***
········***
·······******
···********
···**·*****
··**···****
··**·****
·******
*


## 68000 Assembly

Works with: NEOGEO

The NEOGEO's hardware-supported sprite scaling helps a lot with this task. Each sprite has a shrink variable that is written to offset 0x8000 in video memory. A value of 0x0FFF is full-size, and the sprite gets smaller as the value decreases. (A sprite's tiles must be drawn in ROM at full size.) This code uses the following macros:

pushall: MOVEM.L D0-D7/A0-A6,-(SP)
popall:  MOVEM.L (SP)+,D0-D7/A0-A6
pushWord: MOVE.W <argument>,-(SP)
popWord:  MOVE.W (SP)+,<argument>


The code:

	pushall
MOVE.W #1,D0
;base sprite number, needed by NEOGEO hardware
;the yin-yang is 8 sprites total, it is important that
;two different sprite objects do not overlap!

MOVE.W #$F800,D4 ;x position on screen MOVE.W #$1000,D5	;y position on screen
MOVE.W #$0777,D7 ;size parameter JSR generateOAM popall pushall MOVE.W #$10,D0
;base sprite number, needed by NEOGEO hardware
MOVE.W #$F800,D4 ;x position on screen MOVE.W #$6000,D5	;y position on screen
MOVE.W #$0444,D7 ;size parameter JSR generateOAM popall forever: bra forever ;trap the program counter generateOAM: ;this is just boilerplate required to show hardware sprites to the screen, it's not really relevant to the task. ; all this does is copy the sprite data to video memory. ;INPUT: D0 = SPRITENUM. ; D4 = Y POS ; D5 = X POS ; D7 = SHRINK FACTOR (SIZE PARAMETER) ; THESE VALUES ARE PASSED IN USING THE ABOVE REGISTERS pushWord D0 ADD.W #$8000,D0		        ;VRAM OFFSET FOR SPRITE 1
MOVE.B (A0)+,D2			;SPRITE WIDTH - 8 SPRITES PER OBJECT
;    (A NEOGEO SPRITE IS ALWAYS 1 TILE WIDE BUT CAN BE OF ARBITRARY HEIGHT)

MOVE.B (A0)+,D3			;SPRITE HEIGHT - 8 TILES PER SPRITE
AND.W #$00FF,D3 ;BYTE SANITIZE SPRITE HEIGHT MOVE.W #$0200,$3C0004 ;INCREMENT THE VALUE IN$3C0000 BY $200 AFTER EACH WRITE TO ;$3C0002

MOVE.W D0,$3C0000 ;SET DESTINATION ADDRESS OF SIZE PARAMETER MOVE.W D7,$3C0002		;WRITE SIZE PARAMETER TO VRAM

;AUTO INCS TO $8201 WHICH IS WHERE Y POS MUST BE STORED. MOVE.W D4,D1 ;GET Y POS OR.W D3,D1 ;COMBINE WITH SPRITE HEIGHT,SINCE NEOGEO STORES THEM TOGETHER AS ONE UNIT. MOVE.W D1,$3C0002		;STORE IN VRAM

;AUTO INCS TO $8401 WHICH IS WHERE X POS MUST BE STORED. MOVE.W D5,D1 ;GET X POS MOVE.W D1,$3C0002		;STORE IN VRAM

CMP.B #1,D2                     ;IS THIS SPRITE EXACTLY ONE TILE WIDE?
BEQ skipChainedOAM		;A 1-WIDE SPRITE NEEDS NO CHAINED SPRITES.
;    IN THIS EXAMPLE THE YIN-YANGS ARE 8 TILES WIDE, THIS BRANCH IS NEVER TAKEN.

pushWord D2
SUBQ.B #2,D2		;WE NEED TO LOOP (SPRITE_WIDTH-2) TIMES.

loop_generateChainedOAM:
MOVE.W D0,$3C0000 ;SET VRAM DESTINATION. MOVE.W D7,$3C0002		;EACH STRIP HAS ITS OWN SHRINK VALUE.
MOVE.W #$0040,$3C0002	        ;MARK THIS SPRITE AS CHAINED. CHAINED SPRITES MOVE AND SCALE AS ONE UNIT.
MOVE.W #$0000,$3C0002	        ;DUMMY MOVE FOR PADDING.
DBRA D2,loop_generateChainedOAM
popWord D2

skipChainedOAM:
;NOW DO TILE DATA:
MOVE.W #1,$3C0004 ;SET VRAM INC TO 1. SUBQ.B #1,D2 SUBQ.B #1,D3 ;DBRA CORRECTION popWord D0 MOVE.W D0,D1 LSL.W #6,D1 ;TILE/PAL OFFSET IS SPRITENUM<<6 LEA YinYang_Tile,A0 ;LOAD ADDRESS OF SOURCE DATA LEA YinYang_Pal,A1 ;LOAD ADDRESS OF SOURCE DATA MOVE.W D3,D6 ;BACKUP D3, IT WILL GET RESTORED AT THE OUTER LOOP loop_sprite_OAM: MOVE.W D1,$3C0000		;SET VRAM ADDRESS
loop_tile_OAM:
MOVE.W (A0)+,$3C0002 ;SET TILE DATA MOVE.W (A1)+,$3C0002		;SET PAL DATA
DBRA D3,loop_tile_OAM		;NEXT TILE IN STRIP

MOVE.W D6,D3			;RESTORE D3
ADD.W #$0040,D1 ;NEXT SPRITE DBRA D2,loop_sprite_OAM ;REPEAT UNTIL ALL SPRITES FINISHED. RTS YinYang_Data: DC.B 8,8 ;SPRITE WIDTH,SPRITE HEIGHT YinYang_Tile: ;EACH NUMBER REPRESENTS A TILE IN THE CHARACTER ROM ;THESE VALUES ARE ARBITRARY AND WILL DIFFER DEPENDING ON HOW THE YIN-YANG PIXEL ART IS STORED IN YOUR CARTRIDGE. DC.W$0060,$0068,$0070,$0078,$0080,$0088,$0090,$0098 DC.W$0061,$0069,$0071,$0079,$0081,$0089,$0091,$0099 DC.W$0062,$006A,$0072,$007A,$0082,$008A,$0092,$009A DC.W$0063,$006B,$0073,$007B,$0083,$008B,$0093,$009B DC.W$0064,$006C,$0074,$007C,$0084,$008C,$0094,$009C DC.W$0065,$006D,$0075,$007D,$0085,$008D,$0095,$009D DC.W$0066,$006E,$0076,$007E,$0086,$008E,$0096,$009E DC.W$0067,$006F,$0077,$007F,$0087,$008F,$0097,$009F YinYang_Pal: ;$0100 = USE PALETTE 1.
DC.W $0100,$0100,$0100,$0100,$0100,$0100,$0100,$0100
DC.W $0100,$0100,$0100,$0100,$0100,$0100,$0100,$0100
DC.W $0100,$0100,$0100,$0100,$0100,$0100,$0100,$0100
DC.W $0100,$0100,$0100,$0100,$0100,$0100,$0100,$0100
DC.W $0100,$0100,$0100,$0100,$0100,$0100,$0100,$0100
DC.W $0100,$0100,$0100,$0100,$0100,$0100,$0100,$0100
DC.W $0100,$0100,$0100,$0100,$0100,$0100,$0100,$0100
DC.W $0100,$0100,$0100,$0100,$0100,$0100,$0100,$0100

And here is the output: Screenshot of NEOGEO displaying two Yin-Yangs

## Action!

INCLUDE "H6:REALMATH.ACT"
INCLUDE "D2:CIRCLE.ACT" ;from the Action! Tool Kit

PROC YinYang(INT x BYTE y BYTE r)
INT i,a,b,rr,r2,rr2,r5,rr5,y1,y2
REAL tmp1,tmp2

Circle(x,y,r,1)

rr=r*r
r2=r/2 rr2=rr/4
Color=1
FOR i=0 TO r
DO
a=rr-i*i
IntToReal(a,tmp1)
Sqrt(tmp1,tmp2)
a=RealToInt(tmp2)

b=rr2-(i-r2)*(i-r2)
IntToReal(b,tmp1)
Sqrt(tmp1,tmp2)
b=RealToInt(tmp2)

Plot(x+b,y-i) DrawTo(x+a,y-i)
Plot(x-b,y+i) DrawTo(x+a,y+i)
OD

r5=r/5
rr5=rr/25
y1=y-r2 y2=y+r2
FOR i=0 TO r5
DO
a=rr5-i*i
IntToReal(a,tmp1)
Sqrt(tmp1,tmp2)
a=RealToInt(tmp2)

Color=1
Plot(x-a,y1-i) DrawTo(x+a,y1-i)
Plot(x-a,y1+i) DrawTo(x+a,y1+i)

Color=0
Plot(x-a,y2-i) DrawTo(x+a,y2-i)
Plot(x-a,y2+i) DrawTo(x+a,y2+i)
OD
RETURN

PROC Main()
BYTE CH=$02FC,COLOR1=$02C5,COLOR2=$02C6 Graphics(8+16) MathInit() COLOR1=$00
COLOR2=$0F YinYang(180,120,60) YinYang(100,40,30) DO UNTIL CH#$FF OD
CH=$FF RETURN Output: ## Ada Library: GtkAda Uses the Cairo component of GtkAda to create and save as png with Glib; use Glib; with Cairo; use Cairo; with Cairo.Png; use Cairo.Png; with Cairo.Image_Surface; use Cairo.Image_Surface; procedure YinYang is subtype Dub is Glib.Gdouble; procedure Draw (C : Cairo_Context; x : Dub; y : Dub; r : Dub) is begin Arc (C, x, y, r + 1.0, 1.571, 7.854); Set_Source_Rgb (C, 0.0, 0.0, 0.0); Fill (C); Arc_Negative (C, x, y - r / 2.0, r / 2.0, 1.571, 4.712); Arc (C, x, y + r / 2.0, r / 2.0, 1.571, 4.712); Arc_Negative (C, x, y, r, 4.712, 1.571); Set_Source_Rgb (C, 1.0, 1.0, 1.0); Fill (C); Arc (C, x, y - r / 2.0, r / 5.0, 1.571, 7.854); Set_Source_Rgb (C, 0.0, 0.0, 0.0); Fill (C); Arc (C, x, y + r / 2.0, r / 5.0, 1.571, 7.854); Set_Source_Rgb (C, 1.0, 1.0, 1.0); Fill (C); end Draw; Surface : Cairo_Surface; Context : Cairo_Context; Status : Cairo_Status; begin Surface := Create (Cairo_Format_ARGB32, 200, 200); Context := Create (Surface); Draw (Context, 120.0, 120.0, 75.0); Draw (Context, 35.0, 35.0, 30.0); Status := Write_To_Png (Surface, "YinYangAda.png"); pragma Assert (Status = Cairo_Status_Success); end YinYang;  ## ALGOL 68 Works with: ALGOL 68 version Revision 1 - With Currying extensions to language. Works with: ALGOL 68G version Any - tested with release 1.18.0-9h.tiny. INT scale x=2, scale y=1; CHAR black="#", white=".", clear=" "; PROC print yin yang = (REAL radius)VOID:( PROC in circle = (REAL centre x, centre y, radius, x, y)BOOL: (x-centre x)**2+(y-centre y)**2 <= radius**2; PROC (REAL, REAL)BOOL in big circle = in circle(0, 0, radius, , ), in white semi circle = in circle(0, +radius/2, radius/2, , ), in small black circle = in circle(0, +radius/2, radius/6, , ), in black semi circle = in circle(0, -radius/2, radius/2, , ), in small white circle = in circle(0, -radius/2, radius/6, , ); FOR sy FROM +ROUND(radius * scale y) BY -1 TO -ROUND(radius * scale y) DO FOR sx FROM -ROUND(radius * scale x) TO +ROUND(radius * scale x) DO REAL x=sx/scale x, y=sy/scale y; print( IF in big circle(x, y) THEN IF in white semi circle(x, y) THEN IF in small black circle(x, y) THEN black ELSE white FI ELIF in black semi circle(x, y) THEN IF in small white circle(x, y) THEN white ELSE black FI ELIF x < 0 THEN white ELSE black FI ELSE clear FI ) OD; print(new line) OD ); main:( print yin yang(17); print yin yang(8) ) Output:  . ....................### ...........................###### ................................####### ....................................####### ........................................######### .......................#####..............######### .......................#########............########### .......................###########...........############ .........................###########...........############## ..........................#########............############## .............................#####..............############### ................................................################# ................................................################### ..............................................##################### ............................................####################### ..........................................######################### ...................................################################## .........................########################################## .......................############################################ .....................############################################## ...................################################################ .................################################################ ...............##############.....############################# ..............############.........########################## ..............###########...........######################### ............###########...........####################### ...........############.........####################### .........##############.....####################### .........######################################## .......#################################### .......################################ ......########################### ...#################### # . .............## .................#### ...........###......##### ...........#####......##### .............###......####### ......................######### .....................########## .................################ ..........##################### .........###################### .......######...############# .....######.....########### .....######...########### ....################# ..############# #  ## ARM Assembly Works with: as version Raspberry Pi /* ARM assembly Raspberry PI */ /* program yingyang.s */ /* REMARK 1 : this program use routines in a include file see task Include a file language arm assembly for the routine affichageMess conversion10 see at end of this program the instruction include */ /***************************************************************/ /* File Constantes see task Include a file for arm assembly */ /***************************************************************/ .include "../constantes.inc" .equ SIZEMAXI, 78 /******************************************/ /* Initialized data */ /******************************************/ .data szMessDebutPgm: .asciz "Start program.\n" szMessFinPgm: .asciz "Program End ok.\n" szRetourLigne: .asciz "\n" szMessErrComm: .asciz "Incomplete Command line : yingyang <size> \n" /******************************************/ /* UnInitialized data */ /******************************************/ .bss szLine: .skip SIZEMAXI /******************************************/ /* code section */ /******************************************/ .text .global main main: @ entry of program mov fp,sp // copy stack address register r29 fp ldr r0,iAdrszMessDebutPgm bl affichageMess ldr r0,[fp] // parameter number command line cmp r0,#1 // correct ? ble erreurCommande // error add r0,fp,#8 // address parameter 2 ldr r0,[r0] bl conversionAtoD cmp r0,#SIZEMAXI / 2 movgt r0,#(SIZEMAXI / 2) - 1 // limit size mov r10,r0 // size lsr r11,r10,#1 // R = size / 2 radius great circle mul r9,r11,r11 // R^2 lsr r12,r11,#1 // radius median circle lsr r8,r12,#1 // radius little circle mov r2,#0 // y ldr r0,iAdrszLine 1: mov r1,#0 // x mov r5,#' ' mov r3,#SIZEMAXI 11: // move spaces in display line strb r5,[r0,r1] add r1,#1 cmp r1,r3 blt 11b mov r1,#0 // x 2: // begin loop sub r3,r1,r11 // x1 = x - R mul r4,r3,r3 // x1^2 sub r5,r2,r11 // y1 = y - R mul r6,r5,r5 // y1^2 add r6,r4 // add x1^2 y1^2 cmp r6,r9 // compare R^2 ble 3f mov r5,#' ' // not in great circle strb r5,[r0,r1,lsl #1] b 20f 3: // compute quadrant cmp r1,r11 bgt 10f // x > R cmp r2,r11 bgt 5f // y > R // quadrant 1 x < R and y < R sub r5,r2,r12 mul r7,r5,r5 // y1^2 add r7,r4 // y1^2 + x1^2 mul r6,r8,r8 // little r ^2 cmp r7,r8 bgt 4f mov r5,#' ' // in little circle strb r5,[r0,r1,lsl #1] b 20f 4: // in other part of great circle mov r5,#'.' strb r5,[r0,r1,lsl #1] b 20f 5: // quadrant 3 x < R and y > R mov r5,#3 mul r5,r10,r5 lsr r5,#2 sub r6,r2,r5 // y1 - pos little circle (= (size / 3) * 4 mul r7,r6,r6 // y1^2 add r7,r4 // y1^2 + x1^2 mul r6,r8,r8 // r little cmp r7,r8 bgt 6f mov r5,#' ' // in little circle strb r5,[r0,r1,lsl #1] b 20f 6: mul r6,r12,r12 cmp r7,r6 bge 7f mov r5,#'#' // in median circle strb r5,[r0,r1,lsl #1] b 20f 7: mov r5,#'.' // not in median strb r5,[r0,r1,lsl #1] b 20f 10: cmp r2,r11 bgt 15f // quadrant 2 sub r5,r2,r12 // y - center little mul r6,r5,r5 add r7,r4,r6 mul r6,r8,r8 cmp r7,r6 bge 11f mov r5,#' ' // in little circle strb r5,[r0,r1,lsl #1] b 20f 11: mul r6,r12,r12 cmp r7,r6 bge 12f mov r5,#'.' // in median circle strb r5,[r0,r1,lsl #1] b 20f 12: mov r5,#'#' // in great circle strb r5,[r0,r1,lsl #1] b 20f 15: // quadrant 4 mov r5,#3 mul r5,r10,r5 lsr r5,#2 sub r6,r2,r5 // y1 - pos little mul r7,r6,r6 // y1^2 add r7,r4 // y1^2 + x1^2 mul r6,r8,r8 // little r ^2 cmp r7,r8 bgt 16f mov r5,#' ' // in little circle strb r5,[r0,r1,lsl #1] b 20f 16: mov r5,#'#' strb r5,[r0,r1,lsl #1] b 20f 20: add r1,#1 // increment x cmp r1,r10 // size ? ble 2b // no -> loop lsl r1,#1 mov r5,#'\n' // add return line strb r5,[r0,r1] add r1,#1 mov r5,#0 // add final zéro strb r5,[r0,r1] bl affichageMess // and display line add r2,r2,#1 // increment y cmp r2,r10 // size ? ble 1b // no -> loop ldr r0,iAdrszMessFinPgm bl affichageMess b 100f erreurCommande: ldr r0,iAdrszMessErrComm bl affichageMess mov r0,#1 // error code b 100f 100: // standard end of the program mov r0, #0 // return code mov r7, #EXIT // request to exit program svc 0 // perform the system call iAdrszMessDebutPgm: .int szMessDebutPgm iAdrszMessFinPgm: .int szMessFinPgm iAdrszMessErrComm: .int szMessErrComm iAdrszLine: .int szLine /***************************************************/ /* ROUTINES INCLUDE */ /***************************************************/ .include "../affichage.inc" Output: Start program. . . . . . . . . # # . . . . . . . . . . # # # . . . . . . . . . . . . # # # . . . . . . . . . . # # # # . . . . . . . . . . # # # # . . . . . . . . . . . # # # # # . . . . . . . . . . . . . . # # # # # . . . . . . . . . . . . . # # # # # # . . . . . . . . . . . . # # # # # # # . . . . . . . . . . . # # # # # # # # # # . . . . . . . # # # # # # # # # # # # . . . . . . # # # # # # # # # # # # # . . . . . # # # # # # # # # # # # # # . . . . . # # # # # # # # # # # . . . . # # # # # # # # # # . . . . # # # # # # # # # # . . . # # # # # # # # # # # # . . . # # # # # # # # # # . . # # # # # # # . Program End ok.  ## Asymptote unitsize(1 inch); fill(scale(6)*unitsquare, invisible); picture yinyang(pair center, real radius) { picture p; fill(p, unitcircle, white); fill(p, arc(0, S, N) -- cycle, black); fill(p, circle(N/2, 1/2), white); fill(p, circle(S/2, 1/2), black); fill(p, circle(N/2, 1/5), black); fill(p, circle(S/2, 1/5), white); draw(p, unitcircle, linewidth((1/32) * inch) + gray(0.5)); return shift(center) * scale(radius) * p; } add(yinyang((1 + 1/4, 4 + 3/4), 1)); add(yinyang((3 + 3/4, 2 + 1/4), 2));  ## AutoHotkey Requires the GDI+ Standard Library by tic: http://www.autohotkey.com/forum/viewtopic.php?t=32238 Yin_and_Yang(50, 50, A_ScriptDir "\YinYang1.png") Yin_and_Yang(300, 300,A_ScriptDir "\YinYang2.png") Yin_and_Yang(width, height, fileName , color1=0xFFFFFFFF, color2=0xFF000000, outlineWidth=1){ pToken := gdip_Startup() pBitmap := gdip_CreateBitmap(w := width, h := height) w-=1, h-=1 pGraphics:= gdip_GraphicsFromImage(pBitmap) pBrushW := gdip_BrushCreateSolid(color1) pBrushB := gdip_BrushCreateSolid(color2) gdip_SetSmoothingMode(pGraphics, 4) ; Antialiasing If (outlineWidth){ pPen := gdip_CreatePen(0xFF000000, outlineWidth) gdip_DrawEllipse(pGraphics, pPen, 0, 0, w, h) gdip_DeletePen(pPen) } gdip_FillPie(pGraphics, pBrushB, 0, 0, w, h, -90, 180) gdip_FillPie(pGraphics, pBrushW, 0, 0, w, h, 90, 180) gdip_FillEllipse(pGraphics, pBrushB, w//4, h//2, w//2, h//2) gdip_FillEllipse(pGraphics, pBrushW, w//4, 0 , w//2, h//2) gdip_FillEllipse(pGraphics, pBrushB, 5*w//12, h//6, w//6, h//6) gdip_FillEllipse(pGraphics, pBrushW, 5*w//12, 4*h//6,w//6,h//6) r := gdip_SaveBitmapToFile(pBitmap, filename) ; cleanup: gdip_DeleteBrush(pBrushW), gdip_deleteBrush(pBrushB) gdip_DisposeImage(pBitmap) gdip_DeleteGraphics(pGraphics) gdip_Shutdown(pToken) return r }  ## AWK # syntax: GAWK -f YIN_AND_YANG.AWK # converted from PHL BEGIN { yin_and_yang(16) yin_and_yang(8) exit(0) } function yin_and_yang(radius, black,white,scale_x,scale_y,sx,sy,x,y) { black = "#" white = "." scale_x = 2 scale_y = 1 for (sy = radius*scale_y; sy >= -(radius*scale_y); sy--) { for (sx = -(radius*scale_x); sx <= radius*scale_x; sx++) { x = sx / scale_x y = sy / scale_y if (in_big_circle(radius,x,y)) { if (in_white_semi_circle(radius,x,y)) { printf("%s",(in_small_black_circle(radius,x,y)) ? black : white) } else if (in_black_semi_circle(radius,x,y)) { printf("%s",(in_small_white_circle(radius,x,y)) ? white : black) } else { printf("%s",(x<0) ? white : black) } } else { printf(" ") } } printf("\n") } } function in_circle(center_x,center_y,radius,x,y) { return (x-center_x)*(x-center_x)+(y-center_y)*(y-center_y) <= radius*radius } function in_big_circle(radius,x,y) { return in_circle(0,0,radius,x,y) } function in_black_semi_circle(radius,x,y) { return in_circle(0,0-radius/2,radius/2,x,y) } function in_white_semi_circle(radius,x,y) { return in_circle(0,radius/2,radius/2,x,y) } function in_small_black_circle(radius,x,y) { return in_circle(0,radius/2,radius/6,x,y) } function in_small_white_circle(radius,x,y) { return in_circle(0,0-radius/2,radius/6,x,y) }  Output:  . ...................#### ..........................##### ...............................###### ...................................######## ......................................######### .....................#######............######### ......................#########...........########### ......................###########...........########### ........................#########...........############# ..........................#######............############## .............................................################ ............................................################# ............................................################### ..........................................##################### .......................................######################## .................................################################ ........................####################################### .....................########################################## ...................############################################ .................############################################ ................############################################# ..............############.......########################## .............###########.........######################## ...........###########...........###################### ...........###########.........###################### .........############.......##################### .........###################################### ........################################### ......############################### .....########################## ....################### # . .............## .................#### ...........###......##### ...........#####......##### .............###......####### ......................######### .....................########## .................################ ..........##################### .........###################### .......######...############# .....######.....########### .....######...########### ....################# ..############# #  ## BASIC ### AmigaBASIC pi=3.141592 s=.5 xp=320:yp=100:size=150 GOSUB DrawYY xp=500:yp=40:size=50 GOSUB DrawYY END DrawYY: CIRCLE (xp,yp),size,,,,s CIRCLE (xp,yp+size/4),size/8,,,,s CIRCLE (xp,yp-size/4),size/8,,,,s CIRCLE (xp,yp+size/4),size/2,,.5*pi,1.5*pi,s CIRCLE (xp,yp-size/4),size/2,,1.5*pi,2*pi,s CIRCLE (xp,yp-size/4),size/2,,0,.5*pi,s PAINT (xp,yp-size/4) PSET (xp,yp) PAINT (xp+size/4,yp) RETURN ### Applesoft BASIC 0 GOTO 6 1Y=R:D=1-R:X=0:FORC=0TO1STEP0:M=D>=0:Y=Y-M:D=D-Y*2*M:D=D+X*2+3:HPLOTXC-X,YC+YTOXC+X,YC+Y:HPLOTXC-Y,YC+XTOXC+Y,YC+X:HPLOTXC-X,YC-YTOXC+X,YC-Y:HPLOTXC-Y,YC-XTOXC+Y,YC-X:X=X+1:C=X>=Y:NEXTC:RETURN 2Y=R:D=1-R:X=0:FORC=0TO1STEP0:M=D>=0:Y=Y-M:D=D-Y*2*M:D=D+X*2+3:HPLOTXC-X,YC+Y:HPLOTXC+X,YC+Y:HPLOTXC-Y,YC+X:HPLOTXC+Y,YC+X:HPLOTXC-X,YC-Y:HPLOTXC+X,YC-Y:HPLOTXC-Y,YC-X:HPLOTXC+Y,YC-X:X=X+1:C=X>=Y:NEXTC:RETURN 3Y=R:D=1-R:X=0:FORC=0TO1STEP0:M=D>=0:Y=Y-M:D=D-Y*2*M:D=D+X*2+3:HPLOTXC,YC+YTOXC+X,YC+Y:HPLOTXC,YC+XTOXC+Y,YC+X:HPLOTXC,YC-YTOXC+X,YC-Y:HPLOTXC,YC-XTOXC+Y,YC-X:X=X+1:C=X>=Y:NEXTC:RETURN 6 HGR2 : HCOLOR = 3 : HPLOT 0,0 : CALL 62454 7 XC = 60 : YC = 60 : R = 30 : GOSUB 100YINYANG 8 XC = 180 : YC = 80 : R = 60 : GOSUB 100YINYANG 9 END 100 YP = YC : S = R 110 HCOLOR = 0: GOSUB 3FILLHALFCIRCLE 120 HCOLOR = 3:YC = YP - S / 2 : R = S / 2 : GOSUB 1FILLCIRCLE 130 HCOLOR = 0 140 YC = YP + S / 2 : GOSUB 1FILLCIRCLE 150 YC = YP - S / 2 : R = S / 6 : GOSUB 1FILLCIRCLE 160 HCOLOR = 3 170 YC = YP + S / 2 : GOSUB 1FILLCIRCLE 180 HCOLOR = 0 : YC = YP : R = S : GOSUB 2CIRCLE 190 RETURN ### BASIC256 graphsize 800, 600 clg subroutine Taijitu(x, y, r) color black: circle(x, y, 2*r+1) chord x-2*r, y-2*r, 4*r, 4*r, radians(0), radians(180) color white chord x-2*r, y-2*r, 4*r, 4*r, radians(180), radians(180) circle(x, y-r, r-1) color black: circle(x, y+r, r-1) circle(x, y-r, r/3) color white: circle(x, y+r, r/3) end subroutine call Taijitu(110, 110, 45) call Taijitu(500, 300, 138) end ### BBC BASIC  PROCyinyang(200, 200, 100) PROCyinyang(700, 400, 300) END DEF PROCyinyang(xpos%, ypos%, size%) CIRCLE xpos%, ypos%, size% LINE xpos%, ypos%+size%, xpos%, ypos%-size% FILL xpos%+size%/2, ypos% CIRCLE FILL xpos%, ypos%-size%/2, size%/2+2 GCOL 15 CIRCLE FILL xpos%, ypos%+size%/2, size%/2+2 CIRCLE FILL xpos%, ypos%-size%/2, size%/6+2 GCOL 0 CIRCLE FILL xpos%, ypos%+size%/2, size%/6+2 CIRCLE xpos%, ypos%, size% ENDPROC  ### Commodore BASIC Works with: Commodore BASIC version 2.0+SuperExpander On a VIC-20 with the SuperExpander cartridge: 0 REM VIC-20 WITH SUPEREXPANDER 10 GRAPHIC 2 20 COLOR 0,1,1,1 30 X=312:Y=500:XR=310:YR=464:GOSUB 100 40 X=812:Y=750:XR=186:YR=248:GOSUB 100 50 GET K$:IF K$="" THEN 50 60 GRAPHIC 0 70 END 100 CIRCLE 1,X,Y,XR,YR 110 CIRCLE 1,X,Y-YR/2,XR/2,YR/2,75,25 120 CIRCLE 1,X,Y+YR/2,XR/2,YR/2,25,75 130 CIRCLE 1,X,Y-YR/2,XR/8+1,YR/8+1 140 CIRCLE 1,X,Y+YR/2,XR/8-1,YR/8-1 150 PAINT 1,X,Y+YR/2 160 PAINT 1,X-XR/2,Y 170 RETURN  Works with: Simons' BASIC 0 REM C64 WITH SIMONS' BASIC 10 COLOUR 0,0 20 HIRES 1,0 30 X=100:Y=100:XR=98:YR=74:GOSUB 100 40 X=260:Y=150:XR=48:YR=36:GOSUB 100 50 GET K$:IF K$="" THEN 50 60 END 100 CIRCLE X,Y,XR,YR,1 110 ARC X,Y+YR/2,180,360,1,XR/2,YR/2+1,1 120 ARC X,Y-YR/2,0,180,1,XR/2,YR/2+1,1 130 CIRCLE X,Y-YR/2,XR/8,YR/8,1 140 CIRCLE X,Y+YR/2,XR/8,YR/8,1 150 PAINT X,Y+YR/2,1 160 PAINT X-XR/2,Y,1 170 RETURN  Works with: Commodore BASIC version 3.5,7.0 Using the built-in graphics statements available in BASIC 3.5 on the Commodore TED computers (C-16, Plus/4) or BASIC 7.0 on the C-128: 0 REM BASIC 3.5,7.0 10 COLOR 0,1:COLOR 1,2:COLOR 4,1 20 GRAPHIC 1,1 30 X=100:Y=100:XR=98:YR=74:GOSUB 100 40 X=260:Y=150:XR=48:YR=36:GOSUB 100 50 GETKEY K$
60 END
100 CIRCLE 1,X,Y,XR,YR
110 CIRCLE 1,X,Y-YR/2,XR/2,YR/2,0,180
120 CIRCLE 1,X,Y+YR/2,XR/2,YR/2,180,360
130 CIRCLE 1,X,Y-YR/2,XR/8,YR/8
140 CIRCLE 1,X,Y+YR/2,XR/8,YR/8
150 PAINT 1,X,Y+YR/2
160 PAINT 1,X-XR/2,Y
170 RETURN


Images of the results can be seen here.

### FreeBASIC

Screen 19
Color ,7
Cls

Sub Taijitu(x As Integer, y As Integer, r As Integer)
Circle(x, y), 2 * r, 0,,,, F
Line (x, y - 2 * r) - (x, y + 2 * r), 7, B
Paint (x - r, y), 15, 7
Circle(x, y - r), r - 1, 15,,,, F
Circle(x, y + r), r - 1,  0,,,, F
Circle(x, y - r), r / 3,  0,,,, F
Circle(x, y + r), r / 3, 15,,,, F
End Sub

Taijitu(110, 110, 45)
Taijitu(500, 300, 138)
End

### Gambas

Public Sub Form_Open()
Dim hPictureBox As PictureBox
Dim siCount As Short

With Me
.Title = "Yin and yang"
.Height = 210
.Width = 310
.Arrangement = Arrange.Row
End With

For siCount = 2 DownTo 1
hPictureBox = New PictureBox(Me)
With hPictureBox
.Height = siCount * 100
.Width = siCount * 100
.Stretch = True
End With
Next

End

### IS-BASIC

100 PROGRAM "YinYang.bas"
110 GRAPHICS HIRES 2
120 SET PALETTE WHITE,BLACK
130 CALL YINYANG(200,400,150)
140 CALL YINYANG(800,340,300)
150 DEF YINYANG(X,Y,R)
160   PLOT X,Y,ELLIPSE R,R,
170   PLOT X,Y+R/2,ELLIPSE R/2,R/2,ELLIPSE R/6,R/6,PAINT
180   PLOT X,Y-R/2,ELLIPSE R/2,R/2,ELLIPSE R/6,R/6,
190   PLOT X,Y-6,PAINT,X+R/2,Y,PAINT
200   SET INK 0:PLOT X,Y+R/2,ELLIPSE R/2,R/2,
210   SET INK 1:PLOT X,Y,ELLIPSE R,R,
220 END DEF

### Liberty BASIC

    WindowWidth  =410
WindowHeight =440

open "Yin & Yang" for graphics_nf_nsb as #w

#w "trapclose [quit]"

call YinYang 200, 200, 200
call YinYang 120,  50,  50

wait

sub YinYang x, y, size

#w "up ; goto "; x; " "; y
#w "backcolor black ; color black"
#w "down ; circlefilled "; size /2

#w "color 255 255 255 ; backcolor 255 255 255"
#w "up   ; goto ";      x -size /2; " "; y -size /2
#w "down ; boxfilled "; x;          " "; y +size /2

#w "up ; goto "; x; " "; y -size /4
#w "down ; backcolor black ; color black   ; circlefilled "; size  /4
#w "up ; goto "; x; " "; y -size /4
#w "down ; backcolor white ; color white ; circlefilled "; size /12

#w "up ; goto "; x; " "; y +size /4
#w "down ; backcolor white ; color white ; circlefilled "; size  /4
#w "up ; goto "; x; " "; y +size /4
#w "down ; backcolor black ; color black ; circlefilled "; size /12

#w "up ; goto "; x; " "; y
#w "down ; color black ; circle "; size /2

#w "flush"

end sub

scan

wait

[quit]
close #w
end

### Locomotive Basic

10 mode 2:deg:defint a-z:ink 0,26:ink 1,0:border 26
20 xp=320:yp=200:size=150:gosub 100
30 xp=550:yp=350:size=40:gosub 100
40 while inkey$="":wend 50 end 100 cx=xp:cy=yp:cr=size:gosub 1000 110 cy=yp+size/2:cr=size/8:gosub 1000 120 cr=size/2:half=0:gosub 2000 130 cy=yp-size/2:cr=size/8:gosub 1000 140 cr=size/2:half=1:gosub 2000 150 move xp, yp+size/2:fill 1 160 move xp+size/2, yp:fill 1 170 return 1000 plot cx,cy+cr 1010 for i=0 to 360 step 10 1020 draw cx+cr*sin(i),cy+cr*cos(i) 1030 next 1040 return 2000 p=180*half 2010 plot cx+cr*sin(p),cy+cr*cos(p) 2020 for i=p to p+180 step 10 2030 draw cx+cr*sin(i),cy+cr*cos(i) 2040 next 2050 return ### PureBasic Procedure Yin_And_Yang(x, y, radius) DrawingMode(#PB_2DDrawing_Outlined) Circle(x, y, 2 * radius, #Black) ;outer circle DrawingMode(#PB_2DDrawing_Default) LineXY(x, y - 2 * radius, x, y + 2 * radius, #Black) FillArea(x + 1, y, #Black, #Black) Circle(x, y - radius, radius - 1, #White) Circle(x, y + radius, radius - 1, #Black) Circle(x, y - radius, radius / 3, #Black) ;small contrasting inner circles Circle(x, y + radius, radius / 3, #White) EndProcedure If CreateImage(0, 700, 700) And StartDrawing(ImageOutput(0)) FillArea(1, 1, -1, #White) Yin_And_Yang(105, 105, 50) Yin_And_Yang(400, 400, 148) StopDrawing() ; UsePNGImageEncoder() path$ = SaveFileRequester("Save image", "Yin And yang.png", "*.png", 0)
If path$<> "": SaveImage(0, path$, #PB_ImagePlugin_PNG, 0, 2): EndIf
EndIf

### uBasic/4tH

Proc _YinYang (18)
End

_YinYang
Param (1)
Local (2)

For b@ = -a@ To a@
For c@ = -2*a@ To 2*a@
Print Chr(FUNC(_Pixel (c@, b@, a@)));
Next
Print
Next
Return

_Circle
Param (4)
Local (1)

e@ = ((a@/2) * (a@/2)) + ((b@-c@) * (b@-c@))
Return ((d@ * d@) + 1  > e@)

_Pixel
Param (3)

If FUNC(_Circle (a@, b@, -c@ / 2, c@ / 6)) Then Return (Ord ("#"))
If FUNC(_Circle (a@, b@, c@ / 2, c@ / 6))  Then Return (Ord ("."))
If FUNC(_Circle (a@, b@, -c@ / 2, c@ / 2)) Then Return (Ord ("."))
If FUNC(_Circle (a@, b@, c@ / 2, c@ / 2))  Then Return (Ord ("#"))
If FUNC(_Circle (a@, b@, 0, c@)) Then Return (Iif (a@ < 0, Ord ("."), Ord ("#")))
Return (Ord (" "))


### VBA

Private Sub yinyang(Top As Integer, Left As Integer, Size As Integer)
With Selection.ShapeRange
.Fill.ForeColor.RGB = RGB(255, 255, 255)
.Line.ForeColor.RGB = RGB(0, 0, 0)
End With
With Selection.ShapeRange
.IncrementRotation 180
.Fill.ForeColor.RGB = RGB(0, 0, 0)
.Line.ForeColor.RGB = RGB(0, 0, 0)
End With
ActiveSheet.Shapes.AddShape(msoShapeOval, Top + Size \ 4, Left, Size \ 2, Size \ 2).Select
With Selection.ShapeRange
.Fill.ForeColor.RGB = RGB(255, 255, 255)
.Line.ForeColor.RGB = RGB(255, 255, 255)
End With
ActiveSheet.Shapes.AddShape(msoShapeOval, Top + Size \ 4, Left + Size \ 2, Size \ 2, Size \ 2).Select
With Selection.ShapeRange
.Fill.ForeColor.RGB = RGB(0, 0, 0)
.Line.ForeColor.RGB = RGB(0, 0, 0)
End With
ActiveSheet.Shapes.AddShape(msoShapeOval, Top + 5 * Size \ 12, Left + Size \ 6, Size \ 6, Size \ 6).Select
With Selection.ShapeRange
.Fill.ForeColor.RGB = RGB(0, 0, 0)
.Line.ForeColor.RGB = RGB(0, 0, 0)
End With
ActiveSheet.Shapes.AddShape(msoShapeOval, Top + 5 * Size \ 12, Left + 2 * Size \ 3, Size \ 6, Size \ 6).Select
With Selection.ShapeRange
.Fill.ForeColor.RGB = RGB(255, 255, 255)
.Line.ForeColor.RGB = RGB(255, 255, 255)
End With
ActiveSheet.Shapes.SelectAll
Selection.ShapeRange.Group
End Sub
Public Sub draw()
yinyang 200, 100, 100
yinyang 275, 175, 25
End Sub

### Visual Basic .NET

#### GDI graphics

Shows a form with the symbols drawn on it if no command line arguments are given; otherwise, the first and only argument is an integer representing the width and height of the PNG image to generate. The raw data of the generated image is written to the console (redirect to a file to view).

Imports System.Drawing
Imports System.Windows.Forms

Module Program
''' <summary>
''' Draws a Taijitu symbol on the specified <see cref="Graphics" /> surface at a specified location with a specified size.
''' </summary>
''' <param name="g">The <see cref="Graphics" /> surface to draw on.</param>
''' <param name="location">The coordinates of the upper-left corner of the bounding rectangle that defines the symbol.</param>
''' <param name="diameter">The diameter of the symbol, or the width and height of its bounding rectangle.</param>
''' <param name="drawOutline">Whether to draw an outline around the symbol.</param>
Sub DrawTaijitu(g As Graphics, location As PointF, diameter As Single, drawOutline As Boolean)
Const sixth = 1 / 6

g.ResetTransform()
g.TranslateTransform(location.X, location.Y)
g.ScaleTransform(diameter, diameter)

g.FillPie(Brushes.Black, x:=0, y:=0, width:=1, height:=1, startAngle:=90, sweepAngle:=180)  ' Left half.
g.FillPie(Brushes.White, x:=0, y:=0, width:=1, height:=1, startAngle:=270, sweepAngle:=180) ' Right half.
g.FillEllipse(Brushes.Black, x:=0.25, y:=0, width:=0.5, height:=0.5)                        ' Upper ball.
g.FillEllipse(Brushes.White, x:=0.25, y:=0.5, width:=0.5, height:=0.5)                      ' Lower ball.
g.FillEllipse(Brushes.White, x:=0.5 - sixth / 2, y:=sixth, width:=sixth, height:=sixth)     ' Upper dot.
g.FillEllipse(Brushes.Black, x:=0.5 - sixth / 2, y:=4 * sixth, width:=sixth, height:=sixth) ' Lower dot.

If drawOutline Then
Using p As New Pen(Color.Black, width:=2 / diameter)
g.DrawEllipse(p, x:=0, y:=0, width:=1, height:=1)
End Using
End If
End Sub

''' <summary>
''' Draws one large and one small Taijitu symbol on the specified <see cref="Graphics" /> surface.
''' </summary>
''' <param name="g">The <see cref="Graphics" /> surface to draw on.</param>
''' <param name="bounds">The width and height of the area to draw in.</param>
Sub DrawDemo(g As Graphics, bounds As Single)
Dim ACTUAL = bounds - (PADDING * 2)

g.SmoothingMode = Drawing2D.SmoothingMode.AntiAlias

DrawTaijitu(g, location:=New PointF(PADDING + (bounds / 5), PADDING + (ACTUAL / 5)), diameter:=ACTUAL * 4 / 5, drawOutline:=True)
End Sub

Sub Main(args As String())
If args.Length = 0 Then
Using frm As New YinYangForm()
frm.ShowDialog()
End Using

Else
Dim imageSize = Integer.Parse(args(0), Globalization.CultureInfo.InvariantCulture)

Using bmp As New Bitmap(imageSize, imageSize),
g = Graphics.FromImage(bmp),
output = Console.OpenStandardOutput()

Try
DrawDemo(g, imageSize)
bmp.Save(output, Imaging.ImageFormat.Png)
Catch ex As Exception
MessageBox.Show("Specified size is too small", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error)
End Try
End Using
End If
End Sub

Private Class YinYangForm
Inherits Form

Sub Form_Paint() Handles Me.Paint
Dim availableSize = Math.Min(Me.DisplayRectangle.Width, Me.DisplayRectangle.Height)
Dim g As Graphics
Try
g = Me.CreateGraphics()
DrawDemo(g, availableSize)
Catch ex As Exception
MessageBox.Show("Window size too small.", "Exception thrown", MessageBoxButtons.OK, MessageBoxIcon.Error)
Finally
If g IsNot Nothing Then g.Dispose()
End Try
End Sub
End Class
End Module


#### SVG

Translation of: zkl

Uses minimal string literals by favoring proper use of the .NET System.Linq.Xml classes (and VB.NET's XML literals, of course ;).

Imports System.IO

' Yep, VB.NET can import XML namespaces. All literals have xmlns changed, while xmlns:xlink is only
' declared in literals that use it directly (e.g. the output of this program has it defined in both
' of the <use /> tags and not the root, <svg />).
Imports <xmlns="http://www.w3.org/2000/svg">

Module Program
Sub Main()
Dim doc =
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg version="1.1" width="30" height="30">
<defs>
<g id="y">
<circle cx="0" cy="0" r="200" stroke="black"
fill="white" stroke-width="1"/>
<path d="M0 -200 A 200 200 0 0 0 0 200 100 100 0 0 0 0 0 100 100 0 0 1 0 -200 z" fill="black"/>
<circle cx="0" cy="100" r="33" fill="white"/>
<circle cx="0" cy="-100" r="33" fill="black"/>
</g>
</defs>
</svg>

' XML literals don't support DTDs.
Dim type As New XDocumentType(name:="svg", publicId:="-//W3C//DTD SVG 1.1//EN", systemId:="http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd", internalSubset:=Nothing)

Dim draw_yinyang =
Sub(trans As Double, scale As Double) doc.Root.Add(<use xlink:href="#y" transform=<%= $"translate({trans},{trans}) scale({scale})" %>/>) draw_yinyang(20, 0.05) draw_yinyang(8, 0.02) Using s = Console.OpenStandardOutput(), sw As New StreamWriter(s) doc.Save(sw, SaveOptions.OmitDuplicateNamespaces) sw.WriteLine() End Using End Sub End Module  Output: <?xml version="1.0" encoding="utf-8" standalone="no"?> <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"> <svg version="1.1" width="30" height="30" xmlns="http://www.w3.org/2000/svg"> <defs> <g id="y"> <circle cx="0" cy="0" r="200" stroke="black" fill="white" stroke-width="1" /> <path d="M0 -200 A 200 200 0 0 0 0 200 100 100 0 0 0 0 0 100 100 0 0 1 0 -200 z" fill="black" /> <circle cx="0" cy="100" r="33" fill="white" /> <circle cx="0" cy="-100" r="33" fill="black" /> </g> </defs> <use xlink:href="#y" transform="translate(20,20) scale(0.05)" xmlns:xlink="http://www.w3.org/1999/xlink" /> <use xlink:href="#y" transform="translate(8,8) scale(0.02)" xmlns:xlink="http://www.w3.org/1999/xlink" /> </svg>  #### SVG (harder cheating) Translation of: Raku Module Program Sub Main() Console.OutputEncoding = Text.Encoding.Unicode Dim cheat_harder = Function(scale As Integer) <span style=<%=$"font-size:{scale}%;" %>>&#x262f;</span>
Console.WriteLine(<div><%= cheat_harder(700) %><%= cheat_harder(350) %></div>)
End Sub
End Module

Output:
<div>
<span style="font-size:700%;">☯</span>
<span style="font-size:350%;">☯</span>
</div>

Rendered by RosettaCode (MediaWiki):

### Yabasic

open window 640, 480

color 0,0,0
clear window

taijitu(640/2, 480/2, 480/4)
taijitu(100,100,50)

sub taijitu(x,y,r)
fill circle x,y,r
color 255,255,255
fill circle x,y,r-4
color 0,0,0
line x, y-r to x, y+r
infill(x-2, y-2)
fill circle x,y-r/2,r/2
color 255,255,255
fill circle x,y+r/2-2,r/2-1
fill circle x,y-r/2-2,r/8-1
color 0,0,0
fill circle x,y+r/2-2,r/8-1
end sub

sub infill(x,y)
local oy,lx,rx,nx,i,m,t,l$,r$,a$,test$
test$=getbit$(x,y,x,y)		// get a sample of fill area
oy=y-1 : lx=x : rx=x  : m=1	// m=1 makes go downwards
for t=1 to 2
repeat
repeat
l$=getbit$(lx,y,lx,y)
lx=lx-1 : if lx<0 break 	// test how far left to go
until (l$<>test$)
repeat
r$=getbit$(rx,y,rx,y)
rx=rx+1 : if rx>peek("winwidth") break 	// test how far right to go
until (r$<>test$)
lx=lx+2 : rx=rx-2 : line lx,y to rx,y  			// draw line across fill area
nx=0
for i=lx to rx
a$=getbit$(i,y+m,i,y+m)				// get sample for next line
if a$=test$ let nx=i  : break			// test if new cycle reqd
next i
lx=nx : rx=nx
y=y+m : if (y<0 or y>peek("winheight")) break		// test how far up or down to go
until (nx=0)
lx=x : rx=x : y=oy : m=-1					// m=-1 makes go upwards
next t
end sub

Other solution:

open window 640, 480
backcolor 255,0,0
color 0,0,0
clear window

taijitu(640/2, 480/2, 480/4)
taijitu(100,100,50)

sub taijitu(x,y,r)
local n, x1, x2, y1, y2

for n = 0 to pi*1.5 step pi/r
x1 = x + (r / 2) * cos(n) : y1 = y + (r / 2) * sin(n)
x2 = x - (r / 2) * cos(n) : y2 = y - (r / 2) * sin(n)
color 0, 0, 0 : fill circle x1, y1, r/2
color 255, 255, 255 : fill circle x1, y1, r/4
color 255, 255, 255 : fill circle x2, y2, r/2
color 0, 0, 0 : fill circle x2, y2, r/4
pause .025
next n
end sub

### ZX Spectrum Basic

ZX Spectrum Basic lacks a flood fill command, so we have to write a subroutine to do it for us; as such it takes a while. Recommend full speed on an emulator.

This could be done with fewer fills by defining the outline with arcs instead of circles, but it'd be just as "fast".

10 CLS
20 LET i=0
30 PRINT "Recommended size is a multiple  of 4 between 40 and 80": REM smaller sizes don't render properly and larger ones don't fit
40 INPUT "Size? ";s
50 IF size>87 THEN GOTO 50: REM size check
60 INPUT "Position?";t
70 IF t<s OR t+s>254 THEN GOTO 60
80 INK i
90 CIRCLE t,s/2,s/2
100 CIRCLE t,s*1.5,s/2
110 CIRCLE t,s*1.5,s/4
120 CIRCLE t,s/2,s/4: REM we draw the big circle later
130 LET bxl=t-s/4: REM these four variables define the bounding box for the fill routine
140 LET bxr=t+s/4
150 LET byb=s*1.25+1
160 LET byt=s*1.75-1
170 GOSUB 9000: REM fill top small circle first
180 LET bxl=t-s/2
190 LET bxr=t+s/2
200 LET byb=1
210 LET byt=s-1
220 GOSUB 9000: REM lower ring
230 PLOT t,s*.75
240 DRAW OVER 1;s/2,0
250 PLOT t,s*.25
260 DRAW OVER 1;s/2,0: REM fix top and bottom edges of lower circle - the top and bottom of a ZX Basic circle are horizontal lines, which screws with the parity fill
270 CIRCLE t,s/2,s/4
280 CIRCLE t,s,s: REM now draw the big circle - it would have clashed with the ring bounding box earlier
290 LET bxl=t
300 LET bxr=t+s
310 LET byb=s+1
320 LET byt=s*1.25-1
330 GOSUB 9000: REM right half, top, lower quadrant - we have to fill it in three goes
340 LET bxl=t+s*.25+1
350 LET byb=byt+1
360 LET byt=s*1.75
370 GOSUB 9000: REM right half, top, right of spot - we move bxl to the right of the spot to make sure it doesn't clash
380 LET bxl=t
390 LET byb=byt+1
400 LET byt=s*2-2
410 GOSUB 9000: REM finish top right - bounding box stops two pixels short to prevent parity faults
420 LET byb=2
430 LET byt=s/4
440 GOSUB 9000: REM bottom of right side done in similar manner
450 LET bxl=t+s/4+1
460 LET byb=byt+1
470 LET byt=s*.75
480 GOSUB 9000
490 LET bxl=t
500 LET byb=byt+1
510 LET byt=s-1
520 GOSUB 9000
530 PLOT t,s
540 DRAW s-1,0: REM missing line in right side - would have messed up during the fill cycle
550 CIRCLE OVER 1;t,s*1.5,s/2: REM remove top wide circle to clear left loop
560 CIRCLE t,s,s: REM repair big circle, done!
570 INPUT "Again? ";a$580 IF a$="y" THEN LET i=i+1: GO TO 40
590 INK 0
600 STOP

8999 REM area fill; checks along each pixel line and starts and stops PLOTting if it hits a boundary
9000 FOR y=byb TO byt
9010 LET p=0: REM parity
9020 FOR x=bxl TO bxr
9030 LET r1=POINT (x,y): REM POINT is 1 if the pixel at (x,y) is filled (INK), otherwise 0
9040 LET r2=POINT (x+1,y): REM test next point as well, in case of edges rendered as multiple pixels
9050 IF r1=1 AND r2=0 THEN LET p=p+1: IF p=2 THEN LET p=0: REM boundary check
9060 IF p=1 THEN PLOT x,y
9070 NEXT x
9080 NEXT y
9090 RETURN

Resultant image at Imgur (uses size=40 and position=40, then size=80 and position=160)

## BCPL

get "libhdr"

let circle(x, y, c, r) = (r*r) >= (x/2) * (x/2) + (y-c) * (y-c)

let pixel(x, y, r) =
circle(x, y, -r/2, r/6) -> '#',
circle(x, y, r/2, r/6)  -> '.',
circle(x, y, -r/2, r/2) -> '.',
circle(x, y, r/2, r/2)  -> '#',
circle(x, y, 0, r)      -> x<0 -> '.', '#',
' '

let yinyang(r) be
for y = -r to r
$( for x = -2*r to 2*r do wrch(pixel(x,y,r)) wrch('*N')$)

let start() be
$( yinyang(4) yinyang(8)$)
Output:
       ...
.........##
......###....##
...........####
..........#######
....###########
..####...######
..#########
###
...
.............##
...................####
............###......######
..........#######......####
..............###......########
.......................########
.....................##########
..................###############
..........#####################
........#######################
........######...##############
....######.......##########
......######...############
....###################
..#############
###        

## Befunge

Translation of: PicoLisp

The radius is specified by the first value on the stack - set to 10 (55+) in this example.

55+:#. 00p:2*10p:2/20p6/30p01v
@#!g01:+1g07,+55$<v0-g010p07_ 0g-20g+:*+30g:*v ^_:2/:*:70g0 3+*:-g02-g00g07:_ 0v v!*:g0 g-20g+:*+20g:*>v> ^ v1_:70g00 2+*:-g02-g00g07:_ 1v v!*:g0 g-:*+00g:*#v_$:0!0\v0_:70g00
0#+g#1,#$< > 2 #^>#g>#04#1+#:  Output:  ... .................## .......................#### .........................###### ................###........######## ..............#######........###### ..................###........########## .............................########## .............................########## ...........................############ ......................################### ............########################### ..........############################# ..........############################# ..........########...################## ......########.......############## ........########...################ ......######################### ....####################### ..################# ###  ## C Writes to stdout a SVG file with two yin-yangs (no, it's really just that big): #include <stdio.h> void draw_yinyang(int trans, double scale) { printf("<use xlink:href='#y' transform='translate(%d,%d) scale(%g)'/>", trans, trans, scale); } int main() { printf( "<?xml version='1.0' encoding='UTF-8' standalone='no'?>\n" "<!DOCTYPE svg PUBLIC '-//W3C//DTD SVG 1.1//EN'\n" " 'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'>\n" "<svg xmlns='http://www.w3.org/2000/svg' version='1.1'\n" " xmlns:xlink='http://www.w3.org/1999/xlink'\n" " width='30' height='30'>\n" " <defs><g id='y'>\n" " <circle cx='0' cy='0' r='200' stroke='black'\n" " fill='white' stroke-width='1'/>\n" " <path d='M0 -200 A 200 200 0 0 0 0 200\n" " 100 100 0 0 0 0 0 100 100 0 0 1 0 -200\n" " z' fill='black'/>\n" " <circle cx='0' cy='100' r='33' fill='white'/>\n" " <circle cx='0' cy='-100' r='33' fill='black'/>\n" " </g></defs>\n"); draw_yinyang(20, .05); draw_yinyang(8, .02); printf("</svg>"); return 0; }  ## C++ Translation of: Java #include <iostream> bool circle(int x, int y, int c, int r) { return (r * r) >= ((x = x / 2) * x) + ((y = y - c) * y); } char pixel(int x, int y, int r) { if (circle(x, y, -r / 2, r / 6)) { return '#'; } if (circle(x, y, r / 2, r / 6)) { return '.'; } if (circle(x, y, -r / 2, r / 2)) { return '.'; } if (circle(x, y, r / 2, r / 2)) { return '#'; } if (circle(x, y, 0, r)) { if (x < 0) { return '.'; } else { return '#'; } } return ' '; } void yinYang(int r) { for (int y = -r; y <= r; y++) { for (int x = -2 * r; x <= 2 * r; x++) { std::cout << pixel(x, y, r); } std::cout << '\n'; } } int main() { yinYang(18); return 0; }  Output:  ... .....................## .............................###### .................................###### .......................................######## ...........................................######## ..........................###................########## ........................###########............############ ........................###########............############ ........................###############............############ ............................###########............################ ............................###########............################ ................................###................################ .....................................................################## ...................................................#################### .................................................###################### ...............................................######################## .............................................########################## ......................................################################### ..........................############################################# ........................############################################### ......................################################################# ....................################################################### ..................##################################################### ................################...################################ ................############...........############################ ................############...........############################ ............############...............######################## ............############...........######################## ............############...........######################## ..........################...########################## ........########################################### ........####################################### ......################################# ......############################# ..##################### ### ## C# Translation of: Visual Basic .NET (Cleaned up)  public partial class Form1 : Form { public Form1() { InitializeComponent(); Paint += Form1_Paint; } private void Form1_Paint(object sender, PaintEventArgs e) { Graphics g = e.Graphics; g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.AntiAlias; DrawTaijitu(g, new Point(50, 50), 200, true); DrawTaijitu(g, new Point(10, 10), 60, true); } private void DrawTaijitu(Graphics g, Point pt, int width, bool hasOutline) { g.FillPie(Brushes.Black, pt.X, pt.Y, width, width, 90, 180); g.FillPie(Brushes.White, pt.X, pt.Y, width, width, 270, 180); float headSize = Convert.ToSingle(width * 0.5); float headXPosition = Convert.ToSingle(pt.X + (width * 0.25)); g.FillEllipse(Brushes.Black, headXPosition, Convert.ToSingle(pt.Y), headSize, headSize); g.FillEllipse(Brushes.White, headXPosition, Convert.ToSingle(pt.Y + (width * 0.5)), headSize, headSize); float headBlobSize = Convert.ToSingle(width * 0.125); float headBlobXPosition = Convert.ToSingle(pt.X + (width * 0.4375)); g.FillEllipse(Brushes.White, headBlobXPosition, Convert.ToSingle(pt.Y + (width * 0.1875)), headBlobSize, headBlobSize); g.FillEllipse(Brushes.Black, headBlobXPosition, Convert.ToSingle(pt.Y + (width * 0.6875)), headBlobSize, headBlobSize); if (hasOutline) g.DrawEllipse(Pens.Black, pt.X, pt.Y, width, width); } }  Output: Source Code: http://rosettacode.org/wiki/Yin_and_yang#C.23 ## CLU taijitu = cluster is make rep = null circle = proc (x,y,c,r: int) returns (bool) return (r**2 >= (x/2)**2 + (y-c)**2) end circle pixel = proc (x,y,r: int) returns (char) if circle(x,y,-r/2,r/6) then return('#') elseif circle(x,y, r/2,r/6) then return('.') elseif circle(x,y,-r/2,r/2) then return('.') elseif circle(x,y, r/2,r/2) then return('#') elseif circle(x,y, 0, r) then if x<0 then return('.') else return('#') end end return(' ') end pixel make = proc (r: int) returns (string) chars: array[char] := array[char]$predict(1, r*r*2+r)
for y: int in int$from_to(-r, r) do for x: int in int$from_to(-2*r, 2*r) do
array[char]$addh(chars, pixel(x,y,r)) end array[char]$addh(chars, '\n')
end
return (string$ac2s(chars)) end make end taijitu start_up = proc () po: stream := stream$primary_output()
stream$putl(po, taijitu$make(4))
stream$putl(po, taijitu$make(8))
end start_up
Output:
        ..
........##
......##....##
..........####
..........#######
....##########
..####..######
..########
##

..
............##
..................####
............##......######
..........######......####
..............##......########
......................########
....................##########
..................###############
..........####################
........######################
........######..##############
....######......##########
......######..############
....##################
..############
##

## D

Translation of: Python
import std.stdio, std.algorithm, std.array, std.math, std.range,
std.conv, std.typecons;

string yinYang(in int n) pure /*nothrow @safe*/ {
enum : char { empty = ' ', white = '.', black = '#' }

const radii = [1, 3, 6].map!(i => i * n).array;
auto ranges = radii.map!(r => iota(-r, r + 1).array).array;
alias V = Tuple!(int,"x", int,"y");
V[][] squares, circles;
squares = ranges.map!(r => cartesianProduct(r, r).map!V.array).array;

circles ~= sqrPoints.filter!(p => p[].hypot <= radius).array;
auto m = squares[$- 1].zip(empty.repeat).assocArray; foreach (immutable p; circles[$ - 1])
m[p] = black;
foreach (immutable p; circles[$- 1]) if (p.x > 0) m[p] = white; foreach (immutable p; circles[$ - 2]) {
m[V(p.x, p.y + 3 * n)] = black;
m[V(p.x, p.y - 3 * n)] = white;
}
foreach (immutable p; circles[$- 3]) { m[V(p.x, p.y + 3 * n)] = white; m[V(p.x, p.y - 3 * n)] = black; } return ranges[$ - 1]
.map!(y => ranges[- 1].retro.map!(x => m[V(x, y)]).text) .join('\n'); } void main() { 2.yinYang.writeln; 1.yinYang.writeln; }  Output:  . ........# ...........## .............## ........#.....### ........###....#### ........#####....#### .........###....##### ...........#.....###### .................###### ................####### ...............######## .............############ ........############### .......################ ......################# ......#####.########### .....####...######### ....####.....######## ....####...######## ...#####.######## ..############# ..########### .######## # . ......# ....#..## ....###..## .....#..### ........### .......###### ...######## ...##.##### ..##...#### ..##.#### .###### #  A simpler alternative version: Translation of: PicoLisp void yinYang(in int r) { import std.stdio, std.math; foreach (immutable y; -r .. r + 1) { foreach (immutable x; -2 * r .. 2 * r + 1) { enum circle = (in int c, in int r) pure nothrow @safe @nogc => r ^^ 2 >= (x / 2) ^^ 2 + (y - c) ^^ 2; write(circle(-r / 2, r / 6) ? '#' : circle( r / 2, r / 6) ? '.' : circle(-r / 2, r / 2) ? '.' : circle( r / 2, r / 2) ? '#' : circle( 0, r ) ? "#."[x < 0] : ' '); } writeln; } } void main() { 16.yinYang; }  Output:  ... ...................#### ...........................#### .................................###### ...................................######## .......................................######## ........................###..............########## ........................#######............############ ......................###########............########## ..........................#######............############## ............................###..............############## ...............................................################ .............................................################## .............................................################## ...........................................#################### .......................................######################## ..................................############################### ........................####################################### ....................########################################### ..................############################################# ..................############################################# ................############################################### ..............##############...############################ ..............############.......########################## ..........############...........###################### ............############.......######################## ..........##############...######################## ........####################################### ........################################### ......################################# ....########################### ....################### ###  ## EasyLang proc circ r c . . color c circle r . proc yinyang x y r . . move x y circ 2 * r 000 color 999 circseg 2 * r 90 -90 move x y - r circ r 000 circ r / 3 999 move x y + r circ r 999 circ r / 3 000 . background 555 clear yinyang 20 20 6 yinyang 50 60 14 Output: ## Evaldraw ### (x,y,r,g,b) 2D graphing mode Translation of: xpl0 Inspired by the xpl0 solution. First out is the implicit 2D function mode. (x,y,&r,&g,&b) { r=255; g=0; b=0; // Notice rad is radius square YinYang(x-8,y+8,7,r,g,b); YinYang(x-25,y+24,15,r,g,b); }//main YinYang(x,y,rad,&r,&g,&b) { circ0 = Circle(x, y, rad); circ1 = Circle(x, y-rad/2, rad/2); circ2 = Circle(x, y-rad/2, rad/6); circ3 = Circle(x, y+rad/2, rad/2); circ4 = Circle(x, y+rad/2, rad/6); if (circ0 <= rad) { if (x<0) { r=g=b=255; } else {r=g=b=0; } } if (circ1 <= rad/6) { r=g=b=255; } if (circ2 <= rad/6) { r=g=b=0; } if (circ3 <= rad/2) { r=g=b=0; } if (circ4 <= rad/6) { r=g=b=255; } } Circle(x,y,r) { return (x^2+y^2)-r^2 }  ### General program mode Translation of: xpl0 Another solution is to use the general () program mode. () { cls(0x646464); YinYang(80, 80, 70); YinYang(240, 240, 150); } circle(x0, y0, r, col_left, col_right) { for(y=-r; y<r; y++) for(x=-r; x<r; x++) { if (x^2 + y^2 <= r^2) { if (x<0) setcol(col_left); else setcol(col_right); setpix(x+x0, y+y0); } } } YinYang(x0, y0, r) { white = rgb(255,255,255); black = 0; circle(x0, y0, r, white, black); circle(x0, y0-r/2, r/2, white, white); circle(x0, y0-r/2, r/6, black, black); circle(x0, y0+r/2, r/2, black, black); circle(x0, y0+r/2, r/6, white, white); }  ## Dart ### Text /* Imports and Exports */ import 'dart:io'; /* Main Block */ int main() { yinYang(18); return 0; } /* Function Definitions */ bool circle(int x, int y, int c, int r) { return (r * r) >= ((x = x ~/ 2) * x) + ((y = y - c) * y); } String pixel(int x, int y, int r) { if (circle(x, y, -r ~/ 2, r ~/ 6)) { return '#'; } if (circle(x, y, r ~/ 2, r ~/ 6)) { return '.'; } if (circle(x, y, -r ~/ 2, r ~/ 2)) { return '.'; } if (circle(x, y, r ~/ 2, r ~/ 2)) { return '#'; } if (circle(x, y, 0, r)) { if (x < 0) { return '.'; } else { return '#'; } } return ' '; } void yinYang(int r) { for (int y = -r; y <= r; y++) { for (int x = -2 * r; x <= 2 * r; x++) { stdout.write(pixel(x, y, r)); } stdout.write('\n'); } }  Output:  ... .....................## .............................###### .................................###### .......................................######## ...........................................######## ..........................###................########## ........................###########............############ ........................###########............############ ........................###############............############ ............................###########............################ ............................###########............################ ................................###................################ .....................................................################## ...................................................#################### .................................................###################### ...............................................######################## .............................................########################## ......................................################################### ..........................############################################# ........................############################################### ......................################################################# ....................################################################### ..................##################################################### ................################...################################ ................############...........############################ ................############...........############################ ............############...............######################## ............############...........######################## ............############...........######################## ..........################...########################## ........########################################### ........####################################### ......################################# ......############################# ..##################### ###  ### Flutter import 'dart:math' show pi; import 'package:flutter/material.dart'; Path yinYang(double r, double x, double y, [double th = 1.0]) { cR(double dY, double radius) => Rect.fromCircle(center: Offset(x, y + dY), radius: radius); return Path() ..fillType = PathFillType.evenOdd ..addOval(cR(0, r + th)) ..addOval(cR(r / 2, r / 6)) ..addOval(cR(-r / 2, r / 6)) ..addArc(cR(0, r), -pi / 2, -pi) ..addArc(cR(r / 2, r / 2), pi / 2, pi) ..addArc(cR(-r / 2, r / 2), pi / 2, -pi); } void main() => runApp(CustomPaint(painter: YinYangPainter())); class YinYangPainter extends CustomPainter { @override void paint(Canvas canvas, Size size) { final fill = Paint()..style = PaintingStyle.fill; canvas ..drawColor(Colors.white, BlendMode.src) ..drawPath(yinYang(50.0, 60, 60), fill) ..drawPath(yinYang(20.0, 140, 30), fill); } @override bool shouldRepaint(CustomPainter oldDelegate) => true; }  ### Flutter (without CustomPaint) import 'package:flutter/material.dart'; const color = [Colors.black, Colors.white]; Widget cR(int iColor, double r, {Widget? child}) => DecoratedBox( decoration: BoxDecoration(color: color[iColor], shape: BoxShape.circle), child: SizedBox.square(dimension: r * 2, child: Center(child: child))); Widget yinYang(double r, [double th = 1.0]) => Padding( padding: const EdgeInsets.all(5), child: ClipOval( child: cR(0, r + th, child: cR(1, r, child: Stack(alignment: Alignment.center, children: [ Container(color: color[0], margin: EdgeInsets.only(left: r)), Column(children: List.generate(2, (i) => cR(1 - i, r / 2, child: cR(i, r / 6)))) ]))))); void main() => runApp(MaterialApp( home: ColoredBox(color: color[1], child: Wrap(children: [yinYang(50), yinYang(20)]))));  ## Delphi Works with: Delphi version 6.0 procedure DrawCircle(Canvas: TCanvas; Center: TPoint; Radius: integer); {Draw circle at specified center and size (Radius)} var R: TRect; begin R.TopLeft:=Center; R.BottomRight:=Center; InflateRect(R,Radius,Radius); Canvas.Ellipse(R); end; procedure DrawYinYang(Canvas: TCanvas; Center: TPoint; Radius: integer); {Draw Yin-Yang symbol at specified center and size (Radius)} var X1,Y1,X2,Y2,X3,Y3,X4,Y4: integer; var R2,R6: integer; begin R2:=Radius div 2; R6:=Radius div 6; Canvas.Pen.Width:=3; {Draw outer circle} DrawCircle(Canvas,Center,Radius); {Draw bottom half circle} X1:=Center.X - R2; Y1:=Center.Y; X2:=Center.X + R2; Y2:=Center.Y + Radius; X3:=Center.X; Y3:=Center.Y; X4:=Center.X; Y4:=Center.Y + Radius; Canvas.Arc(X1,Y1, X2,Y2, X3,Y3, X4, Y4); {Draw top half circle} X1:=Center.X - R2; Y1:=Center.Y; X2:=Center.X + R2; Y2:=Center.Y - Radius; X3:=Center.X; Y3:=Center.Y; X4:=Center.X; Y4:=Center.Y- Radius; Canvas.Arc(X1,Y1, X2,Y2, X3,Y3, X4, Y4); {Fill right half with black} Canvas.Brush.Color:=clBlack; Canvas.FloodFill(Center.X,Center.Y+5,clWhite, fsSurface); {Draw top small circle} DrawCircle(Canvas, Point(Center.X, Center.Y-R2), R6); {Draw bottom small circle} Canvas.Brush.Color:=clWhite; DrawCircle(Canvas, Point(Center.X, Center.Y+R2), R6); end; procedure ShowYinYang(Image: TImage); begin DrawYinYang(Image.Canvas,Point(75,75),50); DrawYinYang(Image.Canvas,Point(200,200),100); Image.Invalidate; end;  Output:  Elapsed Time: 0.595 ms.  ## Draco proc circle(int x, c, y, r) bool: r*r >= (x/2)*(x/2) + (y-c)*(y-c) corp proc pixel(int x, y, r) char: if circle(x, y, -r/2, r/6) then '\#' elif circle(x, y, r/2, r/6) then '.' elif circle(x, y, -r/2, r/2) then '.' elif circle(x, y, r/2, r/2) then '\#' elif circle(x, y, 0, r) then if x<0 then '.' else '\#' fi else ' ' fi corp proc yinyang(int r) void: int x, y; for y from -r upto r do for x from -2*r upto 2*r do write(pixel(x, y, r)) od; writeln() od corp proc main() void: yinyang(4); yinyang(8) corp Output:  ... .........## ......###....## ...........#### ..........####### ....########### ..####...###### ..######### ### ... .............## ...................#### ............###......###### ..........#######......#### ..............###......######## .......................######## .....................########## ..................############### ..........##################### ........####################### ........######...############## ....######.......########## ......######...############ ....################### ..############# ### ## DWScript Translation of: D type TColorFuncX = function (x : Integer) : Integer; type TSquareBoard = class Scale : Integer; Pix : array of array of Integer; constructor Create(aScale : Integer); begin Scale := aScale; Pix := new Integer[aScale*12+1, aScale*12+1]; end; method Print; begin var i, j : Integer; for i:=0 to Pix.High do begin for j:=0 to Pix.High do begin case Pix[j, i] of 1 : Print('.'); 2 : Print('#'); else Print(' '); end; end; PrintLn(''); end; end; method DrawCircle(cx, cy, cr : Integer; color : TColorFuncX); begin var rr := Sqr(cr*Scale); var x, y : Integer; for x := 0 to Pix.High do begin for y := 0 to Pix.High do begin if Sqr(x-cx*Scale)+Sqr(y-cy*Scale)<=rr then Pix[x, y] := color(x); end; end; end; method ColorHalf(x : Integer) : Integer; begin if (x<6*Scale) then Result:=1 else Result:=2; end; method ColorYin(x : Integer) : Integer; begin Result:=2; end; method ColorYang(x : Integer) : Integer; begin Result:=1; end; method YinYang; begin DrawCircle(6, 6, 6, ColorHalf); DrawCircle(6, 3, 3, ColorYang); DrawCircle(6, 9, 3, ColorYin); DrawCircle(6, 9, 1, ColorYang); DrawCircle(6, 3, 1, ColorYin); end; end; var sq := new TSquareBoard(2); sq.YinYang; sq.Print; sq := new TSquareBoard(1); sq.YinYang; sq.Print;  Output:  . ........# ...........## .............## ........#.....### ........###....#### ........#####....#### .........###....##### ...........#.....###### .................###### ................####### ...............######## ............############# ........############### .......################ ......################# ......#####.########### .....####...######### ....####.....######## ....####...######## ...#####.######## ..############# ..########### .######## # . ......# ....#..## ....###..## .....#..### ........### ......####### ...######## ...##.##### ..##...#### ..##.#### .###### #  ## 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. In this page you can see and run the program(s) related to this task and their results. You can also change either the programs or the parameters they are called with, for experimentation, but remember that these programs were created with the main purpose of showing a clear solution of the task, and they generally lack any kind of validation. Solution Test cases ## Forth Translation of: C++ Works with: gforth version 0.7.3 : circle ( x y r h -- f ) rot - dup * rot dup * + swap dup * swap < invert ; : pixel ( r x y -- r c ) 2dup 4 pick 6 / 5 pick 2 / negate circle if 2drop '#' exit then 2dup 4 pick 6 / 5 pick 2 / circle if 2drop '.' exit then 2dup 4 pick 2 / 5 pick 2 / negate circle if 2drop '.' exit then 2dup 4 pick 2 / 5 pick 2 / circle if 2drop '#' exit then 2dup 4 pick 0 circle if drop 0< if '.' exit else '#' exit then then 2drop bl ; : yinyang ( r -- ) dup dup 1+ swap -1 * do cr dup dup 2 * 1+ swap -2 * do I 2 / J pixel emit loop loop drop ;  Output: 8 yinyang .. ............## ..................#### ............##......###### ..........######......#### ..............##......######## ......................######## ....................########## ..................############### ..........#################### ........###################### ........######..############## ....######......########## ......######..############ ....################## ..############ ## ok Works with: 4tH v3.64 4tH has a graphics library, which makes it quite easy to generate this picture using graphics commands only. [PRAGMA] usestackflood \ don't use additional memory for fill include lib/graphics.4th \ load the graphics library include lib/gcircle.4th \ we need a full circle include lib/garccirc.4th \ we need a partial circle include lib/gflood.4th \ we need a flood fill 600 pic_width ! 600 pic_height ! \ set canvas size color_image 255 whiteout black \ paint black on white 300 300 296 circle \ make the large circle 152 300 49 circle \ make the top small circle 448 300 49 circle \ make the bottom small circle 152 300 149 -15708 31416 arccircle \ create top teardrop 448 300 148 15708 31416 arccircle \ create bottom teardrop 150 300 flood \ fill the top small circle 500 300 flood \ fill the bottom teardrop 300 300 295 circle \ let's make it a double line width s" gyinyang.ppm" save_image \ save the image  ## FutureBasic _window = 1 begin enum output 1 _imageView1 _imageView2 end enum local fn YinYangImage( size as float ) as ImageRef CFDictionaryRef attributes = @{NSFontAttributeName:fn FontWithName( @"Menlo", size ), NSBackgroundColorAttributeName:fn ColorClear} CFMutableAttributedStringRef aString = fn MutableAttributedStringWithAttributes( @"\u262F", attributes ) ImageRef image = fn ImageWithSize( fn AttributedStringSize( aString ) ) ImageLockFocus( image ) GraphicsContextSaveGraphicsState AttributedStringDrawAtPoint( aString, fn CGPointMake( 0, 0 ) ) GraphicsContextRestoreGraphicsState ImageUnlockFocus( image ) end fn = image void local fn BuildWindow CGRect r = fn CGRectMake( 0, 0, 300, 200 ) window _window, @"Rosetta Code Yin and Yang", r, NSWindowStyleMaskTitled + NSWindowStyleMaskClosable + NSWindowStyleMaskMiniaturizable WindowSetBackgroundColor( _window, fn ColorWhite ) ImageRef yinyang = fn YinYangImage( 250.0 ) r = fn CGRectMake( 20, 10, 170, 180 ) imageview _imageView1, YES, yinyang, r, NSImageScaleNone, NSImageAlignCenter, NSImageFrameNone, _window r = fn CGRectMake( 190, 90, 100, 100 ) imageview _imageView2, YES, yinyang, r, NSImageScaleProportionallyDown, NSImageAlignCenter, NSImageFrameNone, _window end fn void local fn DoDialog( ev as long, tag as long, wnd as long ) select ( ev ) case _windowWillClose : end end select end fn on dialog fn DoDialog fn BuildWindow HandleEvents Output: ## Go There are some emerging third-party 2D graphics libraries for Go; meanwhile, here is an SVG solution using only standard libraries. package main import ( "fmt" "os" "text/template" ) var tmpl = <?xml version="1.0"?> <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="210" height="150"> <symbol id="yy" viewBox="0 0 200 200"> <circle stroke="black" stroke-width="2" fill="white" cx="100" cy="100" r="99" /> <path fill="black" d="M100 100 a49 49 0 0 0 0 -98 v-1 a99 99 0 0 1 0 198 v-1 a49 49 0 0 1 0 -98" /> <circle fill="black" cx="100" cy="51" r="17" /> <circle fill="white" cx="100" cy="149" r="17" /> </symbol> {{range .}}<use xlink:href="#yy" x="{{.X}}" y="{{.Y}}" width="{{.Sz}}" height="{{.Sz}}"/> {{end}}</svg>  // structure specifies position and size to draw symbol type xysz struct { X, Y, Sz int } // example data to specify drawing the symbol twice, // with different position and size. var yys = []xysz{ {20, 20, 100}, {140, 30, 60}, } func main() { xt := template.New("") template.Must(xt.Parse(tmpl)) f, err := os.Create("yy.svg") if err != nil { fmt.Println(err) return } if err := xt.Execute(f, yys); err != nil { fmt.Println(err) } f.Close() }  ## Haskell This program uses the diagrams package to produce the Yin and Yang image. The package implements an embedded DSL for producing vector graphics. Depending on the command-line arguments, the program can generate SVG, PNG, PDF or PostScript output. The sample output was created with the command yinyang -o YinYang-Haskell.svg. {-# LANGUAGE NoMonomorphismRestriction #-} import Diagrams.Prelude import Diagrams.Backend.Cairo.CmdLine yinyang = lw 0
perim # lw 0.003 <>
torus white black # xform id <>
torus black white # xform negate <>
clipBy perim base
where perim      = arc 0 (360 :: Deg) # scale (1/2)
torus c c' = circle (1/3) # fc c' <> circle 1 # fc c
xform f    = translateY (f (1/4)) . scale (1/4)
base       = rect (1/2) 1 # fc white ||| rect (1/2) 1 # fc black

main = defaultMain $pad 1.1$
beside (2,-1) yinyang (yinyang # scale (1/4))


## Icon and Unicon

link graphics

procedure main()
YinYang(100)
YinYang(40,"blue","yellow","white")
WDone()  # quit on Q/q
end

procedure YinYang(R,lhs,rhs,bg)   # draw YinYang with radius of R pixels and ...
/lhs := "white"                   # left hand side
/rhs := "black"                   # right hand side
/bg  := "grey"                    # background

wsize  := 2*(C := R + (margin := R/5))

W := WOpen("size="||wsize||","||wsize,"bg="||bg) | stop("Unable to open Window")
WAttrib(W,"fg="||lhs) & FillCircle(W,C,C,R,+dtor(90),dtor(180))        # main halves
WAttrib(W,"fg="||rhs) & FillCircle(W,C,C,R,-dtor(90),dtor(180))
WAttrib(W,"fg="||lhs) & FillCircle(W,C,C+R/2,R/2,-dtor(90),dtor(180))  # sub halves
WAttrib(W,"fg="||rhs) & FillCircle(W,C,C-R/2,R/2,dtor(90),dtor(180))
WAttrib(W,"fg="||lhs) & FillCircle(W,C,C-R/2,R/8)                      # dots
WAttrib(W,"fg="||rhs) & FillCircle(W,C,C+R/2,R/8)
end


## J

Based on the Python implementation:

yinyang=:3 :0
squares=. ,"0/~each ranges
circles=. radii ([ >: +/"1&.:*:@])each squares
cInds=. ({:radii) +each circles #&(,/)each squares

M=. ' *.' {~  circles (*  1 + 0 >: {:"1)&(_1&{::) squares
offset=. 3*y,0
M=. '*' ((_2 {:: cInds) <@:+"1 offset)} M
M=. '.' ((_2 {:: cInds) <@:-"1 offset)} M
M=. '.' ((_3 {:: cInds) <@:+"1 offset)} M
M=. '*' ((_3 {:: cInds) <@:-"1 offset)} M
)


Note: although the structure of this program is based on the python implementation, some details are different. In particular, in the python implementation, the elements of squares and circles have no x,y structure -- they are flat list of coordinates.

Here, the three squares are each 3 dimensional arrays. The first two dimensions correspond to the x and y values and the last dimension is 2 (the first value being the y coordinate and the second being the x coordinate -- having the dimensions as y,x pairs like this works because in J the first dimension of a matrix is the number of rows and the second dimension is the number of columns).

Also, the three elements in the variable circles are represented by 2 dimensional arrays. The dimensions correspond to x and y values and the values are bits -- 1 if the corresponding coordinate pair in squares is a member of the circle and 0 if not.

Finally, the variable cInds corresponds very closely to the variable circles in the python code. Except, instead of having y and x values, cInds has indices into M. In other words, I added the last value from radii to the y and x values. In other words, instead of having values in the range -18..18, I would have values in the range 0..36 (but replace 18 and 36 with whatever values are appropriate).

Example use:

   yinyang 1
.
......*
....*..**
....***..**
.....*..***
........***
.......******
...********
...**.*****
..**...****
..**.****
.******
*
yinyang 2
.
........*
...........**
.............**
........*.....***
........***....****
........*****....****
.........***....*****
...........*.....******
.................******
................*******
...............********
.............************
........***************
.......****************
......*****************
......*****.***********
.....****...*********
....****.....********
....****...********
...*****.********
..*************
..***********
.********
*


## Java

### Graphical

This example shows how to draw using the built in graphics context of Java.

package org.rosettacode.yinandyang;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.image.BufferedImage;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;

public class YinYangGenerator
{
private final int size;

public YinYangGenerator(final int size)
{
this.size = size;
}

/**
*  Draw a yin yang symbol on the given graphics context.
*/
public void drawYinYang(final Graphics graphics)
{
// Preserve the color for the caller
final Color colorSave = graphics.getColor();

graphics.setColor(Color.WHITE);
// Use fillOval to draw a filled in circle
graphics.fillOval(0, 0, size-1, size-1);

graphics.setColor(Color.BLACK);
// Use fillArc to draw part of a filled in circle
graphics.fillArc(0, 0, size-1, size-1, 270, 180);
graphics.fillOval(size/4, size/2, size/2, size/2);

graphics.setColor(Color.WHITE);
graphics.fillOval(size/4, 0, size/2, size/2);
graphics.fillOval(7*size/16, 11*size/16, size/8, size/8);

graphics.setColor(Color.BLACK);
graphics.fillOval(7*size/16, 3*size/16, size/8, size/8);
// Use drawOval to draw an empty circle for the outside border
graphics.drawOval(0, 0, size-1, size-1);

// Restore the color for the caller
graphics.setColor(colorSave);
}

/**
*  Create an image containing a yin yang symbol.
*/
public Image createImage(final Color bg)
{
// A BufferedImage creates the image in memory
final BufferedImage image = new BufferedImage(size, size, BufferedImage.TYPE_INT_RGB);
// Get the graphics object for the image; note in many
// applications you actually use Graphics2D for the
final Graphics graphics = image.getGraphics();
// Color in the background of the image
graphics.setColor(bg);
graphics.fillRect(0,0,size,size);
drawYinYang(graphics);
return image;
}

public static void main(final String args[])
{
final int size = Integer.parseInt(args[0]);
final YinYangGenerator generator = new YinYangGenerator(size);

final JFrame frame = new JFrame("Yin Yang Generator");
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
final Image yinYang = generator.createImage(frame.getBackground());
// Use JLabel to display an image
frame.pack();
frame.setVisible(true);
}
}


### Text

Translation of: PicoLisp
Works with: Java version 1.8
import java.util.Collection;
import java.util.Map;
import java.util.Optional;
import java.util.function.BooleanSupplier;
import java.util.function.Supplier;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import static java.util.Collections.singletonMap;

public interface YinYang {
public static boolean circle(
int x,
int y,
int c,
int r
) {
return
(r * r) >=
((x = x / 2) * x)
+ ((y = y - c) * y)
;
}

public static String pixel(int x, int y, int r) {
return Stream.<Map<BooleanSupplier, Supplier<String>>>of(
singletonMap(
() -> circle(x, y, -r / 2, r / 6),
() -> "#"
),
singletonMap(
() -> circle(x, y, r / 2, r / 6),
() -> "."
),
singletonMap(
() -> circle(x, y, -r / 2, r / 2),
() -> "."
),
singletonMap(
() -> circle(x, y, r / 2, r / 2),
() -> "#"
),
singletonMap(
() -> circle(x, y, 0, r),
() -> x < 0 ? "." : "#"
)
)
.sequential()
.map(Map::entrySet)
.flatMap(Collection::stream)
.filter(e -> e.getKey().getAsBoolean())
.map(Map.Entry::getValue)
.map(Supplier::get)
.findAny()
.orElse(" ")
;
}

public static void yinYang(int r) {
IntStream.rangeClosed(-r, r)
.mapToObj(
y ->
IntStream.rangeClosed(
0 - r - r,
r + r
)
.mapToObj(x -> pixel(x, y, r))
.reduce("", String::concat)
)
.forEach(System.out::println)
;
}

public static void main(String... arguments) {
Optional.of(arguments)
.filter(a -> a.length == 1)
.map(a -> a[0])
.map(Integer::parseInt)
.ifPresent(YinYang::yinYang)
;
}
}


Test:

> java YinYang 18
...
.....................##
.............................######
.................................######
.......................................########
...........................................########
..........................###................##########
........................###########............############
........................###########............############
........................###############............############
............................###########............################
............................###########............################
................................###................################
.....................................................##################
...................................................####################
.................................................######################
...............................................########################
.............................................##########################
......................................###################################
..........................#############################################
........................###############################################
......................#################################################
....................###################################################
..................#####################################################
................################...################################
................############...........############################
................############...........############################
............############...............########################
............############...........########################
............############...........########################
..........################...##########################
........###########################################
........#######################################
......#################################
......#############################
..#####################
###


## JavaScript

Another way, a more JavaScript-style way.

function Arc(posX,posY,radius,startAngle,endAngle,color){//Angle in radians.
this.posX=posX;
this.posY=posY;
this.startAngle=startAngle;
this.endAngle=endAngle;
this.color=color;
}
//0,0 is the top left of the screen
var YingYang=[
new Arc(0.5,0.5,1,0.5*Math.PI,1.5*Math.PI,"white"),//Half white semi-circle
new Arc(0.5,0.5,1,1.5*Math.PI,0.5*Math.PI,"black"),//Half black semi-circle
new Arc(0.5,0.25,.5,0,2*Math.PI,"black"),//black circle
new Arc(0.5,0.75,.5,0,2*Math.PI,"white"),//white circle
new Arc(0.5,0.25,1/6,0,2*Math.PI,"white"),//small white circle
new Arc(0.5,0.75,1/6,0,2*Math.PI,"black")//small black circle
]
//Ying Yang is DONE!
//Now we'll have to draw it.
//We'll draw it in a matrix that way we can get results graphically or by text!
function Array2D(width,height){
this.height=height;
this.width=width;
this.array2d=[];
for(var i=0;i<this.height;i++){
this.array2d.push(new Array(this.width));
}
}
Array2D.prototype.resize=function(width,height){//This is expensive
//nheight and nwidth is the difference of the new and old height
var nheight=height-this.height,nwidth=width-this.width;
if(nwidth>0){
for(var i=0;i<this.height;i++){
if(i<height)
Array.prototype.push.apply(this.array2d[i],new Array(nwidth));
}
}
else if(nwidth<0){
for(var i=0;i<this.height;i++){
if(i<height)
this.array2d[i].splice(width,nwidth);
}
}
if(nheight>0){
Array.prototype.push.apply(this.array2d,new Array(width));
}
else if(nheight<0){
this.array2d.splice(height,nheight)
}
}
Array2D.prototype.loop=function(callback){
for(var i=0;i<this.height;i++)
for(var i2=0;i2<this.width;i++)
callback.call(this,this.array2d[i][i2],i,i2);

}
var mat=new Array2D(100,100);//this sounds fine;
YingYang[0];
//In construction.


### Text

Translation of: ALGOL 68
YinYang = (function () {
var scale_x = 2,
scale_y = 1,
black = "#",
white = ".",
clear = " ",
out = "";

function inCircle(centre_x, centre_y, radius, x, y) {
return Math.pow(x - centre_x, 2) + Math.pow(y - centre_y, 2) <= Math.pow(radius, 2)
}
var bigCircle = function (x, y) {
return inCircle(0, 0, radius, x, y)
}, whiteSemiCircle = function (x, y) {
}, smallBlackCircle = function (x, y) {
}, blackSemiCircle = function (x, y) {
}, smallWhiteCircle = function (x, y) {
};
i = 0
for (var sy = Math.round(radius * scale_y); sy >= -Math.round(radius * scale_y); sy--) {
//console.log(sy)
for (var sx = -Math.round(radius * scale_x); sx <= Math.round(radius * scale_x); sx++) {

var x = sx / scale_x,
y = sy / scale_y;
//out+=sx
//console.log(sx,bigCircle(x,y))
if (bigCircle(x, y)) {
//out+="";
if (whiteSemiCircle(x, y)) {
//console.log(x,y)
if (smallBlackCircle(x, y)) {
out += black
} else {
out += white
}
} else if (blackSemiCircle(x, y)) {
if (smallWhiteCircle(x, y)) {
out += white
} else {
out += black
}
} else if (x < 0) {
out += white
} else {
out += black
}

} else {
out += clear;
}

}
out += "\n";
}
return out;
}
return draw
})()
console.log(YinYang(17))
console.log(YinYang(8))


### SVG

JavaScript is amazing in this case for the reason that it can be embedded in SVG itself! This is a SVG embedded in a HTML document; it can be isolated from the HTML document too, making it a standalone SVG

<!DOCTYPE html>
<html>

<body>
<svg
id="svg"
xmlns="http://www.w3.org/2000/svg"
version="1.1"
width="100%"
height="100%">
</svg>
<script>
function makeElem(elemName, attribs) { //atribs must be an Object
var e = document.createElementNS("http://www.w3.org/2000/svg", elemName),
a, b, d = attribs.style;
for (a in attribs) {
if (attribs.hasOwnProperty(a)) {

if (a == 'style') {
for (b in d) {
if (d.hasOwnProperty(b)) {
e.style[b] = d[b];
}
}
continue;
}
e.setAttributeNS(null, a, attribs[a]);
}
}
return e;
}
var svg = document.getElementById("svg");

function drawYingYang(n, x, y) {
var d = n / 10;
h = d * 5, q = h / 2, t = q * 3;
//A white circle, for the bulk of the left-hand part
svg.appendChild(makeElem("circle", {
cx: h,
cy: h,
r: h,
fill: "white"
}));
//A black semicircle, for the bulk of the right-hand part
svg.appendChild(makeElem("path", {
d: "M " + (h + x) + "," + y + " A " + q + "," + q + " -" + d * 3 + " 0,1 " + (h + x) + "," + (n + y) + " z",
fill: "black"
}));
//Circles to extend each part
svg.appendChild(makeElem("circle", {
cx: h + x,
cy: q + y,
r: q,
fill: "white"
}));
svg.appendChild(makeElem("circle", {
cx: h + x,
cy: t + y,
r: q,
fill: "black"
}));
//The spots
svg.appendChild(makeElem("circle", {
cx: h + x,
cy: q + y,
r: d,
fill: "black"
}));
svg.appendChild(makeElem("circle", {
cx: h + x,
cy: t + y,
r: q,
fill: "black"
}));
svg.appendChild(makeElem("circle", {
cx: h + x,
cy: t + y,
r: d,
fill: "white"
}));
//An outline for the whole shape
svg.appendChild(makeElem("circle", {
cx: h + x,
cy: h + y,
r: h,
fill: "none",
stroke: "gray",
"stroke-width": d / 3
}));
if (svg.height.baseVal.valueInSpecifiedUnits < n) {
svg.setAttributeNS(null, "height", y * 1.25 + n + "px")
}
//svg.appendChild(makeElem("circle",{cx:"100", cy:h, r:"40", stroke:"black", "stroke-width":"2", fill:"red"}))
}
drawYingYang(100, 30, 30);
drawYingYang(1000, 200, 200);
</script>
</body>

</html>


### SVG (path evenodd)

Run this script from the browser console (F12) or from the <script> tag in the body of the html document.

function svgEl(tagName, attrs) {
const el = document.createElementNS('http://www.w3.org/2000/svg', tagName);
for (const key in attrs) el.setAttribute(key, attrs[key]);
return el;
}

function yinYang(r, x, y, th = 1) {
const cR = (dY, rad) => M${x},${y + dY + rad} a${rad},${rad},0,1,1,.1,0z ;
const arc = (dY, rad, cw = 1) => A${rad},${rad},0,0,${cw},${x},${y + dY} ; const d = cR(0, r + th) + cR(r / 2, r / 6) + cR(-r / 2, r / 6) + M${x},${y}  + arc(r, r / 2, 0) + arc(-r, r) + arc(0, r / 2); return svgEl('path', {d, 'fill-rule': 'evenodd'}); } const dialog = document.body.appendChild(document.createElement('dialog')); const svg = dialog.appendChild(svgEl('svg', {width: 170, height: 120})); svg.appendChild(yinYang(50.0, 60, 60)); svg.appendChild(yinYang(20.0, 140, 30)); dialog.showModal();  ### Canvas Translation of: Flutter Run this script from the browser console (F12) or from the <script> tag of an html document. function yinYang(r, x, y, th = 1) { const PI = Math.PI; const path = new Path2D(); const cR = (dY, radius) => { path.arc(x, y + dY, radius, 0, PI * 2); path.closePath() }; cR(0, r + th); cR(r / 2, r / 6); cR(-r / 2, r / 6); path.arc(x, y, r, PI / 2, -PI / 2); path.arc(x, y - r / 2, r / 2, -PI / 2, PI / 2); path.arc(x, y + r / 2, r / 2, -PI / 2, PI / 2, true); return path; } document.documentElement.innerHTML = '<canvas width="170" height="120"/>'; const canvasCtx = document.querySelector('canvas').getContext('2d'); canvasCtx.fill(yinYang(50.0, 60, 60), 'evenodd'); canvasCtx.fill(yinYang(20.0, 140, 30), 'evenodd');  ## jq Works with: jq version 1.4 The jq program presented here is adapted from the C version and produces the same image: def svg: "<svg width='100%' height='100%' version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink'>" ; def draw_yinyang(x; scale): "<use xlink:href='#y' transform='translate(\(x),\(x)) scale(\(scale))'/>"; def define_yinyang: "<defs> <g id='y'> <circle cx='0' cy='0' r='200' stroke='black' fill='white' stroke-width='1'/> <path d='M0 -200 A 200 200 0 0 0 0 200 100 100 0 0 0 0 0 100 100 0 0 1 0 -200 z' fill='black'/> <circle cx='0' cy='100' r='33' fill='white'/> <circle cx='0' cy='-100' r='33' fill='black'/> </g> </defs>" ; def draw: svg, define_yinyang, draw_yinyang(20; .05), draw_yinyang(8 ; .02), "</svg>" ; draw To view the image, store the output in a file: $ jq -M -r -n -f yin_and_yang.jq > yin_and_yang.svg


The image can then be viewed in a browser.

## Julia

Works with: Julia version 0.6
Translation of: Python
function yinyang(n::Int=3)
radii   = (i * n for i in (1, 3, 6))
ranges  = collect(collect(-r:r) for r in radii)
squares = collect(collect((x, y) for x in rnge, y in rnge) for rnge in ranges)
circles = collect(collect((x, y) for (x,y) in sqrpoints if hypot(x, y) ≤ radius)
m = Dict((x, y) => ' ' for (x, y) in squares[end])
for (x, y) in circles[end] m[(x, y)] = x > 0 ? '·' : '*' end
for (x, y) in circles[end-1]
m[(x, y + 3n)] = '*'
m[(x, y - 3n)] = '·'
end
for (x, y) in circles[end-2]
m[(x, y + 3n)] = '·'
m[(x, y - 3n)] = '*'
end
return join((join(m[(x, y)]  for x in reverse(ranges[end])) for y in ranges[end]), '\n')
end

println(yinyang(4))


## Kotlin

This is based on the Java entry but I've adjusted the code so that the program displays big and small yin-yangs of a predetermined size in the same frame. Consequently, the program only needs to be run once and doesn't require a command line argument.

// version 1.1.2

import java.awt.Color
import java.awt.Graphics
import java.awt.Image
import java.awt.image.BufferedImage
import javax.swing.ImageIcon
import javax.swing.JFrame
import javax.swing.JPanel
import javax.swing.JLabel

class YinYangGenerator {
private fun drawYinYang(size: Int, g: Graphics) {
with(g) {
// Preserve the color for the caller
val colorSave = color
color = Color.WHITE

// Use fillOval to draw a filled in circle
fillOval(0, 0, size - 1, size - 1)
color = Color.BLACK

// Use fillArc to draw part of a filled in circle
fillArc(0, 0, size - 1, size - 1, 270, 180)
fillOval(size / 4, size / 2, size / 2, size / 2)
color = Color.WHITE
fillOval(size / 4, 0, size / 2, size / 2)
fillOval(7 * size / 16, 11 * size / 16, size /8, size / 8)
color = Color.BLACK
fillOval(7 * size / 16, 3 * size / 16, size / 8, size / 8)

// Use drawOval to draw an empty circle for the outside border
drawOval(0, 0, size - 1, size - 1)

// Restore the color for the caller
color = colorSave
}
}

fun createImage(size: Int, bg: Color): Image {
// A BufferedImage creates the image in memory
val image = BufferedImage(size, size, BufferedImage.TYPE_INT_RGB)

// Get the graphics object for the image
val g = image.graphics

// Color in the background of the image
g.color = bg
g.fillRect(0, 0, size, size)
drawYinYang(size, g)
return image
}
}

fun main(args: Array<String>) {
val gen = YinYangGenerator()
val size = 400 // say
val p = JPanel()
val yinYang = gen.createImage(size, p.background)

val size2 = size / 2 // say
val yinYang2 = gen.createImage(size2, p.background)

val f = JFrame("Big and Small Yin Yang")
with (f) {
defaultCloseOperation = JFrame.EXIT_ON_CLOSE
pack()
isVisible = true
}
}


## Lambdatalk

{{SVG 580 580}
{YY 145 145 300}
{YY 270 195 50}
{YY 270 345 50}
}

{def YY
{lambda {:x :y :s}
{{G :x :y :s}
{CIRCLE 0.5 0.5 0.5 black 0 0}
{{G 0.5 0 1} {HALF_CIRCLE}}
{CIRCLE 0.5 0.25 0.25 black 0 0}
{CIRCLE 0.5 0.75 0.25 white 0 0}
{CIRCLE 0.5 0.25 0.1 white 0 0}
{CIRCLE 0.5 0.75 0.1 black 0 0}
{CIRCLE 0.5 0.5 0.5 none gray 0.01} }}}

{def CIRCLE
{lambda {:x :y :r :f :s :w}
{circle {@ cx=":x" cy=":y" r=":r"
fill=":f" stroke=":s" stroke-width=":w"}}}}

{def HALF_CIRCLE
{path {@ d="M 0 0 A 0.5 0.5 0 0 0 0 1" fill="white"}}}

{def SVG
{lambda {:w :h}
svg {@ width=":w" height=":h"

{def G
{lambda {:x :y :s}
g {@ transform="translate(:x,:y) scale(:s,:s)"}}}

Output: Sorry, I was unable to upload the following PNG picture (45kb). Need help.

http://lambdaway.free.fr/lambdawalks/data/lambdatalk_yinyang.png


## Logo

Works with: UCB_Logo version 5.5
Works with: MSW_Logo version 6.5b
to taijitu :r
; Draw a classic Taoist taijitu of the given radius centered on the current
; turtle position. The "eyes" are placed along the turtle's heading, the
; filled one in front, the open one behind.

; don't bother doing anything if the pen is not down
if not pendown? [stop]

; useful derivative values
localmake "r2 (ashift :r  -1)
localmake "r4 (ashift :r2 -1)
localmake "r8 (ashift :r4 -1)

; remember where we started
localmake "start  pos

; draw outer circle
pendown
arc 360 :r

; draw upper half of S
penup
forward :r2
pendown
arc 180 :r2

; and filled inner eye
arc 360 :r8
fill

; draw lower half of S
penup
back :r
pendown
arc -180 :r2

; other inner eye
arc  360 :r8

; fill this half of the symbol
penup
forward :r4
fill

; put the turtle back where it started
setpos :start
pendown
end

; demo code to produce image at right
clearscreen
pendown
hideturtle
taijitu 100
penup
forward 150
left 90
forward 150
pendown
taijitu 75

## Lua

Translation of: C++
function circle(x, y, c, r)
return (r * r) >= (x * x) / 4 + ((y - c) * (y - c))
end

function pixel(x, y, r)
if circle(x, y, -r / 2, r / 6) then
return '#'
end
if circle(x, y, r / 2, r / 6) then
return '.'
end
if circle(x, y, -r / 2, r / 2) then
return '.'
end
if circle(x, y, r / 2, r / 2) then
return '#'
end
if circle(x, y, 0, r) then
if x < 0 then
return '.'
else
return '#'
end
end
return ' '
end

function yinYang(r)
for y=-r,r do
for x=-2*r,2*r do
io.write(pixel(x, y, r))
end
print()
end
end

yinYang(18)

Output:
                                    .
....................###
............................#####
.................................######
.....................................########
.........................................########
..........................#................##########
........................#########.............###########
........................###########............############
.........................#############............#############
...........................###########............###############
.............................#########.............################
.................................#................#################
...................................................##################
..................................................#####################
.................................................######################
...............................................########################
............................................###########################
.....................................####################################
...........................############################################
........................###############################################
......................#################################################
.....................##################################################
..................###################################################
.................################.#################################
................#############.........#############################
...............############...........###########################
.............############.............#########################
............############...........########################
...........#############.........########################
..........################.##########################
........#########################################
........#####################################
......#################################
.....############################
...####################
#

## M2000 Interpreter

Using Drawing {} to make a emf file, which can play with various sizes and rotation.

Module YinYang {
cls 5,0
Double
Print Over
Cursor 0,0
Report 2,  "阴阳 Yin and yang 음양"
Normal
Drawing {
circle fill 0, 3000,1, 0
circle fill 15, 3000,1,0, pi/2, -pi/2
step 0, -1500
circle fill 15, 1500,1,15
width 4 {
circle fill 0, 500,1,0
}
step 0, 3000
circle fill 0, 1500,1,0
width 4 {
circle fill 15, 500,1,15
step 0, -1500
circle 3000,1,0
}
} as A
Move 6000, 5000-1500
Image A, 6000
Move 2000, 5000
Image A, 3000
Move 2000+1500, 5000+1500
hold // hold surface to release by statement release
Mouse.Icon Hide
i=0
every 10 {
if  inkey$=" " or mouse=2 then exit release move mouse.x, mouse.y Image A, 3000, ,i : i+=5:if i>355 then i=0 Refresh 20 if mouse=1 then hold } Mouse.Icon Show filename$="yin and yang.emf"
// save to file
Open filename$for output as #f Put #f, A, 1 Close #f // open mspaing win "mspaint", quote$(dir$+filename$)
}
YinYang

## Maple


with(plottools):
with(plots):
yingyang := r -> display(
circle([0, 0], r),
disk([0, 1/2*r], 1/10*r, colour = black),
disk([0, -1/2*r], 1/10*r, colour = white),
disk([0, -1/2*r], 1/2*r, colour = black),
inequal({1/4*r^2 <= x^2 + (y - 1/2*r)^2, 1/4*r^2 <= x^2 + (y + 1/2*r)^2, x^2 + y^2 <=
r^2}, x = 0 .. r, y = -r .. r, grid = [100, 100], colour = black),
scaling = constrained, axes = none
);

## Mathematica / Wolfram Language

Mathematica's ability to symbolically build up graphics is often underrated. The following function will create a yin-yang symbol with the parameter size indicating the diameter in multiples of 40 pixels.

YinYang[size_] :=
Graphics[{{Circle[{0, 0}, 2]}, {Disk[{0, 0},
2, {90 Degree, -90 Degree}]}, {White, Disk[{0, 1}, 1]}, {Black,
Disk[{0, -1}, 1]}, {Black, Disk[{0, 1}, 1/4]}, {White,
Disk[{0, -1}, 1/4]}}, ImageSize -> 40 size]


## Metapost

The "function" yinyang returns a picture (a primitive type) that can be drawn (and transformed of course in any way)

vardef yinyang(expr u) =
picture pic_;
path p_;
p_ := halfcircle scaled 2u rotated -90 --
halfcircle scaled u rotated 90 shifted (0, 1/2u) reflectedabout ((0,1), (0,-1)) --
halfcircle scaled u rotated -270 shifted (0, -1/2u) -- cycle;

pic_ := nullpicture;
addto pic_ contour fullcircle scaled 2u withcolor black;
addto pic_ contour p_ withcolor white;
addto pic_ doublepath p_ withcolor black withpen pencircle scaled 0.5mm;
addto pic_ contour fullcircle scaled 1/3u shifted (0, 1/2u) withcolor white;
addto pic_ contour fullcircle scaled 1/3u shifted (0, -1/2u) withcolor black;
pic_
enddef;

beginfig(1)
% let's create a Yin Yang symbol with a radius of 5cm
draw yinyang(5cm) shifted (5cm, 5cm);
% and another one, radius 2.5cm, rotated 180 degrees and translated
draw yinyang(2.5cm) rotated 180 shifted (11cm, 11cm);
endfig;

end.

## Modula-2

MODULE Taijitu;
FROM InOut IMPORT Write, WriteLn;

PROCEDURE YinYang(r: INTEGER);
VAR x, y: INTEGER;

PROCEDURE circle(x, y, c, r: INTEGER): BOOLEAN;
BEGIN
RETURN r*r >= (x DIV 2) * (x DIV 2) + (y-c) * (y-c);
END circle;

PROCEDURE pixel(x, y, r: INTEGER): CHAR;
BEGIN
IF circle(x, y, -r DIV 2, r DIV 6) THEN RETURN '#';
ELSIF circle(x, y, r DIV 2, r DIV 6) THEN RETURN '.';
ELSIF circle(x, y, -r DIV 2, r DIV 2) THEN RETURN '.';
ELSIF circle(x, y, r DIV 2, r DIV 2) THEN RETURN '#';
ELSIF circle(x, y, 0, r) THEN
IF x<0 THEN RETURN '.';
ELSE RETURN '#';
END;
ELSE RETURN ' ';
END;
END pixel;
BEGIN
FOR y := -r TO r DO
FOR x := -2*r TO 2*r DO
Write(pixel(x,y,r));
END;
WriteLn();
END;
END YinYang;

BEGIN
YinYang(4);
WriteLn();
YinYang(8);
END Taijitu.

Output:
        ..
........##
......##....##
..........####
..........#######
....##########
..####..######
..########
##

..
............##
..................####
............##......######
..........######......####
..............##......########
......................########
....................##########
..................###############
..........####################
........######################
........######..##############
....######......##########
......######..############
....##################
..############
##               

## NetRexx

Writes an SVG document to standard output:

Translation of: C
/* NetRexx */

options replace format comments java crossref savelog symbols binary

say "<?xml version='1.0' encoding='UTF-8' standalone='no'?>"
say "<!DOCTYPE svg PUBLIC '-//W3C//DTD SVG 1.1//EN'"
say "  'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'>"
say "<svg xmlns='http://www.w3.org/2000/svg' version='1.1'"
say "  width='30' height='30'>"
say "  <defs><g id='y'>"
say "    <circle cx='0' cy='0' r='200' stroke='black'"
say "      fill='white' stroke-width='1'/>"
say "    <path d='M0 -200 A 200 200 0 0 0 0 200"
say "      100 100 0 0 0 0 0 100 100 0 0 1 0 -200"
say "      z' fill='black'/>"
say "    <circle cx='0' cy='100' r='33' fill='white'/>"
say "    <circle cx='0' cy='-100' r='33' fill='black'/>"
say "  </g></defs>"

say draw_yinyang(20, 0.05)
say draw_yinyang(8, 0.02)

say "</svg>"

return

method draw_yinyang(trans = int, scale = double) inheritable static returns String
yy = String.format("  <use xlink:href='#y' transform='translate(%d,%d) scale(%g)'/>", -
[Object Integer(trans), Integer(trans), Double(scale)])
return yy

## Nim

Library: gintro
import gintro/cairo

proc draw(ctx: Context; x, y, r: float) =
ctx.arc(x, y, r + 1, 1.571, 7.854)
ctx.setSource(0.0, 0.0, 0.0)
ctx.fill()
ctx.arcNegative(x, y - r / 2, r / 2, 1.571, 4.712)
ctx.arc(x, y + r / 2, r / 2, 1.571, 4.712)
ctx.arcNegative(x, y, r, 4.712, 1.571)
ctx.setSource(1.0, 1.0, 1.0)
ctx.fill()
ctx.arc(x, y - r / 2, r / 5, 1.571, 7.854)
ctx.setSource(0.0, 0.0, 0.0)
ctx.fill()
ctx.arc(x, y + r / 2, r / 5, 1.571, 7.854)
ctx.setSource(1.0, 1.0, 1.0)
ctx.fill()

let surface = imageSurfaceCreate(argb32, 200, 200)
let context = newContext(surface)
context.draw(120, 120, 75)
context.draw(35, 35, 30)
let status = surface.writeToPng("yin-yang.png")
assert status == Status.success


## OCaml

open Graphics

let draw_yinyang x y radius black white =
let hr = radius / 2 in
let sr = radius / 6 in
set_color black;
set_line_width 6;
set_line_width 0;
set_color black;
set_color white;
fill_arc x (y + hr) hr hr 270 450;
set_color black;
fill_arc x (y - hr) hr hr 90 270;
fill_circle x (y + hr) sr;
set_color white;
fill_circle x (y - hr) sr

let () =
open_graph "";
let width = size_x()
and height = size_y() in
set_color (rgb 200 200 200);
fill_rect 0 0 width height;
let w = width / 3
and h = height / 3 in
let r = (min w h) / 3 in
draw_yinyang w (h*2) (r*2) black white;
draw_yinyang (w*2) h r blue magenta;


run with:

$ocaml graphics.cma yinyang.ml ## PARI/GP YinYang(r)={ for(y=-r,r, print(concat(apply( x-> if( x^2+y^2>r^2, " ", [y<0,y>0,x>0][logint((x^2+(abs(y)-r/2)^2)<<8\r^2+1,2)\3+1], "#", "." ), [-r..r] )))) } If outside the big circle, we leave blank, else we distinguish three cases depending on D = (x/r)^2+(|y/r|-1/2)^2 or rather log_2(D)+8: Less than 3 (D < 1/32: small circles), black iff y < 0; between 3 and 6 (1/32 < D < 1/4: rings around circles), black iff y > 0; beyond 6 (D > 1/4: left or right half outside rings), black iff x > 0. In all other cases white. For y we use a for() loop, for x we use apply( x -> ..., [-r .. r]), the anonymous function returns a character for each integer in [-r .. r], which we concatenate and print as one string, followed by a newline. ## Pascal Translation of: JavaScript //Written for TU Berlin //Compiled with fpc Program yingyang; Uses Math; const scale_x=2; scale_y=1; black='#'; white='.'; clear=' '; function inCircle(centre_x:Integer;centre_y:Integer;radius:Integer;x:Integer;y:Integer):Boolean ; begin inCircle:=power(x-centre_x,2)+power(y-centre_y,2)<=power(radius,2); end; function bigCircle(radius:Integer;x:Integer;y:Integer):Boolean ; begin bigCircle:=inCircle(0,0,radius,x,y); end; function whiteSemiCircle(radius:Integer;x:Integer;y:Integer):Boolean ; begin whiteSemiCircle:=inCircle(0,radius div 2 ,radius div 2,x,y); end; function smallBlackCircle(radius:Integer;x:Integer;y:Integer):Boolean ; begin smallBlackCircle:=inCircle(0,radius div 2 ,radius div 6,x,y); end; function blackSemiCircle(radius:Integer;x:Integer;y:Integer):Boolean ; begin blackSemiCircle:=inCircle(0,-radius div 2 ,radius div 2,x,y); end; function smallWhiteCircle(radius:Integer;x:Integer;y:Integer):Boolean ; begin smallWhiteCircle:=inCircle(0,-radius div 2 ,radius div 6,x,y); end; var radius,sy,sx,x,y:Integer; begin writeln('Please type a radius:'); readln(radius); if radius<3 then begin writeln('A radius bigger than 3');halt end; sy:=round(radius*scale_y); while(sy>=-round(radius*scale_y)) do begin sx:=-round(radius*scale_x); while(sx<=round(radius*scale_x)) do begin x:=sx div scale_x; y:=sy div scale_y; if bigCircle(radius,x,y) then begin if (whiteSemiCircle(radius,x,y)) then if smallblackCircle(radius,x,y) then write(black) else write(white) else if blackSemiCircle(radius,x,y) then if smallWhiteCircle(radius,x,y) then write(white) else write(black) else if x>0 then write(white) else write(black); end else write(clear); sx:=sx+1 end; writeln; sy:=sy-1; end; end.  Output: Please type a radius: 6 ... ##............. ####....###........ ####....#######........ ######....###.......... ######................. ###########.............. #################...... ##########...####...... ########.......####.... ########...####.... #############.. ### Please type a radius: 10 ... ##................. ####....................... ######......................... ########........###................ ######........#######.............. ##########........###.................. ##########............................. ##########............................. ############........................... ###################...................... ###########################............ #############################.......... #############################.......... ##################...########.......... ##############.......########...... ################...########........ #########################...... #######################.... #################.. ###  ## Perl sub circle { my ($radius, $cx,$cy, $fill,$stroke) = @_;
print   "<circle cx='$cx' cy='$cy' r='$radius' ", "fill='$fill' stroke='$stroke' stroke-width='1'/>\n"; } sub yin_yang { my ($rad, $cx,$cy, %opt) = @_;
my ($c,$w) = (1, 0);
$opt{fill} //= 'white';$opt{stroke} //= 'black';
$opt{recurangle} //= 0; print "<g transform='rotate($opt{angle}, $cx,$cy)'>"
if $opt{angle}; if ($opt{flip}) { ($c,$w) = ($w,$c) };

circle($rad,$cx, $cy,$opt{fill}, $opt{stroke}); print "<path d='M$cx ", $cy +$rad, "A ",
$rad/2, " ",$rad/2, " 0 0 $c$cx $cy ",$rad/2, " ", $rad/2, " 0 0$w $cx ",$cy - $rad, " ",$rad,   " ", $rad, " 0 0$c $cx ",$cy + $rad, " ", "z' fill='$opt{stroke}' stroke='none' />";

if ($opt{recur} and$rad > 1) {
# recursive "eyes" are slightly larger
yin_yang($rad/4,$cx, $cy +$rad/2, %opt,
angle   => $opt{recurangle}, fill =>$opt{stroke},
stroke  => $opt{fill} ); yin_yang($rad/4, $cx,$cy - $rad/2, %opt, angle => 180 +$opt{recurangle});
} else {
circle($rad/5,$cx, $cy +$rad/2, $opt{fill},$opt{stroke});
circle($rad/5,$cx, $cy -$rad/2, $opt{stroke},$opt{fill});
}
print "</g>" if $opt{angle}; } print <<'HEAD'; <?xml version="1.0" encoding="UTF-8" standalone="no"?> <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"> <svg xmlns="http://www.w3.org/2000/svg" version="1.1" xmlns:xlink="http://www.w3.org/1999/xlink"> HEAD yin_yang(200, 250, 250, recur=>1, angle=>0, recurangle=>90, fill=>'white', stroke=>'black'); yin_yang(100, 500, 500); print "</svg>"  Messy code. Note that the larger yin-yang is drawn recursively. ## Phix Library: Phix/pGUI Library: Phix/online You can run this online here. -- -- demo\rosetta\Yin_and_yang.exw -- ============================= -- with javascript_semantics include pGUI.e Ihandle dlg, canvas cdCanvas cd_canvas procedure cdCanvasSecArc(cdCanvas hCdCanvas, atom xc, atom yc, atom w, atom h, atom angle1, atom angle2) -- cdCanvasSector does not draw anti-aliased edges, but cdCanvasArc does, so over-draw... cdCanvasSector(hCdCanvas, xc, yc, w, h, angle1, angle2) cdCanvasArc (hCdCanvas, xc, yc, w, h, angle1, angle2) end procedure procedure yinyang(atom cx, cy, r) cdCanvasArc(cd_canvas, cx, cy, r, r, 0, 360) cdCanvasSecArc(cd_canvas, cx, cy, r, r, 270, 90) cdCanvasSecArc(cd_canvas, cx, cy-r/4, r/2-1, r/2-1, 0, 360) cdCanvasSetForeground(cd_canvas, CD_WHITE) cdCanvasSecArc(cd_canvas, cx, cy+r/4, r/2-1, r/2-1, 0, 360) cdCanvasSecArc(cd_canvas, cx, cy-r/4, r/8, r/8, 0, 360) cdCanvasSetForeground(cd_canvas, CD_BLACK) cdCanvasSecArc(cd_canvas, cx, cy+r/4, r/8, r/8, 0, 360) end procedure function redraw_cb(Ihandle /*ih*/) integer {width, height} = IupGetIntInt(canvas, "DRAWSIZE"), r = min(width,height)-40, cx = floor(width/2), cy = floor(height/2) cdCanvasActivate(cd_canvas) cdCanvasClear(cd_canvas) yinyang(cx-r*.43,cy+r*.43,r/6) yinyang(cx,cy,r) cdCanvasFlush(cd_canvas) return IUP_DEFAULT end function function map_cb(Ihandle ih) IupGLMakeCurrent(canvas) if platform()=JS then cd_canvas = cdCreateCanvas(CD_IUP, canvas) else atom res = IupGetDouble(NULL, "SCREENDPI")/25.4 cd_canvas = cdCreateCanvas(CD_GL, "10x10 %g", {res}) end if cdCanvasSetBackground(cd_canvas, CD_WHITE) cdCanvasSetForeground(cd_canvas, CD_BLACK) return IUP_DEFAULT end function function canvas_resize_cb(Ihandle /*canvas*/) integer {canvas_width, canvas_height} = IupGetIntInt(canvas, "DRAWSIZE") atom res = IupGetDouble(NULL, "SCREENDPI")/25.4 cdCanvasSetAttribute(cd_canvas, "SIZE", "%dx%d %g", {canvas_width, canvas_height, res}) return IUP_DEFAULT end function procedure main() IupOpen() canvas = IupGLCanvas("RASTERSIZE=340x340") IupSetCallbacks(canvas, {"MAP_CB", Icallback("map_cb"), "RESIZE_CB", Icallback("canvas_resize_cb"), "ACTION", Icallback("redraw_cb")}) dlg = IupDialog(canvas, TITLE="Yin and Yang") IupShow(dlg) IupSetAttribute(canvas, "RASTERSIZE", NULL) -- release the minimum limitation if platform()!=JS then IupMainLoop() IupClose() end if end procedure main()  ## PHL Translation of: ALGOL 68 module circles; extern printf; @Boolean in_circle(@Integer centre_x, @Integer centre_y, @Integer radius, @Integer x, @Integer y) [ return (x-centre_x)*(x-centre_x)+(y-centre_y)*(y-centre_y) <= radius*radius; ] @Boolean in_big_circle (@Integer radius, @Integer x, @Integer y) [ return in_circle(0, 0, radius, x, y); ] @Boolean in_while_semi_circle (@Integer radius, @Integer x, @Integer y) [ return in_circle(0, radius/2, radius/2, x, y); ] @Boolean in_small_white_circle (@Integer radius, @Integer x, @Integer y) [ return in_circle(0, 0-radius/2, radius/6, x, y); ] @Boolean in_black_semi_circle (@Integer radius, @Integer x, @Integer y) [ return in_circle(0, 0-radius/2, radius/2, x, y); ] @Boolean in_small_black_circle (@Integer radius, @Integer x, @Integer y) [ return in_circle(0, radius/2, radius/6, x, y); ] @Void print_yin_yang(@Integer radius) [ var white = '.'; var black = '#'; var clear = ' '; var scale_y = 1; var scale_x = 2; for (var sy = radius*scale_y; sy >= -(radius*scale_y); sy=sy-1) { for (var sx = -(radius*scale_x); sx <= radius*scale_x; sx=sx+1) { var x = sx/(scale_x); var y = sy/(scale_y); if (in_big_circle(radius, x, y)) { if (in_while_semi_circle(radius, x, y)) if (in_small_black_circle(radius, x, y)) printf("%c", black); else printf("%c", white); else if (in_black_semi_circle(radius, x, y)) if (in_small_white_circle(radius, x, y)) printf("%c", white); else printf("%c", black); else if (x < 0) printf("%c", white); else printf("%c", black); } else printf("%c", clear); } printf("\n"); } ] @Integer main [ print_yin_yang(17); print_yin_yang(8); return 0; ] Output:  ### .............########## .........................########## ...............................######## ...................................######## .......................................############ .........................................########## ..........................###..............############ ..........................#######............############## ..........................###########............############## ............................#######............################ ..............................###..............################ .................................................################## ...............................................#################### ...............................................#################### .............................................###################### .........................................########################## ....................................################################# ..........................######################################### ......................############################################# ....................############################################### ....................############################################### ..................################################################# ................##############...############################## ................############.......############################ ..............############...........########################## ..............############.......########################## ............##############...########################## ..........######################################### ............####################################### ........################################### ........############################### ..........######################### ..........############# ### ... .............## ...................#### ............###......###### ..........#######......#### ..............###......######## .......................######## .....................########## ..................############### ..........##################### ........####################### ........######...############## ....######.......########## ......######...############ ....################### ..############# ###  ## PicoLisp (de circle (X Y C R) (>= (* R R) (+ (* (setq X (/ X 2)) X) (* (dec 'Y C) Y) ) ) ) (de yinYang (R) (for Y (range (- R) R) (for X (range (- 0 R R) (+ R R)) (prin (cond ((circle X Y (- (/ R 2)) (/ R 6)) "#" ) ((circle X Y (/ R 2) (/ R 6)) "." ) ((circle X Y (- (/ R 2)) (/ R 2)) "." ) ((circle X Y (/ R 2) (/ R 2)) "#" ) ((circle X Y 0 R) (if (lt0 X) "." "#") ) (T " ") ) ) ) (prinl) ) ) Test: : (yinYang 18) ... .....................## .............................###### .................................###### .......................................######## ...........................................######## ..........................###................########## ........................###########............############ ........................###########............############ ........................###############............############ ............................###########............################ ............................###########............################ ................................###................################ .....................................................################## ...................................................#################### .................................................###################### ...............................................######################## .............................................########################## ......................................################################### ..........................############################################# ........................############################################### ......................################################################# ....................################################################### ..................##################################################### ................################...################################ ................############...........############################ ................############...........############################ ............############...............######################## ............############...........######################## ............############...........######################## ..........################...########################## ........########################################### ........####################################### ......################################# ......############################# ..##################### ###  ## Plain English To run: Start up. Clear the screen to the gray color. Draw the Taijitu symbol 4 inches wide at the screen's center. Put the screen's center into a spot. Move the spot 4 inches right. Draw the Taijitu symbol 2 inches wide at the spot. Refresh the screen. Wait for the escape key. Shut down. To draw the Taijitu symbol some twips wide at a spot: Imagine a box the twips high by the twips wide. Imagine an ellipse given the box. Center the ellipse on the spot. Mask outside the ellipse. Imagine a left half box with the screen's left and the screen's top and the spot's x coord and the screen's bottom. Fill the left half with the white color. Imagine a right half box with the spot's x coord and the screen's top and the screen's right and the screen's bottom. Fill the right half with the black color. Imagine a swirl ellipse given the box. Scale the swirl given 1/2. Put the spot into an upper spot. Move the upper spot up the twips divided by 4. Put the spot into a lower spot. Move the lower spot down the twips divided by 4. Fill the swirl on the upper spot with the white color. Fill the swirl on the lower spot with the black color. Put the swirl into a dot. Scale the dot given 1/4. Fill the dot on the lower spot with the white color. Fill the dot on the upper spot with the black color. Unmask everything. Use the fat pen. Draw the ellipse. Output: ## PL/I yinyang: procedure options(main); yinyang: procedure(r); circle: procedure(x, y, c, r) returns(bit); declare (x, y, c, r) fixed; return( r*r >= (x/2) * (x/2) + (y-c) * (y-c) ); end circle; pixel: procedure(x, y, r) returns(char); declare (x, y, r) fixed; if circle(x, y, -r/2, r/6) then return('#'); if circle(x, y, r/2, r/6) then return('.'); if circle(x, y, -r/2, r/2) then return('.'); if circle(x, y, r/2, r/2) then return('#'); if circle(x, y, 0, r) then do; if x<0 then return('.'); else return('#'); end; return(' '); end pixel; declare (x, y, r) fixed; do y=-r to r; do x=-2*r to 2*r; put edit(pixel(x, y, r)) (A(1)); end; put skip; end; end yinyang; call yinyang(4); put skip; call yinyang(8); end yinyang; Output:  ... .........## ......###....## ...........#### ..........####### ....########### ..####...###### ..######### ### ... .............## ...................#### ............###......###### ..........#######......#### ..............###......######## .......................######## .....................########## ..................############### ..........##################### ........####################### ........######...############## ....######.......########## ......######...############ ....################### ..############# ### ## PostScript Output: %!PS-Adobe-3.0 %%BoundingBox: 0 0 400 400 /fs 10 def /ed { exch def } def /dist { 3 -1 roll sub dup mul 3 1 roll sub dup mul add sqrt } def /circ { /r exch def [r neg 1 r { /y exch def [ r 2 mul neg 1 r 2 mul { /x ed x 2 div y 0 0 dist r .05 add gt {( )}{ x 2 div y 0 r 2 div dist dup r 5 div le { pop (.) } { r 2 div le { (@) }{ x 2 div y 0 r 2 div neg dist dup r 5 div le { pop (@)} { r 2 div le {(.)}{ x 0 le {(.)}{(@)}ifelse } ifelse } ifelse } ifelse } ifelse } ifelse } for] } for] } def /dis { moveto gsave { grestore 0 fs 1.15 mul neg rmoveto gsave {show} forall } forall grestore } def /Courier findfont fs scalefont setfont 11 circ 10 390 dis 6 circ 220 180 dis showpage %%EOF  ## POV-Ray // ====== General Scene setup ====== #version 3.7; global_settings { assumed_gamma 2.2 } camera{ location <0,2.7,4> look_at <0,.1,0> right x*1.6 aperture .2 focal_point <1,0,0> blur_samples 200 variance 1/10000 } light_source{<2,4,8>, 1 spotlight point_at 0 radius 10} sky_sphere {pigment {granite scale <1,.1,1> color_map {[0 rgb 1][1 rgb <0,.4,.6>]}}} #default {finish {diffuse .9 reflection {.1 metallic} ambient .3} normal {granite scale .2}} plane { y, -1 pigment {hexagon color rgb .7 color rgb .75 color rgb .65} normal {hexagon scale 5}} // ====== Declare one side of the symbol as a sum and difference of discs ====== #declare yang = difference { merge { difference { cylinder {0 <0,.1,0> 1} // flat disk box {-1 <1,1,0>} // cut in half cylinder {<.5,-.1,0> <.5,.2,0> .5} // remove half-cicle on one side } cylinder {<-.5,0,0> <-.5,.1,0> .5} // add on the other side cylinder {<.5,0,0> <.5,.1,0> .15} // also add a little dot } cylinder {<-.5,-.1,0> <-.5,.2,0> .15} // and carve out a hole pigment{color rgb 0.1} } // ====== The other side is white and 180-degree turned ====== #declare yin = object { yang rotate <0,180,0> pigment{color rgb 1} } // ====== Here we put the two together: ====== #macro yinyang( ysize ) union { object {yin} object {yang} scale ysize } #end // ====== Here we put one into a scene: ====== object { yinyang(1) translate -y*1.08 } // ====== And a bunch more just for fun: ====== #declare scl=1.1; #while (scl > 0.01) object { yinyang(scl) rotate <0,180,0> translate <-scl*4,scl*2-1,0> rotate <0,scl*360,0> translate <-.5,0,0>} object { yinyang(scl) translate <-scl*4,scl*2-1,0> rotate <0,scl*360+180,0> translate <.5,0,0>} #declare scl = scl*0.85; #end ## Prolog Works with SWI-Prolog and XPCE. ying_yang(N) :- R is N * 100, sformat(Title, 'Yin Yang ~w', [N]), new(W, window(Title)), new(Wh, colour(@default, 255*255, 255*255, 255*255)), new(Bl, colour(@default, 0, 0, 0)), CX is R + 50, CY is R + 50, R1 is R / 2, R2 is R / 8, CY1 is R1 + 50, CY2 is 3 * R1 + 50, new(E, semi_disk(point(CX, CY), R, w, Bl)), new(F, semi_disk(point(CX, CY), R, e, Wh)), new(D1, disk(point(CX, CY1), R, Bl)), new(D2, disk(point(CX, CY2), R, Wh)), new(D3, disk(point(CX, CY1), R2, Wh)), new(D4, disk(point(CX, CY2), R2, Bl)), send_list(W, display, [E, F, D1, D2, D3, D4]), WD is 2 * R + 100, send(W, size, size(WD, WD )), send(W, open). :- pce_begin_class(semi_disk, path, "Semi disk with color "). initialise(P, C, R, O, Col) :-> send(P, send_super, initialise), get(C, x, CX), get(C, y, CY), choose(O, Deb, End), forall(between(Deb, End, I), ( X is R * cos(I * pi/180) + CX, Y is R * sin(I * pi/180) + CY, send(P, append, point(X,Y)))), send(P, closed, @on), send(P, fill_pattern, Col). :- pce_end_class. choose(s, 0, 180). choose(n, 180, 360). choose(w, 90, 270). choose(e, -90, 90). :- pce_begin_class(disk, ellipse, "disk with color "). initialise(P, C, R, Col) :-> send(P, send_super, initialise, R, R), send(P, center, C), send(P, pen, 0), send(P, fill_pattern, Col). :- pce_end_class.  Output:  ?- ying_yang(1). true. ?- ying_yang(2). true.  ## Python ### Text For positive integer n > 0, the following generates an ASCII representation of the Yin yang symbol. Works with: Python version 3.x import math def yinyang(n=3): radii = [i * n for i in (1, 3, 6)] ranges = [list(range(-r, r+1)) for r in radii] squares = [[ (x,y) for x in rnge for y in rnge] for rnge in ranges] circles = [[ (x,y) for x,y in sqrpoints if math.hypot(x,y) <= radius ] for sqrpoints, radius in zip(squares, radii)] m = {(x,y):' ' for x,y in squares[-1]} for x,y in circles[-1]: m[x,y] = '*' for x,y in circles[-1]: if x>0: m[(x,y)] = '·' for x,y in circles[-2]: m[(x,y+3*n)] = '*' m[(x,y-3*n)] = '·' for x,y in circles[-3]: m[(x,y+3*n)] = '·' m[(x,y-3*n)] = '*' return '\n'.join(''.join(m[(x,y)] for x in reversed(ranges[-1])) for y in ranges[-1])  Sample generated symbols for n = 2 and n = 3 >>> print(yinyang(2)) · ········* ···········** ·············** ········*·····*** ········***····**** ········*****····**** ·········***····***** ···········*·····****** ·················****** ················******* ···············******** ·············************ ········*************** ·······**************** ······***************** ······*****·*********** ·····****···********* ····****·····******** ····****···******** ···*****·******** ··************* ··*********** ·******** * >>> print(yinyang(1)) · ······* ····*··** ····***··** ·····*··*** ········*** ·······****** ···******** ···**·***** ··**···**** ··**·**** ·****** * >>>  ### Turtle Graphics This was inspired by the Logo example but diverged as some of the Python turtle graphics primitives such as filling and the drawing of arcs work differently. from turtle import * mode('logo') def taijitu(r): '''\ Draw a classic Taoist taijitu of the given radius centered on the current turtle position. The "eyes" are placed along the turtle's heading, the filled one in front, the open one behind. ''' # useful derivative values r2, r4, r8 = (r >> s for s in (1, 2, 3)) # remember where we started x0, y0 = start = pos() startcolour = color() startheading = heading() color('black', 'black') # draw outer circle pendown() circle(r) # draw two 'fishes' begin_fill(); circle(r, 180); circle(r2, 180); circle(-r2, 180); end_fill() # black 'eye' setheading(0); penup(); goto(-(r4 + r8) + x0, y0); pendown() begin_fill(); circle(r8); end_fill() # white 'eye' color('white', 'white'); setheading(0); penup(); goto(-(r+r4+r8) + x0, y0); pendown() begin_fill(); circle(r8); end_fill() # put the turtle back where it started penup() setpos(start) setheading(startheading) color(*startcolour) if __name__ == '__main__': # demo code to produce image at right reset() #hideturtle() penup() goto(300, 200) taijitu(200) penup() goto(-150, -150) taijitu(100) hideturtle()  ## Quackery [$ "turtleduck.qky" loadfile ] now!

[ -1 4 turn
2dup -v fly
1 4 turn
4 wide
' [ 0 0 0 ] colour
' [ 0 0 0 ] fill
[ 2dup 2 1 v/ 1 2 arc
2dup -2 1 v/ 1 2 arc
2dup -v 1 2 arc ]
2dup -v 1 2 arc
1 4 turn
2dup 2 1 v/ fly
' [ 0 0 0 ] colour
1 wide
' [ 255 255 255 ] fill
[ 2dup 7 1 v/ circle ]
2dup fly
' [ 255 255 255 ] colour
' [ 0 0 0 ] fill
[ 2dup 7 1 v/ circle ]
-2 1 v/ fly
-1 4 turn ]               is yinyang ( n/d --> )

turtle
-110 1 fly
100 1 yinyang
420 1 fly
300 1 yinyang
Output:

## R

plot.yin.yang <- function(x=5, y=5, r=3, s=10, add=F){
suppressMessages(require("plotrix"))
if(!add) plot(1:10, type="n", xlim=c(0,s), ylim=c(0,s), xlab="", ylab="", xaxt="n", yaxt="n", bty="n", asp=1)
draw.circle(x, y, r, border="white", col= "black")
draw.ellipse(x, y, r, r, col="white", angle=0, segment=c(90,270), arc.only=F)
draw.ellipse(x, y - r * 0.5, r * 0.5, r * 0.5, col="black", border="black", angle=0, segment=c(90,270), arc.only=F)
draw.circle(x, y - r * 0.5, r * 0.125, border="white", col= "white")
draw.circle(x, y + r * 0.5, r * 0.5, col="white", border="white")
draw.circle(x, y + r * 0.5, r * 0.125, border="black", lty=1, col= "black")
draw.circle(x, y, r, border="black")
}
png("yin_yang.png")
plot.yin.yang()
dev.off()


## Racket

#lang racket
(require slideshow/pict)

(define (yin-yang d)
(define base
(hc-append (inset/clip (circle d) 0 0 (- (/ d 2)) 0)
(inset/clip (disk d) (- (/ d 2)) 0 0 0)))
(define with-top
(ct-superimpose
base
(cc-superimpose (colorize (disk (/ d 2)) "white")
(disk (/ d 8)))))
(define with-bottom
(cb-superimpose
with-top
(cc-superimpose (disk (/ d 2))
(colorize (disk (/ d 8)) "white"))))
(cc-superimpose with-bottom (circle d)))

(yin-yang 200)


## Raku

(formerly Perl 6)

Translation / Modification of C and Perl examples.

sub circle ($rad,$cx, $cy,$fill = 'white', $stroke = 'black' ){ say "<circle cx='$cx' cy='$cy' r='$rad' fill='$fill' stroke='$stroke' stroke-width='1'/>";
}

sub yin_yang ($rad,$cx, $cy, :$fill = 'white', :$stroke = 'black', :$angle = 90) {
my ($c,$w) = (1, 0);
say "<g transform='rotate($angle,$cx, $cy)'>" if$angle;
circle($rad,$cx, $cy,$fill, $stroke); say "<path d='M$cx {$cy +$rad}A {$rad/2} {$rad/2} 0 0 $c$cx $cy ", "{$rad/2} {$rad/2} 0 0$w $cx {$cy - $rad}$rad $rad 0 0$c $cx ", "{$cy + $rad} z' fill='$stroke' stroke='none' />";
circle($rad/5,$cx, $cy +$rad/2, $fill,$stroke);
circle($rad/5,$cx, $cy -$rad/2, $stroke,$fill);
say "</g>" if $angle; } say '<?xml version="1.0" encoding="UTF-8" standalone="no"?> <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"> <svg height="400" width="400" xmlns="http://www.w3.org/2000/svg" version="1.1" xmlns:xlink="http://www.w3.org/1999/xlink">'; yin_yang(100, 130, 130); yin_yang(50, 300, 300); say '</svg>';  Seems like something of a cheat since it relies on a web browser / svg image interpreter to actually view the output image. If that's the case, we may as well cheat harder. ;-) sub cheat_harder ($scale) { "<span style=\"font-size:scale%;\">&#x262f;</span>"; } say '<div>', cheat_harder(700), cheat_harder(350), '</div>';  ## Rascal import util::Math; import vis::Render; import vis::Figure; public void yinyang(){ template = ellipse(fillColor("white")); smallWhite = ellipse(fillColor("white"), shrink(0.1), valign(0.75)); smallBlack = ellipse(fillColor("black"), shrink(0.1), valign(0.25)); dots= [ellipse(fillColor("white"), shrink(0.000001), align(0.5 + sin(0.0031415*n)/4, 0.25 + cos(0.0031415*n)/-4)) | n <- [1 .. 1000]]; dots2 = [ellipse(fillColor("black"), shrink(0.000001), align(0.5 + sin(0.0031415*n)/-4, 0.75 + cos(0.0031415*n)/-4)) | n <- [1 .. 1000]]; dots3= [ellipse(fillColor("black"), shrink(0.000001), align(0.5 + sin(0.0031415*n)/2, 0.5-cos(0.0031415*n)/-2)) | n <- [1 .. 1000]]; black= overlay([*dots, *dots2, *dots3], shapeConnected(true), shapeClosed(true), shapeCurved(true), fillColor("black")); render(hcat([vcat([overlay([template, black, smallWhite, smallBlack], aspectRatio (1.0)), space(), space()]), overlay([template, black, smallWhite, smallBlack], aspectRatio (1.0))])); } ## REXX Translation of: PHL Code was added to this REXX program to try to preserve the aspect ratio when displaying the Yin-Yang symbol. /*REXX program creates & displays an ASCII art version of the Yin─Yang (taijitu) symbol.*/ parse arg s1 s2 . /*obtain optional arguments from the CL*/ if s1=='' | s1=="," then s1= 17 /*Not defined? Then use the default. */ if s2=='' | s2=="," then s2= s1 % 2 /* " " " " " " */ if s1>0 then call Yin_Yang s1 /*create & display 1st Yin-Yang symbol.*/ if s2>0 then call Yin_Yang s2 /* " " " 2nd " " */ exit 0 /*stick a fork in it, we're all done. */ /*──────────────────────────────────────────────────────────────────────────────────────*/ in@: procedure; parse arg cy,r,x,y; return x**2 + (y-cy)**2 <= r**2 big@: /*in big circle. */ return in@( 0 , r , x, y ) semi@: /*in semi circle. */ return in@( r/2, r/2, x, y ) sB@: /*in small black circle. */ return in@( r/2, r/6, x, y ) sW@: /*in small white circle. */ return in@(-r/2, r/6, x, y ) Bsemi@: /*in black semi circle. */ return in@(-r/2, r/2, x, y ) /*──────────────────────────────────────────────────────────────────────────────────────*/ Yin_Yang: procedure; parse arg r; mX= 2; mY= 1 /*aspect multiplier for the X,Y axis.*/ do sy= r*mY to -r*mY by -1;=                           /*$≡ an output line*/ do sx=-r*mX to r*mX; x= sx / mX; y= sy / mY /*apply aspect ratio*/ if big@() then if semi@() then if sB@() then$= $'Θ'; else$= $"°" else if Bsemi@() then if sW@() then$= $'°'; else$= $"Θ" else if x<0 then$= $'°'; else$= $"Θ" else$= $' ' end /*sy*/ say strip($, 'T')                              /*display one line of a Yin─Yang symbol*/
end     /*sx*/;       return

output   when using the inputs of:     35   25

(Shown at one-third size.)

                                                                      °
°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
Θ
°
°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
°°°°°ΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘΘ
Θ


## Ruby

Library: Shoes
Shoes.app(:width => 470, :height => 380) do
PI = Shoes::TWO_PI/2

strokewidth 1

fill black; stroke black

fill white; stroke white

fill black; stroke black

fill white; stroke white

nofill
stroke black
end

yin_yang 190, 190, 360
yin_yang 410, 90, 90
end


## Rust

Creates an svg file

[dependencies]
svg = "0.12.0"

use svg::node::element::Path;

fn main() {
let doc = svg::Document::new()
svg::save("YinYang_rust.svg", &doc.set("viewBox", (-20, -20, 60, 40))).unwrap();
}
/// th - the thickness of the outline around yang
fn yin_yang(r: f32, th: f32) -> Path {
let (cr, cw, ccw) = (",0,1,1,.1,0z", ",0,0,1,0,", ",0,0,0,0,");
let d = format!("M0,{0} a{0},{0}{cr} M0,{1} ", r + th, -r / 3.0) // main_circle
+ &format!("a{0},{0}{cr} m0,{r} a{0},{0}{cr} M0,0 ", r / 6.0) // eyes
+ &format!("A{0},{0}{ccw}{r} A{r},{r}{cw}-{r} A{0},{0}{cw}0", r / 2.0); // yang
Path::new().set("d", d).set("fill-rule", "evenodd")
}


## Scala

Library: Scala
import scala.swing.Swing.pair2Dimension
import scala.swing.{ MainFrame, Panel }
import java.awt.{ Color, Graphics2D }

object YinYang extends scala.swing.SimpleSwingApplication {
var preferedSize = 500

/** Draw a Taijitu symbol on the given graphics context.
*/
def drawTaijitu(g: Graphics2D, size: Int) {
val sizeMinsOne = size - 1
// Preserve the color for the caller
val colorSave = g.getColor()

g.setColor(Color.WHITE)
// Use fillOval to draw a filled in circle
g.fillOval(0, 0, sizeMinsOne, sizeMinsOne)

g.setColor(Color.BLACK)
// Use fillArc to draw part of a filled in circle
g.fillArc(0, 0, sizeMinsOne, sizeMinsOne, 270, 180)
g.fillOval(size / 4, size / 2, size / 2, size / 2)

g.setColor(Color.WHITE)
g.fillOval(size / 4, 0, size / 2, size / 2)
g.fillOval(7 * size / 16, 11 * size / 16, size / 8, size / 8)

g.setColor(Color.BLACK)
g.fillOval(7 * size / 16, 3 * size / 16, size / 8, size / 8)
// Use drawOval to draw an empty circle for the outside border
g.drawOval(0, 0, sizeMinsOne, sizeMinsOne)

// Restore the color for the caller
g.setColor(colorSave)
}

def top = new MainFrame {
title = "Rosetta Code >>> Yin Yang Generator | Language: Scala"
contents = gui(preferedSize)

def gui(sizeInterior: Int) = new Panel() {
preferredSize = (sizeInterior, sizeInterior)

/** Draw a Taijitu symbol in this graphics context.
*/
override def paintComponent(graphics: Graphics2D) = {
super.paintComponent(graphics)

// Color in the background of the image
background = Color.RED
drawTaijitu(graphics, sizeInterior)
}
} // def gui(
}

override def main(args: Array[String]) = {
super.main(args)
}
}


## Scilab

This script uses complex numbers, as in ${\displaystyle x+i\,y}$, to represent ${\displaystyle (x,y)}$ coordinates. Euler's formula is used to calculate points over in a circumference. The output is a single graphic window with two images of Yin and yang.

R = 1;                      //outer radius of first image
scale = 0.5;                //scale of the second image

scf(0); clf();
set(gca(),'isoview','on');
xname('Yin and Yang');

//First one
n_p = 100;                  //number of points per arc
angles = [];                //angles for each arc
angles = linspace(%pi/2, 3*%pi/2, n_p);
Arcs = zeros(7,n_p);

Arcs(1,:) = R * exp(%i * angles);
plot2d(real(Arcs(1,:)),imag(Arcs(1,:)));
line = gce();
set(line.children,'polyline_style',5);
set(line.children,'foreground',8);

Arcs(2,:) = -%i*R/2 + R/2 * exp(%i * angles);
plot2d(real(Arcs(2,:)),imag(Arcs(2,:)));
line = gce();
set(line.children,'polyline_style',5);

angles = [];
angles = linspace(-%pi/2, %pi/2, n_p);

Arcs(3,:) = R * exp(%i * angles);
plot2d(real(Arcs(3,:)), imag(Arcs(3,:)));
line = gce();
set(line.children,'polyline_style',5);

Arcs(4,:) = %i*R/2 + R/2 * exp(%i * angles);
plot2d(real(Arcs(4,:)),imag(Arcs(4,:)));
line = gce();
set(line.children,'polyline_style',5);
set(line.children,'foreground',8);

angles = [];
angles = linspace(0, 2*%pi, n_p);

Arcs(5,:) = %i*R/2 + R/8 * exp(%i * angles);
plot2d(real(Arcs(5,:)),imag(Arcs(5,:)));
line = gce();
set(line.children,'polyline_style',5);

Arcs(6,:) = -%i*R/2 + R/8 * exp(%i * angles);
plot2d(real(Arcs(6,:)),imag(Arcs(6,:)));
line = gce();
set(line.children,'polyline_style',5);
set(line.children,'foreground',8);

Arcs(7,:) = R * exp(%i * angles);
plot2d(real(Arcs(7,:)),imag(Arcs(7,:)));
set(gca(),'axes_visible',['off','off','off']);

//Scaling
new_pos = R + 2*R*scale;
Arcs = new_pos + Arcs .* scale;

plot2d(real(Arcs(1,:)),imag(Arcs(1,:)));
line = gce();
set(line.children,'polyline_style',5);
set(line.children,'foreground',8);

plot2d(real(Arcs(2,:)),imag(Arcs(2,:)));
line = gce();
set(line.children,'polyline_style',5);

plot2d(real(Arcs(3,:)), imag(Arcs(3,:)));
line = gce();
set(line.children,'polyline_style',5);

plot2d(real(Arcs(4,:)),imag(Arcs(4,:)));
line = gce();
set(line.children,'polyline_style',5);
set(line.children,'foreground',8);

plot2d(real(Arcs(5,:)),imag(Arcs(5,:)));
line = gce();
set(line.children,'polyline_style',5);

plot2d(real(Arcs(6,:)),imag(Arcs(6,:)));
line = gce();
set(line.children,'polyline_style',5);
set(line.children,'foreground',8);

plot2d(real(Arcs(7,:)),imag(Arcs(7,:)));
set(gca(),'axes_visible',['off','off','off']);


$include "seed7_05.s7i"; include "float.s7i"; include "math.s7i"; include "draw.s7i"; include "keybd.s7i"; const proc: yinYang (in integer: xPos, in integer: yPos, in integer: size) is func begin pieslice(xPos, yPos, size, 3.0 * PI / 2.0, PI, black); pieslice(xPos, yPos, size, PI / 2.0, PI, white); fcircle(xPos, yPos - size div 2, size div 2, white); fcircle(xPos, yPos + size div 2, size div 2, black); fcircle(xPos, yPos - size div 2, size div 6, black); fcircle(xPos, yPos + size div 2, size div 6, white); circle(xPos, yPos, size, black); end func; const proc: main is func begin screen(640, 480); clear(white); KEYBOARD := GRAPH_KEYBOARD; yinYang(100, 100, 80); yinYang(400, 250, 200); readln(KEYBOARD); end func; ## SETL program yin_yang; print(taijitu 4); print(taijitu 8); op taijitu(r); return +/[+/[pixel(x,y,r) : x in [-2*r..2*r]] + "\n" : y in [-r..r]]; end op; proc pixel(x,y,r); return if circle(x,y,-r/2,r/6) then '#' elseif circle(x,y,r/2,r/6) then '.' elseif circle(x,y,-r/2,r/2) then '.' elseif circle(x,y,r/2,r/2) then '#' elseif circle(x,y,0,r) then if x<0 then '.' else '#' end else ' ' end; end proc; proc circle(x,c,y,r); return r*r >= (x/2)**2 + (y-c)**2; end proc; end program; Output:  . .........## .....###...## ...........#### .........######## ....########### ..###...##### ..######### # . .............## .................#### ...........###......##### ...........#####......##### .............###......####### ......................######### .....................########## .................################ ..........##################### .........###################### .......######...############# .....######.....########### .....######...########### ....################# ..############# # ## Sidef Translation of: Raku func circle (rad, cx, cy, fill='white', stroke='black') { say "<circle cx='#{cx}' cy='#{cy}' r='#{rad}' fill='#{fill}' stroke='#{stroke}' stroke-width='1'/>"; } func yin_yang (rad, cx, cy, fill='white', stroke='black', angle=90) { var (c, w) = (1, 0); angle != 0 && say "<g transform='rotate(#{angle}, #{cx}, #{cy})'>"; circle(rad, cx, cy, fill, stroke); say("<path d='M #{cx} #{cy + rad}A #{rad/2} #{rad/2} 0 0 #{c} #{cx} #{cy} ", "#{rad/2} #{rad/2} 0 0 #{w} #{cx} #{cy - rad} #{rad} #{rad} 0 0 #{c} #{cx} ", "#{cy + rad} z' fill='#{stroke}' stroke='none' />"); circle(rad/5, cx, cy + rad/2, fill, stroke); circle(rad/5, cx, cy - rad/2, stroke, fill); angle != 0 && say "</g>"; } say '<?xml version="1.0" encoding="UTF-8" standalone="no"?> <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"> <svg xmlns="http://www.w3.org/2000/svg" version="1.1" xmlns:xlink="http://www.w3.org/1999/xlink">'; yin_yang(40, 50, 50); yin_yang(20, 120, 120); say '</svg>';  ## SVG SVG has no proper functions or variables, but we can translate and rescale a shape after defining it. <?xml version="1.0" encoding="UTF-8" standalone="no"?> <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"> <svg xmlns="http://www.w3.org/2000/svg" version="1.1" xmlns:xlink="http://www.w3.org/1999/xlink" width="600" height="600"> <!-- We create the symbol in the rectangle from (0, 0) to (1, 1) and then translate it so it's centered on the origin. --> <symbol id="yinyang"> <g transform="translate(-0.5, -0.5)"> <!-- A white circle, for the bulk of the left-hand part --> <circle cx="0.5" cy="0.5" r="0.5" fill="white"/> <!-- A black semicircle, for the bulk of the right-hand part --> <path d="M 0.5,0 A 0.5,0.5 0 0,1 0.5,1 z" fill="black"/> <!-- Circles to extend each part --> <circle cx="0.5" cy="0.25" r="0.25" fill="white"/> <circle cx="0.5" cy="0.75" r="0.25" fill="black"/> <!-- The spots --> <circle cx="0.5" cy="0.25" r="0.1" fill="black"/> <circle cx="0.5" cy="0.75" r="0.1" fill="white"/> <!-- An outline for the whole shape --> <circle cx="0.5" cy="0.5" r="0.5" fill="none" stroke="gray" stroke-width=".01"/> </g> </symbol> <use xlink:href="#yinyang" transform="translate(125, 125) scale(200, 200)"/> <use xlink:href="#yinyang" transform="translate(375, 375) scale(400, 400)"/> </svg>  ## Tcl Library: Tk package require Tcl 8.5 package require Tk namespace import tcl::mathop::$-+$ ;# Shorter coordinate math proc yinyang {c x y r {colors {white black}}} { lassign$colors a b
set tt [expr {$r * 2 / 3.0}] set h [expr {$r / 2.0}]
set t [expr {$r / 3.0}] set s [expr {$r / 6.0}]
$c create arc [-$x $r] [-$y $r] [+$x $r] [+$y $r] \ -fill$a -outline {} -extent 180 -start 90
$c create arc [-$x $r] [-$y $r] [+$x $r] [+$y $r] \ -fill$b -outline {} -extent 180 -start 270
$c create oval [-$x $h] [-$y $r] [+$x $h]$y \
-fill $a -outline {}$c create oval [- $x$h] [+ $y$r] [+ $x$h] $y \ -fill$b -outline {}
$c create oval [-$x $s] [-$y $tt] [+$x $s] [-$y $t] \ -fill$b -outline {}
$c create oval [-$x $s] [+$y $tt] [+$x $s] [+$y $t] \ -fill$a -outline {}
}

pack [canvas .c -width 300 -height 300 -background gray50]
yinyang .c 110 110 90
yinyang .c 240 240 40


## UNIX Shell

Works with: Bourne Again SHell
#!/usr/bin/env bash
in_circle() { #(cx, cy, r, x y)
# return true if the point (x,y) lies within the circle of radius r centered
# on (cx,cy)
# (but really scaled to an ellipse with vertical minor semiaxis r and
# horizontal major semiaxis 2r)
local -i cx=$1 cy=$2 r=$3 x=$4 y=$5 local -i dx dy (( dx=(x-cx)/2, dy=y-cy, dx*dx + dy*dy <= r*r )) } taijitu() { #radius local -i radius=${1:-17}
local -i x1=0 y1=0 r1=radius            # outer circle
local -i x y
if ! in_circle $x1$y1 $r1$x $y; then printf ' ' elif in_circle$x2 $y2$r2 $x$y; then
printf '#'
elif in_circle $x3$y3 $r3$x $y; then printf '.' elif in_circle$x4 $y4$r4 $x$y; then
printf '.'
elif in_circle $x5$y5 $r5$x $y; then printf '#' elif (( x <= 0 )); then printf '.' else printf '#' fi done printf '\n' done }  Output: With default radius:  ..# ..........############# ..........######################### ........############################### ........################################### ............####################################### ..........######################################### ............##############...########################## ..............############.......########################## ..............############...........########################## ................############.......############################ ................##############...############################## ..................################################################# ....................############################################### ....................############################################### ......................############################################# ..........................######################################### ....................................################################# .........................................########################## .............................................###################### ...............................................#################### ...............................................#################### .................................................################## ..............................###..............################ ............................#######............################ ..........................###########............############## ..........................#######............############## ..........................###..............############ .........................................########## .......................................############ ...................................######## ...............................######## .........................########## .............########## ..#  With radius 9:  ..# ........########### ......################# ......##################### ........######...############## ........######.......############## ..........######...################ ..........######################### ............####################### ....................################# .......................############ .........................########## ................###......########## ..............#######......######## ..............###......######## .....................###### .................###### ...........######## ..#  ## Wren ### Text Translation of: AWK var inCircle = Fn.new { |centerX, centerY, radius, x, y| return (x-centerX)*(x-centerX)+(y-centerY)*(y-centerY) <= radius*radius } var inBigCircle = Fn.new { |radius, x, y| inCircle.call(0, 0, radius, x, y) } var inBlackSemiCircle = Fn.new { |radius, x, y| inCircle.call(0, -radius/2, radius/2, x, y) } var inWhiteSemiCircle = Fn.new { |radius, x, y| inCircle.call(0, radius/2, radius/2, x, y) } var inSmallBlackCircle = Fn.new { |radius, x, y| inCircle.call(0, radius/2, radius/6, x, y) } var inSmallWhiteCircle = Fn.new { |radius, x, y| inCircle.call(0, -radius/2, radius/6, x, y) } var yinAndYang = Fn.new { |radius| var black = "#" var white = "." var scaleX = 2 var scaleY = 1 for (sy in radius*scaleY..-(radius*scaleY)) { for (sx in -(radius*scaleX)..(radius*scaleX)) { var x = sx / scaleX var y = sy / scaleY if (inBigCircle.call(radius, x, y)) { if (inWhiteSemiCircle.call(radius, x, y)) { System.write(inSmallBlackCircle.call(radius, x, y) ? black : white) } else if (inBlackSemiCircle.call(radius, x, y)) { System.write(inSmallWhiteCircle.call(radius, x, y) ? white : black) } else { System.write((x < 0) ? white : black) } } else { System.write(" ") } } System.print() } } yinAndYang.call(16) yinAndYang.call(8)  Output:  . ...................#### ..........................##### ...............................###### ...................................######## ......................................######### .....................#######............######### ......................#########...........########### ......................###########...........########### ........................#########...........############# ..........................#######............############## .............................................################ ............................................################# ............................................################### ..........................................##################### .......................................######################## .................................################################ ........................####################################### .....................########################################## ...................############################################ .................############################################ ................############################################# ..............############.......########################## .............###########.........######################## ...........###########...........###################### ...........###########.........###################### .........############.......##################### .........###################################### ........################################### ......############################### .....########################## ....################### # . .............## .................#### ...........###......##### ...........#####......##### .............###......####### ......................######### .....................########## .................################ ..........##################### .........###################### .......######...############# .....######.....########### .....######...########### ....################# ..############# #  ### Graphical Library: DOME With a few minor changes, we can use the same code to draw these symbols in DOME. import "dome" for Window import "graphics" for Canvas, Color class YinAndYang { construct new(width, height) { Window.title = "Yin and Yang" Window.resize(width, height) Canvas.resize(width, height) } init() { Canvas.cls(Color.yellow) yinAndYang(200, 220, 220) yinAndYang(100, 460, 460) } inCircle(centerX, centerY, radius, x, y) { return (x-centerX)*(x-centerX)+(y-centerY)*(y-centerY) <= radius*radius } inBigCircle(radius, x, y) { inCircle(0, 0, radius, x, y) } inBlackSemiCircle(radius, x, y) { inCircle(0, radius/2, radius/2, x, y) } inWhiteSemiCircle(radius, x, y) { inCircle(0, -radius/2, radius/2, x, y) } inSmallBlackCircle(radius, x, y) { inCircle(0, -radius/2, radius/6, x, y) } inSmallWhiteCircle(radius, x, y) { inCircle(0, radius/2, radius/6, x, y) } yinAndYang(radius, ox, oy) { Canvas.offset(ox, oy) var scaleX = 2 var scaleY = 1 for (sy in radius*scaleY..-(radius*scaleY)) { for (sx in -(radius*scaleX)..(radius*scaleX)) { var x = sx / scaleX var y = sy / scaleY if (inBigCircle(radius, x, y)) { if (inWhiteSemiCircle(radius, x, y)) { var c = inSmallBlackCircle(radius, x, y) ? Color.black : Color.white Canvas.pset(x, y, c) } else if (inBlackSemiCircle(radius, x, y)) { var c = inSmallWhiteCircle(radius, x, y) ? Color.white : Color.black Canvas.pset(x, y, c) } else { var c = (x < 0) ? Color.white : Color.black Canvas.pset(x, y, c) } } } } } update() {} draw(alpha) {} } var Game = YinAndYang.new(600, 600)  ## XPL0 include c:\cxpl\codes; \intrinsic 'code' declarations def Black=0, Red=4, White=$F;

proc Circle(X0, Y0, R, CL, CR); \Show a filled circle
int X0, Y0, R, CL, CR;          \left and right half colors
int X, Y;
[for Y:= -R to R do
for X:= -R to R do
if X*X + Y*Y <= R*R then
Point(X+X0, Y+Y0, if X<0 then CL else CR);
]; \Circle

proc YinYang(X0, Y0, R);
int  X0, Y0, R;
[Circle(X0, Y0,     R,   White, Black);
Circle(X0, Y0-R/2, R/2, White, White);
Circle(X0, Y0-R/2, R/6, Black, Black);
Circle(X0, Y0+R/2, R/2, Black, Black);
Circle(X0, Y0+R/2, R/6, White, White);
]; \YinYang

copy to browswer
`