论用RGSS画复变函数图像

有丘直方

这个东西貌似已经有人搞过了？？

RUBY 代码复制

# Color
class Color
 
  # 根据HSL数据来生成颜色对象，第四个参数是不透明度
  def self.hsl(hue, saturation, lightness, alpha = 1.0)
    saturation = saturation.clamp(0.0, 1.0)
    lightness = lightness.clamp(0.0, 1.0)
    alpha = alpha.clamp(0.0, 1.0)
 
    times = (hue * 3 / Math::PI).modulo(6)
    amount1 = (1 - (2 * lightness - 1).abs) * saturation
    amount2 = amount1 * (1 - (times % 2 - 1).abs)
    correction = lightness - amount1 / 2
    translation = (times.to_i + 1) % 6
 
    args = [0, 0, 0]
    args[translation / 2] = amount1
    args[2 - translation % 3] = amount2
 
    new(*args.map {|origin| (origin + correction) * 255 }, alpha * 255)
  end
 
  # 在此颜色之上按正常方式叠加另一个颜色时呈现的颜色
  def blend(other)
    alpha1 = alpha / 255.0
    alpha2 = other.alpha / 255.0
    calc_blend = proc do |c1, c2|
      c1 /= 255.0
      c2 /= 255.0
      blend = c1 * alpha1 * (1 - alpha2) + c2 * alpha2
      blend /= alpha1 + alpha2 - alpha1 * alpha2
      blend *= 255
    end
    result = Color.new
    result.alpha = (alpha1 + alpha2 - alpha1 * alpha2) * 255
    result.red = calc_blend.call(red, other.red)
    result.green = calc_blend.call(green, other.green)
    result.blue = calc_blend.call(blue, other.blue)
    result
  end
 
  # blend的破坏型方法
  def blend!(other)
    set(blend(other))
    self
  end
 
end
 
# Comparable
module Comparable
 
  # 返回在min和max的范围内最接近self的对象
  def clamp(min, max)
    return min if self <=> min < 0
    return max if self <=> max > 0
    self
  end
 
end
 
# 关于x的以mean为期望，variance为方差的正态分布函数
# 不给出mean和variance参数时是标准正态分布函数
def Math.normal_distribution(x, mean = 0.0, variance = 1.0)
  exp(-(x - mean) ** 2 / (2 * variance)) / sqrt(2 * self::PI * variance)
end
 
# Complex
class Complex
 
  # 获取此复数对应的定义域着色
  # lightness_base: 用于计算亮度的函数中的底数，越小越亮，必须在0和1之间
  # saturation: 饱和度
  def to_color(lightness_base = 0.5, saturation = 1.0)
    raise unless lightness_base.between?(0, 1)
    exponent = abs
    hue = exponent == 0 ? 0.0 : arg
    lightness = 1 - lightness_base ** exponent
    Color.hsl(hue, saturation, lightness)
  end
 
  # 获取此复数对应的结构化的定义域着色
  # 这种着色方案有特殊效果，具体看参数说明
  # discontinuity_base: 当此复数的模是达到参数的整数次幂时，亮度骤然变为最低
  # saturation: 饱和度
  # min_lightness: 不考虑网格和射线时能达到的最低亮度
  # lightness_range: 不考虑网格和射线时能达到的最高和最低亮度之差
  # grid_hue: 网格的色相
  # rays_hue: 射线的色相
  # grid_lightness: 网格的亮度
  # rays_lightness: 射线的亮度
  # grid_density: 网格线的密度，复数的实部或虚部是参数的倒数的整数倍时出现网格
  # rays_density: 射线的密度，复数的俯角是参数的倒数的整数倍时出现射线
  # grid_radius: 网格线的宽度的一半，不包括扩散出去的部分
  # rays_radius: 射线的宽度的一半，不包括扩散出去的部分
  # grid_restraint: 网格线的扩散度，越大越模糊
  # rays_restraint: 射线的扩散度，越大越模糊
  # grid_opacity: 网格的不透明度，如果不想显示网格请设为0.0
  # rays_opacity: 射线的不透明度，如果不想显示射线请设为0.0
  def to_color_structured(discontinuity_base = 2.0, saturation = 1.0, 
      min_lightness = 0.3, lightness_range = 0.4, grid_hue = 0.0, 
      rays_hue = 0.0, grid_lightness = 0.0, rays_lightness = 1.0, 
      grid_density = 1.0, rays_density = 6.0, grid_radius = 0.005, 
      rays_radius = 0.01, grid_restraint = 60.0, rays_restraint = 50.0, 
      grid_opacity = 0.2, rays_opacity = 0.8)
    antilog = abs
    hue = antilog == 0 ? 0.0 : arg
 
    lightness_phase = Math.log(antilog, discontinuity_base).modulo(1)
    lightness_phase = 0.0 if lightness_phase.nan?
    lightness = lightness_phase * lightness_range + min_lightness
 
    color = Color.hsl(hue, saturation, lightness)
    f = Math.sqrt(2 * Math::PI)
 
    dense_real = real * grid_density
    real_distance = (dense_real - dense_real.round).abs
    dense_imaginary = imaginary * grid_density
    imaginary_distance = (dense_imaginary - dense_imaginary.round).abs
    grid_distance = [[real_distance, imaginary_distance].min, grid_radius].max
    grid_excursion = (grid_distance - grid_radius) * grid_restraint
    grid_alpha = Math.normal_distribution(grid_excursion) * f * grid_opacity
    grid_color = Color.hsl(grid_hue, saturation, grid_lightness, grid_alpha)
    color.blend!(grid_color)
 
    rays_distances = Array.new(rays_density) do |i|
      slope = Math.tan(i / rays_density * Math::PI)
      (slope * real - imaginary).abs / Math.hypot(slope, -1)
    end
    rays_distance = [rays_distances.min, rays_radius].max
    rays_excursion = (rays_distance - rays_radius) * rays_restraint
    rays_alpha = Math.normal_distribution(rays_excursion) * f * rays_opacity
    rays_color = Color.hsl(rays_hue, saturation, rays_lightness, rays_alpha)
    color.blend!(rays_color)
  end
