gsl 1.12.109 → 1.14.5

data/rdoc/changes.rdoc

@@ -0,0 +1,164 @@
+#
+# = Changes since Ruby/GSL 1.10.3
+#
+# Ruby/GSL 1.11.2 introduced enhancements and some important bug fixes since the
+# earlier 1.10.3 release.  Some of the enhancements and bug fixes involve changes
+# that are not backwards compatible.  Existing scripts that work with Ruby/GSL
+# 1.10.3 may break under 1.11.2 (or later) if they use certain constructs that
+# are no longer supported or have changed in an incompatible way.
+#
+# The changes that could break old scripts are described below.  They are
+# followed by highlights of the other enhancements and new features.
+#
+# A complete log of changes since Ruby/GSL version 1.10.3 can be obtained by
+# using Subversion's log command to look at the repository...
+#
+#   svn log http://rb-gsl.rubyforge.org/svn/trunk/rb-gsl
+#
+# == {}[link:index.html"name="1] Backwards incompatibilities introduced in Ruby/GSL 1.11.2
+#
+# * FFT interface has been extensively changed.
+#
+# * Matrix#get has been modified.
+#
+# * Size changing methods of GSL::Vector et al have, in general, been removed.
+#
+# * The #shift, #unshift, #push, and #pop methods have been removed from
+#   GSL::Vector et al since they result increasing the size of <tt>self</tt>.  This
+#   can cause new memory to be allocated and old memory to be freed, but because
+#   existing Views contain pointers to the old memory, this cannot be allowed.
+#   Also removed #up and #down aliases from GSL::Poly.
+#
+# * The #concat method of GSL::Vector et al has been changed to always return a
+#   new, longer instance rather than reallocating memory for <tt>self</tt>.
+#
+# * Return values from #delete, #delete_at, and #delete_if now follow same
+#   convention as similarly named methods in Ruby's Array class.  These methods
+#   should be considered deprecated because existing Views could still refer to
+#   now unmanged (but still allocated) memory.
+#
+# * GSL::Complex objects are now immutable.
+#
+# == {}[link:index.html"name="2] Enhancements and features introduced in Ruby/GSL 1.11.2
+#
+# * Now distributed and installable as a Ruby Gem.
+#
+# * Allow nil for real and/or imag in GSL::Vector::Complex#set(i,re,im) to NOT
+#   set that component.  For example, "z=GSL::Vector::Complex[1]; z[0] = [nil,
+#   1]" will set z[0] to GSL::Complex[0,1].
+#
+# * Added GSL::Vector::Complex#to_s method.
+#
+# * Improved GSL::Vector::Complex#inspect.
+#
+# * Added GSL::Vector::Complex#set_real and GSL::Vector::Complex#set_imag methods
+#   (and real=, re=, imag=, im= aliases).  Currently only work with Numerics, but
+#   could be made to work with GSL::Vectors (and Arrays of Floats).
+#
+# * Added GSL::Vector::Complex#conjugate and GSL::Vector::Complex#conjugate!
+#   methods along with corresponding "conj" and "conj!" aliases.
+#
+# * Added "#add!", "#sub!", "#mul!", and "#div!" methods to GSL::Vector::Complex.
+#   Also "add_constant!", and "scale!" aliases.
+#
+# * Added the following stats methods to GSL::Vector::Complex, #sum, #mean, #tss,
+#   #tss_m, #variance, #variance_m, #variance_fm, #sd, #sd_m, and #sd_fm.  #sum
+#   and #mean return GSL::Complex; all others return Float.
+#
+# * Added "dup" alias for "clone" method of Vector and Maxtrix.
+#
+# * Added support for three parameter call to #subvector to support stride.
+#
+# * Added #shape method with alias #size for Matrix.
+#
+# * Provide GSL_Object#dup method to override Object#dup.  GSL_Object#dup simply
+#   raises NotImplementedError.  Subclasses that want dup functionality should
+#   provide their own implementation.
+#
+# * Added length alias to Vector and Vector::Complex.
+#
+# * Added #angle alias for #arg method of Complex, Vector::Complex, and
+#   Matrix::Complex
+#
+# * Added #conj alias for #conjugate for GSL::Complex.  Added #conjugate! method
+#   with #conj! alias for GSL::Complex.
+#
+# * Added #[]= alias for #set method, #conj alias for #conjugate method, and
+#   #conj! alias for #conjugate! method to GSL::Matrix::Complex
+#
+# * Support GSL::Permutation as parameter to Vector::Complex#get (and #[]).
+#
+# * Disallow the stride and length parameters of the various FFT methods.  The
+#   Vector being transformed could really be a Vector::View (e.g. a view of a
+#   Matrix column).  In that case, we need to use the stride of the Vector::View.
+#   Users wishing to use a custom stride or length will be able to do so by
+#   transforming  a subvector of the Vector.
+#
+# * Added Block#length alias for Block#size.
+#
+# * Fixed bug #16023.
+#
+# * Calling #to_v on a single column matrix view will return column vector.
+#   Related to #19757.
+#
+# * Provided GSL::Matrix::Complex with reasonable #to_s and #inspect
+#   implementations.
+#
+# * Made Vector#{add,sub,mul,div}! methods work with non-Vector parameter (i.e.
+#   constant).
+#
+# * Added #collect and #collect! methods to Matrix::Complex.
+#
+# * Added #map and #map! aliases for collect and collect! to Block, Vector et al,
+#   and Matrix et al.
+#
+# * Vector::Complex#each, #reverse_each, #collect, and #collect! now yield
+#   objects that are allocated on heap rather than stack.
+#
+# * Made Vector#subvector work with negative offsets
+#
+# * Added Vector#sgn and Matrix#sgn, both with #signum alias.
+#
+# * Added support for a Range parameter (with optional stride) to
+#   Vector#subvector and Vector::Complex#subvector.
+#
+# * Modified Vector#get and Vector::Complex#get to return Views (via #subvector)
+#   if more than one (or none) parameters are given or if a single Range
+#   parameter is given.
+#
+# * Enhanced Matrix#submatrix with many new options and updated docs to reflect
+#   changes
+#
+# * Modified Matrix#get to use new Matrix#submatrix functionality.
+#
+# * Added Matrix#to_a and Matrix::Complex#to_a methods.
+#
+# * Enhanced Vector#set functionality.
+#
+# * Added more details, examples, and a warning to Vector#set documentation.
+#
+# * Changed Range handling to support Floats for begin and end values where
+#   appropriate.
+#
+# * Changed Vector#view_with_stride to require non-zero stride rather then
+#   positive stride.
+#
+# * Enhanced Vector::Complex#set functionality.
+#
+# * Enhanced Matrix#set.  Changed behavior of Matrix#get when called with a
+#   single Fixnum argument; now returns individual element rather than
+#   Vector::View of row.  See html/matrix.html for more details.  Changed tests
+#   and examples to accomdate the change in Matrix#get.
+#
+# * Match to the latest tensor extension (version 0.99)
+#
+# * Modified GSL::Matrix::Complex#set to have same (i.e. newly enhanced)
+#   functionality as GSL::Matrix#set.  [Possibly incomplete; please report any
+#   discrepancies.]
+#
+# * Added #diag alias for Matrix#diagonal.
+#
+# * Added #fftshift, #fftshift!, #ifftshift, and #ifftshift!  methods to
+#   GSL::Vector::Complex and documented them.
+#
+#

