DISLIN Examples / Ruby

Demonstration of CURVE / Ruby

#!/usr/bin/ruby
require 'dislin'

n = 101
pi = 3.1415926
f = pi / 180.0
step = 360.0 / (n - 1)

xray = Array.new(n)
y1ray = Array.new(n)
y2ray = Array.new(n)

for i  in 0..n-1
  xray[i] = i * step
  x = xray[i] * f
  y1ray[i] = Math.sin(x)
  y2ray[i] = Math.cos(x)
end

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

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

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

Dislin.labdig(-1, 'X')
Dislin.ticks(10, 'XY')

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 / Ruby

#!/usr/bin/ruby
require 'dislin'

n = 300
m = 10
pi = 3.1415926
f = pi / 180.0
step = 360.0 / (n - 1)

xray = Array.new(n)
x1 = Array.new(n)
y1 = Array.new(n)

x2 = Array.new(m)
y2 = Array.new(m)

for i  in 0..n-1
  a = (i * step) * f
  xray[i] = i * step
  x = xray[i] * f
  y1[i] = a
  x1[i] = Math.sin(5 * a)
end

for i  in 0..m-1
  x2[i] = i + 1
  y2[i] = i + 1
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 / Ruby

#!/usr/bin/ruby
require 'dislin'

ctit = "Symbols"

Dislin.setpag('da4p')
Dislin.metafl('cons')
Dislin.disini()
Dislin.complx()
Dislin.pagera()

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

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

ny = 150
for i in 0..21
  if (i % 4) == 0
    ny = ny + 400
    nxp = 550
  else
    nxp = nxp + 350
  end

  nl = Dislin.nlnumb(i, -1)
  Dislin.number(i, -1, nxp - nl/2, ny + 150)
  Dislin.symbol(i, nxp, ny)
end
Dislin.disfin()

Interpolation Methods / Ruby

#!/usr/bin/ruby
require '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 in 0..5
  Dislin.axspos(350, nya - i * 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 == 5
    Dislin.height(50)
    Dislin.title()
  end

  Dislin.endgrf()
end

Dislin.disfin()

Bar Graphs / Ruby

#!/usr/bin/ruby
require '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]

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)

cbuf = ' '
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 in 0..2
  if i > 0
    Dislin.labels('none','x')
  end

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

  if i == 0
    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')
  elsif i == 1
    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') 
  elsif i == 2
    Dislin.labels('second', 'bars')
    Dislin.labpos('outside', 'bars')
    Dislin.color('red')
    Dislin.bars(x, y, y1, 9)
    Dislin.color('fore')
  end

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

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

Dislin.disfin()

Pie Charts / Ruby

#!/usr/bin/ruby
require 'dislin'

xray = [1.0, 2.5, 2.0, 2.7, 1.8]

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)

cbuf = ' '
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 / Ruby

#!/usr/bin/ruby
require '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]

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(ic1ray, ic2ray, 5)
Dislin.pietyp('3d')
Dislin.axspos(300, 2700)
cbuf = ' '
Dislin.piegrf(cbuf, 0, y2ray, 5)  
Dislin.disfin()

3-D Bars / BARS3D / Ruby

#!/usr/bin/ruby
require '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]

xwray = Array.new(n)
ywray = Array.new(n)
for i in 0..n-1
  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, icray, n)

cbuf = ' '
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 / Ruby

#!/usr/bin/ruby
require 'dislin'

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

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, (2970 - nl)/2, 200)

nx0 = 335
ny0 = 350

iclr = 0
for i in 0..2
  ny = ny0 + i * 600

  for j in 0..5
    nx = nx0 + j * 400
    ii = i * 6 + j
    Dislin.shdpat(ii)
    iclr = iclr + 1
    iclr = iclr % 8
    if iclr == 0
      iclr = 8
    end 
    Dislin.setclr(iclr)
    for k in 0..3
      ixp[k] = ix[k] + nx
      iyp[k] = iy[k] + ny
    end

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

Dislin.disfin()

3-D Colour Plot / Ruby

