rb-gsl 1.15.3.1

data/examples/complex/RC-lpf.rb

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+# Transfer function of a RC low-pass filter
+require("gsl")
+include GSL::CONST::NUM
+
+class RC_LPF
+  def initialize(r, c)
+    @r = r
+    @c = c
+    @fp = 1.0/(2*Math::PI*r*c)
+    @omegap = 1.0/(r*c)
+    puts("Pole at #{fp} Hz")
+  end
+
+  def Vout(f)
+    if f.class == GSL::Vector
+      out = GSL::Vector::Complex[f.size]
+      i = 0
+      f.each do |freq|
+        a = 1.0/GSL::Complex[1.0, freq/@fp]
+        out[i] = a
+        i += 1
+      end
+      return out
+    else
+      1.0/GSL::Complex(1.0, f/@fp)
+    end
+  end
+
+  attr_reader :r, :c, :fp
+end
+
+# Create RC filter
+R = 1*KILO    # 1 [kOhm]
+C = 1*MICRO   # 1 [muF]
+lpf = RC_LPF.new(R, C)
+
+# Frequency, 1Hz - 10kHz, 100 divisions
+f = GSL::Vector.logspace2(1, 10*KILO, 100)
+
+# Transfer function
+tf = lpf.Vout(f)
+
+GSL::graph([f, tf.amp.dB], "-C -l x -g 3 -y -100 10 -X 'Frequency [Hz]' -Y 'dB' --toggle-rotate-y-label")
+GSL::graph([f, tf.phase/Math::PI], "-C -l x -g 3 -X 'Frequency [Hz]' -Y 'Phase [Pi]' --toggle-rotate-y-label")
+
+

data/examples/complex/add.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+require 'gsl'
+
+a = GSL::Complex.rect(1, 2)
+b = GSL::Complex[3, 4]
+
+p a + b
+p a
+
+a += b
+p a
+
+p a - b
+p a
+
+a -= b
+p a
+
+p a + b + a
+
+p a.add(b)
+p a
+
+p a.sub(b)
+p a
+
+p a + 5
+p a.add_real(5)
+p a
+
+p a.sub_real(5)
+p a
+
+p a.add_real(6).sub_real(6)
+
+

data/examples/complex/coerce.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+require 'gsl'
+
+a = GSL::Complex.rect(1, 2)
+
+p 2 + a
+p 2 - a
+p 2*a
+
+p a - 3
+p a * 3
+
+p 2.0/a  # 0.4 - 0.8i
+

data/examples/complex/complex.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+require 'gsl'
+
+a = GSL::Complex.rect(1, 2)
+b = GSL::Complex[3, 4]
+c = GSL::Complex.alloc(5, 6)
+d = GSL::Complex.alloc([7, 8])
+p a
+p b
+p c
+p d
+
+e = GSL::Complex.polar(1, Math::PI/6)
+p e
+
+p a.abs
+p a.abs2
+p a.logabs
+p Math::log(a.abs)
+
+p e.abs
+p e.arg
+p Math::PI/6
+exit
+

data/examples/complex/fpmi.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env ruby
+# Frequency response of a Fabry-Perot Michelson interferometer
+#
+require("gsl")
+CLIGHT = GSL::CONST::MKSA::SPEED_OF_LIGHT
+
+class Michelson
+  def initialize(len, wavelength)
+    @len = len.to_f
+    @laserfreq = 2.0*Math::PI*CLIGHT/wavelength.to_f
+  end
+
+  def response(f)
+    if f.class != GSL::Vector; f = GSL::Vector[f]; end
+    r = GSL::Vector::Complex[f.size]
+    f.each_index do |i|
+      freq = f[i]
+      omega = 2.0*Math::PI*freq
+      a = @len*omega/CLIGHT
+      #      r[i] = 2.0*@laserfreq/omega*Math::sin(a)*GSL::Complex[0, -a].exp
+      r[i] = 2.0*@laserfreq/omega*Math::sin(a)*GSL::Complex::exp(0, -a)
+    end
+    r
+  end
+  attr_reader :len, :laserfreq
+end
+
+class FabryPerot
+  # rF: Reflectance of the front mirror
+  # rE: Reflectance of the end mirror
+  # tF: Transmittance of the front mirror
+  def initialize(len, wavelength, rF, rE)
+    @len = len.to_f
+    @laserfreq = 2.0*Math::PI*CLIGHT/wavelength.to_f
+    @tF = Math::sqrt(1.0 - rF*rF)
+    @rF = rF
+    @rE = rE
+  end
+  def response(f)
+    if f.class != GSL::Vector; f = GSL::Vector[f]; end
+    r = GSL::Vector::Complex[f.size]
+    f.each_index do |i|
+      freq = f[i]
+      omega = 2.0*Math::PI*freq
+      a = 2.0*@len*omega/CLIGHT
+      r[i] = @tF*@tF*@rE/(1.0 - @rF*@rE)/(1.0 - @rF*@rE*GSL::Complex::exp(0, -a))
+    end
+    r
+  end
+  attr_reader :len, :laserfreq, :tF, :rF, :rE
+end
+
+class FPMI
+  def initialize(len, wavelength, rF, rE)
+    @mi = Michelson.new(len, wavelength)
+    @fp = FabryPerot.new(len, wavelength, rF, rE)
+  end
+  def response(f)
+    @mi.response(f)*@fp.response(f)
+  end
+  attr_reader :mi, :fp
+end
+
+# Fabry-Perot Michelson IFO of the same length
+fpmi = FPMI.new(3000, 1e-6, 0.85, 1.0)
+
+f = GSL::Vector.linspace(10, 100000, 1000)
+rmi = fpmi.mi.response(f).amp/1e11
+rfpmi = fpmi.response(f).amp/1e11
+GSL::graph(f, rmi, rfpmi, "-C -g 3 -l x -l y -y 1e-3 1e2 -L 'Red: MI 3km, Green: FPMI 3km'")

