index.htm

利用这个模板可以分析基因表达数据

</ul>
<a href="#Classes"><img SRC="leftb.gif" ALT="back" BORDER=0 ></a>
<hr>
<p><a NAME="PPM_processor"></a>
<h2>
PPM_processor</h2>

<p><br>This class is a simple ascii PPM image file processor. It is not
complete and is only included for use by the demo programs that come with
this library.
<br><b>Authors:</b> W.R.Pitt
<br><b>Friends:</b> ostream operator
<br><b>Files:</b> <a href="btl/PPM_processor.h">PPM_processor.h</a>
<br><b>Dependencies:</b> none
<p><b>Operations</b>
<br>&nbsp;
<br>&nbsp;
<ul>
<li>
<tt><a href="#PPM_processorO0">ReadFile</a> - - <i>Read in a file with
a given name.</i></tt></li>

<li>
<tt><a href="#PPM_processorO1">ReadImageData</a> - - <i>Get image data.</i></tt></li>

<li>
<tt><a href="#PPM_processorO2">WriteImageData</a> - - <i>Write image data.</i></tt></li>

<li>
<tt><a href="#PPM_processorO3">ReadWidth</a> - - <i>Read width of image.</i></tt></li>

<li>
<tt><a href="#PPM_processorO4">ReadHeight</a> - - <i>Read image height.</i></tt></li>
</ul>
<a href="#Classes"><img SRC="leftb.gif" ALT="back" BORDER=0 ></a>
<hr>
<p><a NAME="XYZ_processor"></a>
<h2>
XYZ_processor</h2>

<p><br>This is simple class for reading xyz format files. It is really
only included in the library so that real data can be used in the test
programs.
<br><b>Friends:</b> an output operator
<br><b>Authors:</b> W.R.Pitt
<br><b>Files:</b> <a href="btl/XYZ_processor.h">XYZ_processor.h</a>
<br><b>Dependencies:</b> None
<p><b>Operations</b>
<br>&nbsp;
<br>&nbsp;
<ul>
<li>
<tt><a href="#XYZ_processorO0">XYZ_processor</a> - - <i>Default constructor
(does nothing)</i></tt></li>

<li>
<tt><a href="#XYZ_processorO1">empty</a> - - <i>Returns true if no coordinates
have been read</i></tt></li>

<li>
<tt><a href="#XYZ_processorO2">ReadFile</a> - - <i>Read an xyz format file
with the given name</i></tt></li>

<li>
<tt><a href="#XYZ_processorO3">Coords</a> - - <i>Return a reference to
the read coordinates in a STL vector of float. Coordinates are stored in
the following order: x,y,z,x,y,z,x,...</i></tt></li>

<li>
<tt><a href="#XYZ_processorO4">Elements</a> - - <i>Return a reference to
the read atomic elements in a STL vector of char. Each element is stored
as 2 chars.</i></tt></li>
</ul>
<a href="#Classes"><img SRC="leftb.gif" ALT="back" BORDER=0 ></a>
<hr>
<p><a NAME="needleman_wunsch_similarity"></a>
<h2>
needleman_wunsch_similarity</h2>

<p><br>Pairwise similarity score for two sequences.
<br><b><font color="#FF0000">Restrictions:</font></b> The containers holding
the sequences must have at least forward iterators and an equality operator
(==) should be defined for pairs of elements. The score for any pair of
elements is match_score (or mismatch_score) - total gap penalty. The total
gap penalty = gap_penalty + (length_of_gap * gap_length_multiplier)
<p><b>Operations</b>
<br>&nbsp;
<br>&nbsp;
<ul>
<li>
<tt><a href="#needleman_wunsch_similarityO0">needleman_wunsch_similarity</a>
-</tt></li>
</ul>
<a href="#Classes"><img SRC="leftb.gif" ALT="back" BORDER=0 ></a>
<hr>
<p><a NAME="needleman_wusch_align"></a>
<h2>
needleman_wusch_align</h2>

