gsl 1.12.109 → 1.14.5

data/rdoc/perm.rdoc

@@ -0,0 +1,221 @@
+#
+# = Permutations
+# Contents:
+# 1. {Permuation allocations}[link:files/rdoc/perm_rdoc.html#1]
+# 1. {Methods}[link:files/rdoc/perm_rdoc.html#2]
+#    1. {Accessing permutation elements}[link:files/rdoc/perm_rdoc.html#2.1]
+#    1. {Permuation properties}[link:files/rdoc/perm_rdoc.html#2.2]
+#    1. {Permuation functions}[link:files/rdoc/perm_rdoc.html#2.3]
+#    1. {Reading and writing permutations}[link:files/rdoc/perm_rdoc.html#2.4]
+# 1. {Permutations in cyclic form}[link:files/rdoc/perm_rdoc.html#2.5]
+# 1. {Applying Permutations}[link:files/rdoc/perm_rdoc.html#3]
+#
+# == {}[link:index.html"name="1] Permuation allocations
+# ---
+# * GSL::Permutation.alloc(n)
+#
+#   These functions create a new permutation of size <tt>n</tt>. 
+#   The permutation is not initialized and its elements are undefined. 
+#   Use <tt>GSL::Permutation.calloc</tt> if you want to create a permutation 
+#   which is initialized to the identity. 
+#
+# ---
+# * GSL::Permutation.calloc(n)
+#
+#   This creates a new permutation of size <tt>n</tt> and initializes it to the identity. 
+#
+# == {}[link:index.html"name="2] Methods
+# ---
+# * GSL::Permutation#init()
+#
+#   This initializes the permutation to the identity, i.e. (0,1,2,...,n-1). 
+#
+# ---
+# * GSL::Permutation.memcpy(dest, src)
+#
+#   This method copies the elements of the permutation <tt>src</tt> 
+#   into the permutation <tt>dest</tt>. The two permutations must have the same size.
+#
+# ---
+# * GSL::Permutation#clone
+#
+#   This creates a new permutation with the same elements of <tt>self</tt>.
+#
+# === {}[link:index.html"name="2.1] Accessing permutation elements
+#
+# ---
+# * GSL::Permutation#get(i)
+#
+#   Returns the value of the <tt>i</tt>-th element of the permutation. 
+#
+# ---
+# * GSL::Permutation#swap(i, j)
+#
+#   This exchanges the <tt>i</tt>-th and <tt>j</tt>-th elements of the permutation.
+#
+# === {}[link:index.html"name="2.2] Permutation properties
+# ---
+# * GSL::Permutation#size
+#
+#   Returns the size of the permutation.
+# ---
+# * GSL::Permutation#valid
+#
+#   This checks that the permutation <tt>self</tt> is valid. 
+#   The n elements should contain each of the numbers 0 .. n-1 once and only once.
+#
+# ---
+# * GSL::Permutation#valid?
+#
+#   This returns true if the permutation <tt>self</tt> is valid, and false otherwise.
+#
+# === {}[link:index.html"name="2.3] Permutation functions
+#
+# ---
+# * GSL::Permutation#reverse
+#
+#   This reverses the elements of the permutation <tt>self</tt>.
+# ---
+# * GSL::Permutation#inverse
+#
+#   This computes the inverse of the permutation <tt>self</tt>, and returns
+#   as a new permutation.
+#
+# ---
+# * GSL::Permutation#next
+#
+#   This method advances the permutation <tt>self</tt> to the next permutation in 
+#   lexicographic order and returns <tt>GSL::SUCCESS</tt>. If no further permutations 
+#   are available it returns <tt>GSL::FAILURE</tt> and leaves <tt>self</tt> unmodified. 
+#   Starting with the identity permutation and repeatedly applying this function 
+#   will iterate through all possible permutations of a given order.
+# ---
+# * GSL::Permutation#prev
+#
+#   This method steps backwards from the permutation <tt>self</tt> to the previous 
+#   permutation in lexicographic order, returning <tt>GSL_SUCCESS</tt>. 
+#   If no previous permutation is available it returns <tt>GSL_FAILURE</tt> 
+#   and leaves <tt>self</tt> unmodified.
+#
+# === {}[link:index.html"name="2.4] Reading and writing permutations
+# ---
+# * GSL::Permutation#fwrite(io)
+# * GSL::Permutation#fwrite(filename)
+# * GSL::Permutation#fread(io)
+# * GSL::Permutation#fread(filename)
+# * GSL::Permutation#fprintf(io, format = "%u\n")
+# * GSL::Permutation#fprintf(filename, format = "%u\n")
+# * GSL::Permutation#fscanf(io)
+# * GSL::Permutation#fscanf(filename)
+#
+#
+# === {}[link:index.html"name="2.5] Permutations in cyclic Form
+# A permutation can be represented in both <tt>linear</tt> and 
+# <tt>cyclic</tt> notations. The functions described in this section convert 
+# between the two forms. The linear notation is an index mapping, and has 
+# already been described above. The cyclic notation expresses a 
+# permutation as a series of circular rearrangements of groups 
+# of elements, or <tt>cycles</tt>. 
+#
+# For example, under the cycle (1 2 3), 1 is replaced by 2, 2 is replaced 
+# by 3 and 3 is replaced by 1 in a circular fashion. Cycles of different 
+# sets of elements can be combined independently, for example (1 2 3) (4 5) 
+# combines the cycle (1 2 3) with the cycle (4 5), which is an exchange of 
+# elements 4 and 5. A cycle of length one represents an element which is 
+# unchanged by the permutation and is referred to as a <tt>singleton</tt>. 
+#
+# It can be shown that every permutation can be decomposed into combinations 
+# of cycles. The decomposition is not unique, but can always be rearranged 
+# into a standard <tt>canonical form</tt> by a reordering of elements. 
+# The library uses the canonical form defined in Knuth's 
+# <tt>Art of Computer Programming</tt> (Vol 1, 3rd Ed, 1997) Section 1.3.3, p.178. 
+#
+# The procedure for obtaining the canonical form given by Knuth is, 
+#
+#
+# 1. Write all singleton cycles explicitly 
+# 1. Within each cycle, put the smallest number first 
+# 1. Order the cycles in decreasing order of the first number in the cycle. 
+#
+# For example, the linear representation (2 4 3 0 1) is represented as 
+# (1 4) (0 2 3) in canonical form. The permutation corresponds to an 
+# exchange of elements 1 and 4, and rotation of elements 0, 2 and 3. 
+#
+# The important property of the canonical form is that it can be reconstructed 
+# from the contents of each cycle without the brackets. In addition, by removing 
+# the brackets it can be considered as a linear representation of a different 
+# permutation. In the example given above the permutation (2 4 3 0 1) would 
+# become (1 4 0 2 3). This mapping has many applications in the theory of 
+# permutations. 
+#
+# ---
+# * GSL::Permutation#linear_to_canonical
+# * GSL::Permutation#to_canonical
+#
+#   Computes the canonical form of the permutation <tt>self</tt> and 
+#   returns it as a new <tt>GSL::Permutation</tt>.
+#
+# ---
+# * GSL::Permutation#canonical_to_linear
+# * GSL::Permutation#to_linear
+#
+#   Converts a permutation <tt>self</tt> in canonical form back into linear 
+#   form and returns it as a new <tt>GSL::Permutation</tt>.
+#
+#
+# ---
+# * GSL::Permutation#inversions
+#
+#   Counts the number of inversions in the permutation <tt>self</tt>. 
+#   An inversion is any pair of elements that are not in order. 
+#   For example, the permutation 2031 has three inversions, corresponding
+#   to the pairs (2,0) (2,1) and (3,1). 
+#   The identity permutation has no inversions. 
+#
+# ---
+# * GSL::Permutation#linear_cycles
+#
+#   Counts the number of cycles in the permutation <tt>self</tt>, 
+#   given in linear form. 
+#
+# ---
+# * GSL::Permutation#canonical_cycles
+#
+#   Counts the number of cycles in the permutation <tt>self</tt>, 
+#   given in canonical form. 
+#
+# == {}[link:index.html"name="3] Applying Permutations
+# ---
+# * GSL::Permutation::permute(v)
+#
+#   Applies the permutation <tt>self</tt> to the elements of the vector <tt>v</tt>, 
+#   considered as a row-vector acted on by a permutation matrix from the 
+#   right, v' = v P. The j-th column of the permutation matrix P is 
+#   given by the p_j-th column of the identity matrix. 
+#   The permutation <tt>self</tt> and the vector <tt>v</tt> must have the same length.
+# ---
+# * GSL::Permutation::permute_inverse(v)
+#
+#   Applies the inverse of the permutation <tt>self</tt> to the elements of 
+#   the vector <tt>v</tt>, considered as a row-vector acted on by an inverse 
+#   permutation matrix from the right, v' = v P^T. 
+#   Note that for permutation matrices the inverse is the same as the 
+#   transpose. The j-th column of the permutation matrix P is given by 
+#   the p_j-th column of the identity matrix. 
+#   The permutation <tt>self</tt> and the vector <tt>v</tt> must have the same length.
+# ---
+# * GSL::Permutation.mul(pa, pb)
+#
+#   Combines the two permutations <tt>pa</tt> and <tt>pb</tt> into a single 
+#   permutation <tt>p</tt> and returns it. 
+#   The permutation <tt>p</tt> is equivalent to applying <tt>pb</tt> first 
+#   and then <tt>pa</tt>. 
+#
+#
+# {prev}[link:files/rdoc/matrix_rdoc.html]
+# {next}[link:files/rdoc/combi_rdoc.html]
+#
+# {Reference index}[link:files/rdoc/ref_rdoc.html]
+# {top}[link:files/rdoc/index_rdoc.html]
+#
+#

