Yin and yang: Difference between revisions

{{trans|Python}}

V radii = [1, 3, 6].map(i -> i * @n)

V ranges = radii.map(r -> Array(-r .. r))

print(yinyang(2))

{{out}}

</pre>

The code:

MOVE.W #1,D0

;base sprite number, needed by NEOGEO hardware

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: [https://ibb.co/fDxTXhY Screenshot of NEOGEO displaying two Yin-Yangs]

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

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

DO UNTIL CH#$FF OD

CH=$FF

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Yin_and_yang.png Screenshot from Atari 8-bit computer]

Uses the Cairo component of GtkAda to create and save as png

[[file:YinYangAda.png|right]]

with Cairo; use Cairo;

with Cairo.Png; use Cairo.Png;

Status := Write_To_Png (Surface, "YinYangAda.png");

pragma Assert (Status = Cairo_Status_Success);

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due use of Currying.}}

CHAR black="#", white=".", clear=" ";

print yin yang(17);

print yin yang(8)

{{out}}

<pre>

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program yingyang.s */

.include "../affichage.inc"

{{Output}}

<pre>

=={{header|Asymptote}}==

[[File:Yinyang-asymptote.svg|thumb|The resulting EPS, converted to SVG]]

fill(scale(6)*unitsquare, invisible);

add(yinyang((1 + 1/4, 4 + 3/4), 1));

=={{header|AutoHotkey}}==

[[file:yin-yang-ahk.png|right]]

Requires the GDI+ Standard Library by tic: http://www.autohotkey.com/forum/viewtopic.php?t=32238

Yin_and_Yang(300, 300,A_ScriptDir "\YinYang2.png")

gdip_Shutdown(pToken)

return r

=={{header|AWK}}==

# syntax: GAWK -f YIN_AND_YANG.AWK

# converted from PHL

return in_circle(0,0-radius/2,radius/6,x,y)

}

{{out}}

<pre>

==={{header|AmigaBASIC}}===

s=.5

PSET (xp,yp)

PAINT (xp+size/4,yp)

==={{header|Applesoft BASIC}}===

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

170 YC = YP + S / 2 : GOSUB 1FILLCIRCLE

180 HCOLOR = 0 : YC = YP : R = S : GOSUB 2CIRCLE

==={{header|BASIC256}}===

graphsize 800, 600

clg

call Taijitu(500, 300, 138)

end

==={{header|BBC BASIC}}===

[[File:Yinyangbbc.gif|right]]

PROCyinyang(700, 400, 300)

END

CIRCLE FILL xpos%, ypos%+size%/2, size%/6+2

CIRCLE xpos%, ypos%, size%

==={{header|Commodore BASIC}}===

On a VIC-20 with the SuperExpander cartridge:

10 GRAPHIC 2

20 COLOR 0,1,1,1

160 PAINT 1,X-XR/2,Y

170 RETURN