<p><br>Pairwise alignment for two complete sequences. The score for any
pair of elements is match_score (or mismatch_score) - total gap penalty.
The total gap penalty = gap_penalty + (length_of_gap * gap_length_multiplier).
The aligned sequence elements are placed alternately in the output container
i.e with the odd elements representing the first sequence.
<br><b><font color="#FF0000">Restrictions:</font></b> The containers holding
the sequences must have at least forward iterators and an equality operator
(==) should be defined for pairs of elements. The result container should
either have no fixed size or be created at least twice the size of the
longer sequence.
<p><b>Operations</b>
<br>&nbsp;
<br>&nbsp;
<ul>
<li>
<tt><a href="#needleman_wusch_alignO0">needleman_wunsch_align</a> -</tt></li>
</ul>
<a href="#Classes"><img SRC="leftb.gif" ALT="back" BORDER=0 ></a>
<hr>
<p><a NAME="fourier_transform"></a>
<h2>
fourier_transform</h2>

<p><br>Two dimensional FFT. 1D and 3D versions also available
<p><b>Operations</b>
<br>&nbsp;
<br>&nbsp;
<ul>
<li>
<tt><a href="#fourier_transformO0">fourier_transform</a> -</tt></li>
</ul>
<a href="#Classes"><img SRC="leftb.gif" ALT="back" BORDER=0 ></a>
<hr>
<p><a NAME="mean"></a>
<h2>
mean</h2>

<p><br>Calculate the mean value of the elements in a container.
<p><b>Operations</b>
<br>&nbsp;
<br>&nbsp;
<ul>
<li>
<tt><a href="#meanO0">mean</a> -</tt></li>
</ul>
<a href="#Classes"><img SRC="leftb.gif" ALT="back" BORDER=0 ></a>
<hr>
<p><a NAME="mean_absolute_deviation"></a>
<h2>
mean_absolute_deviation</h2>

<p><br>Calculate mean absolute deviation from the mean of the elements
in a container.
<p><b>Operations</b>
<br>&nbsp;
<br>&nbsp;
<ul>
<li>
<tt><a href="#mean_absolute_deviationO0">mean_absolute_deviation</a> -</tt></li>
</ul>
<a href="#Classes"><img SRC="leftb.gif" ALT="back" BORDER=0 ></a>
<hr>
<p><a NAME="variance"></a>
<h2>
variance</h2>

<p><br>Calculate the sample variance of the elements in a container.
<p><b>Operations</b>
<br>&nbsp;
<br>&nbsp;
<ul>
<li>
<tt><a href="#varianceO0">variance</a> -</tt></li>
</ul>
<a href="#Classes"><img SRC="leftb.gif" ALT="back" BORDER=0 ></a>
<hr>
<p><a NAME="normal_statistics"></a>
<h2>
normal_statistics</h2>

<p><br>Calculate the mean, mean absolute deviation from mean, sample variance,
skew and kurtosis of the distribution of the elements in a container.
<p><b>Operations</b>
<br>&nbsp;
<br>&nbsp;
<ul>
<li>
<tt><a href="#normal_statisticsO0">normal_statistics</a> -</tt></li>
</ul>
<a href="#Classes"><img SRC="leftb.gif" ALT="back" BORDER=0 ></a>
<hr>
<p><a NAME="max_mismatch"></a>
<h2>
max_mismatch</h2>

<p><br>Returns the maximum difference between equivalent elements in two
containers in the sense of (a-b)
<p><b>Operations</b>
<br>&nbsp;
<br>&nbsp;
<ul>
<li>
<tt><a href="#max_mismatchO0">max_mismatch</a> -</tt></li>
</ul>
<a href="#Classes"><img SRC="leftb.gif" ALT="back" BORDER=0 ></a>
<hr>
<p><a NAME="max_absolute_mismatch"></a>
<h2>
max_absolute_mismatch</h2>

<p><br>Returns the largest absolute difference between equivalent elements
in two containers
<p><b>Operations</b>
<br>&nbsp;
<br>&nbsp;
<ul>
<li>
<tt><a href="#max_absolute_mismatchO0">max_absolute_mismatch</a> -</tt></li>
</ul>
<a href="#Classes"><img SRC="leftb.gif" ALT="back" BORDER=0 ></a>
<hr>
<p><a NAME="min_mismatch"></a>
<h2>
min_mismatch</h2>

