Free elliptic curve software for linux

C++ Elliptic Curve Cryptography library is a C++ library for elliptic curves cryptography.
Libecc is a C++ elliptic curve cryptography library that supports fixed-size keys for maximum speed.
The goal of this project is to become the first free Open Source library providing the means to generate safe elliptic curves, and to provide an important source of information for anyone with general interest in ECC.
Enhancements:
- This version brings the code completely up to date again with the latest of version of the working set (autoconf, compiler, etc.).
- The previous version was almost two years old and didnt even compile anymore.

Algorithm::CurveFit - Nonlinear Least Squares Fitting.

SYNOPSIS

use Algorithm::CurveFit;
# Known form of the formula
my $formula = c + a * x^2;
my $variable = x;
my @xdata = read_file(xdata); # The data corresponsing to $variable
my @ydata = read_file(ydata); # The data on the other axis
my @parameters = (
# Name Guess Accuracy
[a, 0.9, 0.00001], # If an iteration introduces smaller
[c, 20, 0.00005], # changes that the accuracy, end.
);
my $max_iter = 100; # maximum iterations

my $square_residual = Algorithm::CurveFit->curve_fit(
formula => $formula, # may be a Math::Symbolic tree instead
params => @parameters,
variable => $variable,
xdata => @xdata,
ydata => @ydata,
maximum_iterations => $max_iter,
);

use Data::Dumper;
print Dumper @parameters;
# Prints
# $VAR1 = [
# [
# a,
# 0.201366784209602,
# 1e-05
# ],
# [
# c,
# 1.94690440147554,
# 5e-05
# ]
# ];
#
# Real values of the parameters (as demonstrated by noisy input data):
# a = 0.2
# c = 2

Algorithm::CurveFit implements a nonlinear least squares curve fitting algorithm. That means, it fits a curve of known form (sine-like, exponential, polynomial of degree n, etc.) to a given set of data points.

For details about the algorithm and its capabilities and flaws, youre encouraged to read the MathWorld page referenced below. Note, however, that it is an iterative algorithm that improves the fit with each iteration until it converges. The following rule of thumb usually holds true:

A good guess improves the probability of convergence and the quality of the fit.
Increasing the number of free parameters decreases the quality and convergence speed.