{{works with|Simons' BASIC}}

10 COLOUR 0,0

20 HIRES 1,0

160 PAINT X-XR/2,Y,1

170 RETURN

{{works with|Commodore BASIC|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:

10 COLOR 0,1:COLOR 1,2:COLOR 4,1

20 GRAPHIC 1,1

160 PAINT 1,X-XR/2,Y

170 RETURN

Images of the results can be seen [https://imgur.com/a/GCekCvC here].

==={{header|FreeBASIC}}===

Screen 19

Color ,7

Taijitu(500, 300, 138)

End

==={{header|Gambas}}===

Dim hPictureBox As PictureBox

Dim siCount As Short

Next

'''[http://www.cogier.com/gambas/Yin%20and%20yang_270.png Click here to view image]'''

==={{header|IS-BASIC}}===

110 GRAPHICS HIRES 2

120 SET PALETTE WHITE,BLACK

200 SET INK 0:PLOT X,Y+R/2,ELLIPSE R/2,R/2,

210 SET INK 1:PLOT X,Y,ELLIPSE R,R,

==={{header|Liberty BASIC}}===

[[File:YinYangLB.gif||200px|thumb|right|Liberty BASIC Graphic Output]]

WindowHeight =440

[quit]

close #w

==={{header|Locomotive Basic}}===

20 xp=320:yp=200:size=150:gosub 100

30 xp=550:yp=350:size=40:gosub 100

2030 draw cx+cr*sin(i),cy+cr*cos(i)

2040 next

==={{header|PureBasic}}===

[[File:Yin And yang.png|300px]]

DrawingMode(#PB_2DDrawing_Outlined)

Circle(x, y, 2 * radius, #Black) ;outer circle

path$ = SaveFileRequester("Save image", "Yin And yang.png", "*.png", 0)

If path$ <> "": SaveImage(0, path$, #PB_ImagePlugin_PNG, 0, 2): EndIf

==={{header|uBasic/4tH}}===

End

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 ("#")))

==={{header|VBA}}===

ActiveSheet.Shapes.AddShape(msoShapeChord, Top, Left, Size, Size).Select

With Selection.ShapeRange

yinyang 200, 100, 100

yinyang 275, 175, 25

==={{header|Visual Basic .NET}}===

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.Windows.Forms

End Sub

End Class

====SVG====

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

' Yep, VB.NET can import XML namespaces. All literals have xmlns changed, while xmlns:xlink is only

End Using

End Sub

{{out}}

<!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">

<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 (harder cheating)====

{{trans|Raku}}

Sub Main()

Console.OutputEncoding = Text.Encoding.Unicode

Console.WriteLine(<div><%= cheat_harder(700) %><%= cheat_harder(350) %></div>)

End Sub

{{out}}

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

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

Rendered by RosettaCode (MediaWiki):

==={{header|Yabasic}}===

color 0,0,0

lx=x : rx=x : y=oy : m=-1 // m=-1 makes go upwards

next t

Other solution:

backcolor 255,0,0

color 0,0,0

pause .025

next n

==={{header|ZX Spectrum Basic}}===

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

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

9070 NEXT x

9080 NEXT y

[https://i.imgur.com/J1DK7qQl.png Resultant image at Imgur] (uses size=40 and position=40, then size=80 and position=160)

=={{header|BCPL}}==

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

$( yinyang(4)

yinyang(8)

{{out}}

<pre> ...

{{trans|PicoLisp}}

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

@#!`g01:+1g07,+55$<v0-g010p07_

0g-20g+:*+30g:*`v ^_:2/:*:70g0

2+*:-g02-g00g07:_ 1v v!`*:g0

g-:*+00g:*`#v_$:0`!0\v0_:70g00

{{out}}

=={{header|C}}==

Writes to stdout a SVG file with two yin-yangs (no, it's really just that big): [[File:yinyang-C.svg]]

void draw_yinyang(int trans, double scale)

printf("</svg>");

return 0;

=={{header|C++}}==

{{trans|Java}}

bool circle(int x, int y, int c, int r) {

yinYang(18);

return 0;

{{out}}

<pre> ...

(Cleaned up)

public partial class Form1 : Form

{

if (hasOutline) g.DrawEllipse(Pens.Black, pt.X, pt.Y, width, width);

}

{{out}}

=={{header|CLU}}==

rep = null

stream$putl(po, taijitu$make(4))

stream$putl(po, taijitu$make(8))

{{out}}

<pre> ..

=={{header|D}}==

{{trans|Python}}

std.conv, std.typecons;

2.yinYang.writeln;

1.yinYang.writeln;

{{out}}

<pre> .

A simpler alternative version:

{{trans|PicoLisp}}

import std.stdio, std.math;

void main() {

16.yinYang;

{{out}}

<pre> ...

=={{header|Delphi}}==

Instructions: Create an empty project. Paste code below and adjust the interface section for the form. Then assign 'FormCreate' to TForm1.OnCreate and 'FormPaint' to TForm1.OnPaint.

begin

Canv.Brush.Color := clWhite;

DrawYinAndYang(Canvas, R);

end;

{{output?}}

{{Trans|D}}

TColorFuncX = function (x : Integer) : Integer;

sq := new TSquareBoard(1);

sq.YinYang;

{{out}}

<pre>

{{works with|gforth|0.7.3}}

rot - dup *

rot dup * +

loop

loop drop

{{out}}

{{works with|4tH v3.64}}

4tH has a graphics library, which makes it quite easy to generate this picture using graphics commands only.

include lib/graphics.4th \ load the graphics library

include lib/gcircle.4th \ we need a full circle

300 300 295 circle \ let's make it a double line width

=={{header|Go}}==

There are some emerging third-party 2D graphics libraries for Go; meanwhile, here is an SVG solution using only standard libraries.

[[file:GoYinYang.svg|right]]

import (

}

f.Close()

=={{header|Haskell}}==

Depending on the command-line arguments, the program can generate SVG, PNG, PDF or PostScript output.

The sample output was created with the command <tt>yinyang -o YinYang-Haskell.svg</tt>.

import Diagrams.Prelude

main = defaultMain $

pad 1.1 $

=={{header|Icon}} and {{header|Unicon}}==

[[File:YinYang-unicon.PNG|thumb|Sample Output]]

procedure main()

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)

{{libheader|Icon Programming Library}}

Based on the Python implementation:

radii=. y*1 3 6

ranges=. i:each radii

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 [[Yin_and_yang/J|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.

Example use:

.

......*

..***********

.********

=={{header|Java}}==

[[File:Java-yinyang-240.png | right]]

import java.awt.Color;

frame.setVisible(true);

}

===Text===

{{works with|Java|1.8}}

import java.util.Map;

import java.util.Optional;

}

}

Test:

=={{header|JavaScript}}==

Another way, a more JavaScript-style way.

function Arc(posX,posY,radius,startAngle,endAngle,color){//Angle in radians.

this.posX=posX;

YingYang[0];

//In construction.

===Text===

{{trans|ALGOL 68}}

var scale_x = 2,

scale_y = 1,

})()

console.log(YinYang(17))

===SVG===

This is a SVG embedded in a HTML document;

it can be isolated from the HTML document too, making it a standalone SVG

<html>

</head>

=={{header|jq}}==

The jq program presented here is adapted from the C version and produces the same image:

[[File:yinyang-C.svg]]

def svg:

"<svg width='100%' height='100%' version='1.1'

"</svg>" ;

To view the image, store the output in a file:

The image can then be viewed in a browser.

{{trans|Python}}

radii = (i * n for i in (1, 3, 6))

ranges = collect(collect(-r:r) for r in radii)

println(yinyang(4))

=={{header|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.

import java.awt.Color

isVisible = true

}

=={{header|Lambdatalk}}==

{{SVG 580 580}

{YY 145 145 300}

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

=={{header|Logo}}==

{{works with|MSW_Logo|6.5b}}

; 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

forward 150

pendown

=={{header|Lua}}==

{{trans|C++}}

return (r * r) >= (x * x) / 4 + ((y - c) * (y - c))

end

end

{{out}}

<pre> .

=={{header|Maple}}==

with(plottools):

with(plots):

scaling = constrained, axes = none

);

=={{header|Mathematica}} / {{header|Wolfram Language}}==

[[File:Mathca.png|thumb|200px]]

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.

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,

=={{header|Metapost}}==

[[File:Mp-Yingyang.jpg||200px|thumb|right|Metapost output (once converted to jpg)]]

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

picture pic_;

path p_;

endfig;

=={{header|Modula-2}}==

FROM InOut IMPORT Write, WriteLn;

WriteLn();

YinYang(8);

{{out}}

<pre> ..

Writes an SVG document to standard output: [[File:yinyang-NRX.svg]]

{{trans|C}}

options replace format comments java crossref savelog symbols binary

yy = String.format(" <use xlink:href='#y' transform='translate(%d,%d) scale(%g)'/>", -

[Object Integer(trans), Integer(trans), Double(scale)])

=={{header|Nim}}==

{{trans|Ada}}

{{libheader|gintro}}

proc draw(ctx: Context; x, y, r: float) =

context.draw(35, 35, 30)

let status = surface.writeToPng("yin-yang.png")

=={{header|OCaml}}==

let draw_yinyang x y radius black white =

draw_yinyang w (h*2) (r*2) black white;

draw_yinyang (w*2) h r blue magenta;

run with:

=={{header|PARI/GP}}==

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.

{{Trans|JavaScript}}

//Compiled with fpc

Program yingyang;

{{out}}

<pre>

[[File:yinyang-perl.svg|thumb]]

my ($radius, $cx, $cy, $fill, $stroke) = @_;

print "<circle cx='$cx' cy='$cy' r='$radius' ",

yin_yang(100, 500, 500);

Messy code. Note that the larger yin-yang is drawn recursively.

{{libheader|Phix/online}}

You can run this online [http://phix.x10.mx/p2js/yinyang.htm here].

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\Yin_and_yang.exw

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

=={{header|PHL}}==

{{trans|ALGOL 68}}

extern printf;

print_yin_yang(8);

return 0;

{{out}}

=={{header|PicoLisp}}==

(>=

(* R R)

(if (lt0 X) "." "#") )

(T " ") ) ) )

{{out|Test}}

=={{header|Plain English}}==

Start up.

Clear the screen to the gray color.

Unmask everything.

Use the fat pen.

{{out}}

[https://commons.wikimedia.org/wiki/File:Taijitu_symbols_drawn_with_Plain_English.png]

=={{header|PL/I}}==

yinyang: procedure(r);

circle: procedure(x, y, c, r) returns(bit);

put skip;

call yinyang(8);

{{out}}

<pre> ...

=={{header|PostScript}}==

{{out}} [[File:PSyinyang.png|thumb]]

%%BoundingBox: 0 0 400 400

6 circ 220 180 dis

showpage

=={{header|POV-Ray}}==

[[File:Yys.png|thumb]]

// ====== General Scene setup ======

#version 3.7;

#declare scl = scl*0.85;

=={{header|Prolog}}==

Works with SWI-Prolog and XPCE.

R is N * 100,

sformat(Title, 'Yin Yang ~w', [N]),

send(P, fill_pattern, Col).

{{out}}

<pre> ?- ying_yang(1).

an ASCII representation of the Yin yang symbol.

{{works with|Python|3.x}}

def yinyang(n=3):

radii = [i * n for i in (1, 3, 6)]

m[(x,y+3*n)] = '·'

m[(x,y-3*n)] = '*'

;Sample generated symbols for <code>n = 2</code> and <code>n = 3</code>:

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.

[[File:Yinyang.GIF||200px|thumb|right|Python turtle graphics program output]]

mode('logo')

goto(-150, -150)

taijitu(100)

=={{header|Quackery}}==

[ -1 4 turn

100 1 yinyang

420 1 fly

{{output}}

=={{header|R}}==

[[File:yin_yang.png|thumb|Output of this R program]]

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)

plot.yin.yang()

plot.yin.yang(1,7,1, add=T)

=={{header|Racket}}==

[[File:Rosetta-yin-yang.png||200px|thumb|right]]

#lang racket

(require slideshow/pict)

(yin-yang 200)

=={{header|Raku}}==

Translation / Modification of C and Perl examples.

say "<circle cx='$cx' cy='$cy' r='$rad' fill='$fill' stroke='$stroke' stroke-width='1'/>";

}

yin_yang(50, 300, 300);

Seems like something of a cheat since it relies on a web browser /

If that's the case, we may as well cheat harder. ;-)

<div><span style="font-size:700%;">&#x262f;</span><span style="font-size:350%;">&#x262f;</span></div>

=={{header|Rascal}}==

[[File:Yinyang.jpg||200px|thumb|right]]

import vis::Render;

import vis::Figure;

render(hcat([vcat([overlay([template, black, smallWhite, smallBlack], aspectRatio (1.0)), space(), space()]),

overlay([template, black, smallWhite, smallBlack], aspectRatio (1.0))]));

=={{header|REXX}}==

{{trans|PHL}}

Code was added to this REXX program to try to preserve the aspect ratio when displaying the Yin-Yang symbol.

parse arg s1 s2 . /*obtain optional arguments from the CL*/

if s1=='' | s1=="," then s1= 17 /*Not defined? Then use the default. */

end /*sy*/

say strip($, 'T') /*display one line of a Yin─Yang symbol*/

{{out|output|text=&nbsp; when using the inputs of: &nbsp; &nbsp; <tt> 35 &nbsp; 25 </tt>}}

[[File:yin_yang.shoes.png|thumb|Output of this Ruby Shoes program]]

{{libheader|Shoes}}

PI = Shoes::TWO_PI/2

yin_yang 190, 190, 360

yin_yang 410, 90, 90

=={{header|Rust}}==

'''[dependencies]'''<br>

svg = "0.10.0"

fn main() {

+ &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")

=={{header|Scala}}==

{{libheader|Scala}}

import scala.swing.{ MainFrame, Panel }

import java.awt.{ Color, Graphics2D }

super.main(args)

}

=={{header|Scilab}}==

This script uses complex numbers, as in <math>x + i\,y</math>, to represent <math>(x,y)</math> coordinates. [[wp:Euler's formula|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.

scale = 0.5; //scale of the second image

plot2d(real(Arcs(7,:)),imag(Arcs(7,:)));

=={{header|Seed7}}==

[[File:yinandyang.png|thumb|Output of the Seed7 program]]

include "float.s7i";

include "math.s7i";

yinYang(400, 250, 200);

readln(KEYBOARD);

=={{header|Sidef}}==

{{trans|Raku}}

say "<circle cx='#{cx}' cy='#{cy}' r='#{rad}' fill='#{fill}' stroke='#{stroke}' stroke-width='1'/>";

}

yin_yang(20, 120, 120);

=={{header|SVG}}==

but we can translate and rescale a shape after defining it.

<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"

"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">

transform="translate(375, 375) scale(400, 400)"/>

=={{header|Tcl}}==

[[File:yinyang-tcl.gif|thumb|Output of this Tcl program]]

{{libheader|Tk}}

package require Tk

pack [canvas .c -width 300 -height 300 -background gray50]

yinyang .c 110 110 90

=={{header|UNIX Shell}}==

{{works with|Bourne Again SHell}}

in_circle() { #(cx, cy, r, x y)

# return true if the point (x,y) lies within the circle of radius r centered

printf '\n'

done

{{Output}}

===Text===

{{trans|AWK}}

return (x-centerX)*(x-centerX)+(y-centerY)*(y-centerY) <= radius*radius

}

yinAndYang.call(16)

{{out}}

{{libheader|DOME}}

With a few minor changes, we can use the same code to draw these symbols in DOME.

import "graphics" for Canvas, Color

}

=={{header|XPL0}}==

[[File:YinXPL0.png|180px|thumb|right|Output]]

def Black=0, Red=4, White=$F;

if ChIn(1) then []; \wait for keystroke

SetVid(3); \restore normal text mode

=={{header|zkl}}==

Writes to stdout a SVG file with two yin-yangs.

0'|<use xlink:href="#y" transform="translate(%d,%d) scale(%g)"/>|

.fmt(trans,trans,scale).print();

draw_yinyang(20, 0.05);

draw_yinyang( 8, 0.02);

A here doc (#<<<) could be used to wrap the HTML but, depending on the editor used, the formatting may not be what you want (eg "\n" vs "\r\n").

{{out}}