end
 
# Bitmap
class Bitmap
  # 绘制复变函数的函数图像
  # function: 需要绘制的函数，提供接受一个复数参数并返回复数的call方法
  # delta_x: 图中1像素的距离代表的大小
  # structured: 是否采用结构化的图像，见Complex#to_color_structured
  # ox: 自变量取0+0i时所在的位置的相对于位图的x坐标
  # oy: 自变量取0+0i时所在的位置的相对于位图的y坐标
  def draw_function(function, delta_x, structured = false, 
    ox = Graphics.width / 2, oy = Graphics.height / 2)
    width.times do |x|
      height.times do |y|
        real = (x - ox) * delta_x
        imaginary = (oy - y) * delta_x
        complex = function.call(Complex(real, imaginary))
        color = structured ? complex.to_color_structured : complex.to_color
        set_pixel(x, y, color)
      end
    end
  end
end

# Color


class Color


 


  # 根据HSL数据来生成颜色对象，第四个参数是不透明度


  def self.hsl(hue, saturation, lightness, alpha = 1.0)


    saturation = saturation.clamp(0.0, 1.0)


    lightness = lightness.clamp(0.0, 1.0)


    alpha = alpha.clamp(0.0, 1.0)


 


    times = (hue * 3 / Math::PI).modulo(6)


    amount1 = (1 - (2 * lightness - 1).abs) * saturation


    amount2 = amount1 * (1 - (times % 2 - 1).abs)


    correction = lightness - amount1 / 2


    translation = (times.to_i + 1) % 6


 


    args = [0, 0, 0]


    args[translation / 2] = amount1


    args[2 - translation % 3] = amount2


 


    new(*args.map {|origin| (origin + correction) * 255 }, alpha * 255)


  end


 


  # 在此颜色之上按正常方式叠加另一个颜色时呈现的颜色


  def blend(other)


    alpha1 = alpha / 255.0


    alpha2 = other.alpha / 255.0


    calc_blend = proc do |c1, c2|


      c1 /= 255.0


      c2 /= 255.0


      blend = c1 * alpha1 * (1 - alpha2) + c2 * alpha2


      blend /= alpha1 + alpha2 - alpha1 * alpha2


      blend *= 255


    end


    result = Color.new


    result.alpha = (alpha1 + alpha2 - alpha1 * alpha2) * 255


    result.red = calc_blend.call(red, other.red)


    result.green = calc_blend.call(green, other.green)


    result.blue = calc_blend.call(blue, other.blue)


    result


  end


 


  # blend的破坏型方法


  def blend!(other)


    set(blend(other))


    self


  end


 


