RubyGems - alglib - Versions diffs - 0.1.1 - Mend

alglib 0.1.1

Files changed (255) hide show

data/History.txt +7 -0
data/Manifest.txt +253 -0
data/README.txt +33 -0
data/Rakefile +27 -0
data/ext/Rakefile +24 -0
data/ext/alglib.i +24 -0
data/ext/alglib/Makefile +157 -0
data/ext/alglib/airyf.cpp +372 -0
data/ext/alglib/airyf.h +81 -0
data/ext/alglib/alglib.cpp +8558 -0
data/ext/alglib/alglib_util.cpp +19 -0
data/ext/alglib/alglib_util.h +14 -0
data/ext/alglib/ap.cpp +877 -0
data/ext/alglib/ap.english.html +364 -0
data/ext/alglib/ap.h +666 -0
data/ext/alglib/ap.russian.html +442 -0
data/ext/alglib/apvt.h +754 -0
data/ext/alglib/bdss.cpp +1500 -0
data/ext/alglib/bdss.h +251 -0
data/ext/alglib/bdsvd.cpp +1339 -0
data/ext/alglib/bdsvd.h +164 -0
data/ext/alglib/bessel.cpp +1226 -0
data/ext/alglib/bessel.h +331 -0
data/ext/alglib/betaf.cpp +105 -0
data/ext/alglib/betaf.h +74 -0
data/ext/alglib/bidiagonal.cpp +1328 -0
data/ext/alglib/bidiagonal.h +350 -0
data/ext/alglib/binomialdistr.cpp +247 -0
data/ext/alglib/binomialdistr.h +153 -0
data/ext/alglib/blas.cpp +576 -0
data/ext/alglib/blas.h +132 -0
data/ext/alglib/cblas.cpp +226 -0
data/ext/alglib/cblas.h +57 -0
data/ext/alglib/cdet.cpp +138 -0
data/ext/alglib/cdet.h +92 -0
data/ext/alglib/chebyshev.cpp +216 -0
data/ext/alglib/chebyshev.h +76 -0
data/ext/alglib/chisquaredistr.cpp +157 -0
data/ext/alglib/chisquaredistr.h +144 -0
data/ext/alglib/cholesky.cpp +285 -0
data/ext/alglib/cholesky.h +86 -0
data/ext/alglib/cinverse.cpp +298 -0
data/ext/alglib/cinverse.h +111 -0
data/ext/alglib/clu.cpp +337 -0
data/ext/alglib/clu.h +120 -0
data/ext/alglib/correlation.cpp +280 -0
data/ext/alglib/correlation.h +77 -0
data/ext/alglib/correlationtests.cpp +726 -0
data/ext/alglib/correlationtests.h +134 -0
data/ext/alglib/crcond.cpp +826 -0
data/ext/alglib/crcond.h +148 -0
data/ext/alglib/creflections.cpp +310 -0
data/ext/alglib/creflections.h +165 -0
data/ext/alglib/csolve.cpp +312 -0
data/ext/alglib/csolve.h +99 -0
data/ext/alglib/ctrinverse.cpp +387 -0
data/ext/alglib/ctrinverse.h +98 -0
data/ext/alglib/ctrlinsolve.cpp +297 -0
data/ext/alglib/ctrlinsolve.h +81 -0
data/ext/alglib/dawson.cpp +234 -0
data/ext/alglib/dawson.h +74 -0
data/ext/alglib/descriptivestatistics.cpp +436 -0
data/ext/alglib/descriptivestatistics.h +112 -0
data/ext/alglib/det.cpp +140 -0
data/ext/alglib/det.h +94 -0
data/ext/alglib/dforest.cpp +1819 -0
data/ext/alglib/dforest.h +316 -0
data/ext/alglib/elliptic.cpp +497 -0
data/ext/alglib/elliptic.h +217 -0
data/ext/alglib/estnorm.cpp +429 -0
data/ext/alglib/estnorm.h +107 -0
data/ext/alglib/expintegrals.cpp +422 -0
data/ext/alglib/expintegrals.h +108 -0
data/ext/alglib/faq.english.html +258 -0
data/ext/alglib/faq.russian.html +272 -0
data/ext/alglib/fdistr.cpp +202 -0
data/ext/alglib/fdistr.h +163 -0
data/ext/alglib/fresnel.cpp +211 -0
data/ext/alglib/fresnel.h +91 -0
data/ext/alglib/gammaf.cpp +338 -0
data/ext/alglib/gammaf.h +104 -0
data/ext/alglib/gqgengauss.cpp +235 -0
data/ext/alglib/gqgengauss.h +92 -0
data/ext/alglib/gqgenhermite.cpp +268 -0
data/ext/alglib/gqgenhermite.h +63 -0
data/ext/alglib/gqgenjacobi.cpp +297 -0
data/ext/alglib/gqgenjacobi.h +72 -0
data/ext/alglib/gqgenlaguerre.cpp +265 -0
data/ext/alglib/gqgenlaguerre.h +69 -0
data/ext/alglib/gqgenlegendre.cpp +300 -0
data/ext/alglib/gqgenlegendre.h +62 -0
data/ext/alglib/gqgenlobatto.cpp +305 -0
data/ext/alglib/gqgenlobatto.h +97 -0
data/ext/alglib/gqgenradau.cpp +232 -0
data/ext/alglib/gqgenradau.h +95 -0
data/ext/alglib/hbisinv.cpp +480 -0
data/ext/alglib/hbisinv.h +183 -0
data/ext/alglib/hblas.cpp +228 -0
data/ext/alglib/hblas.h +64 -0
data/ext/alglib/hcholesky.cpp +339 -0
data/ext/alglib/hcholesky.h +91 -0
data/ext/alglib/hermite.cpp +114 -0
data/ext/alglib/hermite.h +49 -0
data/ext/alglib/hessenberg.cpp +370 -0
data/ext/alglib/hessenberg.h +152 -0
data/ext/alglib/hevd.cpp +247 -0
data/ext/alglib/hevd.h +107 -0
data/ext/alglib/hsschur.cpp +1316 -0
data/ext/alglib/hsschur.h +108 -0
data/ext/alglib/htridiagonal.cpp +734 -0
data/ext/alglib/htridiagonal.h +180 -0
data/ext/alglib/ialglib.cpp +6 -0
data/ext/alglib/ialglib.h +9 -0
data/ext/alglib/ibetaf.cpp +960 -0
data/ext/alglib/ibetaf.h +125 -0
data/ext/alglib/igammaf.cpp +430 -0
data/ext/alglib/igammaf.h +157 -0
data/ext/alglib/inv.cpp +274 -0
data/ext/alglib/inv.h +115 -0
data/ext/alglib/inverseupdate.cpp +480 -0
data/ext/alglib/inverseupdate.h +185 -0
data/ext/alglib/jacobianelliptic.cpp +164 -0
data/ext/alglib/jacobianelliptic.h +94 -0
data/ext/alglib/jarquebera.cpp +2271 -0
data/ext/alglib/jarquebera.h +80 -0
data/ext/alglib/kmeans.cpp +356 -0
data/ext/alglib/kmeans.h +76 -0
data/ext/alglib/laguerre.cpp +94 -0
data/ext/alglib/laguerre.h +48 -0
data/ext/alglib/lbfgs.cpp +1167 -0
data/ext/alglib/lbfgs.h +218 -0
data/ext/alglib/lda.cpp +434 -0
data/ext/alglib/lda.h +133 -0
data/ext/alglib/ldlt.cpp +1130 -0
data/ext/alglib/ldlt.h +124 -0
data/ext/alglib/leastsquares.cpp +1252 -0
data/ext/alglib/leastsquares.h +290 -0
data/ext/alglib/legendre.cpp +107 -0
data/ext/alglib/legendre.h +49 -0
data/ext/alglib/linreg.cpp +1185 -0
data/ext/alglib/linreg.h +380 -0
data/ext/alglib/logit.cpp +1523 -0
data/ext/alglib/logit.h +333 -0
data/ext/alglib/lq.cpp +399 -0
data/ext/alglib/lq.h +160 -0
data/ext/alglib/lu.cpp +462 -0
data/ext/alglib/lu.h +119 -0
data/ext/alglib/mannwhitneyu.cpp +4490 -0
data/ext/alglib/mannwhitneyu.h +115 -0
data/ext/alglib/minlm.cpp +918 -0
data/ext/alglib/minlm.h +312 -0
data/ext/alglib/mlpbase.cpp +3375 -0
data/ext/alglib/mlpbase.h +589 -0
data/ext/alglib/mlpe.cpp +1369 -0
data/ext/alglib/mlpe.h +552 -0
data/ext/alglib/mlptrain.cpp +1056 -0
data/ext/alglib/mlptrain.h +283 -0
data/ext/alglib/nearunityunit.cpp +91 -0
data/ext/alglib/nearunityunit.h +17 -0
data/ext/alglib/normaldistr.cpp +377 -0
data/ext/alglib/normaldistr.h +175 -0
data/ext/alglib/nsevd.cpp +1869 -0
data/ext/alglib/nsevd.h +140 -0
data/ext/alglib/pca.cpp +168 -0
data/ext/alglib/pca.h +87 -0
data/ext/alglib/poissondistr.cpp +143 -0
data/ext/alglib/poissondistr.h +130 -0
data/ext/alglib/polinterpolation.cpp +685 -0
data/ext/alglib/polinterpolation.h +206 -0
data/ext/alglib/psif.cpp +173 -0
data/ext/alglib/psif.h +88 -0
data/ext/alglib/qr.cpp +414 -0
data/ext/alglib/qr.h +168 -0
data/ext/alglib/ratinterpolation.cpp +134 -0
data/ext/alglib/ratinterpolation.h +72 -0
data/ext/alglib/rcond.cpp +705 -0
data/ext/alglib/rcond.h +140 -0
data/ext/alglib/reflections.cpp +504 -0
data/ext/alglib/reflections.h +165 -0
data/ext/alglib/rotations.cpp +473 -0
data/ext/alglib/rotations.h +128 -0
data/ext/alglib/rsolve.cpp +221 -0
data/ext/alglib/rsolve.h +99 -0
data/ext/alglib/sbisinv.cpp +217 -0
data/ext/alglib/sbisinv.h +171 -0
data/ext/alglib/sblas.cpp +185 -0
data/ext/alglib/sblas.h +64 -0
data/ext/alglib/schur.cpp +156 -0
data/ext/alglib/schur.h +102 -0
data/ext/alglib/sdet.cpp +193 -0
data/ext/alglib/sdet.h +101 -0
data/ext/alglib/sevd.cpp +116 -0
data/ext/alglib/sevd.h +99 -0
data/ext/alglib/sinverse.cpp +672 -0
data/ext/alglib/sinverse.h +138 -0
data/ext/alglib/spddet.cpp +138 -0
data/ext/alglib/spddet.h +96 -0
data/ext/alglib/spdgevd.cpp +842 -0
data/ext/alglib/spdgevd.h +200 -0
data/ext/alglib/spdinverse.cpp +509 -0
data/ext/alglib/spdinverse.h +122 -0
data/ext/alglib/spdrcond.cpp +421 -0
data/ext/alglib/spdrcond.h +118 -0
data/ext/alglib/spdsolve.cpp +275 -0
data/ext/alglib/spdsolve.h +105 -0
data/ext/alglib/spline2d.cpp +1192 -0
data/ext/alglib/spline2d.h +301 -0
data/ext/alglib/spline3.cpp +1264 -0
data/ext/alglib/spline3.h +290 -0
data/ext/alglib/srcond.cpp +595 -0
data/ext/alglib/srcond.h +127 -0
data/ext/alglib/ssolve.cpp +895 -0
data/ext/alglib/ssolve.h +139 -0
data/ext/alglib/stdafx.h +0 -0
data/ext/alglib/stest.cpp +131 -0
data/ext/alglib/stest.h +94 -0
data/ext/alglib/studenttdistr.cpp +222 -0
data/ext/alglib/studenttdistr.h +115 -0
data/ext/alglib/studentttests.cpp +377 -0
data/ext/alglib/studentttests.h +178 -0
data/ext/alglib/svd.cpp +620 -0
data/ext/alglib/svd.h +126 -0
data/ext/alglib/tdbisinv.cpp +2608 -0
data/ext/alglib/tdbisinv.h +228 -0
data/ext/alglib/tdevd.cpp +1229 -0
data/ext/alglib/tdevd.h +115 -0
data/ext/alglib/tridiagonal.cpp +594 -0
data/ext/alglib/tridiagonal.h +171 -0
data/ext/alglib/trigintegrals.cpp +490 -0
data/ext/alglib/trigintegrals.h +131 -0
data/ext/alglib/trinverse.cpp +345 -0
data/ext/alglib/trinverse.h +98 -0
data/ext/alglib/trlinsolve.cpp +926 -0
data/ext/alglib/trlinsolve.h +73 -0
data/ext/alglib/tsort.cpp +405 -0
data/ext/alglib/tsort.h +54 -0
data/ext/alglib/variancetests.cpp +245 -0
data/ext/alglib/variancetests.h +134 -0
data/ext/alglib/wsr.cpp +6285 -0
data/ext/alglib/wsr.h +96 -0
data/ext/ap.i +97 -0
data/ext/correlation.i +24 -0
data/ext/extconf.rb +6 -0
data/ext/logit.i +89 -0
data/lib/alglib.rb +71 -0
data/lib/alglib/correlation.rb +26 -0
data/lib/alglib/linearregression.rb +63 -0
data/lib/alglib/logit.rb +42 -0
data/test/test_alglib.rb +52 -0
data/test/test_correlation.rb +44 -0
data/test/test_correlationtest.rb +45 -0
data/test/test_linreg.rb +35 -0
data/test/test_logit.rb +43 -0
data/test/test_pca.rb +27 -0
metadata +326 -0