data/examples/complex/functions.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+require("gsl")
+include Math
+
+# Test GSL::Complex#sqrt
+z = GSL::Complex.alloc(1, 2)
+sqrtz = z.sqrt
+p sqrtz
+d = sqrtz*sqrtz
+p z == d
+sqrtz = GSL::Complex.sqrt(z)
+d = sqrtz*sqrtz
+p z == d
+
+# Test GSL::Complex::sqrt_real
+a = -2.0
+c = GSL::Complex.sqrt_real(a)
+p GSL::equal?(a, (c*c).re)
+
+# Test GSL::Complex#exp, log
+p f = z.exp
+p GSL::Complex.exp(z)
+p f.log
+p f.log == z
+
+p z.pow(f)  # [1.931e-02 1.752e-02], verified with Octave result
+
+# The results below are verified with the Octave results
+p GSL::Complex.sin(z) 
+p GSL::Complex.cos(z) 
+p GSL::Complex.tan(z)
+p GSL::Complex.sec(z)
+p GSL::Complex.csc(z)
+p GSL::Complex.cot(z)
+p GSL::Complex.arcsin(z)
+p GSL::Complex.arcsin_real(2)
+p GSL::Complex.arccos(z)
+p GSL::Complex.arccos_real(2)
+p GSL::Complex.arctan(z)
+p GSL::Complex.arcsec(z)
+p GSL::Complex.arcsec_real(2)
+p GSL::Complex.arccsc(z)
+p GSL::Complex.arccsc_real(2)
+p GSL::Complex.arccot(z)
+
+p GSL::Complex.sinh(z) 
+p GSL::Complex.cosh(z) 
+p GSL::Complex.tanh(z)
+p GSL::Complex.sech(z)
+p GSL::Complex.csch(z)
+p GSL::Complex.coth(z)
+
+p GSL::Complex.arcsinh(z)
+p GSL::Complex.arccosh(z)
+p GSL::Complex.arccosh_real(2)
+p GSL::Complex.arctanh(z)
+p GSL::Complex.arctanh_real(2)
+p GSL::Complex.arcsech(z)
+p GSL::Complex.arccsch(z)
+p GSL::Complex.arccoth(z)
+
+p 1/z
+p z.inverse
+p z.conjugate
+p z.negative
+p -z
+z2 = GSL::Complex.alloc(2, 3)
+p z*z2
+p z/z2
+p z - z2
+p z + z2
+p z + 1
+p 2 + z
+p 2 * z
+p 2/z
+p z/2
+

data/examples/complex/michelson.rb

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+# Frequency response of a Michelson interferometer
+#
+require("gsl")
+
+class Michelson
+  CLIGHT = GSL::CONST::MKSA::SPEED_OF_LIGHT
+
+  def initialize(len, wavelength)
+    @len = len.to_f
+    @laserfreq = 2.0*Math::PI*CLIGHT/wavelength.to_f
+  end
+
+  def response(f)
+    if f.class != GSL::Vector; f = GSL::Vector[f]; end
+    r = GSL::Vector::Complex[f.size]
+    f.each_index do |i|
+      freq = f[i]
+      omega = 2.0*Math::PI*freq
+      a = @len*omega/CLIGHT
+      r[i] = 2.0*@laserfreq/omega*Math::sin(a)*GSL::Complex::exp([0, -a])
+    end
+    r
+  end
+  attr_reader :len, :laserfreq
+end
+
+# 3km
+mi1 = Michelson.new(3000, 1e-6)
+# 75km
+mi2 = Michelson.new(75000, 1e-6)
+
+f = GSL::Vector.linspace(10, 100000, 1000)
+r1 = mi1.response(f).amp
+r2 = mi2.response(f).amp
+GSL::graph(f, r2/1e11, r1/1e11, "-C -g 3 -l x -l y -y 1e-2 1e2 -L 'Transfer function of Michelson interferometer'")