data/rdoc/cheb.rdoc

@@ -0,0 +1,99 @@
+#
+# = Chebyshev Approximations
+# This chapter describes routines for computing Chebyshev approximations to 
+# univariate functions. A Chebyshev approximation is a truncation of the series 
+# f(x) = \sum c_n T_n(x), 
+# where the Chebyshev polynomials T_n(x) = \cos(n \arccos x) 
+# provide an orthogonal basis of polynomials on the interval [-1,1] 
+# with the weight function 1 / \sqrt{1-x^2}. 
+# The first few Chebyshev polynomials are, 
+# T_0(x) = 1, T_1(x) = x, T_2(x) = 2 x^2 - 1. 
+# For further information see Abramowitz & Stegun, Chapter 22. 
+#
+# 1. {GSL::Cheb class}[link:files/rdoc/cheb_rdoc.html#1]
+# 1. {Chebyshev Series Evaluation}[link:files/rdoc/cheb_rdoc.html#2]
+# 1. {Derivatives and Integrals}[link:files/rdoc/cheb_rdoc.html#3]
+# 1. {Examples}[link:files/rdoc/cheb_rdoc.html#4]
+#
+# == {}[link:index.html"name="1] <tt>GSL::Cheb</tt> class
+#
+# ---
+# * GSL::Cheb.alloc(n) 
+#
+#   This create an instance of the GSL::Cheb class for a Chebyshev series of order n.
+#
+#
+# ---
+# * GSL::Cheb#init(f, a, b)
+#
+#   This computes the Chebyshev approximation the function <tt>f</tt> over the range (<tt>a,b</tt>) to the previously specified order. Where <tt>f</tt> is a {GSL::Function}[link:files/rdoc/function_rdoc.html] object. The computation of the Chebyshev approximation is an O(n^2) process, and requires <tt>n</tt> function evaluations.
+#
+#   * ex: Approximate a step function defined in (0, 1) by a Chebyshev series of order 40.
+#       f = GSL::Function.alloc { |x|
+#         if x < 0.5
+#           0.25
+#         else
+#           0.75
+#         end
+#       }
+#
+#       cs = GSL::Cheb.alloc(40)
+#       cs.init(f, 0, 1)
+#
+# == {}[link:index.html"name="2] Chebyshev Series Evaluation
+# ---
+# * GSL::Cheb#eval(x)
+#
+#   This evaluates the Chebyshev series at a given point <tt>x</tt>.
+#
+# ---
+# * GSL::Cheb#eval_n(n, x)
+#
+#   This evaluates the Chebyshev series at a given point <tt>x</tt>, to (at most) the given order <tt>n</tt>.
+#
+# == {}[link:index.html"name="3] Derivatives and Integrals 
+#
+# ---
+# * GSL::Cheb#calc_deriv()
+# * GSL::Cheb#deriv()
+#
+#   This computes the derivative of the series, and returns a new GSL::Cheb object which contains the computed derivative. The reciever is not changed.
+#
+# ---
+# * GSL::Cheb#calc_integ()
+# * GSL::Cheb#integ()
+#
+#   This computes the integral of the series, and returns a new GSL::Cheb object which contains the computed integral coefficients. The reciever is not changed.
+#
+# == {}[link:index.html"name="4] Example
+#    #!/usr/bin/env ruby
+#    require("gsl")
+#
+#    f = GSL::Function.alloc { |x|
+#      if x < 0.5
+#        0.25
+#      else
+#        0.75
+#      end
+#    }
+#
+#    n = 1000
+#    order = 40
+#    cs = GSL::Cheb.alloc(order)
+#    cs.init(f, 0, 1)
+#
+#    x = Vector.linspace(0, 1, n)
+#    ff = f.eval(x)
+#    r10 = cs.eval_n(10, x)
+#    r40 = cs.eval(x)
+#    GSL::graph(x, ff, r10, r40)
+#
+#
+# See also the example scripts in <tt>examples/cheb/</tt>.
+#
+# {prev}[link:files/rdoc/diff_rdoc.html]
+# {next}[link:files/rdoc/sum_rdoc.html]
+#
+# {Reference index}[link:files/rdoc/ref_rdoc.html]
+# {top}[link:files/rdoc/index_rdoc.html]
+#

