DISLIN Beispiele / Julia

Demonstration of CURVE / Julia

using Dislin

n = 300
fpi = 3.1415926 / 180
stp = 360.0 / (n - 1)

xray  = Array{Float64}(n)
y1ray = Array{Float64}(n)
y2ray = Array{Float64}(n)

for i = 1:n
  xray[i] = (i - 1) * stp
  x = xray[i] * fpi 
  y1ray[i] = sin(x)
  y2ray[i] = cos(x)
end

Dislin.scrmod("revers")
Dislin.metafl("xwin")
Dislin.disini()
Dislin.pagera()
Dislin.complx()

Dislin.axspos(450, 1800)
Dislin.axslen(2200, 1200)

Dislin.name("X-axis", "X")
Dislin.name("Y-axis", "Y")
Dislin.labdig(-1, "X")
Dislin.ticks(10, "Y")
Dislin.ticks(9, "X")

Dislin.titlin("Demonstration of CURVE", 1)
Dislin.titlin("SIN(X), COS(X)", 3)

ic = Dislin.intrgb(0.95, 0.95, 0.95)
Dislin.axsbgd(ic)

Dislin.graf(0.0, 360.0, 0.0, 90.0, -1.0, 1.0, -1.0, 0.5)

Dislin.setrgb(0.7, 0.7, 0.7)
Dislin.grid(1, 1)

Dislin.color("fore")
Dislin.height(50)
Dislin.title()

Dislin.color("red")
Dislin.curve(xray, y1ray, n)
Dislin.color("green")
Dislin.curve(xray, y2ray, n)
Dislin.disfin()

Polar Plots / Julia

using Dislin

n = 300
m = 10
step = 360.0 / (n - 1)

xray  = Array{Float64}(n)
x1  = Array{Float64}(n)
y1  = Array{Float64}(n)

x2  = Array{Float64}(m)
y2  = Array{Float64}(m)

for i = 1:n
  xray[i] = (i - 1) * step
  y1[i] = ((i - 1) * step) * 3.1415926 / 180.0
  x1[i] = sin(5 * y1[i])
end

for i = 1:m
  x2[i] = i
  y2[i] = i
end

Dislin.setpag("da4p")
Dislin.scrmod("revers")
Dislin.metafl("cons")
Dislin.disini()
Dislin.complx()
Dislin.pagera()

Dislin.titlin("Polar Plots", 2)
Dislin.ticks(3, "Y")
Dislin.axends("NOENDS", "X")
Dislin.labdig(-1, "Y")
Dislin.axslen(1000, 1000)
Dislin.axsorg(1050, 900)

ic = Dislin.intrgb(0.95,0.95,0.95)
Dislin.axsbgd(ic)
Dislin.grafp(1.0, 0.0, 0.2, 0.0, 30.0);
Dislin.color("blue")
Dislin.curve(x1, y1, n)
Dislin.color("fore")
Dislin.htitle(50)
Dislin.title()
Dislin.endgrf()

Dislin.labdig(-1, "X")
Dislin.axsorg(1050, 2250)
Dislin.labtyp("VERT", "Y")
Dislin.grafp(10.0, 0.0, 2.0, 0.0, 30.0)
Dislin.barwth(-5.0)
Dislin.polcrv("FBARS")
Dislin.color("blue")
Dislin.curve(x2, y2, m)

Dislin.disfin()

Symbols / Julia

using Dislin

ctit = "Symbols"

Dislin.setpag("da4p")
Dislin.metafl("cons")

Dislin.disini()
Dislin.pagera()
Dislin.hwfont()
Dislin.paghdr("H. Michels (", ")", 2, 0)

Dislin.height(60)
nl = Dislin.nlmess(ctit)
Dislin.messag(ctit, div(2100 - nl, 2), 200)

Dislin.height(50)
Dislin.hsymbl(120)

ny = 150
nxp = 0 
for j = 1:24
  i = j - 1
  x = j - 1.0
  if((i % 4) == 0)
    ny  = ny + 400
    nxp = 550
  else 
    nxp = nxp + 350
  end
  nl = Dislin.nlnumb(x, -1)
  Dislin.number(x, -1, nxp - div(nl, 2), ny + 150)
  Dislin.symbol(i, nxp, ny)
end
Dislin.disfin()

Interpolation Methods / Julia

using Dislin

ctit = "Interpolation Methods"