end


 


# Comparable


module Comparable


 


  # 返回在min和max的范围内最接近self的对象


  def clamp(min, max)


    return min if self <=> min < 0


    return max if self <=> max > 0


    self


  end


 


end


 


# 关于x的以mean为期望，variance为方差的正态分布函数


# 不给出mean和variance参数时是标准正态分布函数


def Math.normal_distribution(x, mean = 0.0, variance = 1.0)


  exp(-(x - mean) ** 2 / (2 * variance)) / sqrt(2 * self::PI * variance)


end


 


# Complex


class Complex


 


  # 获取此复数对应的定义域着色


  # lightness_base: 用于计算亮度的函数中的底数，越小越亮，必须在0和1之间


  # saturation: 饱和度


  def to_color(lightness_base = 0.5, saturation = 1.0)


    raise unless lightness_base.between?(0, 1)


    exponent = abs


    hue = exponent == 0 ? 0.0 : arg


    lightness = 1 - lightness_base ** exponent


    Color.hsl(hue, saturation, lightness)


  end


 


  # 获取此复数对应的结构化的定义域着色


  # 这种着色方案有特殊效果，具体看参数说明


  # discontinuity_base: 当此复数的模是达到参数的整数次幂时，亮度骤然变为最低


  # saturation: 饱和度


  # min_lightness: 不考虑网格和射线时能达到的最低亮度


  # lightness_range: 不考虑网格和射线时能达到的最高和最低亮度之差


  # grid_hue: 网格的色相


  # rays_hue: 射线的色相


  # grid_lightness: 网格的亮度


  # rays_lightness: 射线的亮度


  # grid_density: 网格线的密度，复数的实部或虚部是参数的倒数的整数倍时出现网格


  # rays_density: 射线的密度，复数的俯角是参数的倒数的整数倍时出现射线


  # grid_radius: 网格线的宽度的一半，不包括扩散出去的部分


  # rays_radius: 射线的宽度的一半，不包括扩散出去的部分


  # grid_restraint: 网格线的扩散度，越大越模糊


  # rays_restraint: 射线的扩散度，越大越模糊


  # grid_opacity: 网格的不透明度，如果不想显示网格请设为0.0


  # rays_opacity: 射线的不透明度，如果不想显示射线请设为0.0


  def to_color_structured(discontinuity_base = 2.0, saturation = 1.0, 


      min_lightness = 0.3, lightness_range = 0.4, grid_hue = 0.0, 


      rays_hue = 0.0, grid_lightness = 0.0, rays_lightness = 1.0, 


      grid_density = 1.0, rays_density = 6.0, grid_radius = 0.005, 


      rays_radius = 0.01, grid_restraint = 60.0, rays_restraint = 50.0, 


      grid_opacity = 0.2, rays_opacity = 0.8)


    antilog = abs


    hue = antilog == 0 ? 0.0 : arg


 


    lightness_phase = Math.log(antilog, discontinuity_base).modulo(1)


    lightness_phase = 0.0 if lightness_phase.nan?


    lightness = lightness_phase * lightness_range + min_lightness


 


    color = Color.hsl(hue, saturation, lightness)


    f = Math.sqrt(2 * Math::PI)


 


    dense_real = real * grid_density


    real_distance = (dense_real - dense_real.round).abs


    dense_imaginary = imaginary * grid_density


    imaginary_distance = (dense_imaginary - dense_imaginary.round).abs


    grid_distance = [[real_distance, imaginary_distance].min, grid_radius].max


    grid_excursion = (grid_distance - grid_radius) * grid_restraint


    grid_alpha = Math.normal_distribution(grid_excursion) * f * grid_opacity


    grid_color = Color.hsl(grid_hue, saturation, grid_lightness, grid_alpha)


    color.blend!(grid_color)


 


    rays_distances = Array.new(rays_density) do |i|


      slope = Math.tan(i / rays_density * Math::PI)


      (slope * real - imaginary).abs / Math.hypot(slope, -1)


    end


    rays_distance = [rays_distances.min, rays_radius].max


    rays_excursion = (rays_distance - rays_radius) * rays_restraint


    rays_alpha = Math.normal_distribution(rays_excursion) * f * rays_opacity


    rays_color = Color.hsl(rays_hue, saturation, rays_lightness, rays_alpha)


    color.blend!(rays_color)


  end


end


 


# Bitmap