#!/usr/bin/ruby
require 'dislin'

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

n = 50
m = 50
zmat = Array.new(n*m)

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

for i in 0..n-1
  x = i * stepx
  for j in 0..m-1
    y = j * stepy
    zmat[i*m+j] = 2 * Math.sin(x * fpi) * Math.sin(y * fpi)
  end
end

Dislin.scrmod('revers')
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 / Ruby

#!/usr/bin/ruby
require 'dislin'

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

n = 50
m = 50
zmat = Array.new(n*m)

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

for i in 0..n-1
  x = i * stepx
  for j in 0..m-1
    y = j * stepy
    zmat[i*m+j] = 2 * Math.sin(x * fpi) * Math.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 / Ruby

#!/usr/bin/ruby
require 'dislin'

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

n = 50
m = 50
xray = Array.new(n)
yray = Array.new(m)
zmat = Array.new(n*m)

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

for i in 0..n-1
  x = i * stepx
  xray[i] = x
  for j in 0..m-1
    y = j * stepy
    yray[j] = y
    zmat[i*m+j] = 2 * Math.sin(x * fpi) * Math.sin(y * fpi)
  end
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 / Ruby

#!/usr/bin/ruby
require 'dislin'

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

n = 50
m = 50
xray = Array.new(n)
yray = Array.new(m)
zlev = Array.new(12)
zmat = Array.new(n * m)

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

for i in 0..n-1
  xray[i] = i * stepx
end

for i in 0..m-1
  yray[i] = i * stepy
end

for i in 0..n-1
  x = xray[i] * fpi
  for j in 0..m-1
    y = yray[j] * fpi
    zmat[i*m+j] = 2 * Math.sin(x) * Math.sin(y)
  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 in 0..8
  zlev = -2.0 + i * 0.5
  if i == 4
    Dislin.labels('NONE', 'CONTUR')
  else
    Dislin.labels('FLOAT', 'CONTUR')
  end

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

Dislin.disfin()

Shaded Contour Plot / Ruby

#!/usr/bin/ruby
require 'dislin'

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

n = 50
m = 50
xray = Array.new(n)
yray = Array.new(m)
zlev = Array.new(12)
zmat = Array.new(n * m)

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

for i in 0..n-1
  xray[i] = i * stepx
end

for i in 0..m-1
  yray[i] = i * stepy
end

for i in 0..n-1
  x = xray[i] * xray[i] - 1.0
  x = x * x
  for j in 0..m-1
    y = yray[j] * yray[j] - 1.0
    zmat[i*m+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 in 0..11
  zlev[11-i] = 0.1 + i * 0.1
end

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

Dislin.height(50)
Dislin.title()

Dislin.disfin()

Shaded Surface / Contour Plot / Ruby

#!/usr/bin/ruby
require 'dislin'

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

n = 50
m = 50
nlev = 20

zmat = Array.new(n*m)
xray = Array.new(n)
yray = Array.new(m)
zlev = Array.new(nlev)

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

for i in 0..n-1
  x = i * stepx
  xray[i] = x
  for j in 0..m-1
    y = j * stepy
    yray[j] = y
    zmat[i*m+j] = 2 * Math.sin(x * fpi) * Math.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 in 0..nlev-1
   zlev[i] = -2.0 + i * 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 / Ruby

#!/usr/bin/ruby
require '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 in 0..16
  Dislin.sphe3d(x[i], y[i], z[i], 2.0, 50, 25)
end

Dislin.matop3(0.0, 1.0, 0.0, 'diffuse')
for i in 0..27
  j = 2 * i
  j1 = idx[j] - 1
  j2 = idx[j+1] - 1
  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 / Ruby

#!/usr/bin/ruby
require '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 / Ruby

#!/usr/bin/ruby
require 'dislin'

Dislin.scrmod('revers')
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('foreground')
Dislin.height(50)
Dislin.title()

Dislin.disfin()

Tex Instructions for Mathematical Formulas / Ruby

#!/usr/bin/ruby
require '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, (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