xray = [0.0, 1.0, 3.0, 4.5, 6.0, 8.0, 9.0, 11.0, 12.0, 12.5, 
        13.0, 15.0, 16.0, 17.0, 19.0, 20.0]
yray = [2.0, 4.0, 4.5, 3.0, 1.0, 7.0, 2.0, 3.0, 5.0, 2.0, 2.5,
        2.0, 4.0, 6.0, 5.5, 4.0]
cpol = ["SPLINE", "STEM", "BARS", "STAIRS", "STEP", "LINEAR"]

Dislin.setpag("da4p")
Dislin.scrmod("revers")
Dislin.metafl("cons")

Dislin.disini()
Dislin.pagera()
Dislin.complx()

Dislin.incmrk(1)
Dislin.hsymbl(25)
Dislin.titlin(ctit, 1)
Dislin.axslen(1500, 350)
Dislin.setgrf("LINE", "LINE", "LINE", "LINE")

ic = Dislin.intrgb(1.0, 1.0, 0.0)
Dislin.axsbgd(ic)

nya = 2700
for i = 1:6
  Dislin.axspos(350, nya - (i - 1)  * 350)
  Dislin.polcrv(cpol[i])
  Dislin.marker(0)
  Dislin.graf(0.0, 20.0, 0.0, 5.0, 0.0, 10.0, 0.0, 5.0)
  nx = Dislin.nxposn(1.0)
  ny = Dislin.nyposn(8.0)
  Dislin.messag(cpol[i], nx, ny)
  Dislin.color("red")
  Dislin.curve(xray, yray, 16)
  Dislin.color("fore")

  if (i == 6)
    Dislin.height(50)
    Dislin.title()
  end

  Dislin.endgrf()
end

Dislin.disfin()

Bar Graphs / Julia

using Dislin

x  = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]
y  = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
y1 = [1.0, 1.5, 2.5, 1.3, 2.0, 1.2, 0.7, 1.4, 1.1]
y2 = [2.0, 2.7, 3.5, 2.1, 3.2, 1.9, 2.0, 2.3, 1.8]
y3 = [4.0, 3.5, 4.5, 3.7, 4.0, 2.9, 3.0, 3.2, 2.6]
cbuf = Array{UInt8}(80)

nya = 2700
ctit = "Bar Graphs(BARS)"

Dislin.scrmod("revers")
Dislin.setpag("da4p")
Dislin.metafl("cons")
Dislin.disini()
Dislin.pagera()
Dislin.complx()
Dislin.ticks(1, "x")
Dislin.intax()
Dislin.axslen(1600, 700)
Dislin.titlin(ctit, 3)

Dislin.legini(cbuf, 3, 8)
Dislin.leglin(cbuf, "FIRST", 1)
Dislin.leglin(cbuf, "SECOND", 2)
Dislin.leglin(cbuf, "THIRD", 3)
Dislin.legtit(" ")
Dislin.shdpat(5)

for i = 1:3
  if (i > 1)
    Dislin.labels("none","x")
  end

  Dislin.axspos(300, nya - (i - 1) * 800)
  Dislin.graf(0.0, 10.0, 0.0, 1.0, 0.0, 5.0, 0.0, 1.0)

  if (i == 1)
    Dislin.bargrp(3, 0.15)
    Dislin.color("red")
    Dislin.bars(x, y, y1, 9)
    Dislin.color("green")
    Dislin.bars(x, y, y2, 9)
    Dislin.color("blue")
    Dislin.bars(x, y, y3, 9)
    Dislin.color("fore")
    Dislin.reset("bargrp")
  elseif (i == 2)
    Dislin.height(30)
    Dislin.labels("delta","bars")
    Dislin.labpos("center","bars")
    Dislin.color("red")
    Dislin.bars(x, y, y1, 9)
    Dislin.color("green")
    Dislin.bars(x, y1, y2, 9)
    Dislin.color("blue")
    Dislin.bars(x, y2, y3, 9)
    Dislin.color("fore")
    Dislin.reset("height") 
  elseif (i == 3)
    Dislin.labels("second", "bars")
    Dislin.labpos("outside", "bars")
    Dislin.color("red")
    Dislin.bars(x, y, y1, 9)
    Dislin.color("fore")
  end

  if (i != 3)
    Dislin.legend(cbuf,7)
  end 

  if (i == 3)
    Dislin.height(50)
    Dislin.title()
  end
  Dislin.endgrf()
end

Dislin.disfin()

Pie Charts / Julia