Make sure that there are no correlated parameters such as in a + b * e^(c+x). (The example can be rewritten as a + b * e^c * e^x in which c and b are basically equivalent parameters.

The curve fitting algorithm is accessed via the curve_fit subroutine. It requires the following parameters as key => value pairs:

formula

The formula should be a string that can be parsed by Math::Symbolic. Alternatively, it can be an existing Math::Symbolic tree. Please refer to the documentation of that module for the syntax.

Evaluation of the formula for a specific value of the variable (X-Data) and the parameters (see below) should yield the associated Y-Data value in case of perfect fit.

variable

The variable is the variable in the formula that will be replaced with the X-Data points for evaluation. If omitted in the call to curve_fit, the name x is default. (Hence xdata.)

params

The parameters are the symbols in the formula whose value is varied by the algorithm to find the best fit of the curve to the data. There may be one or more parameters, but please keep in mind that the number of parameters not only increases processing time, but also decreases the quality of the fit.

The value of this options should be an anonymous array. This array should hold one anonymous array for each parameter. That array should hold (in order) a parameter name, an initial guess, and optionally an accuracy measure.

Example:

$params = [
[parameter1, 5, 0.00001],
[parameter2, 12, 0.0001 ],
...
];

Then later:
curve_fit(
...
params => $params,
...
);

The accuracy measure means that if the change of parameters from one iteration to the next is below each accuracy measure for each parameter, convergence is assumed and the algorithm stops iterating.

In order to prevent looping forever, you are strongly encouraged to make use of the accuracy measure (see also: maximum_iterations).

The final set of parameters is not returned from the subroutine but the parameters are modified in-place. That means the original data structure will hold the best estimate of the parameters.

xdata

This should be an array reference to an array holding the data for the variable of the function. (Which defaults to x.)

ydata

This should be an array reference to an array holding the function values corresponding to the x-values in xdata.

maximum_iterations

Optional parameter to make the process stop after a given number of iterations. Using the accuracy measure and this option together is encouraged to prevent the algorithm from going into an endless loop in some cases.

The subroutine returns the sum of square residuals after the final iteration as a measure for the quality of the fit.

Lanai Core is a mature OOP framework for building Web, command line, and GUI applications. Lanai Core allows PHP developers to easily integrate and manage code resources and build complex applications quickly.
The compact core framework includes a basic CMS and other modules to help you get started. It features a shallow learning curve, a performance-conscious design, and tight integration with the PEAR libraries.
Lanai Core build in standard modules for build your website :
- Banner allow yout to rotate your banner or agencies banner.
- Contect a simple form mail allow your visitors contact to you via e-mail.
- Download you can publish your file or archive contents by using this.
- F.A.Q. create frequenly ask questions to give more information for your service or support.
- News publish your news or events.
- Poll create simple questionaire.
- RSS feed RSS content to your site.
- SiteMap automatic generate site map for google site map service.
- Syndication automatic content syndication for your visitor.
- Language easy to switch the site interface language.
- Theme change look and feel for your site just click!.
- Logs record visitor behavior and analyze in to graphs.
- and more...

Derbrill Tutorials are Free Tutorials For Writing Games and Multimedia Applications in Runtime Revolution with ArcadeEngine.

The tutorials come in a visually appealing e-book format which is both easy to read and use, the range of topics covered includes:

* The basics of Revolution such as: stacks, cards, scripts, messages and timers
* How to use geometric properties such as distances, angles and intersection rectangles
* Understanding and using different movements including linear, polygonal, circular and elliptic
* Advanced use of images
* Using the built-in collision detection

Keystone is a cross-platform, object oriented application framework which allows applications to be written to build on the target platforms of GNU/Linux and Win32 without modification of their source.
Keystone Application Framework implements several modern Web standards, including SVG graphics and the XUL user interface description language.
Enhancements:
- A significant development in this release is the optional use of the GDI+ (Win32) and CairoGraphics (Linux) rendering backends to render SVG content.
- In addition, support for SVG paths has been much improved with the ability to render bezier and elliptical segments.

Splint is a tool for statically checking C programs for security vulnerabilities and programming mistakes.
Splint does many of the traditional lint checks including unused declarations, type inconsistencies, use before definition, unreachable code, ignored return values, execution paths with no return, likely infinite loops, and fall through cases.
More powerful checks are made possible by additional information given in source code annotations. Annotations are stylized comments that document assumptions about functions, variables, parameters and types.
In addition to the checks specifically enabled by annotations, many of the traditional lint checks are improved by exploiting this additional information.
As more effort is put into annotating programs, better checking results. A representational effort-benefit curve for using Splint is shown in Figure 1.
Splint is designed to be flexible and allow programmers to select appropriate points on the effort-benefit curve for particular projects.
As different checks are turned on and more information is given in code annotations the number of bugs that can be detected increases dramatically.
Problems detected by Splint include:
- Dereferencing a possibly null pointer
- Using possibly undefined storage or returning storage that is not properly defined
- Type mismatches, with greater precision and flexibility than provided by C compilers
- Violations of information hiding
- Memory management errors including uses of dangling references and memory leaks
- Dangerous aliasing
- Modifications and global variable uses that are inconsistent with specified interfaces
- Problematic control flow such as likely infinite loops, fall through cases or incomplete switches, and suspicious statements
- Buffer overflow vulnerabilities
- Dangerous macro implementations or invocations
- Violations of customized naming conventions.

Statistics::ROC is a Perl module with receiver-operator-characteristic (ROC) curves with nonparametric confidence bounds.

SYNOPSIS

use Statistics::ROC;

my ($y) = loggamma($x);
my ($y) = betain($x, $p, $q, $beta);
my ($y) = Betain($x, $p, $q);
my ($y) = xinbta($p, $q, $beta, $alpha);
my ($y) = Xinbta($p, $q, $alpha);
my (@rk) = rank($type, @r);
my (@ROC) = roc($model_type,$conf,@val_grp);

This program determines the ROC curve and its nonparametric confidence bounds for data categorized into two groups. A ROC curve shows the relationship of probability of false alarm (x-axis) to probability of detection (y-axis) for a certain test. Expressed in medical terms: the probability of a positive test, given no disease to the probability of a positive test, given disease. The ROC curve may be used to determine an optimal cutoff point for the test.
The main function is roc(). The other exported functions are used by roc(), but might be useful for other nonparametric statistical procedures.

loggamma

This procedure evaluates the natural logarithm of gamma(x) for all x>0, accurate to 10 decimal places. Stirlings formula is used for the central polynomial part of the procedure. For x=0 a value of 743.746924740801 will be returned: this is loggamma(9.9999999999E-324).

betain

Computes incomplete beta function ratio

Remarks:
Complete beta function: B(p,q)=gamma(p)*gamma(q)/gamma(p+q)
log(B(p,q))=ln(gamma(p))+ln(gamma(q))-ln(gamma(p+q))

Incomplete beta function ratio:
I_x(p,q)=1/B(p,q) * int_0^x t^{p-1}*(1-t)^{q-1} dt

--> log(B(p,q)) has to be supplied to calculate I_x(p,q)
log denotes the natural logarithm
$beta = log(B(p,q))
$x = x
$p = p
$q = q
The subroutine returns I_x(p,q). If an error occurs a negative value
{-1,-2} is returned.

Betain

Computes the incomplete beta function by calling loggamma() and betain().

xinbta

Computes inverse of incomplete beta function ratio

Remarks:

Complete beta function: B(p,q)=gamma(p)*gamma(q)/gamma(p+q)
log(B(p,q))=ln(gamma(p))+ln(gamma(q))-ln(gamma(p+q))

Incomplete beta function ratio:
alpha = I_x(p,q) = 1/B(p,q) * int_0^x t^{p-1}*(1-t)^{q-1} dt

--> log(B(p,q)) has to be supplied to calculate I_x(p,q)
log denotes the natural logarithm
$beta = log(B(p,q))
$alpha= I_x(p,q)
$p = p
$q = q
The subroutine returns x. If an error occurs a negative value {-1,-2,-3}
is returned.

Xinbta

Computes the inverse of the incomplete beta function by calling loggamma() and xinbta().

rank

Computes the ranks of the values specified as the second argument (an array). Returns a vector of ranks corresponding to the input vector. Different types of ranking are possible (high, low, mean), and are specified as first argument. These differ in the way ties of the input vector, i.e. identical values, are treated:

high:

replace ranks of identical values with their highest rank

low:

replace ranks of identical values with their lowest rank

mean:

replace ranks of identical values with the mean of their ranks

roc

Determines the ROC curve and its nonparametric confidence bounds. The ROC curve shows the relationship of "probability of false alarm" (x-axis) to "probability of detection" (y-axis) for a certain test. Or in medical terms: the "probability of a positive test, given no disease" to the "probability of a positive test, given disease". The ROC curve may be used to determine an "optimal" cutoff point for the test.

The routine takes three arguments:

(1) type of model: decrease or increase, this states the assumption that a higher (increase) value of the data tends to be an indicator of a positive test result or for the model decrease a lower value.
(2) two-sided confidence interval (usually 0.95 is chosen).
(3) the data stored as a list-of-lists: each entry in this list consits of an "value / true group" pair, i.e. value / disease present. Group values are from {0,1}. 0 stands for disease (or signal) not present (prior knowledge) and 1 for disease (or signal) present (prior knowledge). Example: @s=([2, 0], [12.5, 1], [3, 0], [10, 1], [9.5, 0], [9, 1]); Notice the small overlap of the groups. The optimal cutoff point to separate the two groups would be between 9 and 9.5 if the criterion of optimality is to maximize the probability of detection and simultaneously minimize the probability of false alarm.

Returns a list-of-lists with the three curves: @ROC=([@lower_b], [@roc], [@upper_b]) each of the curves is again a list-of-lists with each entry consisting of one (x,y) pair.

Examples:

$,=" ";
print loggamma(10), "n";
print Xinbta(3,4,Betain(.6,3,4)),"n";

@e=(0.7, 0.7, 0.9, 0.6, 1.0, 1.1, 1,.7,.6);
print rank(low,@e),"n";
print rank(high,@e),"n";
print rank(mean,@e),"n";

@var_grp=([1.5,0],[1.4,0],[1.4,0],[1.3,0],[1.2,0],[1,0],[0.8,0],
[1.1,1],[1,1],[1,1],[0.9,1],[0.7,1],[0.7,1],[0.6,1]);
@curves=roc(decrease,0.95,@var_grp);
print "$curves[0][2][0] $curves[0][2][1] n";

Concepts project is a C++ class library for solving elliptic partial differential equations (PDEs) numerically.

The design principle is the transfer of mathematical objects and grammar used to specify mathematical and numerical models of physical systems isomorphically into simulation software.

The design realization uses the C++ functionality of inheritance and derived classes.