<p><br>Returns the minimum difference between equivalent elements in two
containers in the sense of (a-b)
<p><b>Operations</b>
<br>&nbsp;
<br>&nbsp;
<ul>
<li>
<tt><a href="#min_mismatchO0">min_mismatch</a> -</tt></li>
</ul>
<a href="#Classes"><img SRC="leftb.gif" ALT="back" BORDER=0 ></a>
<hr>
<p><a NAME="min_absolute_mismatch"></a>
<h2>
min_absolute_mismatch</h2>

<p><br>Returns the smallest absolute difference between equivalent elements
in two containers
<p><b>Operations</b>
<br>&nbsp;
<br>&nbsp;
<ul>
<li>
<tt><a href="#min_absolute_mismatchO0">min_absolute_mismatch</a> -</tt></li>
</ul>
<a href="#Classes"><img SRC="leftb.gif" ALT="back" BORDER=0 ></a>
<hr>
<p><a NAME="every_less_equal"></a>
<h2>
every_less_equal</h2>

<p><br>Returns true if every element of a is less than or equal to the
equivalent element of b
<p><b>Operations</b>
<br>&nbsp;
<br>&nbsp;
<ul>
<li>
<tt><a href="#every_less_equalO0">every_less_equal</a> -</tt></li>
</ul>
<a href="#Classes"><img SRC="leftb.gif" ALT="back" BORDER=0 ></a>
<hr>
<p><a NAME="every_less"></a>
<h2>
every_less</h2>

<p><br>Returns true if every element of a is less than the equivalent element
of b
<p><b>Operations</b>
<br>&nbsp;
<br>&nbsp;
<ul>
<li>
<tt><a href="#every_lessO0">every_less</a> -</tt></li>
</ul>
<a href="#Classes"><img SRC="leftb.gif" ALT="back" BORDER=0 ></a>
<hr>
<p><a NAME="less_absolute"></a>
<h2>
less_absolute</h2>

<p><br>Compare the absolute values of two arguements true if |x| &lt; |y|
<p><b>Operations</b>
<br>&nbsp;
<br>&nbsp;
<ul>
<li>
<tt><a href="#less_absoluteO0">operator()</a> -</tt></li>
</ul>
<a href="#Classes"><img SRC="leftb.gif" ALT="back" BORDER=0 ></a>
<hr>
<p><a NAME="random_uniform"></a>
<h2>
random_uniform</h2>

<p><br>Portable random number generator that produces float,double, int
and long random numbers. In the case of float &amp; double the numbers
are uniformly distributed in the range 0 to 1. In the case of long they
are uniformly distributed in the range 0 to 2**31 and in the int case from
0 to 2**15. It is an implementation of Donald Knuth's floating point ranf_array
generator, a lagged additive generator x(i) = (x(i-KK) + x(i-LL))mod 1.0
for float and double numbers and Knuth's lagged subtractive generator x(i)
= (x(i-KK) - x(i-LL))mod 2**MM where MM = 15 for int and MM=30 for long.
An object containing random numbers is constructed and used by random_uniform<T>
numbers(seed); T temp = numbers(); The seed integer should be &lt; 1073741822
for float, double and long numbers and &lt; 32765 in the case of of int
data. N.B. it is best not to generate a sequence of more than 2**70 numbers
using the same seed. This generator fails the birthday spacings test i.e
some differences between pairs of numbers occur more often than desired.
See Knuth's Art of Computer Programming 3rd Edition for solutions
<p><b>Operations</b>
<br>&nbsp;
<br>&nbsp;
<ul>
<li>
<tt><a href="#random_uniformO0">random_uniform</a> -</tt></li>

<li>
<tt><a href="#random_uniformO1">operator()</a> -</tt></li>
</ul>
<a href="#Classes"><img SRC="leftb.gif" ALT="back" BORDER=0 ></a>
<hr>
<p><a NAME="random_normal"></a>
<h2>
random_normal</h2>

<p><br>Portable random number generator that produces float or double precision
random numbers from a normal distibution using the ratio method of Kinderman
&amp; Monahan (see Knuth TAOCP).
<p><b>Operations</b>
<br>&nbsp;
<br>&nbsp;
<ul>
<li>
<tt><a href="#random_normalO0">random_normal</a> -</tt></li>

<li>
<tt><a href="#random_normalO1">random_normal</a> -</tt></li>