using Dislin
xray = [1.0, 2.5, 2.0, 2.7, 1.8]
cbuf = Array{UInt8}(80)

ctit = "Pie Charts(PIEGRF)"

Dislin.scrmod("revers")
Dislin.setpag("da4p")
Dislin.metafl("cons")
Dislin.disini()
Dislin.pagera()
Dislin.complx()
Dislin.chnpie("BOTH")

Dislin.axslen(1600, 1000)
Dislin.titlin(ctit, 2)

Dislin.legini(cbuf, 5, 8)
Dislin.leglin(cbuf, "FIRST",  1)
Dislin.leglin(cbuf, "SECOND", 2)
Dislin.leglin(cbuf, "THIRD",  3)
Dislin.leglin(cbuf, "FOURTH", 4)
Dislin.leglin(cbuf, "FIFTH",  5)

# Selecting shading patterns
Dislin.patcyc(1, 7)
Dislin.patcyc(2, 4)
Dislin.patcyc(3, 13)
Dislin.patcyc(4, 3)
Dislin.patcyc(5, 5)

Dislin.axspos(250, 2800)
Dislin.piegrf(cbuf, 1, xray, 5)
Dislin.endgrf()

Dislin.axspos(250, 1600)
Dislin.labels("DATA", "PIE")
Dislin.labpos("EXTERNAL", "PIE")
Dislin.piegrf(cbuf, 1, xray, 5)

Dislin.height(50)
Dislin.title()
Dislin.disfin()

3-D Bar Graph / 3-D Pie Chart / Julia

using Dislin

xray  = [2.0, 4.0, 6.0, 8.0, 10.0]
y1ray = [0.0, 0.0, 0.0, 0.0, 0.0]
y2ray = [3.2, 1.5, 2.0, 1.0, 3.0]

ic1ray = [50, 150, 100, 200, 175]
ic2ray = [50, 150, 100, 200, 175]

ic1 = Array{Int32}(5)
ic2 = Array{Int32}(5)

for i = 1:5
  ic1[i] = ic1ray[i]
  ic2[i] = ic2ray[i]
end

cbuf = Array{UInt8}(80)

Dislin.scrmod("revers")
Dislin.metafl("cons")
Dislin.setpag("da4p")
Dislin.disini()
Dislin.pagera()
Dislin.hwfont()

Dislin.titlin("3-D Bar Graph / 3-D Pie Chart", 2)
Dislin.htitle(40)

Dislin.shdpat(16)
Dislin.axslen(1500, 1000)
Dislin.axspos(300, 1400)

Dislin.barwth(0.5)
Dislin.bartyp("3dvert")
Dislin.labels("second", "bars")
Dislin.labpos("outside", "bars")
Dislin.labclr(255, "bars")
Dislin.graf(0.0, 12.0, 0.0, 2.0, 0.0, 5.0, 0.0, 1.0)
Dislin.title()
Dislin.color("red")
Dislin.bars(xray, y1ray, y2ray, 5)
Dislin.endgrf()

Dislin.shdpat(16)
Dislin.labels("data", "pie")
Dislin.labclr(255, "pie")
Dislin.chnpie("none")
Dislin.pieclr(ic1, ic2, 5)      # integer arrays must be Int32
Dislin.pietyp("3d")
Dislin.axspos(300, 2700)
Dislin.piegrf(cbuf, 0, y2ray, 5)  
Dislin.disfin()

3-D Bars / BARS3D / Julia

using Dislin

n = 18

xray  =  [1.0, 3.0, 8.0, 1.5, 9.0, 6.3, 5.8, 2.3, 8.1, 3.5,
          2.2, 8.7, 9.2, 4.8, 3.4, 6.9, 7.5, 3.8]
yray  =  [5.0, 8.0, 3.5, 2.0, 7.0, 1.0, 4.3, 7.2, 6.0, 8.5,
          4.1, 5.0, 7.3, 2.8, 1.6, 8.9, 9.5, 3.2]