data/examples/complex/mul.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+require 'gsl'
+
+a = GSL::Complex.rect(1, 2)
+b = GSL::Complex[3, 4]
+ 
+p a*b  # -5 + 10i
+p a.mul(b)
+p a
+
+p a.div(b)
+p a
+
+a *= b
+p a
+
+a /= b
+p a
+
+p a.mul(2)
+p a.mul_real(2)
+p a.div_real(2)
+
+p a.conjugate
+p a.inverse
+p 1.0/a
+p a.negative
+p -a

data/examples/complex/oscillator.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+require("gsl")
+
+m = 1.0
+k = 1.0
+b = 1.0
+mode = GSL::Poly.complex_solve_quadratic(m, b, k)
+p mode.class
+
+f = GSL::Vector.linspace(0.01, 100, 1000)
+p f.class
+tf0 = 1.0/((m*mode[0]*f + b)*mode[0]*f + k)
+tf1 = 1.0/((m*mode[1]*f + b)*mode[1]*f + k)
+p tf0.class
+GSL::graph(f, tf0.amp, tf1.amp, "-C -g 3 -l x -l y -L 'Transfer function: amplitude'")
+GSL::graph(f, tf0.phase, tf1.phase, "-C -g 3 -l x -L 'Transfer function: phase'")
+

data/examples/complex/set.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+require 'gsl'
+
+a = GSL::Complex.rect(1, 2)
+p a
+
+a.set(5)
+p a
+
+a.set(3, 6)
+p a
+
+p a.re
+p a.im
+p a.real
+p a.imag
+p a.REAL
+p a.IMAG
+
+a.re = 7
+p a
+
+a.im = 1
+p a
+
+a.real = 4
+p a
+
+a.imag = 9
+p a
+
+a.set_real(2)
+p a
+
+a.set_imag(3)
+p a
+

data/examples/const/physconst.rb