<li>
<tt><a href="#random_normalO2">operator()</a> -</tt></li>
</ul>
<a href="#Classes"><img SRC="leftb.gif" ALT="back" BORDER=0 ></a>
<hr>
<p><a NAME="random_exponential"></a>
<h2>
random_exponential</h2>

<p><br>Portable random number generator that produces float or double precision
random numbers from an exponential distibution.
<p><b>Operations</b>
<br>&nbsp;
<br>&nbsp;
<ul>
<li>
<tt><a href="#random_exponentialO0">random_exponential</a> -</tt></li>

<li>
<tt><a href="#random_exponentialO1">random_exponential</a> -</tt></li>

<li>
<tt><a href="#random_exponentialO2">operator()</a> -</tt></li>
</ul>
<a href="#Classes"><img SRC="leftb.gif" ALT="back" BORDER=0 ></a>
<hr>
<p><a NAME="numeric_vector"></a>
<h2>
numeric_vector</h2>

<p><br>this template class represents a numerical vector of any size.
<p>&nbsp;V = xi + yj + zk + ...
<p>&nbsp;However, its primary use will probably in representing the position
of atoms in three dimensions. The default contructor contructs a 3 element
numeric_vector.
<p>&nbsp;There are several types associated with this class:
<p>&nbsp;<tt>value_type</tt> : by default the same as the type BTL_REAL
which is defined in BTL.h
<p>&nbsp;<tt>iterator</tt> : this is a STL type iterator. It can be used
to randomly access the elements of the numeric_vector e.g.
<p><tt>&nbsp;numeric_vector&lt;> v1; ... for (numeric_vector&lt;>::iterator
i = v1.begin(); i != v1.end(); i++) cout &lt;&lt; *i;</tt>
<p><tt>const_iterator</tt> : used to access a const numeric_vector.
<p>&nbsp;<tt>size_type</tt> : this is an unsigned integer type that represents
the size of any numeric_vector object.
<br><b>Authors:</b> D.S.Moss, W.R.Pitt, M.A.Williams
<br><b>Files:</b> <a href="btl/btl_numeric_vector.h">btl_numeric_vector.h</a>
<br><b>Friends:</b> Friend equivalents to some functions are available
and are documented with these functions. Also available is: friend ostream&amp;
operator&lt;&lt;(ostream &amp;os, const numeric_vector<T> &amp;m);
<br><b>Dependencies:</b> <a href="#NumericLimits">NumericLimits.h</a>
<p><b>Operations</b>
<br>&nbsp;
<br>&nbsp;
<ul>
<li>
<tt><a href="#numeric_vectorO0">numeric_vector</a> - - <i>Constructs a
3D vector and initialises each value to zero.</i></tt></li>

<li>
<tt><a href="#numeric_vectorO1">numeric_vector</a> - - <i>Constructs a
3D vector with initialization and initialises the values with the numbers
given.</i></tt></li>

<li>
<tt><a href="#numeric_vectorO2">numeric_vector</a> - - <i>Constructor for
a vector of n elements. All n values initiated to a value v. The default
value is zero .</i></tt></li>

<li>
<tt><a href="#numeric_vectorO3">numeric_vector</a> - - <i>Construct from
an array given a value_type*. This constructor is obsolete and will be
deleted in future releases.</i></tt></li>

<li>
<tt><a href="#numeric_vectorO4">numeric_vector</a> - - <i>Copy constructor.</i></tt></li>

<li>
<tt><a href="#numeric_vectorO5">~numeric_vector</a> - - <i>Destructor.</i></tt></li>

<li>
<tt><a href="#numeric_vectorO6">begin</a> - - <i>Returns iterator that
can be used to begin traversing through all elements of the numeric_vector.
(There is also a const version of this function.)</i></tt></li>

<li>
<tt><a href="#numeric_vectorO7">begin</a> -</tt></li>

<li>
<tt><a href="#numeric_vectorO8">end</a> - - <i>Returns an iterator can
be used in comparison for ending traversal through the numeric_vector.
(There is also a const version of this function.)</i></tt></li>

<li>
<tt><a href="#numeric_vectorO9">end</a> -</tt></li>

<li>
<tt><a href="#numeric_vectorO10">operator[]</a> - - <i>Returns the element,
i positions from the beginning of the numeric_vector, in constant time.