data/rdoc/poly.rdoc

@@ -0,0 +1,335 @@
+#
+# = Polynomials
+# Contents:
+# 1. {Polynomial Evaluation}[link:files/rdoc/poly_rdoc.html#1]
+# 1. {Solving polynomial equations}[link:files/rdoc/poly_rdoc.html#2]
+#    1. {Quadratic Equations}[link:files/rdoc/poly_rdoc.html#2.1]
+#    1. {Cubic Equations}[link:files/rdoc/poly_rdoc.html#2.2]
+#    1. {General Polynomial Equations}[link:files/rdoc/poly_rdoc.html#2.3]
+# 1. {GSL::Poly Class}[link:files/rdoc/poly_rdoc.html#3]
+#    1. {Constructors}[link:files/rdoc/poly_rdoc.html#3.1]
+#    1. {Methods}[link:files/rdoc/poly_rdoc.html#3.2]
+# 1. {Polynomial Fitting}[link:files/rdoc/poly_rdoc.html#4]
+# 1. {Divided-difference representations}[link:files/rdoc/poly_rdoc.html#5]
+# 1. {Extensions}[link:files/rdoc/poly_rdoc.html#6]
+#    1. {Special Polynomials}[link:files/rdoc/poly_rdoc.html#6.1]
+#    1. {Polynomial Operations}[link:files/rdoc/poly_rdoc.html#6.2]
+#
+# == {}[link:index.html"name="1] Polynomial Evaluation
+# ---
+# * GSL::Poly.eval(c, x)
+#
+#   Evaluates the polynomial <tt>c[0] + c[1]x + c[2]x^2 + ...</tt>. 
+#   The polynomial coefficients <tt>c</tt> can be an <tt>Array</tt>, 
+#   a <tt>GSL::Vector</tt>, or an <tt>NArray</tt>. The evaluation point <tt>x</tt>
+#   is a <tt>Numeric</tt>, <tt>Array</tt>, <tt>GSL::Vector</tt> or <tt>NArray</tt>.
+#   From GSL 1.11, <tt>x</tt> can be a complex number, and <tt>c</tt> can be a complex polynomial given by a <tt>GSL::Vector::Complex</tt> or an <tt>Array</tt>.
+#
+#   Ex)
+#      >> require("gsl")
+#      => true
+#      >> GSL::Poly.eval([1, 2, 3], 2)
+#      => 17.0
+#      >> GSL::Poly.eval(GSL::Vector[1, 2, 3], 2)
+#      => 17.0
+#      >> GSL::Poly.eval(NArray[1.0, 2, 3], 2)
+#      => 17.0
+#      >> GSL::Poly.eval([1, 2, 3], [1, 2, 3])
+#      => [6.0, 17.0, 34.0]
+#      >> GSL::Poly.eval([1, 2, 3], GSL::Vector[1, 2, 3])
+#      => GSL::Vector
+#      [ 6.000e+00 1.700e+01 3.400e+01 ]
+#      >> GSL::Poly.eval([1, 2, 3], NArray[1.0, 2, 3])
+#      => NArray.float(3):
+#      [ 6.0, 17.0, 34.0 ]
+#
+# ---
+# * GSL::Poly.eval_derivs(c, x)
+# * GSL::Poly.eval_derivs(c, x, lenres)
+#
+#   (GSL-1.13) Evaluate and return a polynomial and its derivatives. The output contains the values of d^k P/d x^k for the specified value of x starting with k = 0. The input polynomial <tt>c</tt> can be an <tt>Array</tt>, <tt>GSL::Poly</tt> or an <tt>NArray</tt>. If <tt>lenres</tt> is not given, <tt>lenres = LENGTH(c) + 1</tt> is used, therefore the last element of the output is 0.
+#
+# ---
+# * GSL::Poly#eval_derivs(x)
+# * GSL::Poly#eval_derivs(x, lenres)
+#
+#   (GSL-1.13) Evaluate and return a polynomial and its derivatives. The output contains the values of d^k P/d x^k for the specified value of x starting with k = 0. If <tt>lenres</tt> is not given, <tt>lenres = LENGTH(self) + 1</tt> is used, therefore the last element of the output is 0.
+#    
+#   Ex.)
+#    >> ary = [1, 2, 3]
+#    => [1, 2, 3]
+#    >> GSL::Poly.eval_derivs(ary, 1)
+#    => [6.0, 8.0, 6.0, 0.0]
+#    >> na = NArray[1.0, 2, 3]
+#    => NArray.float(3): 
+#    [ 1.0, 2.0, 3.0 ]
+#    >> GSL::Poly.eval_derivs(na, 1)
+#    => NArray.float(4): 
+#    [ 6.0, 8.0, 6.0, 0.0 ]
+#    >> poly = GSL::Poly[1.0, 2, 3]
+#    => GSL::Poly
+#    [ 1.000e+00 2.000e+00 3.000e+00 ]
+#    >> GSL::Poly.eval_derivs(poly, 1)
+#    => GSL::Poly
+#    [ 6.000e+00 8.000e+00 6.000e+00 0.000e+00 ]
+#    >> poly.eval_derivs(1)
+#    => GSL::Poly
+#    [ 6.000e+00 8.000e+00 6.000e+00 0.000e+00 ]
+#    >> poly.eval_derivs(1, 3)
+#    => GSL::Poly
+#    [ 6.000e+00 8.000e+00 6.000e+00 ]
+#
+# == {}[link:index.html"name="2] Solving polynomial equations
+# === {}[link:index.html"name="2.1] Quadratic Equations
+# ---
+# * GSL::Poly::solve_quadratic(a, b, c)
+# * GSL::Poly::solve_quadratic([a, b, c])
+#
+#   Find the real roots of the quadratic equation,
+#     a x^2 + b x + c = 0
+#   The coefficients are given by 3 numbers, or a Ruby array, 
+#   or a <tt>GSL::Vector</tt> object. The roots are returned as a <tt>GSL::Vector</tt>.
+#
+#   * Ex: z^2 - 3z + 2 = 0
+#       >> GSL::Poly::solve_quadratic(1, -3, 2)
+#       => GSL::Vector: 
+#       [ 1.000e+00 2.000e+00 ]
+#
+#
+# ---
+# * GSL::Poly::complex_solve_quadratic(a, b, c)
+# * GSL::Poly::complex_solve_quadratic([a, b, c])
+#
+#   Find the complex roots of the quadratic equation,
+#     a z^2 + b z + z = 0
+#   The coefficients are given by 3 numbers or a Ruby array, or a 
+#   <tt>GSL::Vector</tt>.
+#   The roots are returned as a <tt>GSL::Vector::Complex</tt> of two elements.
+#   
+#   * Ex: z^2 - 3z + 2 = 0
+#      >> require("gsl")
+#      => true
+#      >> GSL::Poly::complex_solve_quadratic(1, -3, 2)
+#      [ [1.000e+00 0.000e+00] [2.000e+00 0.000e+00] ]   
+#      => #<GSL::Vector::Complex:0x764014>
+#      >> GSL::Poly::complex_solve_quadratic(1, -3, 2).real  <--- Real part
+#      => GSL::Vector::View: 
+#      [ 1.000e+00 2.000e+00 ]
+#
+# === {}[link:index.html"name="2.2] Cubic Equations
+# ---
+# * GSL::Poly::solve_cubic(same as solve_quadratic)
+#
+#   This method finds the real roots of the cubic equation,
+#     x^3 + a x^2 + b x + c = 0
+#
+# ---
+# * GSL::Poly::complex_solve_cubic(same as solve_cubic)
+#
+#   This method finds the complex roots of the cubic equation,
+#     z^3 + a z^2 + b z + c = 0
+#
+# === {}[link:index.html"name="2.3] General Polynomial Equations
+# ---
+# * GSL::Poly::complex_solve(c0, c1, c2,,, )
+# * GSL::Poly::solve(c0, c1, c2,,, )
+#
+#   Find the complex roots of the polynomial equation. Note that 
+#   the coefficients are given by "ascending" order.
+#
+#   * Ex: x^2 - 3 x + 2 == 0 
+#        >> GSL::Poly::complex_solve(2, -3, 1)    <--- different from Poly::quadratic_solve
+#        [ [1.000e+00 0.000e+00] [2.000e+00 0.000e+00] ]
+#        => #<GSL::Vector::Complex:0x75e614>
+#
+# == {}[link:index.html"name="3] GSL::Poly Class
+# This class expresses polynomials of arbitrary orders.
+#
+# === {}[link:index.html"name="3.1] Constructors
+# ---
+# * GSL::Poly.alloc(c0, c1, c2, ....)
+# * GSL::Poly[c0, c1, c2, ....]
+#
+#   This creates an instance of the <tt>GSL::Poly</tt> class, 
+#   which represents a polynomial
+#       c0 + c1 x + c2 x^2 + ....
+#   This class is derived from <tt>GSL::Vector</tt>.
+#
+#   * Ex: x^2 - 3 x + 2
+#       poly = GSL::Poly.alloc([2, -3, 1])
+#
+# === {}[link:index.html"name="3.2] Instance Methods
+# ---
+# * GSL::Poly#eval(x)
+# * GSL::Poly#at(x)
+#
+#   Evaluates the polynomial 
+#   c[0] + c[1] x + c[2] x^2 + ... + c[len-1] x^{len-1} 
+#   using Horner's method for stability. The argument <tt>x</tt> is a
+#   <tt>Numeric</tt>, <tt>GSL::Vector, Matrix</tt> or an <tt>Array</tt>.
+#
+# ---
+# * GSL::Poly#solve_quadratic
+#
+#   Solve the quadratic equation.
+#
+#   * Ex:  z^2 - 3 z + 2 = 0:
+#       >> a = GSL::Poly[2, -3, 1]
+#       => GSL::Poly: 
+#       [ 2.000e+00 -3.000e+00 1.000e+00 ]
+#       >> a.solve_quadratic
+#       => GSL::Vector: 
+#       [ 1.000e+00 2.000e+00 ]
+#
+# ---
+# * GSL::Poly#solve_cubic
+#
+#   Solve the cubic equation.
+#
+# ---
+# * GSL::Poly#complex_solve
+# * GSL::Poly#solve
+# * GSL::Poly#roots
+#
+#   These methods find the complex roots of the quadratic equation,
+#     c0 + c1 z + c2 z^2 + .... = 0
+#
+#   * Ex: z^2 - 3 z + 2 = 0:
+#       >> a = GSL::Poly[2, -3, 1]
+#       => GSL::Poly: 
+#       [ 2.000e+00 -3.000e+00 1.000e+00 ]
+#       >> a.solve
+#       [ [1.000e+00 0.000e+00] [2.000e+00 0.000e+00] ]
+#       => #<GSL::Vector::Complex:0x35db28>
+#
+# == {}[link:index.html"name="4] Polynomial fitting
+# ---
+# * GSL::Poly.fit(x, y, order)
+# * GSL::Poly.wfit(x, w, y, order)
+#
+#   Finds the coefficient of a polynomial of order <tt>order</tt> 
+#   that fits the vector data (<tt>x, y</tt>) in a least-square sense.
+#   This provides a higher-level interface to the method
+#   {GSL::Multifit#linear}[link:files/rdoc/fit_rdoc.html] in a case of polynomial fitting.
+#
+#   Example:
+#     #!/usr/bin/env ruby
+#     require("gsl")
+#
+#     x = GSL::Vector[1, 2, 3, 4, 5]
+#     y = GSL::Vector[5.5, 43.1, 128, 290.7, 498.4]
+#     # The results are stored in a polynomial "coef"
+#     coef, cov, chisq, status = Poly.fit(x, y, 3) 
+#
+#     x2 = GSL::Vector.linspace(1, 5, 20)
+#     graph([x, y], [x2, coef.eval(x2)], "-C -g 3 -S 4")
+#
+# == {}[link:index.html"name="5] Divided-difference representations
+#
+# ---
+# * GSL::Poly::dd_init(xa, ya)
+#
+#   This method computes a divided-difference representation of the 
+#   interpolating polynomial for the points <tt>(xa, ya)</tt>.
+#
+# ---
+# * GSL::Poly::DividedDifference#eval(x)
+#
+#   This method evaluates the polynomial stored in divided-difference form 
+#   <tt>self</tt> at the point <tt>x</tt>.
+#
+# ---
+# * GSL::Poly::DividedDifference#taylor(xp)
+#
+#   This method converts the divided-difference representation of a polynomial 
+#   to a Taylor expansion. On output the Taylor coefficients of the polynomial 
+#   expanded about the point <tt>xp</tt> are returned.
+#
+# == {}[link:index.html"name="6] Extensions
+# === {}[link:index.html"name="6.1] Special Polynomials
+# ---
+# * GSL::Poly.hermite(n)
+#
+#   This returns coefficients of the <tt>n</tt>-th order Hermite polynomial, <tt>H(x; n)</tt>.
+#   For order of <tt>n</tt> >= 3, this method uses the recurrence relation
+#        H(x; n+1) = 2 x H(x; n) - 2 n H(x; n-1)
+#   * Ex:
+#       >> GSL::Poly.hermite(2)
+#       => GSL::Poly::Int: 
+#       [ -2 0 4 ]                            <----- 4x^2 - 2
+#       >> GSL::Poly.hermite(5)
+#       => GSL::Poly::Int: 
+#       [ 0 120 0 -160 0 32 ]                 <----- 32x^5 - 160x^3 + 120x
+#       >> GSL::Poly.hermite(7)
+#       => GSL::Poly::Int: 
+#       [ 0 -1680 0 3360 0 -1344 0 128 ]
+#
+# ---
+# * GSL::Poly.cheb(n)
+# * GSL::Poly.chebyshev(n)
+#
+#   Return the coefficients of the <tt>n</tt>-th order Chebyshev polynomial, <tt>T(x; n</tt>.
+#   For order of <tt>n</tt> >= 3, this method uses the recurrence relation
+#        T(x; n+1) = 2 x T(x; n) - T(x; n-1)
+#
+# ---
+# * GSL::Poly.cheb_II(n)
+# * GSL::Poly.chebyshev_II(n)
+#
+#   Return the coefficients of the <tt>n</tt>-th order Chebyshev polynomial of type II,
+#   <tt>U(x; n</tt>.
+#        U(x; n+1) = 2 x U(x; n) - U(x; n-1)
+#
+# ---
+# * GSL::Poly.bell(n)
+#
+#   Bell polynomial
+#
+# ---
+# * GSL::Poly.bessel(n)
+#
+#   Bessel polynomial
+#
+# ---
+# * GSL::Poly.laguerre(n)
+#
+#   Retunrs the coefficients of the <tt>n</tt>-th order Laguerre polynomial
+#   multiplied by n!.
+#
+#   Ex:
+#        rb(main):001:0> require("gsl")
+#        => true
+#        >> GSL::Poly.laguerre(0)
+#        => GSL::Poly::Int: 
+#        [ 1 ]                              <--- 1
+#        >> GSL::Poly.laguerre(1)
+#        => GSL::Poly::Int: 
+#        [ 1 -1 ]                           <--- -x + 1
+#        >> GSL::Poly.laguerre(2)
+#        => GSL::Poly::Int: 
+#        [ 2 -4 1 ]                         <--- (x^2 - 4x + 2)/2!
+#        >> GSL::Poly.laguerre(3)
+#        => GSL::Poly::Int:                   
+#        [ 6 -18 9 -1 ]                     <--- (-x^3 + 9x^2 - 18x + 6)/3!
+#        >> GSL::Poly.laguerre(4)
+#        => GSL::Poly::Int:  
+#        [ 24 -96 72 -16 1 ]                <--- (x^4 - 16x^3 + 72x^2 - 96x + 24)/4!
+#  
+# === {}[link:index.html"name="6.2] Polynomial Operations
+# ---
+# * GSL::Poly#conv
+# * GSL::Poly#deconv
+# * GSL::Poly#reduce
+# * GSL::Poly#deriv
+# * GSL::Poly#integ
+# * GSL::Poly#compan
+#
+#
+# {prev}[link:files/rdoc/complex_rdoc.html]
+# {next}[link:files/rdoc/sf_rdoc.html]
+#
+# {Reference index}[link:files/rdoc/ref_rdoc.html]
+# {top}[link:files/rdoc/index_rdoc.html]
+#
+#
+#