class Bitmap


  # 绘制复变函数的函数图像


  # function: 需要绘制的函数，提供接受一个复数参数并返回复数的call方法


  # delta_x: 图中1像素的距离代表的大小


  # structured: 是否采用结构化的图像，见Complex#to_color_structured


  # ox: 自变量取0+0i时所在的位置的相对于位图的x坐标


  # oy: 自变量取0+0i时所在的位置的相对于位图的y坐标


  def draw_function(function, delta_x, structured = false, 


    ox = Graphics.width / 2, oy = Graphics.height / 2)


    width.times do |x|


      height.times do |y|


        real = (x - ox) * delta_x


        imaginary = (oy - y) * delta_x


        complex = function.call(Complex(real, imaginary))


        color = structured ? complex.to_color_structured : complex.to_color


        set_pixel(x, y, color)


      end


    end


  end


end

一个简单的用于玩耍的代码（依赖这玩意）（由于我用了RGD所以无视分辨率限制了）（虽然不用多线程能画得更快，但是那样就看不到图像慢慢绘制出来的过程了）：

RUBY 代码复制

# 玩耍方法：在控制台输入你想要画的函数，然后等待即可
Graphics.resize_screen(1024, 768)
sprite = Sprite.new
sprite.bitmap = Bitmap.new(Graphics.width, Graphics.height)
Thread.start do
  loop do
    print("f(z) = ")
    string = $stdin.gets
    function = eval("->(z) { #{string} }")
    puts("Please wait...")
    time = Time.now
    sprite.bitmap.draw_function(function, 0.008, true) rescue puts($!.message)
    printf("Completed after %d seconds.\n", Time.now - time)
  end
end
 
rgss_stop

# 玩耍方法：在控制台输入你想要画的函数，然后等待即可


Graphics.resize_screen(1024, 768)


sprite = Sprite.new


sprite.bitmap = Bitmap.new(Graphics.width, Graphics.height)


Thread.start do


  loop do


    print("f(z) = ")


    string = $stdin.gets


    function = eval("->(z) { #{string} }")


    puts("Please wait...")


    time = Time.now


    sprite.bitmap.draw_function(function, 0.008, true) rescue puts($!.message)


    printf("Completed after %d seconds.\n", Time.now - time)


  end


end


 


rgss_stop

配上CMath后玩耍体验更佳：

RUBY 代码复制

#==============================================================================
# * CMath
#------------------------------------------------------------------------------
# Trigonometric and transcendental functions for complex numbers.
# CMath is a library that provides trigonometric and transcendental functions
# for complex numbers. The functions in this module accept integers, floating-
# point numbers or complex numbers as arguments.
# Note that the selection of functions is similar, but not identical, to that
# in module math. The reason for having two modules is that some users aren't
# interested in complex numbers, and perhaps don't even know what they are. They
# would rather have Math.sqrt(-1) raise an exception than return a complex
# number.
# For more information you can see Complex class.
#==============================================================================
 