data/rdoc/cholesky_complex.rdoc

@@ -0,0 +1,46 @@
+#
+# === Cholesky decomposition (>= GSL-1.10)
+# A symmetric, positive definite square matrix <tt>A</tt> has 
+# a Cholesky decomposition into a product of a lower triangular matrix 
+# <tt>L</tt> and its transpose <tt>L^T</tt>.
+# This is sometimes referred to as taking the square-root of a matrix. 
+# The Cholesky decomposition can only be carried out when all the eigenvalues 
+# of the matrix are positive. This decomposition can be used to convert the 
+# linear system <tt>A x = b</tt> into a pair of triangular systems 
+# <tt>L y = b, L^T x = y</tt>,
+# which can be solved by forward and back-substitution. 
+#
+# ---
+# * GSL::Linalg::Complex::Cholesky::decomp(A)
+# * GSL::Linalg::Complex::cholesky_decomp(A)
+#
+#   Factorize the positive-definite square matrix <tt>A</tt> into the 
+#   Cholesky decomposition <tt>A = L L^H</tt>.
+#   On input only the diagonal and lower-triangular part of the matrix <tt>A</tt> 
+#   are needed. The diagonal and lower triangular part of the returned matrix
+#   contain the matrix <tt>L</tt>. The upper triangular part of the 
+#   returned matrix contains L^T, and
+#   the diagonal terms being identical for both L and L^T. 
+#   If the input matrix is not positive-definite then the decomposition 
+#   will fail, returning the error code <tt>GSL::EDOM</tt>. 
+#
+# ---
+# * GSL::Linalg::Complex::Cholesky::solve(chol, b, x)
+# * GSL::Linalg::Complex::cholesky_solve(chol, b, x)
+#
+#   Solve the system <tt>A x = b</tt> using the Cholesky decomposition 
+#   of <tt>A</tt> into the matrix <tt>chol</tt> given by 
+#   <tt>GSL::Linalg::Complex::Cholesky::decomp</tt>.
+#
+# ---
+# * GSL::Linalg::Complex::Cholesky::svx(chol, x)
+# * GSL::Linalg::Complex::cholesky_svx(chol, x)
+#
+#   Solve the system <tt>A x = b</tt> in-place using the Cholesky decomposition 
+#   of <tt>A</tt> into the matrix <tt>chol</tt> given by 
+#   <tt>GSL::Linalg::Complex::Cholesky::decomp</tt>. On input <tt>x</tt> 
+#   should contain the right-hand side <tt>b</tt>, 
+#   which is replaced by the solution on output. 
+#
+# {back}[link:files/rdoc/linalg_rdoc.html]
+#