@@ -0,0 +1,364 @@
+<html>
+<head>
+<title>AP Library adapted for C++</title>
+<style type="text/css">
+<!--
+h1 { font-family: Tahoma,sans-serif; font-size : larger; }
+h2 { font-family: Arial,sans-serif; font-size : 11pt; }
+h3 { font-family: Arial,sans-serif; font-size : 9pt; }
+.cond  { color:blue; }
+.const { color:#222222; }
+.func  { color:#111111; }
+-->
+</style>
+</head>
+<body>
+<h1>AP Library adapted for C++</h1>
+<p align=justify>
+The document describes an AP library adapted for C++. The AP library for C++ contains a basic set of mathematical functions and collection classes needed to run the programs from the <a href="http://www.alglib.net/">ALGLIB</a> website.
+</p>
+<h1>Compatibility</h1>
+<p align=justify>
+This library must be compatible with any C++ compiler.
+</p>
+<h1>Structure and Use</h1>
+<p align=justify>
+The library includes the only module <code>ap.cpp</code> (with header file <code>ap.h</code>). Just add it to your project.
+</p>
+<h1>AP Library Description</h1>
+<font size=-1>
+<a href="#intro">Introduction</a><br>
+<a href="#conditionals">Conditional compilation settings</a><br>
+<a href="#constants">Constants</a><br>
+<a href="#functions">Functions</a><br>
+<a href="#aperror">Class ap_error</a><br>
+<a href="#arrays">Array classes</a><br>
+<a href="#blas">Basic subroutines of linear algebra</a><br>
+<a href="#complex">Class of complex numbers</a><br>
+</font>
+<a name="intro"><h1>Introduction</h1></a>
+<p align=justify>
+In the header file <code>ap.h</code> the namespace <code>ap</code> is defined. It must be taken into account that the names of functions, constants and classes listed further should be prefixed by <i>ap::</i>.
+</p>
+<a name="conditionals"><h1>Conditional Compilation Settings</h1></a>
+<p align=justify>
+<span class=cond>AP_WIN32</span><br>
+This symbol (<b>if defined by user</b>) indicates that AP library is compiled under Win32. It allows library to use ABLAS (lightweight BLAS-like library with SSE2 support) if ABLAS is present on your system.
+</p>
+<p align=justify>
+<span class=cond>AP_ASSERT</span><br> This symbol enables checking of the array boundaries. If it is set by the &quot;define&quot; directive, then at each addressing to the dynamic array elements, the transferred index is verified for its correctness. In case of error the <code>ap_error</code> exception is thrown. Checking the array boundaries makes the program more reliable, but slows down the program operation.
+</p>
+<p align=justify>
+<span class=cond>NO_AP_ASSERT</span><br> This symbol disables checking of the array boundaries. If it is set by the &quot;define&quot; directive, then the index being outside the array boundaries is not checked when the dynamic array elements are addressed.
+</p>
+<p align=justify>
+<span class=cond>UNSAFE_MEM_COPY</span><br> The &quot;define&quot; directive that sets this symbol is disabled. Do not activate it. The library contains no documentation concerning this symbol.
+</p>
+<a name="constants"><h1>Constants</h1></a>
+<p align=justify>
+<span class=const>machineepsilon</span><br> The constant represents the accuracy of machine operations, that is the minimum number for <code>1+machineepsilon&ne;1</code> in the given bit grid. The constant may be taken &quot;oversized&quot;, that is real accuracy can be even higher.
+</p>
+<p align=justify>
+<span class=const>maxrealnumber</span><br> The constant represents the highest value of the positive real number, which could be represented on this machine. The constant may be taken &quot;oversized&quot;, that is real boundary can be even higher.
+</p>
+<p align=justify>
+<span class=const>minrealnumber</span><br> The constant represents the lowest value of positive real number, which could be represented on this machine. The constant may be taken &quot;oversized&quot;, that is real boundary can be even lower.
+</p>
+<a name="functions"><h1>Functions</h1></a>
+<p align=justify>
+<span class=func><b>int</b> sign(<b>double</b> x)</span><br> Returns:<br> +1, if X&gt;0<br> -1, if X&lt;0<br> 0, if X=0
+</p>
+<p align=justify>
+<span class=func><b>double</b> randomreal()</span><br> Returns a random real number from half-interval [0,1).
+</p>
+<p align=justify>
+<span class=func><b>int</b> randominteger(<b>int</b> maxv) </span><br> Returns a random integer between 0 and maxv-1.
+</p>
+<p align=justify>
+<span class=func><b>double</b> round(<b>double</b> x)</span><br> Returns the nearest integer to x. If x is right in the middle between two integers, then the function result depends on the implementation.
+</p>
+<p align=justify>
+<span class=func><b>double</b> trunc(<b>double</b> x)</span><br> Truncates the fractional part of x.<br> trunc(1.3) =  1<br> trunc(-1.3)= -1
+</p>
+<p align=justify>
+<span class=func><b>double</b> pi()</span><br> Returns the constant  &pi;
+</p>
+<p align=justify>
+<span class=func><b>double</b> sqr(<b>double</b> x)</span><br> Returns x<sup>2</sup>.
+</p>
+<p align=justify>
+<span class=func><b>double</b> maxreal(<b>double</b> m1, <b>double</b> m2)</span><br> Returns the maximum of two real numbers.
+</p>
+<p align=justify>
+<span class=func><b>double</b> minreal(<b>double</b> m1, <b>double</b> m2)</span><br> Returns the minimum of two real numbers.
+</p>
+<p align=justify>
+<span class=func><b>int</b> maxint(<b>int</b> m1, <b>int</b> m2)</span><br> Returns the maximum of two integers.
+</p>
+<p align=justify>
+<span class=func><b>int</b> minint(<b>int</b> m1, <b>int</b> m2)</span><br> Returns the minimum of two integers.
+</p>
+<a name="aperror"><h1>Class &quot;ap_error&quot;</h1></a>
+<p align=justify>
+This is a class of exception which is thrown when different errors occur in the AP library, for example - if the array index is found incorrect when the array boundaries check is enabled. The current version of the class contains no fields and doesn't allow to find the cause for the exception generated.
+</p>
+<a name="arrays"><h1>Array classes</h1></a>
+<h2>Working with arrays</h2>
+<p align=justify>
+First we will discuss general principles of working with array classes, then describe the classes and their methods.
+</p>
+<p align=justify>
+Classes of the standard library allow operations with matrixes and vectors (one-dimensional and two-dimensional arrays) of variable size and with variable numeration of elements, that is, the array numeration can start at any number, end at any number and change dynamically. Because the array classes are templates, the arrays of the same dimension have the same set of member functions. And as the member functions of arrays with different dimensions differ only by the number of arguments, there is little difference between two-dimensional and one-dimenstional arrays.
+</p>
+<p align=justify>
+Working with an array starts with the array creation. You should distinguish the creation of array class instance and the memory allocation for the array.  When creating the class instance, you can use constructor without any parameters, that creates an empty array without any elements, or you can use copy and assignment constructors that copy one array into another.  In case the array is created by the default constructor, it contains no elements and an attempt to address them may cause the program failure. If, during the copy operation, the source array has no memory allocated for the array elements, destination array will contain no elements either. If the source array has memory allocated for its elements, destination array will allocate the same amount of memory and copy the elements there. That is, the copy operation yields into two independent arrays with indentical contents.
+</p>
+<p align=justify>
+After an empty array has been created, you should allocate the memory for its elements, using the <code:>setbounds</code:> method The method parameters set upper and lower boundaries of the array indexes. The upper boundary should be not less than the lower one. When called, memory for corresponding number of elements is allocated. The content of the created array elements is not defined and no suppositions should be made about it. If the <code:>setbounds</code:> method is called for the array with already allocated memory, then, after changing its parameters, the newly allocated elements also become undefined and the old content is deleted.
+</p>
+<p align=justify>
+To address the array elements, an overloaded <code:>operator()</code:> is used. That is, the code addressing the element of array <code:>a</code:> with indexes <code:>a(i,j,k)</code:> will look like <code:>a(i,j,k)</code:>. Below is given an example of factorial array calculation, illustrating the work with arrays.
+</p>
+<pre>
+integer_1d_array factarr(<b>int</b> n)
+{
+    integer_1d_array result;
+    result.setbounds(1,n);
+    result(1) = 1;
+    <b>for</b>(<b>int</b> i=2; i&lt;=n; i++)
+        result(i) = result(i-1)*i;
+    <b>return</b> result;
+}
+</pre>
+<h2>Class &quot;template_1d_array&quot;</h2>
+<p align=justify>
+This class is a template of dynamical one-dimensional array with variable upper and lower boundaries. Based on this class, the following classes are constructed:
+</p>
+<pre>
+<b>typedef</b> template_1d_array&lt;<b>int</b>&gt;     integer_1d_array;
+<b>typedef</b> template_1d_array&lt;<b>double</b>&gt;  real_1d_array;
+<b>typedef</b> template_1d_array&lt;<b>bool</b>&gt;    boolean_1d_array;
+<b>typedef</b> template_1d_array&lt;complex&gt; complex_1d_array;
+</pre>
+<h2>Class member functions</h2>
+<p align=justify>
+<span class=func>template_1d_array()</span><br> Constructor. Creates an empty array.
+</p>
+<p align=justify>
+<span class=func>~template_1d_array()</span><br> Destructor. Frees memory, which had been allocated for the array.
+</p>
+<p align=justify>
+<span class=func>template_1d_array(<b>const</b> template_1d_array &amp;rhs)</span><br> Copy constructor. Allocates the separate storage and copies source array content there.
+</p>
+<p align=justify>
+<span class=func><b>const</b> template_1d_array&amp; <b>operator=</b>(<b>const</b> template_1d_array &amp;rhs)</span><br> Assignment constructor. Deletes destination array content, frees allocated memory, then allocates a separate storage and copies source array content there.
+</p>
+<p align=justify>
+<span class=func>T&amp; operator()(<b>int</b> i)</span><br> Addressing the array element number i
+</p>
+<p align=justify>
+<span class=func><b>void</b> setbounds(<b>int</b> iLow, <b>int</b> iHigh)</span><br> Memory allocation for the array .  Deletes the array content, frees allocated memory, then allocates a separate storage for iHigh-iLow+1 elements.<br> The elements numeration in the new array starts with iLow and ends with iHigh The content of the new array is not defined.
+</p>
+<p align=justify>
+<span class=func><b>void</b> setcontent(<b>int</b> iLow, <b>int</b> iHigh, <b>const</b> T *pContent)</span><br> The method is similar to the setbounds() method, but after allocating a memory for a destination array it copies the content of pContent[] there.
+</p>
+<p align=justify>
+<span class=func>T* getcontent()</span><br> Gets pointer to the array. The data pointed by the returned pointer can be changed, and the array content will be changed as well.
+</p>
+<p align=justify>
+<span class=func><b>int</b> getlowbound()<br><b>int</b> gethighbound()</span><br> Get lower and upper boundaries.
+</p>
+<p align=justify>
+<span class=func>raw_vector&lt;T&gt; getvector(<b>int</b> iStart, <b>int</b> iEnd)</span><br> The method is used by the basic subroutines of linear algebra to get access to the internal memory of the array. The method returns an object, holding the pointer to a vector part (starting from the element with iStart index value and finishing with iEnd index value). If iEnd&lt;iStart, then an empty vector is considered to be set.
+</p>
+<p align=justify>
+<span class=func>const_raw_vector&lt;T&gt; getvector(<b>int</b> iStart, <b>int</b> iEnd) <b>const</b></span><br> The method is used by the basic subroutines of linear algebra to get access to the internal memory of the array. The method returns an object, holding the pointer to a vector part (starting from the element with iStart index value and finishing with iEnd index value). If iEnd&lt;iStart, then an empty vector is considered to be set. The returned object is for read only.
+</p>
+<h2>Class &quot;template_2d_array&quot;</h2>
+<p align=justify>
+This class is a template of dynamical two-dimensional array with variable upper and lower boundaries. Based on this class, the following classes are constructed:
+</p>
+<pre>
+<b>typedef</b> template_2d_array&lt;<b>int</b>&gt;     integer_2d_array;
+<b>typedef</b> template_2d_array&lt;<b>double</b>&gt;  real_2d_array;
+<b>typedef</b> template_2d_array&lt;<b>bool</b>&gt;    boolean_2d_array;
+<b>typedef</b> template_2d_array&lt;complex&gt; complex_2d_array;
+</pre>
+<h2>Class member functions</h2>
+<p align=justify>
+<span class=func>template_2d_array()</span><br> Constructor. Creates an empty array.
+</p>
+<p align=justify>
+<span class=func>~template_2d_array()</span><br> Destructor. Frees memory, which had been allocated for the array.
+</p>
+<p align=justify>
+<span class=func>template_2d_array(<b>const</b> template_2d_array &amp;rhs)</span><br> Copy constructor. Allocates the separate storage and copies source array content there.
+</p>
+<p align=justify>
+<span class=func><b>const</b> template_2d_array&amp; <b>operator=</b>(<b>const</b> template_2d_array &amp;rhs)</span><br> Assignment constructor. Deletes destination array content, frees allocated memory, then allocates a separate storage and copies source array content there.
+</p>
+<p align=justify>
+<span class=func>T&amp; operator()(<b>int</b> i1, <b>int</b> i2)</span><br> Addressing the array element with [i1,i2] index value.
+</p>
+<p align=justify>
+<span class=func><b>void</b> setbounds(<b>int</b> iLow1, <b>int</b> iHigh1, <b>int</b> iLow2, <b>int</b> iHigh2)</span><br> Memory allocation for the array .    Deletes the array content, frees allocated memory, then allocates a separate storage for (iHigh1-iLow1+1)*(iHigh2-iLow2+1) elements.<br> The elements numeration in the new array starts with iLow1 and finishes with iHigh1 for the first dimension, and similarly for the second dimension.<br> The content of the new array is not defined.
+</p>
+<p align=justify>
+<span class=func><b>void</b> setcontent(<b>int</b> iLow1, <b>int</b> iHigh1, <b>int</b> iLow2, <b>int</b> iHigh2, <b>const</b> T *pContent)</span><br> The method is similar to the setbounds() method, but after allocating a memory for a destination array it copies the content of pContent[] there.<br> The pContent array contains two-dimensional array, written in line, that is, the first element is [iLow1, iLow2], then goes [iLow1, iLow2+1], and so on.<br>
+</p>
+<p align=justify>
+<span class=func><b>int</b> getlowbound(<b>int</b> iBoundNum)<br><b>int</b> gethighbound(<b>int</b> iBoundNum)</span><br> Get lower and upper boundaries of one-dimensional array with number iBoundNum.
+</p>
+<p align=justify>
+<span class=func>raw_vector<T> getcolumn(<b>int</b> iColumn, <b>int</b> iRowStart, <b>int</b> iRowEnd)<br> const_raw_vector<T> getcolumn(<b>int</b> iColumn, <b>int</b> iRowStart, <b>int</b> iRowEnd) <b>const</b><br></span> The methods are used by the basic subroutines of linear algebra to get access to the internal memory of the array. The methods return the object holding the pointer to the part of column iColumn (starting from the line iRowStart and finishing with the line iRowEnd). <br> The iColumn parameter must be the valid column number (that is be within the boundaries of the array). If iRowEnd&lt;iRowStart, then an empty column is considered to be set.
+</p>
+<p align=justify>
+<span class=func>raw_vector<T> getrow(<b>int</b> iRow, <b>int</b> iColumnStart, <b>int</b> iColumnEnd)<br> const_raw_vector<T> getrow(<b>int</b> iRow, <b>int</b> iColumnStart, <b>int</b> iColumnEnd) <b>const</b><br></span> The methods are used by the basic subroutines of linear algebra to get access to the internal memory of the array. The methods return the object holding the pointer to the part of line iRow (starting from the column iColumnStart and finishing with the column iColumnEnd). <br> The iRow parameter must be the valid line number (that is be within the boundaries of the array). If iColumnEnd&lt;iColumnStart, then an empty line is considered to be set.
+</p>
+<a name="blas"><h1>Basic subroutines of linear algebra</h1></a>
+<p align=justify>
+Basic subroutines of linear algebra included into the AP library are close by their functions to the Level 1 BLAS, allowing to perform the simplest operations with vectors and with the matrix lines and columns.
+</p>
+<p align=justify>
+Subroutines should be used in the following way. First you need to get an object of the  <code>raw_vector</code> type or  <code>const_raw_vector</code> type, pointing to the part of the matrix or array being processed using the methods <code>getcolumn</code>/<code>getrow</code> (for the matrix), or  <code>getvector</code> (for the array). The object holds the pointer for the line (or column) start, the number of elements in the processed line (column), and the interval between the two adjacent elements. When using a standard scheme for matrixes storage in the memory (that is, by lines), the interval between the elements of one line equals 1, and the interval between the adjacent elements of one column equals the number of columns. The received object is transferred as argument to the corresponding subroutine, which performs operations on the matrix part pointed by the internal object pointer.
+</p>
+<p align=justify>
+Below is given the list of basic subroutines of linear algebra, available in the AP library.
+</p>
+<p align=justify>
+<span class=func>template&lt;<b>class</b> T&gt; T vdotproduct(const_raw_vector&lt;T&gt; v1, const_raw_vector&lt;T&gt; v2)</span><br> The subroutine calculates the scalar product of transferred vectors.
+</p>
+<p align=justify>
+<span class=func>template&lt;<b>class</b> T&gt; <b>void</b> vmove(raw_vector&lt;T&gt; vdst, const_raw_vector&lt;T&gt; vsrc)<br> template&lt;<b>class</b> T&gt; <b>void</b> vmoveneg(raw_vector&lt;T&gt; vdst, const_raw_vector&lt;T&gt; vsrc)<br> template&lt;<b>class</b> T, <b>class</b> T2&gt; <b>void</b> vmove(raw_vector&lt;T&gt; vdst, const_raw_vector&lt;T&gt; vsrc, T2 alpha)<br></span> This subroutine set is used to copy one vector content to another vector using different methods: simple copy, copy multiplied by -1, copy multiplied by a number.
+</p>
+<p align=justify>
+<span class=func>template&lt;<b>class</b> T&gt; <b>void</b> vadd(raw_vector&lt;T&gt; vdst, const_raw_vector&lt;T&gt; vsrc)<br> template&lt;<b>class</b> T, <b>class</b> T2&gt; <b>void</b> vadd(raw_vector&lt;T&gt; vdst, const_raw_vector&lt;T&gt; vsrc, T2 alpha)<br></span> This subroutine set is used to add one vector to another using different methods: simple addition or addition multiplied by a number.
+</p>
+<p align=justify>
+<span class=func>template&lt;<b>class</b> T&gt; <b>void</b> vsub(raw_vector&lt;T&gt; vdst, const_raw_vector&lt;T&gt; vsrc)<br> template&lt;<b>class</b> T, <b>class</b> T2&gt; <b>void</b> vsub(raw_vector&lt;T&gt; vdst, const_raw_vector&lt;T&gt; vsrc, T2 alpha)<br></span> This subroutine set is used to subtract one vector from another using different methods: simple subtraction or subtraction multiplied by a number.
+</p>
+<p align=justify>
+<span class=func>template&lt;<b>class</b> T, <b>class</b> T2&gt; <b>void</b> vmul(raw_vector&lt;T&gt; vdst, T2 alpha)</span><br> Multiplies vector by a number and stores the result in the same place.
+</p>
+<h2>Alternative syntax</h2>
+<p align=justify>
+If both operands are vectors/rows with interval between the elements equals 1 and length equals N, alternative syntax can be used.
+</p>
+<p align=justify>
+<span class=func>
+template&lt;<b>class</b> T&gt; T vdotproduct(<b>const</b> T *v1, <b>const</b> T *v2, <b>int</b> N)<br>
+template&lt;<b>class</b> T&gt; <b>void</b> vmove(T *vdst, <b>const</b> T *vsrc, <b>int</b> N)<br>
+template&lt;<b>class</b> T&gt; <b>void</b> vmoveneg(T *vdst, <b>const</b> T *vsrc, <b>int</b> N)<br>
+template&lt;<b>class</b> T, <b>class</b> T2&gt; <b>void</b> vmove(T *vdst, <b>const</b> T *vsrc, <b>int</b> N, T2 alpha)<br>
+template&lt;<b>class</b> T&gt; <b>void</b> vadd(T *vdst, <b>const</b> T *vsrc, <b>int</b> N)<br>
+template&lt;<b>class</b> T, <b>class</b> T2&gt; <b>void</b> vadd(T *vdst, <b>const</b> T *vsrc, <b>int</b> N, T2 alpha)<br>
+template&lt;<b>class</b> T&gt; <b>void</b> vsub(T *vdst, <b>const</b> T *vsrc, <b>int</b> N)<br>
+template&lt;<b>class</b> T, <b>class</b> T2&gt; <b>void</b> vsub(T *vdst, <b>const</b> T *vsrc, <b>int</b> N, T2 alpha)<br>
+template&lt;<b>class</b> T, <b>class</b> T2> <b>void</b> vmul(T *vdst, <b>int</b> N, T2 alpha)
+</span>
+</p>
+<a name="complex"><h1>Class of complex numbers</h1></a>
+<p align=justify>
+AP library includes the <code>ap::complex</code> class that allows operations with compex numbers. Access to real and imaginary parts of complex number is implemented through the public fields <code>x</code> and <code>y</code>. Arithmetical operations are supported, the same as with embedded data types, by overloading of operations: addition, subtraction, multiplication and division. Addition, subtraction and multiplication are performed by a usual way (i.e., according to their definition which can be found in any textdook in algebra), division is performed using so called &quot;safe&quot; algorithm that could never cause overflow when calculating intermediate results. The library also includes several functions performing elementary operations with complex numbers.
+</p>
+<p align=justify>
+<span class=func><b>const</b> double abscomplex(<b>const</b> complex &amp;z)</span><br> Returns the modulus of complex number z. It should be noted that the modulus calculation is performed using so called &quot;safe&quot; algorithm, that could never cause overflow when calculating intermediate results.
+</p>
+<p align=justify>
+<span class=func><b>const</b> complex conj(<b>const</b> complex &amp;z)</span><br> Returns complex conjugate to z.
+</p>
+<p align=justify>
+<span class=func><b>const</b> complex csqr(<b>const</b> complex &amp;z)</span><br> Returns the square of z.
+</p>
+</body>
+</html>

data/ext/alglib/ap.h ADDED

@@ -0,0 +1,666 @@
+/********************************************************************
+AP Library version 1.3
+Copyright (c) 2003-2007, Sergey Bochkanov (ALGLIB project).
+See www.alglib.net or alglib.sources.ru for details.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+- Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+- Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer listed
+  in this license in the documentation and/or other materials
+  provided with the distribution.
+- Neither the name of the copyright holders nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+********************************************************************/
+#ifndef AP_H
+#define AP_H
+#include <stdlib.h>
+#include <string>
+#include <cstring>
+#include <math.h>
+#ifdef __BORLANDC__
+#include <list.h>
+#include <vector.h>
+#else
+#include <list>
+#include <vector>
+#endif
+/********************************************************************
+Array bounds check
+********************************************************************/
+#define AP_ASSERT
+#ifndef AP_ASSERT     //
+#define NO_AP_ASSERT  // This code avoids definition of the
+#endif                // both AP_ASSERT and NO_AP_ASSERT symbols
+#ifdef NO_AP_ASSERT   //
+#ifdef AP_ASSERT      //
+#undef NO_AP_ASSERT   //
+#endif                //
+#endif                //
+/********************************************************************
+Current environment.
+********************************************************************/
+#ifndef AP_WIN32
+#ifndef AP_UNKNOWN
+#define AP_UNKNOWN
+#endif
+#endif
+#ifdef AP_WIN32
+#ifdef AP_UNKNOWN
+#error Multiple environments are declared!
+#endif
+#endif
+/********************************************************************
+This symbol is used for debugging. Do not define it and do not remove
+comments.
+********************************************************************/
+//#define UNSAFE_MEM_COPY
+/********************************************************************
+Namespace of a standard library AlgoPascal.
+********************************************************************/
+namespace ap
+{
+/********************************************************************
+Service routines:
+    amalloc - allocates an aligned block of size bytes
+    afree - frees block allocated by amalloc
+    vlen - just alias for n2-n1+1
+********************************************************************/
+void* amalloc(size_t size, size_t alignment);
+void afree(void *block);
+int vlen(int n1, int n2);
+/********************************************************************
+Exception class.
+********************************************************************/
+class ap_error
+{
+public:
+    ap_error(){};
+    ap_error(const char *s){ msg = s; };
+    std::string msg;
+    static void make_assertion(bool bClause)
+        { if(!bClause) throw ap_error(); };
+    static void make_assertion(bool bClause, const char *msg)
+        { if(!bClause) throw ap_error(msg); };
+private:
+};
+/********************************************************************
+Class defining a complex number with double precision.
+********************************************************************/
+class complex;
+class complex
+{
+public:
+    complex():x(0.0),y(0.0){};
+    complex(const double &_x):x(_x),y(0.0){};
+    complex(const double &_x, const double &_y):x(_x),y(_y){};
+    complex(const complex &z):x(z.x),y(z.y){};
+    complex& operator= (const double& v){ x  = v; y = 0.0; return *this; };
+    complex& operator+=(const double& v){ x += v;          return *this; };
+    complex& operator-=(const double& v){ x -= v;          return *this; };
+    complex& operator*=(const double& v){ x *= v; y *= v;  return *this; };
+    complex& operator/=(const double& v){ x /= v; y /= v;  return *this; };
+    complex& operator= (const complex& z){ x  = z.x; y  = z.y; return *this; };
+    complex& operator+=(const complex& z){ x += z.x; y += z.y; return *this; };
+    complex& operator-=(const complex& z){ x -= z.x; y -= z.y; return *this; };
+    complex& operator*=(const complex& z){ double t = x*z.x-y*z.y; y = x*z.y+y*z.x; x = t; return *this; };
+    complex& operator/=(const complex& z)
+    {
+        ap::complex result;
+        double e;
+        double f;
+        if( fabs(z.y)<fabs(z.x) )
+        {
+            e = z.y/z.x;
+            f = z.x+z.y*e;
+            result.x = (z.x+z.y*e)/f;
+            result.y = (z.y-z.x*e)/f;
+        }
+        else
+        {
+            e = z.x/z.y;
+            f = z.y+z.x*e;
+            result.x = (z.y+z.x*e)/f;
+            result.y = (-z.x+z.y*e)/f;
+        }
+        *this = result;
+        return *this;
+    };
+    double x, y;
+};
+const complex operator/(const complex& lhs, const complex& rhs);
+const bool operator==(const complex& lhs, const complex& rhs);
+const bool operator!=(const complex& lhs, const complex& rhs);
+const complex operator+(const complex& lhs);
+const complex operator-(const complex& lhs);
+const complex operator+(const complex& lhs, const complex& rhs);
+const complex operator+(const complex& lhs, const double& rhs);
+const complex operator+(const double& lhs, const complex& rhs);
+const complex operator-(const complex& lhs, const complex& rhs);
+const complex operator-(const complex& lhs, const double& rhs);
+const complex operator-(const double& lhs, const complex& rhs);
+const complex operator*(const complex& lhs, const complex& rhs);
+const complex operator*(const complex& lhs, const double& rhs);
+const complex operator*(const double& lhs, const complex& rhs);
+const complex operator/(const complex& lhs, const complex& rhs);
+const complex operator/(const double& lhs, const complex& rhs);
+const complex operator/(const complex& lhs, const double& rhs);
+const double abscomplex(const complex &z);
+const complex conj(const complex &z);
+const complex csqr(const complex &z);
+/********************************************************************
+Templates for vector operations
+********************************************************************/
+#include "apvt.h"
+/********************************************************************
+BLAS functions
+********************************************************************/
+double vdotproduct(const double *v1, const double *v2, int N);
+complex vdotproduct(const complex *v1, const complex *v2, int N);
+void vmove(double *vdst, const double* vsrc, int N);
+void vmove(complex *vdst, const complex* vsrc, int N);
+void vmoveneg(double *vdst, const double *vsrc, int N);
+void vmoveneg(complex *vdst, const complex *vsrc, int N);
+void vmove(double *vdst, const double *vsrc, int N, double alpha);
+void vmove(complex *vdst, const complex *vsrc, int N, double alpha);
+void vmove(complex *vdst, const complex *vsrc, int N, complex alpha);
+void vadd(double *vdst, const double *vsrc, int N);
+void vadd(complex *vdst, const complex *vsrc, int N);
+void vadd(double *vdst, const double *vsrc, int N, double alpha);
+void vadd(complex *vdst, const complex *vsrc, int N, double alpha);
+void vadd(complex *vdst, const complex *vsrc, int N, complex alpha);
+void vsub(double *vdst, const double *vsrc, int N);
+void vsub(complex *vdst, const complex *vsrc, int N);
+void vsub(double *vdst, const double *vsrc, int N, double alpha);
+void vsub(complex *vdst, const complex *vsrc, int N, double alpha);
+void vsub(complex *vdst, const complex *vsrc, int N, complex alpha);
+void vmul(double *vdst, int N, double alpha);
+void vmul(complex *vdst, int N, double alpha);
+void vmul(complex *vdst, int N, complex alpha);
+/********************************************************************
+Template of a dynamical one-dimensional array
+********************************************************************/
+template<class T, bool Aligned = false>
+class template_1d_array
+{
+public:
+    template_1d_array()
+    {
+        m_Vec=0;
+        m_iVecSize = 0;
+        m_iLow = 0;
+        m_iHigh = -1;
+    };
+    ~template_1d_array()
+    {
+        if(m_Vec)
+        {
+            if( Aligned )
+                ap::afree(m_Vec);
+            else
+                delete[] m_Vec;
+        }
+    };
+    template_1d_array(const template_1d_array &rhs)
+    {
+        m_Vec=0;
+        m_iVecSize = 0;
+        m_iLow = 0;
+        m_iHigh = -1;
+        if( rhs.m_iVecSize!=0 )
+            setcontent(rhs.m_iLow, rhs.m_iHigh, rhs.getcontent());
+    };
+    const template_1d_array& operator=(const template_1d_array &rhs)
+    {
+        if( this==&rhs )
+            return *this;
+        if( rhs.m_iVecSize!=0 )
+            setcontent(rhs.m_iLow, rhs.m_iHigh, rhs.getcontent());
+        else
+        {
+            m_Vec=0;
+            m_iVecSize = 0;
+            m_iLow = 0;
+            m_iHigh = -1;
+        }
+        return *this;
+    };
+    const T& operator()(int i) const
+    {
+        #ifndef NO_AP_ASSERT
+        ap_error::make_assertion(i>=m_iLow && i<=m_iHigh);
+        #endif
+        return m_Vec[ i-m_iLow ];
+    };
+    T& operator()(int i)
+    {
+        #ifndef NO_AP_ASSERT
+        ap_error::make_assertion(i>=m_iLow && i<=m_iHigh);
+        #endif
+        return m_Vec[ i-m_iLow ];
+    };
+    void setbounds( int iLow, int iHigh )
+    {
+        if(m_Vec)
+        {
+            if( Aligned )
+                ap::afree(m_Vec);
+            else
+                delete[] m_Vec;
+        }
+        m_iLow = iLow;
+        m_iHigh = iHigh;
+        m_iVecSize = iHigh-iLow+1;
+        if( Aligned )
+            m_Vec = (T*)ap::amalloc(m_iVecSize*sizeof(T), 16);
+        else
+            m_Vec = new T[m_iVecSize];
+    };
+    void setlength(int iLen)
+    {
+        setbounds(0, iLen-1);
+    }
+    void setcontent( int iLow, int iHigh, const T *pContent )
+    {
+        setbounds(iLow, iHigh);
+        for(int i=0; i<m_iVecSize; i++)
+            m_Vec[i] = pContent[i];
+    };
+    T* getcontent()
+    {
+        return m_Vec;
+    };
+    const T* getcontent() const
+    {
+        return m_Vec;
+    };
+    int getlowbound(int iBoundNum = 0) const
+    {
+        return m_iLow;
+    };
+    int gethighbound(int iBoundNum = 0) const
+    {
+        return m_iHigh;
+    };
+    raw_vector<T> getvector(int iStart, int iEnd)
+    {
+        if( iStart>iEnd || wrongIdx(iStart) || wrongIdx(iEnd) )
+            return raw_vector<T>(0, 0, 1);
+        else
+            return raw_vector<T>(m_Vec+iStart-m_iLow, iEnd-iStart+1, 1);
+    };
+    const_raw_vector<T> getvector(int iStart, int iEnd) const
+    {
+        if( iStart>iEnd || wrongIdx(iStart) || wrongIdx(iEnd) )
+            return const_raw_vector<T>(0, 0, 1);
+        else
+            return const_raw_vector<T>(m_Vec+iStart-m_iLow, iEnd-iStart+1, 1);
+    };
+private:
+    bool wrongIdx(int i) const { return i<m_iLow || i>m_iHigh; };
+    T         *m_Vec;
+    long      m_iVecSize;
+    long      m_iLow, m_iHigh;
+};
+/********************************************************************
+Template of a dynamical two-dimensional array
+********************************************************************/
+template<class T, bool Aligned = false>
+class template_2d_array
+{
+public:
+    template_2d_array()
+    {
+        m_Vec=0;
+        m_iVecSize=0;
+        m_iLow1 = 0;
+        m_iHigh1 = -1;
+        m_iLow2 = 0;
+        m_iHigh2 = -1;
+    };
+    ~template_2d_array()
+    {
+        if(m_Vec)
+        {
+            if( Aligned )
+                ap::afree(m_Vec);
+            else
+                delete[] m_Vec;
+        }
+    };
+    template_2d_array(const template_2d_array &rhs)
+    {
+        m_Vec=0;
+        m_iVecSize=0;
+        m_iLow1 = 0;
+        m_iHigh1 = -1;
+        m_iLow2 = 0;
+        m_iHigh2 = -1;
+        if( rhs.m_iVecSize!=0 )
+        {
+            setbounds(rhs.m_iLow1, rhs.m_iHigh1, rhs.m_iLow2, rhs.m_iHigh2);
+            for(int i=m_iLow1; i<=m_iHigh1; i++)
+                for(int j=m_iLow2; j<=m_iHigh2; j++)
+                    operator()(i,j) = rhs(i,j);
+                //vmove(&(operator()(i,m_iLow2)), &(rhs(i,m_iLow2)), m_iHigh2-m_iLow2+1);
+        }
+    };
+    const template_2d_array& operator=(const template_2d_array &rhs)
+    {
+        if( this==&rhs )
+            return *this;
+        if( rhs.m_iVecSize!=0 )
+        {
+            setbounds(rhs.m_iLow1, rhs.m_iHigh1, rhs.m_iLow2, rhs.m_iHigh2);
+            for(int i=m_iLow1; i<=m_iHigh1; i++)
+                for(int j=m_iLow2; j<=m_iHigh2; j++)
+                    operator()(i,j) = rhs(i,j);
+                //vmove(&(operator()(i,m_iLow2)), &(rhs(i,m_iLow2)), m_iHigh2-m_iLow2+1);
+        }
+        else
+        {
+            if(m_Vec)
+            {
+                if( Aligned )
+                    ap::afree(m_Vec);
+                else
+                    delete[] m_Vec;
+            }
+            m_Vec=0;
+            m_iVecSize=0;
+            m_iLow1 = 0;
+            m_iHigh1 = -1;
+            m_iLow2 = 0;
+            m_iHigh2 = -1;
+        }
+        return *this;
+    };
+    const T& operator()(int i1, int i2) const
+    {
+        #ifndef NO_AP_ASSERT
+        ap_error::make_assertion(i1>=m_iLow1 && i1<=m_iHigh1);
+        ap_error::make_assertion(i2>=m_iLow2 && i2<=m_iHigh2);
+        #endif
+        return m_Vec[ m_iConstOffset + i2 +i1*m_iLinearMember];
+    };
+    T& operator()(int i1, int i2)
+    {
+        #ifndef NO_AP_ASSERT
+        ap_error::make_assertion(i1>=m_iLow1 && i1<=m_iHigh1);
+        ap_error::make_assertion(i2>=m_iLow2 && i2<=m_iHigh2);
+        #endif
+        return m_Vec[ m_iConstOffset + i2 +i1*m_iLinearMember];
+    };
+    void setbounds( int iLow1, int iHigh1, int iLow2, int iHigh2 )
+    {
+        if(m_Vec)
+        {
+            if( Aligned )
+                ap::afree(m_Vec);
+            else
+                delete[] m_Vec;
+        }
+        int n1 = iHigh1-iLow1+1;
+        int n2 = iHigh2-iLow2+1;
+        m_iVecSize = n1*n2;
+        if( Aligned )
+        {
+            //if( n2%2!=0 )
+            while( (n2*sizeof(T))%16!=0 )
+            {
+                n2++;
+                m_iVecSize += n1;
+            }
+            m_Vec = (T*)ap::amalloc(m_iVecSize*sizeof(T), 16);
+        }
+        else
+            m_Vec = new T[m_iVecSize];
+        m_iLow1  = iLow1;
+        m_iHigh1 = iHigh1;
+        m_iLow2  = iLow2;
+        m_iHigh2 = iHigh2;
+        m_iConstOffset = -m_iLow2-m_iLow1*n2;
+        m_iLinearMember = n2;
+    };
+    void setlength(int iLen1, int iLen2)
+    {
+        setbounds(0, iLen1-1, 0, iLen2-1);
+    }
+    void setcontent( int iLow1, int iHigh1, int iLow2, int iHigh2, const T *pContent )
+    {
+        setbounds(iLow1, iHigh1, iLow2, iHigh2);
+        for(int i=m_iLow1; i<=m_iHigh1; i++, pContent += m_iHigh2-m_iLow2+1)
+            for(int j=m_iLow2; j<=m_iHigh2; j++)
+                operator()(i,j) = pContent[j-m_iLow2];
+            //vmove(&(operator()(i,m_iLow2)), pContent, m_iHigh2-m_iLow2+1);
+    };
+    int getlowbound(int iBoundNum) const
+    {
+        return iBoundNum==1 ? m_iLow1 : m_iLow2;
+    };
+    int gethighbound(int iBoundNum) const
+    {
+        return iBoundNum==1 ? m_iHigh1 : m_iHigh2;
+    };
+    raw_vector<T> getcolumn(int iColumn, int iRowStart, int iRowEnd)
+    {
+        if( (iRowStart>iRowEnd) || wrongColumn(iColumn) || wrongRow(iRowStart) ||wrongRow(iRowEnd) )
+            return raw_vector<T>(0, 0, 1);
+        else
+            return raw_vector<T>(&((*this)(iRowStart, iColumn)), iRowEnd-iRowStart+1, m_iLinearMember);
+    };
+    raw_vector<T> getrow(int iRow, int iColumnStart, int iColumnEnd)
+    {
+        if( (iColumnStart>iColumnEnd) || wrongRow(iRow) || wrongColumn(iColumnStart) || wrongColumn(iColumnEnd))
+            return raw_vector<T>(0, 0, 1);
+        else
+            return raw_vector<T>(&((*this)(iRow, iColumnStart)), iColumnEnd-iColumnStart+1, 1);
+    };
+    const_raw_vector<T> getcolumn(int iColumn, int iRowStart, int iRowEnd) const
+    {
+        if( (iRowStart>iRowEnd) || wrongColumn(iColumn) || wrongRow(iRowStart) ||wrongRow(iRowEnd) )
+            return const_raw_vector<T>(0, 0, 1);
+        else
+            return const_raw_vector<T>(&((*this)(iRowStart, iColumn)), iRowEnd-iRowStart+1, m_iLinearMember);
+    };
+    const_raw_vector<T> getrow(int iRow, int iColumnStart, int iColumnEnd) const
+    {
+        if( (iColumnStart>iColumnEnd) || wrongRow(iRow) || wrongColumn(iColumnStart) || wrongColumn(iColumnEnd))
+            return const_raw_vector<T>(0, 0, 1);
+        else
+            return const_raw_vector<T>(&((*this)(iRow, iColumnStart)), iColumnEnd-iColumnStart+1, 1);
+    };
+private:
+    bool wrongRow(int i) const { return i<m_iLow1 || i>m_iHigh1; };
+    bool wrongColumn(int j) const { return j<m_iLow2 || j>m_iHigh2; };
+    T           *m_Vec;
+    long        m_iVecSize;
+    long        m_iLow1, m_iLow2, m_iHigh1, m_iHigh2;
+    long        m_iConstOffset, m_iLinearMember;
+};
+typedef template_1d_array<int>          integer_1d_array;
+typedef template_1d_array<double,true>  real_1d_array;
+typedef template_1d_array<complex>      complex_1d_array;
+typedef template_1d_array<bool>         boolean_1d_array;
+typedef template_2d_array<int>          integer_2d_array;
+typedef template_2d_array<double,true>  real_2d_array;
+typedef template_2d_array<complex>      complex_2d_array;
+typedef template_2d_array<bool>         boolean_2d_array;
+/********************************************************************
+dataset information.
+can store regression dataset, classification dataset, or non-labeled
+task:
+* nout==0 means non-labeled task (clustering, for example)
+* nout>0 && nclasses==0 means regression task
+* nout>0 && nclasses>0 means classification task
+********************************************************************/
+class dataset
+{
+public:
+    dataset():nin(0), nout(0), nclasses(0), trnsize(0), valsize(0), tstsize(0), totalsize(0){};
+    int nin, nout, nclasses;
+    int trnsize;
+    int valsize;
+    int tstsize;
+    int totalsize;
+    ap::real_2d_array trn;
+    ap::real_2d_array val;
+    ap::real_2d_array tst;
+    ap::real_2d_array all;
+};
+bool opendataset(std::string file, dataset *pdataset);
+//
+// internal functions
+//
+std::string strtolower(const std::string &s);
+bool readstrings(std::string file, std::list<std::string> *pOutput);
+bool readstrings(std::string file, std::list<std::string> *pOutput, std::string comment);
+void explodestring(std::string s, char sep, std::vector<std::string> *pOutput);
+std::string xtrim(std::string s);
+/********************************************************************
+reverse communication state
+********************************************************************/
+struct rcommstate
+{
+    int stage;
+    ap::integer_1d_array ia;
+    ap::boolean_1d_array ba;
+    ap::real_1d_array ra;
+    ap::complex_1d_array ca;
+};
+/********************************************************************
+Constants and functions introduced for compatibility with AlgoPascal
+********************************************************************/
+extern const double machineepsilon;
+extern const double maxrealnumber;
+extern const double minrealnumber;
+int sign(double x);
+double randomreal();
+int randominteger(int maxv);
+int round(double x);
+int trunc(double x);
+int ifloor(double x);
+int iceil(double x);
+double pi();
+double sqr(double x);
+int maxint(int m1, int m2);
+int minint(int m1, int m2);
+double maxreal(double m1, double m2);
+double minreal(double m1, double m2);
+}//namespace ap
+#endif