@@ -0,0 +1,151 @@
+#!/usr/bin/env ruby
+require("gsl")
+require("curses")
+
+#SUBWIN_H = 20
+SUBWIN_W = 50
+SUBWIN_Y = 1
+SUBWIN_X = 10
+
+print("MKSA/CGSM ? [m/c] : ")
+sys = gets
+if /^m/ =~ sys
+  include GSL::CONST::MKSA
+  PREFIX = "MKSA"
+else
+  include GSL::CONST::CGSM
+  PREFIX = "CGSM"
+end
+include GSL::CONST::NUM
+
+Curses.init_screen
+W = Curses.stdscr
+Curses.refresh
+
+MAIN_MENU = ["", "Fundamental Constants", "Astronomy and Astrophysics",
+             "Atomic and Nuclear Physics", "Measurement of Time",
+             "Imperial Units", "Nautical Units", "Printers Units",
+             "Volume", "Mass and Weight", "Thermal Energy and Power",
+             "Pressure", "Viscosity", "Light and Illumination",
+             "Radioactivity", "Force and Energy", "Prefixes"]
+
+MENU = Array.new(MAIN_MENU.size)
+MENU[1] = ["", "SPEED_OF_LIGHT", "VACUUM_PERMEABILITY", "VACUUM_PERMITTIVITY",
+           "PLANCKS_CONSTANT_H", "PLANCKS_CONSTANT_HBAR", "AVOGADRO",
+           "FARADAY", "BOLTZMANN", "MOLAR_GAS", "STANDARD_GAS_VOLUME",
+           "STEFAN_BOLTZMANN_CONSTANT", "GAUSS", "MICRON", "HECTARE",
+           "MILES_PER_HOUR", "KILOMETERS_PER_HOUR"]
+
+MENU[2] = ["", "ASTRONOMICAL_UNIT", "GRAVITATIONAL_CONSTANT",
+           "LIGHT_YEAR", "PARSEC", "GRAV_ACCEL", "SOLAR_MASS"]
+
+MENU[3] = ["", "ELECTRON_CHARGE", "ELECTRON_VOLT", "UNIFIED_ATOMIC_MASS",
+           "MASS_ELECTRON", "MASS_MUON", "MASS_PROTON", "MASS_NEUTRON",
+           "FINE_STRUCTURE", "RYDBERG", "BOHR_RADIUS", "ANGSTROM",
+           "BARN", "BOHR_MAGNETON", "NUCLEAR_MAGNETON", 
+           "ELECTRON_MAGNETIC_MOMENT", "PROTON_MAGNETIC_MOMENT",
+           "THOMSON_CROSS_SECTION"]
+
+MENU[4] = ["", "MINUTE", "HOUR", "DAY", "WEEK"]
+MENU[5] = ["", "INCH", "FOOT", "YARD", "MILE", "MIL"]
+MENU[6] = ["", "NAUTICAL_MILE", "FATHOM", "KNOT"]
+MENU[7] = ["", "POINT", "TEXPOINT"]
+MENU[8] = ["", "ACRE", "LITER", "US_GALLON", "CANADIAN_GALLON", "UK_GALLON",
+           "QUART", "PINT"]
+MENU[9] = ["", "POUND_MASS", "OUNCE_MASS", "TON", "METRIC_TON", "UK_TON",
+           "TROY_OUNCE", "CARAT", "GRAM_FORCE", "POUND_FORCE",
+           "KILOPOUND_FORCE", "POUNDAL"]
+MENU[10] = ["", "CALORIE", "BTU", "THERM", "HORSEPOWER"]
+MENU[11] = ["", "BAR", "STD_ATMOSPHERE", "TORR", "METER_OF_MERCURY", 
+            "INCH_OF_MERCURY", "INCH_OF_WATER", "PSI"]
+MENU[12] = ["", "POISE", "STOKES"]
+MENU[13] = ["", "STILB", "LUMEN", "LUX", "PHOT", "FOOTCANDLE", 
+            "LAMBERT", "FOOTLAMBERT"]
+MENU[14] = ["", "CURIE", "ROENTGEN", "RAD"]
+MENU[15] = ["", "NEWTON", "DYNE", "JOULE", "ERG"]
+MENU[16] = ["", "YOTTA", "ZETTA", "EXA", "PETA", "TERA", "GIGA", "MEGA",
+            "KILO", "MILLI", "MICRO", "NANO", "PICO", "FEMTO", "ATTO",
+            "ZEPTO", "YOCTO"]
+
+def mainmenu
+  i = 1
+  Curses.clear
+  W.setpos(0, 1)
+  W.addstr("  GSL-#{GSL::VERSION} Physical Constants:\n")
+  MAIN_MENU[1..-1].each do |str|
+    W.setpos(i, 1)
+    W.addstr(sprintf("  [%2d] %s\n", i, str))
+    i+=1
+  end
+  W.setpos(i, 1)
+  str = "  ? ['q' to quit]: "
+  W.addstr(str)
+  W.setpos(i, str.size+1)
+  W.refresh
+end
+
+def show_submenu(ind, w)
+  w.setpos(1, 0)
+  w.addstr(sprintf(" [%2d] %s\n", ind, MAIN_MENU[ind]))
+  i = 1
+  MENU[ind][1..-1].each do |str|
+    w.setpos(i+1, 1)
+    w.addstr(sprintf("    [%2d] %s\n", i, str))
+    i+=1
+  end
+  w.setpos(i+=1, 1)
+  str = "    ? ['m' to menu]: "
+  w.addstr(str)
+  w.setpos(i, str.size+1)  
+  w.box('|', '-')
+  w.refresh
+end
+
+def show_result(ind, i, w)
+  return if i == 0
+  return if i > MENU[ind].size-1
+  w.setpos(MENU[ind].size+2, 0)
+  w.addstr("  #{MENU[ind][i]} = ")
+  begin
+    val = eval("#{MENU[ind][i]}")
+    w.addstr("#{val}\n")
+  rescue NameError
+    w.addstr("not defined.\n")
+  rescue
+    return
+  ensure
+    w.refresh
+  end
+end
+
+def submenu(ind)
+  return unless MENU[ind]
+  w = W.subwin(MENU[ind].size+4, SUBWIN_W, SUBWIN_Y, SUBWIN_X)
+  while true
+    show_submenu(ind, w)
+    i = w.getstr
+    if /^m/ =~ i
+      w.close
+      return
+    end
+    show_result(ind, i.to_i, w)
+  end
+end
+
+#########
+
+while true
+  mainmenu
+  i = W.getstr
+  W.refresh
+  break if /^q/ =~ i
+  i = i.to_i
+  next if i > MAIN_MENU.size or i < 1
+  submenu(i)
+end
+
+Curses.close_screen
+exit
+
+__END__
+