Hoc, the High Order Calculator, is an interpreted language for
floating-point calculations. Its most basic use is as a powerful and
convenient calculator, interactively evaluating expressions such as
1+2*sin(0.7). But hoc is no ordinary calculator: It also lets you
assign values to variables, define your own functions, and use loops,
conditionals, and everything else you'd expect in a programming
language.
Hoc was developed by Brian Kernighan and Rob Pike, and introduced in
their 1984 book The Unix Programming Environment. This version has been
extended and improved by Nadav Y. Har'El.
The octave-forge package is the result of The GNU Octave Repositry project,
which is intended to be a central location for custom scripts, functions and
extensions for GNU Octave. contains the source for all the functions plus
build and install scripts.
This baseport provides the basic directory structure, and installs a script
"load-octave-pkg", that synchronizes the FreeBSD ports structure to the octave
packaging system.
Another purpose of the script "load-octave-pkg" is to attempt to correct any
errors created by the octave packaging system.
The octave-forge package is the result of The GNU Octave Repositry project,
which is intended to be a central location for custom scripts, functions and
extensions for GNU Octave. contains the source for all the functions plus
build and install scripts.
This is doctest.
The Octave-Forge Doctest package finds specially-formatted blocks of
example code within documentation files. It then executes the code and
confirms the output is correct. This can be useful as part of a testing
framework or simply to ensure that documentation stays up-to-date during
software development.
Chart::Math::Axis implements in a generic way an algorithm for finding a
set of ideal values for an axis. That is, for any given set of data,
what should the top and bottom of the axis scale be, and what should the
interval between the ticks be.
The terms top and bottom are used throughout this module, as it's
primary use is for determining the Y axis. For calculating the X axis,
you should think of 'top' as 'right', and 'bottom' as 'left'.
As with other Pseudo-Random Number Generator (PRNG) algorithms like the
Mersenne Twister (see Math::Random::MT), this algorithm is designed to
take some seed information and produce seemingly random results as output.
However, ISAAC (Indirection, Shift, Accumulate, Add, and Count) has
different goals than these commonly used algorithms. In particular, it's
really fast - on average, it requires only 18.75 machine cycles to generate
a 32-bit value. This makes it suitable for applications where a significant
amount of random data needs to be produced quickly, such solving using the
Monte Carlo method or for games.
As with other Pseudo-Random Number Generator (PRNG) algorithms like the
Mersenne Twister (see Math::Random::MT), this algorithm is designed to
take some seed information and produce seemingly random results as output.
However, ISAAC (Indirection, Shift, Accumulate, Add, and Count) has
different goals than these commonly used algorithms. In particular, it's
really fast - on average, it requires only 18.75 machine cycles to generate
a 32-bit value. This makes it suitable for applications where a significant
amount of random data needs to be produced quickly, such solving using the
Monte Carlo method or for games.
Carve is a C++ library designed to perform boolean operations between two
arbitrary polygonal meshes. The standard union and intersection operations are
supported, as are symmetric and asymmetric difference. It is also possible to
implement custom operations using Carve, allowing results to be formed from any
combination of inputs.
Carve supports a variety of inputs, including both closed and open surfaces,
faces with arbitrary edge counts and datasets with multiple disjoint,
embedded or touching surfaces. Carve can also interpolate arbitrary
values across faces, meaning that CSG operations need not discard colour,
texture coordinates or other data.
The "Statistics::Contingency" class helps you calculate several useful
statistical measures based on 2x2 "contingency tables". I use these measures
to help judge the results of automatic text categorization experiments, but
they are useful in other situations as well.
The general usage flow is to tally a whole bunch of results in the
"Statistics::Contingency" object, then query that object to obtain the
measures you are interested in. When all results have been collected, you
can get a report on accuracy, precision, recall, F1, and so on, with both
macro-averaging and micro-averaging over categories.
ParMETIS is an MPI-based parallel library that implements a variety
of algorithms for partitioning unstructured graphs and for computing
fill-reducing orderings of sparse matrices. ParMETIS extends the
functionality provided by METIS and includes routines that are
especially suited for parallel AMR computations and large scale
numerical simulations. The algorithms implemented in ParMETIS are
based on the parallel multilevel k-way graph-partitioning algorithms
described in [KK95d], [KK96], [KK97], and the adaptive repartitioning
algorithms described in [SKK97a], [SKK97b], [SK+98], and [SKK98].
Another Python Graph Library is a simple, fast and easy to use graph library
with some machine learning features. The main features are as follows:
* Directed, undirected and multigraphs designed under a hierarchical
class structure
* Sparse and Dense graph structures using numpy and scipy for fast linear
algebra computations
* Many operations on graphs such as subgraphs, search, Floyd-Warshall,
Dijkstras algorithm
* Erdos-Renyi, Small-World and Albert-Barabasi random graphs
* Write to Pajek, and simple CSV files
* Some machine learning features - data preprocessing, kernels, PCA, KCCA,
wrappers for LibSVM, and some mlpy learning algorithms
* Unit tested using the Python unittest framework