data/rdoc/combi.rdoc

@@ -0,0 +1,125 @@
+#
+# = Combinations
+# Contents:
+# 1. {Combination allocation}[link:files/rdoc/combi_rdoc.html#1]
+# 1. {Methods}[link:files/rdoc/combi_rdoc.html#2]
+#    1. {Accessing combination elements}[link:files/rdoc/combi_rdoc.html#2.1]
+#    1. {Combination properties}[link:files/rdoc/combi_rdoc.html#2.2]
+#    1. {Combination functions}[link:files/rdoc/combi_rdoc.html#2.3]
+#    1. {Reading and writing combinations}[link:files/rdoc/combi_rdoc.html#2.4]
+#
+# == {}[link:index.html"name="1] Combination allocation
+# ---
+# * GSL::Combination.alloc(n, k)
+#
+#   These create a new combination with parameters <tt>n, k</tt>. 
+#   The combination is not initialized and its elements are undefined. 
+#   Use the method <tt>GSL::Combination.calloc</tt> if you want to create a 
+#   combination which is initialized to the lexicographically first combination. 
+#
+# ---
+# * GSL::Combination.calloc(n, k)
+#
+#   This creates a new combination with parameters <tt>n, k</tt> and initializes 
+#   it to the lexicographically first combination. 
+#
+# == {}[link:index.html"name="2] Methods
+#
+# ---
+# * GSL::Combination#init_first
+#
+#   This method initializes the combination <tt>self</tt> to the lexicographically 
+#   first combination, i.e. (0,1,2,...,k-1).
+#
+# ---
+# * GSL::Combination#init_last
+#
+#   This method initializes the combination <tt>self</tt> to the lexicographically last 
+#   combination, i.e. (n-k,n-k+1,...,n-1).
+#
+# === {}[link:index.html"name="2.1] Accessing combination elements
+# ---
+# * GSL::Combination#get(i)
+# * GSL::Combination#[i]
+#
+#   This returns the value of the <tt>i</tt>-th element of the combination <tt>self</tt>. 
+#
+# === {}[link:index.html"name="2.2] Combination properties
+# ---
+# * GSL::Combination#n
+#
+#   Returns the <tt>n</tt> parameter of the combination <tt>self</tt>.
+#
+# ---
+# * GSL::Combination#k
+#
+#   Returns the <tt>k</tt> parameter of the combination <tt>self</tt>.
+#
+# ---
+# * GSL::Combination#data
+#
+#   Returns the vector of elements in the combination <tt>self</tt>.
+#
+# ---
+# * GSL::Combination#valid
+#
+#   This method checks that the combination <tt>self</tt> is valid. 
+#   The <tt>k</tt> elements should contain numbers from range 0 .. n-1, 
+#   each number at most once. The numbers have to be in increasing order.
+#
+# ---
+# * GSL::Combination#valid?
+#
+#   Thie returns true if the combination is valid, and false otherwise.
+#
+# === {}[link:index.html"name="2.3] Combination functions
+# ---
+# * GSL::Combination#next
+#
+#   This method advances the combination <tt>self</tt> to the next combination in 
+#   lexicographic order and returns <tt>GSL::SUCCESS</tt>. If no further combinations are 
+#   available it returns <tt>GSL::FAILURE</tt> and leaves <tt>self</tt> unmodified. 
+#   Starting with the first combination and repeatedly applying this function will 
+#   iterate through all possible combinations of a given order.
+#
+# ---
+# * GSL::Combination#prev
+#
+#   This method steps backwards from the combination <tt>self</tt> to the previous 
+#   combination in lexicographic order, returning <tt>GSL::SUCCESS</tt>. 
+#   If no previous combination is available it returns <tt>GSL::FAILURE</tt> 
+#   and leaves <tt>self</tt> unmodified.
+#
+# === {}[link:index.html"name="2.4] Reading and writing combinations
+# ---
+# * GSL::Combination#fwrite(filename)
+# * GSL::Combination#fwrite(io)
+# * GSL::Combination#fread(filename)
+# * GSL::Combination#fread(io)
+# * GSL::Combination#fprintf(filename, format = "%u")
+# * GSL::Combination#fprintf(io, format = "%u")
+# * GSL::Combination#fscanf(filename)
+# * GSL::Combination#fscanf(io)
+#
+#
+# == {}[link:index.html"name="3] Example
+#      #!/usr/bin/env ruby
+#      require("gsl")
+#
+#      printf("All subsets of {0,1,2,3} by size:\n") ;
+#      for i in 0...4 do
+#        c = GSL::Combination.calloc(4, i);
+#        begin
+#          printf("{");
+#          c.fprintf(STDOUT, " %u");
+#          printf(" }\n");
+#        end while c.next == GSL::SUCCESS
+#      end
+#
+# {prev}[link:files/rdoc/perm_rdoc.html]
+# {next}[link:files/rdoc/multiset_rdoc.html]
+#
+# {Reference index}[link:files/rdoc/ref_rdoc.html]
+# {top}[link:files/rdoc/index_rdoc.html]
+#
+#