z1ray =  [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
          0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
z2ray =  [4.0, 5.0, 3.0, 2.0, 3.5, 4.5, 2.0, 1.6, 3.8, 4.7,
          2.1, 3.5, 1.9, 4.2, 4.9, 2.8, 3.6, 4.3]
icray =  [30, 30, 30, 30, 30, 30, 100, 100, 100, 100,
         100, 100, 170, 170, 170, 170, 170, 170]

icr = Array{Int32}(n)
cbuf = Array{UInt8}(80)

for i = 1:n
  icr[i] = icray[i]
end

xwray = Array{Float64}(n)
ywray = Array{Float64}(n)
for i = 1:n
  xwray[i] = 0.5
  ywray[i] = 0.5
end

Dislin.scrmod("revers")
Dislin.metafl("xwin")
Dislin.setpag("da4p")
Dislin.disini()
Dislin.hwfont()
Dislin.pagera()

Dislin.axspos(200, 2600)
Dislin.axslen(1800, 1800)

Dislin.name("X-axis", "X")
Dislin.name("Y-axis", "Y")
Dislin.name("Z-axis", "Z")

Dislin.titlin("3-D Bars / BARS3D",3)
Dislin.labl3d("hori")

Dislin.graf3d(0.0,10.0,0.0,2.0,0.0,10.0,0.0,2.0,0.0,5.0,0.0,1.0)
Dislin.grid3d(1, 1, "bottom")

Dislin.bars3d(xray, yray, z1ray, z2ray, xwray, ywray, icr, n)

Dislin.legini(cbuf, 3, 20)
Dislin.legtit(" ")
Dislin.legpos(1350, 1150)
Dislin.leglin(cbuf, "First", 1)
Dislin.leglin(cbuf, "Second", 2)
Dislin.leglin(cbuf, "Third", 3)
Dislin.legend(cbuf, 3)

Dislin.height(50)
Dislin.title()
Dislin.disfin()

Shading Patterns / Julia

using Dislin

ix  = [0, 300, 300,   0]
iy  = [0,   0, 400, 400]

ixp  = Array{Int32}(4)
iyp  = Array{Int32}(4)

Dislin.scrmod("revers")
Dislin.metafl("cons")
Dislin.disini()
Dislin.setvlt("small")
Dislin.pagera()
Dislin.complx()

Dislin.height(50)
ctit = "Shading patterns (AREAF)"
nl = Dislin.nlmess(ctit)
Dislin.messag(ctit, div(2970 - nl, 2), 200)

nx0 = 335
ny0 = 350

iclr = 0
for i = 0:2
  ny = ny0 + i * 600

  for j = 0:5
    nx = nx0 + j * 400
    ii = i * 6 + j
    x = i * 6.0 + j

    Dislin.shdpat(ii)
    iclr = iclr + 1
    iclr = iclr % 8
    if (iclr == 0)
      iclr = 8
    end 
    Dislin.setclr(iclr)
    for k = 1:4
      ixp[k] = ix[k] + nx
      iyp[k] = iy[k] + ny
    end

    Dislin.areaf(ixp, iyp, 4)
    nl = Dislin.nlnumb(x, -1)
    nx = nx + div(300 - nl, 2)
    Dislin.color("foreground")
    Dislin.number(x, -1, nx, ny + 460) 
  end
end

Dislin.disfin()

3-D Colour Plot / Julia

using Dislin

ctit1 = "3-D  Colour Plot of the Function"
ctit2 = "F(X,Y) = 2 * SIN(X) * SIN (Y)"

n = 100
m = 100
zmat = Array{Float64}(n, m)

fpi  = 3.1415927 / 180.0
stepx = 360.0 / (n - 1)
stepy = 360.0 / (m - 1)

for i = 1:n
  x = (i - 1) * stepx
  for j = 1:m
    y = (j - 1) * stepy
    zmat[i,j] = 2 * sin(x * fpi) * sin(y * fpi)
  end
end

Dislin.metafl("xwin")
Dislin.disini()
Dislin.pagera()
Dislin.complx()

Dislin.titlin(ctit1, 1)
Dislin.titlin(ctit2, 3)

Dislin.name("X-axis", "X")
Dislin.name("Y-axis", "Y")
Dislin.name("Z-axis", "Z")

Dislin.intax()
Dislin.autres(n, m)
Dislin.axspos(300, 1850)
Dislin.ax3len(2200, 1400, 1400)

Dislin.graf3(0.0, 360.0, 0.0, 90.0, 0.0, 360.0, 0.0, 90.0,
                -2.0, 2.0, -2.0, 1.0)
Dislin.crvmat(zmat, n, m, 1, 1)
Dislin.height(50)
Dislin.title()
Dislin.disfin()

Surface Plot / Julia

using Dislin

ctit1 = "Surface Plot of the Function"
ctit2 = "F(X,Y) = 2 * SIN(X) * SIN(Y)"

n = 50
m = 50
zmat = Array{Float64}(n, m)

fpi  = 3.1415927 / 180.0
stepx = 360.0 / (n - 1)
stepy = 360.0 / (m - 1)

for i = 1:n
  x = (i - 1) * stepx
  for j = 1:m
    y = (j - 1) * stepy
    zmat[i,j] = 2 * sin(x * fpi) * sin(y * fpi)
  end
end

Dislin.scrmod("revers")
Dislin.metafl("cons")
Dislin.setpag("da4p")
Dislin.disini()
Dislin.pagera()
Dislin.complx()

Dislin.titlin(ctit1, 2)
Dislin.titlin(ctit2, 4)

Dislin.axspos(200, 2600)
Dislin.axslen(1800, 1800)

Dislin.name("X-axis", "X")
Dislin.name("Y-axis", "Y")
Dislin.name("Z-axis", "Z")

Dislin.view3d(-5.0, -5.0, 4.0, "ABS")
Dislin.graf3d(0.0, 360.0, 0.0, 90.0, 0.0, 360.0, 0.0, 90.0,
                -3.0, 3.0, -3.0, 1.0)
Dislin.height(50)
Dislin.title()

Dislin.color("green")
Dislin.surmat(zmat, n, m, 1, 1)
Dislin.disfin()

Shaded Surface Plot / Julia

using Dislin

ctit1 = "Surface Plot of the Function"
ctit2 = "F(X,Y) = 2 * SIN(X) * SIN(Y)"

n = 50
m = 50
zmat = Array{Float64}(n, m)
xray = Array{Float64}(n)
yray = Array{Float64}(m)

fpi  = 3.1415927 / 180.0
stepx = 360.0 / (n - 1)
stepy = 360.0 / (m - 1)

for i = 1:n
  x = (i - 1) * stepx
  xray[i] = x
  for j = 1:m
    y = (j - 1) * stepy
    zmat[i,j] = 2 * sin(x * fpi) * sin(y * fpi)
  end
end

for j = 1:m
  yray[j] = (j - 1) * stepy
end

Dislin.metafl("cons")
Dislin.scrmod("revers")
Dislin.setpag("da4p")
Dislin.disini()
Dislin.pagera()
Dislin.complx()

Dislin.titlin(ctit1, 2)
Dislin.titlin(ctit2, 4)

Dislin.axspos(200, 2600)
Dislin.axslen(1800, 1800)

Dislin.name("X-axis", "X")
Dislin.name("Y-axis", "Y")
Dislin.name("Z-axis", "Z")

Dislin.view3d(-5.0, -5.0, 4.0, "ABS")
Dislin.graf3d(0.0, 360.0, 0.0, 90.0, 0.0, 360.0, 0.0, 90.0,
                -3.0, 3.0, -3.0, 1.0)
Dislin.height(50)
Dislin.title()

Dislin.shdmod("smooth", "surface")
Dislin.surshd(xray,n,yray,n,zmat)
Dislin.disfin()

Contour Plot / Julia

using Dislin

ctit1 = "Contour Plot"
ctit2 = "F(X,Y) = 2 * SIN(X) * SIN(Y)"

n = 50
m = 50
xray = Array{Float64}(n)
yray = Array{Float64}(m)
zlev = Array{Float64}(12)
zmat = Array{Float64}(n, m)

fpi  = 3.1415927 / 180.0
stepx = 360.0 / (n - 1)
stepy = 360.0 / (m - 1)

for i = 1:n
  xray[i] = (i - 1) * stepx
end

for i = 1:m
  yray[i] = (i - 1) * stepy
end

for i = 1:n
  x = (i - 1) * stepx
  for j = 1:m
    y = (j - 1) * stepy
    zmat[i,j] = 2 * sin(x * fpi) * sin(y * fpi)
  end
end

Dislin.scrmod("revers")
Dislin.metafl("cons")
Dislin.setpag("da4p")
Dislin.disini()
Dislin.pagera()
Dislin.complx()

Dislin.titlin(ctit1, 1)
Dislin.titlin(ctit2, 3)

Dislin.intax()
Dislin.axspos(450, 2650)

Dislin.name("X-axis", "X")
Dislin.name("Y-axis", "Y")

Dislin.graf(0.0, 360.0, 0.0, 90.0, 0.0, 360.0, 0.0, 90.0)
Dislin.height(50)
Dislin.title()

Dislin.height(30)
for i = 1:9
  zlev = -2.0 + i * 0.5
  if (i == 5)
    Dislin.labels("NONE", "CONTUR")
  else
    Dislin.labels("FLOAT", "CONTUR")
  end

  Dislin.setclr(i * 28)
  Dislin.contur(xray, n, yray, m, zmat, zlev)
end

Dislin.disfin()

Shaded Contour Plot / Julia

using Dislin

ctit1 = "Shaded Contour Plot"
ctit2 = "F(X,Y) =(X[2\$ - 1)[2\$ +(Y[2\$ - 1)[2\$"

n = 50
m = 50
xray = Array{Float64}(n)
yray = Array{Float64}(m)
zlev = Array{Float64}(12)
zmat = Array{Float64}(n, m)

stepx = 1.6 /(n - 1)
stepy = 1.6 /(m - 1)

for i = 1:n
  xray[i] = (i - 1) * stepx
end

for i = 1:m
  yray[i] = (i - 1) * stepy
end

for i = 1:n
  x = xray[i] * xray[i] - 1.0
  x = x * x
  for j = 1:m
    y = yray[j] * yray[j] - 1.0
    zmat[i,j] = x + y * y
  end
end

Dislin.scrmod("revers")
Dislin.metafl("cons")
Dislin.setpag("da4p")

Dislin.disini()
Dislin.pagera()
Dislin.complx()
Dislin.mixalf()

Dislin.titlin(ctit1, 1)
Dislin.titlin(ctit2, 3)

Dislin.name("X-axis", "X")
Dislin.name("Y-axis", "Y")

Dislin.axspos(450, 2670)
Dislin.shdmod("poly", "contur")
Dislin.graf(0.0, 1.6, 0.0, 0.2, 0.0, 1.6, 0.0, 0.2)

for i = 1:12
  zlev[13-i] = 0.1 + (i - 1) * 0.1
end

Dislin.conshd(xray, n, yray, m, zmat, zlev, 12)

Dislin.height(50)
Dislin.title()

Dislin.disfin()

Shaded Surface / Contour Plot / Julia

using Dislin

ctit1 = "Shaded Surface / Contour Plot"
ctit2 = "F(X,Y) = 2 * SIN(X) * SIN(Y)"

n = 50
m = 50
nlev = 20

zmat = Array{Float64}(n, m)
xray = Array{Float64}(n)
yray = Array{Float64}(m)
zlev = Array{Float64}(nlev)

fpi  = 3.1415927 / 180.0
stepx = 360.0 /(n - 1)
stepy = 360.0 /(m - 1)

for i = 1:n
  x = (i - 1) * stepx
  xray[i] = x
  for j = 1:m
    y = (j - 1) * stepy
    yray[j] = y
    zmat[i,j] = 2 * sin(x * fpi) * sin(y * fpi)
  end
end

Dislin.scrmod("revers")
Dislin.metafl("cons")
Dislin.setpag("da4p")
Dislin.disini()
Dislin.pagera()
Dislin.hwfont()

Dislin.titlin(ctit1, 2)
Dislin.titlin(ctit2, 4)

Dislin.axspos(200, 2600)
Dislin.axslen(1800, 1800)

Dislin.name("X-axis", "X")
Dislin.name("Y-axis", "Y")
Dislin.name("Z-axis", "Z")

Dislin.graf3d(0.0, 360.0, 0.0, 90.0, 0.0, 360.0, 0.0, 90.0,
               -2.0, 2.0, -2.0, 1.0)
Dislin.height(50)
Dislin.title()

Dislin.grfini(-1.0, -1.0, -1.0, 1.0, -1.0, -1.0, 1.0, 1.0, -1.0)
Dislin.nograf()
Dislin.graf(0.0, 360.0, 0.0, 90.0, 0.0, 360.0, 0.0, 90.0)
  
step = 4.0 / nlev
for i = 1:nlev
   zlev[i] = -2.0 + (i - 1) * step 
end
Dislin.conshd(xray, n, yray, n, zmat, zlev, nlev)

Dislin.box2d()
Dislin.reset("nograf")
Dislin.grffin()

Dislin.shdmod("smooth", "surface")
Dislin.surshd(xray, n, yray, m, zmat)
Dislin.disfin()

Spheres and Tubes / Julia

using Dislin

x = [10.0, 20.0, 10.0, 20.0, 5.0, 15.0, 25.0, 5.0, 15.0, 25.0, 
      5.0, 15.0, 25.0, 10.0, 20.0, 10.0, 20.0]
y = [10.0, 10.0, 20.0, 20.0, 5.0, 5.0, 5.0, 15.0, 15.0, 15.0,
      25.0, 25.0, 25.0, 10.0, 10.0, 20.0, 20.0]
z = [5.0, 5.0, 5.0, 5.0, 15.0, 15.0, 15.0, 15.0, 15.0, 15.0,
    15.0, 15.0, 15.0, 25.0, 25.0, 25.0, 25.0]  
idx = [1, 2, 1, 3, 3, 4, 2, 4, 5, 6, 6, 7, 8, 9, 9, 10,
      11, 12, 12, 13,  5, 8, 8, 11, 6, 9, 9, 12, 7, 10,
      10, 13,  14, 15, 16, 17, 14, 16, 15, 17,
       1, 5, 2, 7, 3, 11, 4, 13, 5, 14, 7, 15, 11, 16, 13, 17]


Dislin.setpag("da4p")
Dislin.scrmod("revers")
Dislin.metafl("cons")
Dislin.disini()
Dislin.pagera()
Dislin.hwfont()
Dislin.light("on")
Dislin.matop3(0.02, 0.02, 0.02, "specular")

Dislin.clip3d("none")
Dislin.axspos(0, 2500)
Dislin.axslen(2100, 2100)

Dislin.htitle(50)
Dislin.titlin("Spheres and Tubes", 4)

Dislin.name("X-axis", "x")
Dislin.name("Y-axis", "y")
Dislin.name("Z-axis", "z")

Dislin.labdig(-1, "xyz")
Dislin.labl3d("hori")
Dislin.graf3d(0.0, 30.0, 0.0, 5.0, 0.0, 30.0, 0.0, 5.0, 0.0, 30.0, 0.0, 5.0)
Dislin.title()

Dislin.shdmod("smooth", "surface")

iret = Dislin.zbfini()
Dislin.matop3(1.0, 0.0, 0.0, "diffuse")
for i = 1:17
  Dislin.sphe3d(x[i], y[i], z[i], 2.0, 50, 25)
end

Dislin.matop3(0.0, 1.0, 0.0, "diffuse")
for i = 1:28
  j = 2 * i
  j1 = idx[j-1]
  j2 = idx[j]
  Dislin.tube3d(x[j1], y[j1], z[j1], 
                 x[j2], y[j2], z[j2], 0.5, 5, 5) 
end

Dislin.zbffin()
Dislin.disfin()

Some Solids / Julia

using Dislin

Dislin.setpag("da4p")
Dislin.scrmod("revers")
Dislin.metafl("cons")
Dislin.disini()
Dislin.pagera()
Dislin.hwfont()
Dislin.light("on")
Dislin.litop3(1,0.5,0.5,0.5,"ambient")

Dislin.clip3d("none")
Dislin.axspos(0, 2500)
Dislin.axslen(2100, 2100)

Dislin.htitle(60)
Dislin.titlin("Some Solids", 4)

Dislin.nograf()
Dislin.graf3d(-5.0, 5.0, -5.0, 2.0, -5.0, 5.0, -5.0, 2.0, 
               -5.0, 5.0, -5.0, 2.0)
Dislin.title()
 
Dislin.shdmod("smooth", "surface")
iret = Dislin.zbfini()
Dislin.matop3(1.0, 0.5, 0.0, "diffuse")
Dislin.tube3d(-3.0, -3.0, 8.0, 2.0, 3.0, 5.5, 1.0, 40, 20) 

Dislin.rot3d(-60.0, 0.0, 0.0) 
Dislin.matop3(1.0, 0.0, 1.0, "diffuse")
Dislin.setfce("bottom")
Dislin.matop3(1.0, 0.0, 0.0, "diffuse")
Dislin.cone3d(-3.0, -3.0, 3.5, 2.0, 3.0, 3.0, 40, 20)
Dislin.setfce("top")

Dislin.rot3d(0.0, 0.0, 0.0) 
Dislin.matop3(0.0, 1.0, 1.0, "diffuse")
Dislin.plat3d(4.0, 4.0, 3.0, 3.0, "icos")

Dislin.rot3d(0.0, 0.0, 0.0) 
Dislin.matop3(1.0, 1.0, 0.0, "diffuse")
Dislin.sphe3d(0.0, 0.0, 0.0, 3.0, 40, 20)

Dislin.rot3d(0.0, 0.0, -20.0) 
Dislin.matop3(0.0, 0.0, 1.0, "diffuse")
Dislin.quad3d(-4.0, -4.0, -3.0, 3.0, 3.0, 3.0)

Dislin.rot3d(0.0, 0.0, 30.0) 
Dislin.matop3(1.0, 0.3, 0.3, "diffuse")
Dislin.pyra3d(-2.0, -5.0, -10.0, 3.0, 5.0, 5.0, 4)

Dislin.rot3d(0.0, 0.0, 0.0) 
Dislin.matop3(1.0, 0.0, 0.0, "diffuse")
Dislin.torus3d(7.0, -3.0, -2.0, 1.5, 3.5, 1.5, 0.0, 360.0, 40, 20)
Dislin.rot3d(0.0, 90.0, 0.0) 

Dislin.matop3(0.0, 1.0, 0.0, "diffuse")
Dislin.torus3d(7.0, -5.0, -2.0, 1.5, 3.5, 1.5, 0.0, 360.0, 40, 20)
Dislin.zbffin()
Dislin.disfin()

Map Plot / Julia

using Dislin

Dislin.metafl("cons")
Dislin.disini()
Dislin.pagera()
Dislin.complx()

Dislin.axspos(400, 1850)
Dislin.axslen(2400, 1400)

Dislin.name("Longitude", "X")
Dislin.name("Latitude",  "Y")
Dislin.titlin("World Coastlines and Lakes", 3)

Dislin.labels("MAP", "XY")
Dislin.labdig(-1, "XY")
Dislin.grafmp(-180.0, 180.0, -180.0, 90.0,
               -90.0, 90.0, -90.0, 30.0) 
Dislin.gridmp(1,1)
Dislin.color("green")
Dislin.world()

Dislin.color("fore")
Dislin.height(50) 
Dislin.title()
Dislin.disfin()

Tex Instructions for Mathematical Formulas / Julia

using Dislin
  
Dislin.scrmod("revers")
Dislin.setpag("da4p")
Dislin.metafl("cons")
Dislin.disini()
Dislin.pagera()
Dislin.complx()
Dislin.height(40)

cstr = "TeX Instructions for Mathematical Formulas"
nl = Dislin.nlmess(cstr)
Dislin.messag(cstr, div(2100 - nl, 2), 100)
  
Dislin.texmod("on")
Dislin.messag("\$\\frac{1}{x+y}\$", 150, 400)
Dislin.messag("\$\\frac{a^2 - b^2}{a+b} = a - b\$", 1200, 400)
  
Dislin.messag("\$r = \\sqrt{x^2 + y^2}", 150, 700)
Dislin.messag("\$\\cos \\phi = \\frac{x}{\\sqrt{x^2 + y^2}}\$", 1200, 700)

Dislin.messag("\$\\Gamma(x) = \\int_0^\\infty e^{-t}t^{x-1}dt\$", 150, 1000)
Dislin.messag("\$\\lim_{x \\to \\infty}(1 + \\frac{1}{x})^x = e\$", 1200, 1000)

Dislin.messag("\$\\mu = \\sum_{i=1}^n x_i p_i\$", 150, 1300)
Dislin.messag("\$\\mu = \\int_{-\\infty}^ \\infty x f(x) dx\$", 1200, 1300)

Dislin.messag("\$\\overline{x} = \\frac{1}{n} \\sum_{i=1}^n x_i\$", 150, 1600)
Dislin.messag("\$s^2 = \\frac{1}{n-1} \\sum_{i=1}^n(x_i - \\overline{x})^2\$",
               1200, 1600)

Dislin.messag("\$\\sqrt[n]{\\frac{x^n - y^n}{1 + u^{2n}}}\$", 150, 1900)  
Dislin.messag("\$\\sqrt[3]{-q + \\sqrt{q^2 + p^3}}\$", 1200, 1900)

Dislin.messag("\$\\int \\frac{dx}{1+x^2} = \\arctan x + C\$", 150, 2200)
Dislin.messag("\$\\int \\frac{dx}{\\sqrt{1+x^2}} = {\\rm arsinh} x + C\$",
               1200, 2200)

Dislin.messag("\$\\overline{P_1P_2} = \\sqrt{(x_2-x_1)^2 +(y_2-y_1)^2}\$",
               150,2500)
Dislin.messag("\$x = \\frac{x_1 + \\lambda x_2}{1 + \\lambda}\$", 1200, 2500)
Dislin.disfin()

News