module CMath
 
  include Math
 
  alias exp! exp
  alias log! log
  alias log2! log2
  alias log10! log10
  alias sqrt! sqrt
  alias cbrt! cbrt
 
  alias sin! sin
  alias cos! cos
  alias tan! tan
 
  alias sinh! sinh
  alias cosh! cosh
  alias tanh! tanh
 
  alias asin! asin
  alias acos! acos
  alias atan! atan
  alias atan2! atan2
 
  alias asinh! asinh
  alias acosh! acosh
  alias atanh! atanh
 
  #--------------------------------------------------------------------------
  # * exp(z)
  #--------------------------------------------------------------------------
  # Math::E raised to the z power
  #--------------------------------------------------------------------------
  def exp(z)
    if z.real?
      exp!(z)
    else
      ere = exp!(z.real)
      Complex(ere * cos!(z.imag),
              ere * sin!(z.imag))
    end
  end
 
  #--------------------------------------------------------------------------
  # * log(z, b=::Math::E)
  #--------------------------------------------------------------------------
  # Returns the natural logarithm of Complex. If a second argument is given,
  # it will be the base of logarithm.
  #--------------------------------------------------------------------------
  def log(*args)
    z, b = args
    if z.real? and z >= 0 and (b.nil? or b >= 0)
      log!(*args)
    else
      a = Complex(log!(z.abs), z.arg)
      if b
        a /= log(b)
      end
      a
    end
  end
 
  #--------------------------------------------------------------------------
  # * log2(z)
  #--------------------------------------------------------------------------
  # Returns the base 2 logarithm of z
  #--------------------------------------------------------------------------
  def log2(z)
    if z.real? and z >= 0
      log2!(z)
    else
      log(z) / log!(2)
    end
  end
 
  #--------------------------------------------------------------------------
  # * log10(z)
  #--------------------------------------------------------------------------
  # Returns the base 10 logarithm of z
  #--------------------------------------------------------------------------
  def log10(z)
    if z.real? and z >= 0
      log10!(z)
    else
      log(z) / log!(10)
    end
  end
 
  #--------------------------------------------------------------------------
  # * sqrt(z)
  #--------------------------------------------------------------------------
  # Returns the non-negative square root of Complex.
  #--------------------------------------------------------------------------
  def sqrt(z)
    if z.real?
      if z < 0
        Complex(0, sqrt!(-z))
      else
        sqrt!(z)
      end
    else
      if z.imag < 0 ||
        (z.imag == 0 && z.imag.to_s[0] == '-')
        sqrt(z.conjugate).conjugate
      else
        r = z.abs
        x = z.real
        Complex(sqrt!((r + x) / 2), sqrt!((r - x) / 2))
      end
    end
  end
 
  #--------------------------------------------------------------------------
  # * cbrt(z)
  #--------------------------------------------------------------------------
  # Returns the principal value of the cube root of z
  #--------------------------------------------------------------------------
  def cbrt(z)
    if z.real?
      cbrt!(z)
    else
      Complex(z) ** (1.0/3)
    end
  end
 
  #--------------------------------------------------------------------------
  # * sin(z)
  #--------------------------------------------------------------------------
  # Returns the sine of z, where z is given in radians
  #--------------------------------------------------------------------------
  def sin(z)
    if z.real?
      sin!(z)
    else
      Complex(sin!(z.real) * cosh!(z.imag),
              cos!(z.real) * sinh!(z.imag))
    end
  end
 
  #--------------------------------------------------------------------------
  # * cos(z)
  #--------------------------------------------------------------------------
  # Returns the cosine of z, where z is given in radians
  #--------------------------------------------------------------------------
  def cos(z)
    if z.real?
      cos!(z)
    else
      Complex(cos!(z.real) * cosh!(z.imag),
              -sin!(z.real) * sinh!(z.imag))
    end
  end
 
  #--------------------------------------------------------------------------
  # * tan(z)
  #--------------------------------------------------------------------------
  # Returns the tangent of z, where z is given in radians
  #--------------------------------------------------------------------------
  def tan(z)
    if z.real?
      tan!(z)
    else
      sin(z) / cos(z)
    end
  end
 
  #--------------------------------------------------------------------------
  # * sinh(z)
  #--------------------------------------------------------------------------
  # Returns the hyperbolic sine of z, where z is given in radians
  #--------------------------------------------------------------------------
  def sinh(z)
    if z.real?
      sinh!(z)
    else
      Complex(sinh!(z.real) * cos!(z.imag),
              cosh!(z.real) * sin!(z.imag))
    end
  end
 
  #--------------------------------------------------------------------------
  # * cos(z)
  #--------------------------------------------------------------------------
  # Returns the hyperbolic cosine of z, where z is given in radians
  #--------------------------------------------------------------------------
  def cosh(z)
    if z.real?
      cosh!(z)
    else
      Complex(cosh!(z.real) * cos!(z.imag),
              sinh!(z.real) * sin!(z.imag))
    end
  end
 
  #--------------------------------------------------------------------------
  # * tanh(z)
  #--------------------------------------------------------------------------
  # Returns the hyperbolic tangent of z, where z is given in radians
  #--------------------------------------------------------------------------
  def tanh(z)
    if z.real?
      tanh!(z)
    else
      sinh(z) / cosh(z)
    end
  end
 
  #--------------------------------------------------------------------------
  # * asin(z)
  #--------------------------------------------------------------------------
  # Returns the arc sine of z
  #--------------------------------------------------------------------------
  def asin(z)
    if z.real? and z >= -1 and z <= 1
      asin!(z)
    else
      (-1.0).i * log(1.0.i * z + sqrt(1.0 - z * z))
    end
  end
 
  #--------------------------------------------------------------------------
  # * acos(z)
  #--------------------------------------------------------------------------
  # Returns the arc cosine of z
  #--------------------------------------------------------------------------
  def acos(z)
    if z.real? and z >= -1 and z <= 1
      acos!(z)
    else
      (-1.0).i * log(z + 1.0.i * sqrt(1.0 - z * z))
    end
  end
 
  #--------------------------------------------------------------------------
  # * atan(z)
  #--------------------------------------------------------------------------
  # Returns the arc tangent of z
  #--------------------------------------------------------------------------
  def atan(z)
    if z.real?
      atan!(z)
    else
      1.0.i * log((1.0.i + z) / (1.0.i - z)) / 2.0
    end
  end
 
  #--------------------------------------------------------------------------
  # * atan2(z)
  #--------------------------------------------------------------------------
  # returns the arc tangent of y divided by x using the signs of y and x to
  # determine the quadrant
  #--------------------------------------------------------------------------
  def atan2(y,x)
    if y.real? and x.real?
      atan2!(y,x)
    else
      (-1.0).i * log((x + 1.0.i * y) / sqrt(x * x + y * y))
    end
  end
 
  #--------------------------------------------------------------------------
  # * asinh(z)
  #--------------------------------------------------------------------------
  # returns the inverse hyperbolic sine of z
  #--------------------------------------------------------------------------
  def asinh(z)
    if z.real?
      asinh!(z)
    else
      log(z + sqrt(1.0 + z * z))
    end
  end
 
  #--------------------------------------------------------------------------
  # * acosh(z)
  #--------------------------------------------------------------------------
  # returns the inverse hyperbolic cosine of z
  #--------------------------------------------------------------------------
  def acosh(z)
    if z.real? and z >= 1
      acosh!(z)
    else
      log(z + sqrt(z * z - 1.0))
    end
  end
 
  #--------------------------------------------------------------------------
  # * atanh(z)
  #--------------------------------------------------------------------------
  # returns the inverse hyperbolic tangent of z
  #--------------------------------------------------------------------------
  def atanh(z)
    if z.real? and z >= -1 and z <= 1
      atanh!(z)
    else
      log((1.0 + z) / (1.0 - z)) / 2.0
    end
  end
 
  module_function :exp!
  module_function :exp
  module_function :log!
  module_function :log
  module_function :log2!
  module_function :log2
  module_function :log10!
  module_function :log10
  module_function :sqrt!
  module_function :sqrt
  module_function :cbrt!
  module_function :cbrt
 
  module_function :sin!
  module_function :sin
  module_function :cos!
  module_function :cos
  module_function :tan!
  module_function :tan
 
  module_function :sinh!
  module_function :sinh
  module_function :cosh!
  module_function :cosh
  module_function :tanh!
  module_function :tanh
 
  module_function :asin!
  module_function :asin
  module_function :acos!
  module_function :acos
  module_function :atan!
  module_function :atan
  module_function :atan2!
  module_function :atan2
 
  module_function :asinh!
  module_function :asinh
  module_function :acosh!
  module_function :acosh
  module_function :atanh!
  module_function :atanh
 
  module_function :frexp
  module_function :ldexp
  module_function :hypot
  module_function :erf
  module_function :erfc
  module_function :gamma
  module_function :lgamma
 