data/rdoc/complex.rdoc

@@ -0,0 +1,210 @@
+#
+# = Complex Numbers
+# Contents:
+# 1. {Class methods}[link:files/rdoc/complex_rdoc.html#1]
+# 1. {Properties of Complex Numbers}[link:files/rdoc/complex_rdoc.html#2]
+# 1. {Complex Arithmetic Operators}[link:files/rdoc/complex_rdoc.html#3]
+# 1. {Elementary Complex Functions}[link:files/rdoc/complex_rdoc.html#4]
+# 1. {Complex Trigonometric Functions}[link:files/rdoc/complex_rdoc.html#5]
+# 1. {Inverse Complex Trigonometric Functions}[link:files/rdoc/complex_rdoc.html#6]
+# 1. {Complex Hyperbolic Functions}[link:files/rdoc/complex_rdoc.html#7]
+# 1. {Inverse Complex Hyperbolic Functions}[link:files/rdoc/complex_rdoc.html#8]
+#
+# == {}[link:index.html"name="1] Class Methods
+# ---
+# * GSL::Complex.alloc(re, im)
+# * GSL::Complex.rect(re, im)
+# * GSL::Complex[re, im]
+#
+#   These create a GSL::Complex object with real and imaginary part <tt>re, im</tt>.
+#
+# ---
+# * GSL::Complex.polar(r, theta)
+#
+#   This returns a GSL::Complex object in polar representation, with the amplitude <tt>r</tt> and the phase (argument) <tt>theta</tt>.
+#
+# == {}[link:index.html"name="2] Properties of complex numbers
+# ---
+# * GSL::Complex#real
+# * GSL::Complex#re
+# * GSL::Complex#REAL
+#
+#   Returns the real part
+#
+# ---
+# * GSL::Complex#imag
+# * GSL::Complex#im
+# * GSL::Complex#IMAG
+#
+#   Returns the imaginary part
+#
+# ---
+# * GSL::Complex#arg
+# * GSL::Complex#angle
+# * GSL::Complex#phase
+#
+#   Returns the argument (i.e. phase angle in radians) of <tt>self</tt>.
+#
+# ---
+# * GSL::Complex#abs, abs2, logabs
+#
+#   Returns the magnitude, squared magnitude, and the logarithm of the magnitude
+#
+# == {}[link:index.html"name="3] Complex arithmetic operators
+# ---
+# * GSL::Complex#add(b)
+# * GSL::Complex#+(b)
+#
+#   Return the sum of the complex numbers <tt>self</tt> and <tt>b</tt>. 
+# ---
+# * GSL::Complex#sub(b)
+# * GSL::Complex#-(b)
+#
+#   Return the difference of the complex numbers <tt>self</tt> and <tt>b</tt>. 
+# ---
+# * GSL::Complex#mul(b)
+# * GSL::Complex#*(b)
+#
+#   Returns the product of the complex numbers  <tt>self</tt> and <tt>b</tt>.
+# ---
+# * GSL::Complex#div(b)
+# * GSL::Complex#/(b)
+#
+#   Returns the quotient of the complex numbers  <tt>self</tt> and <tt>b</tt>.
+#
+# ---
+# * GSL::Complex#add_real
+# * GSL::Complex#sub_real
+# * GSL::Complex#mul_real
+# * GSL::Complex#div_real
+# * GSL::Complex#add_imag
+# * GSL::Complex#sub_imag
+# * GSL::Complex#mul_imag
+# * GSL::Complex#div_imag
+#
+#
+# ---
+# * GSL::Complex#conjugate
+# * GSL::Complex#conj
+#
+#   Returns the complex conjugate of the complex number <tt>self</tt>.
+# ---
+# * GSL::Complex#inverse
+#
+#   Returns the inverse of the complex number <tt>self</tt>.
+# ---
+# * GSL::Complex#negative
+#
+#   Returns the negative of the complex number <tt>self</tt>.
+#
+# == {}[link:index.html"name="4] Elementary Complex Functions
+# ---
+# * GSL::Complex#sqrt
+# * GSL::Complex#pow(az)
+# * GSL::Complex#pow_real(a)
+# * GSL::Complex#exp
+# * GSL::Complex#log
+# * GSL::Complex#log10
+# * GSL::Complex#log_b(b)
+#
+#
+# ---
+# * GSL::Complex.sqrt(z)
+# * GSL::Complex.sqrt_real(a)
+# * GSL::Complex.pow(z, za)
+# * GSL::Complex.pow_real(z, a)
+# * GSL::Complex.exp(z)
+# * GSL::Complex.log(z)
+# * GSL::Complex.log10(z)
+# * GSL::Complex.log_b(z, b)
+#
+#
+# == {}[link:index.html"name="5] Complex Trigonometric Functions
+# ---
+# * GSL::Complex#sin
+# * GSL::Complex#cos
+# * GSL::Complex#tan
+# * GSL::Complex#sec
+# * GSL::Complex#csc
+# * GSL::Complex#cot
+#
+#
+# ---
+# * GSL::Complex.sin(z)
+# * GSL::Complex.cos(z)
+# * GSL::Complex.tan(z)
+# * GSL::Complex.sec(z)
+# * GSL::Complex.csc(z)
+# * GSL::Complex.cot(z)
+#
+#
+# == {}[link:index.html"name="6] Inverse Complex Trigonometric Functions
+# ---
+# * GSL::Complex#arcsin
+# * GSL::Complex#arccos
+# * GSL::Complex#arctan
+# * GSL::Complex#arcsec
+# * GSL::Complex#arccsc
+# * GSL::Complex#arccot
+#
+#
+# ---
+# * GSL::Complex.arcsin(z)
+# * GSL::Complex.arcsin_real(a)
+# * GSL::Complex.arccos(z)
+# * GSL::Complex.arccos_real(a)
+# * GSL::Complex.arctan(z)
+# * GSL::Complex.arcsec(z)
+# * GSL::Complex.arcsec_real(a)
+# * GSL::Complex.arccsc(z)
+# * GSL::Complex.arccsc_real(z)
+# * GSL::Complex.arccot(z)
+#
+#
+# == {}[link:index.html"name="7] Complex Hyperbolic Functions
+# ---
+# * GSL::Complex#sinh
+# * GSL::Complex#cosh
+# * GSL::Complex#tanh
+# * GSL::Complex#sech
+# * GSL::Complex#csch
+# * GSL::Complex#coth
+#
+#
+# ---
+# * GSL::Complex.sinh(z)
+# * GSL::Complex.cosh(z)
+# * GSL::Complex.tanh(z)
+# * GSL::Complex.sech(z)
+# * GSL::Complex.csch(z)
+# * GSL::Complex.coth(z)
+#
+#
+# == {}[link:index.html"name="8] Inverse Complex Hyperbolic Functions
+# ---
+# * GSL::Complex#arcsinh
+# * GSL::Complex#arccosh
+# * GSL::Complex#arctanh
+# * GSL::Complex#arcsech
+# * GSL::Complex#arccsch
+# * GSL::Complex#arccoth
+#
+#
+# ---
+# * GSL::Complex#arcsinh(z)
+# * GSL::Complex#arccosh(z)
+# * GSL::Complex#arccosh_real(a)
+# * GSL::Complex#arctanh(z)
+# * GSL::Complex#arctanh_real(z)
+# * GSL::Complex#arcsech(z)
+# * GSL::Complex#arccsch(z)
+# * GSL::Complex#arccoth(z)
+#
+#
+# {prev}[link:files/rdoc/math_rdoc.html]
+# {next}[link:files/rdoc/poly_rdoc.html]
+#
+# {Reference index}[link:files/rdoc/ref_rdoc.html]
+# {top}[link:files/rdoc/index_rdoc.html]
+#
+#