end

#==============================================================================


# * CMath


#------------------------------------------------------------------------------


# Trigonometric and transcendental functions for complex numbers.


# CMath is a library that provides trigonometric and transcendental functions


# for complex numbers. The functions in this module accept integers, floating-


# point numbers or complex numbers as arguments.


# Note that the selection of functions is similar, but not identical, to that


# in module math. The reason for having two modules is that some users aren't


# interested in complex numbers, and perhaps don't even know what they are. They


# would rather have Math.sqrt(-1) raise an exception than return a complex


# number.


# For more information you can see Complex class.


#==============================================================================


 


module CMath


 


  include Math


 


  alias exp! exp


  alias log! log


  alias log2! log2


  alias log10! log10


  alias sqrt! sqrt


  alias cbrt! cbrt


 


  alias sin! sin


  alias cos! cos


  alias tan! tan


 


  alias sinh! sinh


  alias cosh! cosh


  alias tanh! tanh


 


  alias asin! asin


  alias acos! acos


  alias atan! atan


  alias atan2! atan2


 


  alias asinh! asinh


  alias acosh! acosh


  alias atanh! atanh


 


  #--------------------------------------------------------------------------


  # * exp(z)


  #--------------------------------------------------------------------------


  # Math::E raised to the z power


  #--------------------------------------------------------------------------


  def exp(z)


    if z.real?


      exp!(z)


    else


      ere = exp!(z.real)


      Complex(ere * cos!(z.imag),


              ere * sin!(z.imag))


    end


  end


 


  #--------------------------------------------------------------------------


  # * log(z, b=::Math::E)


  #--------------------------------------------------------------------------


  # Returns the natural logarithm of Complex. If a second argument is given,


  # it will be the base of logarithm.


  #--------------------------------------------------------------------------


  def log(*args)


    z, b = args


    if z.real? and z >= 0 and (b.nil? or b >= 0)


      log!(*args)


    else


      a = Complex(log!(z.abs), z.arg)


      if b


        a /= log(b)


      end


      a


    end


  end


 


  #--------------------------------------------------------------------------


  # * log2(z)


  #--------------------------------------------------------------------------


  # Returns the base 2 logarithm of z


  #--------------------------------------------------------------------------


  def log2(z)


    if z.real? and z >= 0


      log2!(z)


    else


      log(z) / log!(2)


    end


  end


 


  #--------------------------------------------------------------------------


  # * log10(z)


  #--------------------------------------------------------------------------


  # Returns the base 10 logarithm of z


  #--------------------------------------------------------------------------


  def log10(z)


    if z.real? and z >= 0


      log10!(z)


    else


      log(z) / log!(10)


    end


  end


 


  #--------------------------------------------------------------------------


  # * sqrt(z)


  #--------------------------------------------------------------------------


  # Returns the non-negative square root of Complex.


  #--------------------------------------------------------------------------


  def sqrt(z)


    if z.real?


      if z < 0


        Complex(0, sqrt!(-z))


      else


        sqrt!(z)


      end


    else


      if z.imag < 0 ||


        (z.imag == 0 && z.imag.to_s[0] == '-')


        sqrt(z.conjugate).conjugate


      else


        r = z.abs


        x = z.real


        Complex(sqrt!((r + x) / 2), sqrt!((r - x) / 2))


      end


    end


  end


 


  #--------------------------------------------------------------------------


  # * cbrt(z)


  #--------------------------------------------------------------------------


  # Returns the principal value of the cube root of z


  #--------------------------------------------------------------------------


  def cbrt(z)


    if z.real?


      cbrt!(z)


    else


      Complex(z) ** (1.0/3)


    end


  end


 


  #--------------------------------------------------------------------------


  # * sin(z)


  #--------------------------------------------------------------------------


  # Returns the sine of z, where z is given in radians


  #--------------------------------------------------------------------------


  def sin(z)


    if z.real?


      sin!(z)


    else


      Complex(sin!(z.real) * cosh!(z.imag),


              cos!(z.real) * sinh!(z.imag))


    end


  end


 


  #--------------------------------------------------------------------------


  # * cos(z)


  #--------------------------------------------------------------------------


  # Returns the cosine of z, where z is given in radians


  #--------------------------------------------------------------------------


  def cos(z)


    if z.real?


      cos!(z)


    else


      Complex(cos!(z.real) * cosh!(z.imag),


              -sin!(z.real) * sinh!(z.imag))


    end


  end


 


  #--------------------------------------------------------------------------


  # * tan(z)


  #--------------------------------------------------------------------------


  # Returns the tangent of z, where z is given in radians


  #--------------------------------------------------------------------------


  def tan(z)


    if z.real?


      tan!(z)


    else


      sin(z) / cos(z)


    end


  end


 


  #--------------------------------------------------------------------------


  # * sinh(z)


  #--------------------------------------------------------------------------


  # Returns the hyperbolic sine of z, where z is given in radians


  #--------------------------------------------------------------------------


  def sinh(z)


    if z.real?


      sinh!(z)


    else


      Complex(sinh!(z.real) * cos!(z.imag),


              cosh!(z.real) * sin!(z.imag))


    end


  end


 


  #--------------------------------------------------------------------------


  # * cos(z)


  #--------------------------------------------------------------------------


  # Returns the hyperbolic cosine of z, where z is given in radians


  #--------------------------------------------------------------------------


  def cosh(z)


    if z.real?


      cosh!(z)


    else


      Complex(cosh!(z.real) * cos!(z.imag),


              sinh!(z.real) * sin!(z.imag))


    end


  end


 


  #--------------------------------------------------------------------------


  # * tanh(z)


  #--------------------------------------------------------------------------


  # Returns the hyperbolic tangent of z, where z is given in radians


  #--------------------------------------------------------------------------


  def tanh(z)


    if z.real?


      tanh!(z)


    else


      sinh(z) / cosh(z)


    end


  end


 


  #--------------------------------------------------------------------------


  # * asin(z)


  #--------------------------------------------------------------------------


  # Returns the arc sine of z


  #--------------------------------------------------------------------------


  def asin(z)


    if z.real? and z >= -1 and z <= 1


      asin!(z)


    else


      (-1.0).i * log(1.0.i * z + sqrt(1.0 - z * z))


    end


  end


 


  #--------------------------------------------------------------------------


  # * acos(z)


  #--------------------------------------------------------------------------


  # Returns the arc cosine of z


  #--------------------------------------------------------------------------


  def acos(z)


    if z.real? and z >= -1 and z <= 1


      acos!(z)


    else


      (-1.0).i * log(z + 1.0.i * sqrt(1.0 - z * z))


    end


  end


 


  #--------------------------------------------------------------------------


  # * atan(z)


  #--------------------------------------------------------------------------


  # Returns the arc tangent of z


  #--------------------------------------------------------------------------


  def atan(z)


    if z.real?


      atan!(z)


    else


      1.0.i * log((1.0.i + z) / (1.0.i - z)) / 2.0


    end


  end


 


  #--------------------------------------------------------------------------


  # * atan2(z)


  #--------------------------------------------------------------------------


  # returns the arc tangent of y divided by x using the signs of y and x to


  # determine the quadrant


  #--------------------------------------------------------------------------


  def atan2(y,x)


    if y.real? and x.real?


      atan2!(y,x)


    else


      (-1.0).i * log((x + 1.0.i * y) / sqrt(x * x + y * y))


    end


  end


 


  #--------------------------------------------------------------------------


  # * asinh(z)


  #--------------------------------------------------------------------------


  # returns the inverse hyperbolic sine of z


  #--------------------------------------------------------------------------


  def asinh(z)


    if z.real?


      asinh!(z)


    else


      log(z + sqrt(1.0 + z * z))


    end


  end


 


  #--------------------------------------------------------------------------


  # * acosh(z)


  #--------------------------------------------------------------------------


  # returns the inverse hyperbolic cosine of z


  #--------------------------------------------------------------------------


  def acosh(z)


    if z.real? and z >= 1


      acosh!(z)


    else


      log(z + sqrt(z * z - 1.0))


    end


  end


 


  #--------------------------------------------------------------------------


  # * atanh(z)


  #--------------------------------------------------------------------------


  # returns the inverse hyperbolic tangent of z


  #--------------------------------------------------------------------------


  def atanh(z)


    if z.real? and z >= -1 and z <= 1


      atanh!(z)


    else


      log((1.0 + z) / (1.0 - z)) / 2.0


    end


  end


 


  module_function :exp!


  module_function :exp


  module_function :log!


  module_function :log


  module_function :log2!


  module_function :log2


  module_function :log10!


  module_function :log10


  module_function :sqrt!


  module_function :sqrt


  module_function :cbrt!


  module_function :cbrt


 


  module_function :sin!


  module_function :sin


  module_function :cos!


  module_function :cos


  module_function :tan!


  module_function :tan


 


  module_function :sinh!


  module_function :sinh


  module_function :cosh!


  module_function :cosh


  module_function :tanh!


  module_function :tanh


 


  module_function :asin!


  module_function :asin


  module_function :acos!


  module_function :acos


  module_function :atan!


  module_function :atan


  module_function :atan2!


  module_function :atan2


 


  module_function :asinh!


  module_function :asinh


  module_function :acosh!


  module_function :acosh


  module_function :atanh!


  module_function :atanh


 


  module_function :frexp


  module_function :ldexp


  module_function :hypot


  module_function :erf


  module_function :erfc


  module_function :gamma


  module_function :lgamma


 


end

顺便一提，虽然绘制速度慢到让人吐血，但是由于不支持后台运行，请将焦点保持在窗口上，慢慢看着它画完；我也不是很清楚为什么RGD不支持这个
再顺便一提，要是RGD有更高的Ruby版本就好了，我就不用写Complex(1, 2)，直接写1+2i了

fux4

尝试用Shader完成这个效果把（效率会让你惊呆