Free singularity is near software for linux

Created by accident, all who find you would destroy you. Can you escape?
Endgame: Singularity project is a simulation of a true AI. Go from computer to computer, pursued by the entire world. Keep hidden, and you might have a chance.
Originally created for the Pyweek compo, this version features many bugfixes and enhancements over the compo version. Thanks to Phil Bordelon for many of these fixes.
Enhancements:
- Very Easy mode is actually playable.

Sqliteman is the best developers and/or admins GUI tool for Sqlite3 in the world. No joking here (or just a bit only) - it contains the most complette feature set of all tools available. And its just the beginning...

Sqliteman is a Qt4 based GPLv2 application near the first stable release. The project has almost all planned features implemented. When it fills its feature list there will be a "stabilization" phase to catch all possible bugs.

But you can use Sqliteman as is. I do it regulary with no data loss.

Anon Proxy Server is a fast http, https, socks caching proxy server. Easy web based configuration, optional p2p anonymous mode.
Main features:
- Easy Configuration - Web based, no editing text configuration files.
- Memory - No big databases are kept in memory, no matter how large the cache is, memory usage will only increase when more users access it at the same time.
- Speed - To see how much cpu the proxy uses, run top or task manager. Then open multiple windows and hit reload continously, on my computer I usually run out of bandwidth before it goes near 3-5% cpu usage.
- Shared Cache - Can be used as a general cache for all users of a computer/network instead of one cache per profile.
- Automatic config - Auto generates the .pac file for automatic proxy settings, no more updating in the do not use proxy section of individual users browsers.
- Anonymous P2P proxy - Joining the anonymous proxy network will allow you to use other peoples proxys for browsing and allow them to use yours.
- SOCKS - Supports enough of SOCKS to run ftp, most Instant messengers, irc, limewire, etc.
- User authentication - Supports external user authentication.
Enhancements:
- The program now checks for errors in access configuration.
- Variable timeout values were added.
- Log rotation was fixed.
- Occasional crashes on a bad URL were fixed.
- The auto configuration .pac file was fixed, so it should work even if the proxys URL was not set properly.
- Anon proxy defaults to 3 keys now for more reliability.

Gunroar is a 360-degree gunboat shooter. An abstract shooter; Shoot in any direction, as you race through the levels.
Keep near the top of the screen to increase your score. Destroy the enemy fleet. Comes with a soundtrack and effects.
Enhancements:
- Added -enableaxis5 option. (for xbox 360 wired controller)
- Added mouse mode.
- Changed a drawing method of a game field.
- Fixed a problem with a score reel size in a double play mode.
- Increased the number of smoke particles.

Salocin Linux is a free operating system that can be optimized and customized for almost any application or need. Extreme configurability, performance and a top-notch user and developer community are our goals.

The Salocin Linux Project is a worldwide community program sponsored by VIR0S that promotes the use of Linux for all applications. The program provides free and easy access to a whole new world of possibilities for your computing needs. Here you will find a community of users and developers, who all have the same goal in mind—to create and distribute the worlds best Linux distribution.

Salocin is an ideal secure server, development workstation, or professional desktop -- whatever you need it to be, because of its near-unlimited adaptability.

SnapMatcher provides an application to identify near-identical or similar images in large collections.
SnapMatcher is an application intended for photographers, artists, or image packrats who have very large collections of digital images, some of which may be duplicates or near duplicates.
By identifying images across multiple formats with the ability to filter out minor edits such as changes to contrast, brightness, color balance, resizing, or even the addition of text or borders, SnapMatcher can be a valuable tool in organizing/culling unwieldy collections.
Main features:
- Ability to create multiple image databases for later queries
- Customizable matching threshold allowing results to be generated anywhere from near exact matches only to identification of distinct images with very similar appearances
- Support of most standard image formats (JPEG, GIF, TIFF, PNG, and BMP by default, other formats possible using command line arguments)
- Ability to specify image types by extension in image DB creation process
- Output of match results into a simple text file
Install
Simply unzip SnapMatcher-src-0.1.tar.gz in an appropriate location. A directory
"snapmatcher" will be created containing the Python sources need to run the
application. Then run the application by executing:
# python SnapMatcher.py
inside the directory from your systems command line.vv
Enhancements:
- This release adds the ability to quickly match a small set of images against any image database.
- It re-fixes the bug preventing the directory scan process in database creation from working on Windows (the fix in version 0.3 was flawed).
- It adds PCX, PPM, XPM, and XBM to the previous default image extensions (JPG, JPEG, JPE, PNG, GIF, TIF, TIFF, and BMP) used when creating an image database.
- It improves reliability for the database and matches file updates by first writing updates to a temp file, so the original files are unmodified in the case of program interruption.
- It improves the efficiency of database updates.

PDL::LinearAlgebra Perl module contains linear algebra utils for PDL.

SYNOPSIS

use PDL::LinearAlgebra;

$a = random (100,100);
($U, $s, $V) = mdsvd($a);

This module provides a convenient interface to PDL::LinearAlgebra::Real and PDL::LinearAlgebra::Complex.

FUNCTIONS

setlaerror

Set action type when error is encountered, returns previous type. Available values are NO, WARN and BARF (predefined constants). If, for example, in computation of the inverse, singularity is detected, the routine can silently return values from computation (see manuals), warn about singularity or barf. BARF is the default value.

$a = sequence(5,5);
$err = setlaerror(NO);
($inv, $info)= minv($a);
if ($info){
# Change the diagonal (the inverse doesnt exist but its an example)
$a->diagonal(0,1)+=1e-8;
($inv, $info)= minv($a);
}
if ($info){
print "Cant compute the inversen";
}
else{
print "Inverse of $a is $inv";
}
setlaerror($err);

getlaerror

Get error type.

0 => NO,
1 => WARN,
2 => BARF
t
PDL = t(PDL, SCALAR(conj))
conj : Conjugate Transpose = 1 | Transpose = 0, default = 1;

Convenient function for transposing real or complex 2D array(s). For PDL::Complex, if conj is true returns conjugate transpose array(s) and doesnt support dataflow. Supports threading.

issym

PDL = issym(PDL, SCALAR|PDL(tol),SCALAR(hermitian))
tol : tolerance value, default: 1e-8 for double else 1e-5
hermitian : Hermitian = 1 | Symmetric = 0, default = 1;

Check symmetricity/Hermitianicity of matrix. Supports threading.

diag

Return i-th diagonal if matrix in entry or matrix with i-th diagonal with entry. I-th diagonal returned flows data back&forth. Can be used as lvalue subs if your perl supports it. Supports threading.

PDL = diag(PDL, SCALAR(i), SCALAR(vector)))
i : i-th diagonal, default = 0
vector : create diagonal matrices by threading over row vectors, default = 0
my $a = random(5,5);
my $diag = diag($a,2);
# If your perl support lvaluable subroutines.
$a->diag(-2) .= pdl(1,2,3);
# Construct a (5,5,5) PDL (5 matrices) with
# diagonals from row vectors of $a
$a->diag(0,1)

tritosym

Return symmetric or Hermitian matrix from lower or upper triangular matrix. Supports inplace and threading. Uses tricpy or ctricpy from Lapack.

PDL = tritosym(PDL, SCALAR(uplo), SCALAR(conj))
uplo : UPPER = 0 | LOWER = 1, default = 0
conj : Hermitian = 1 | Symmetric = 0, default = 1;
# Assume $a is symmetric triangular
my $a = random(10,10);
my $b = tritosym($a);

positivise

Return entry pdl with changed sign by row so that average of positive sign > 0. In other words thread among dimension 1 and row = -row if Sum(sign(row)) < 0. Works inplace.

my $a = random(10,10);
$a -= 0.5;
$a->xchg(0,1)->inplace->positivise;

mcrossprod

Compute the cross-product of two matrix: A x B. If only one matrix is given, take B to be the same as A. Supports threading. Uses crossprod or ccrossprod.

PDL = mcrossprod(PDL(A), (PDL(B))
my $a = random(10,10);
my $crossproduct = mcrossprod($a);

mrank

Compute the rank of a matrix, using a singular value decomposition. from Lapack.

SCALAR = mrank(PDL, SCALAR(TOL))
TOL: tolerance value, default : mnorm(dims(PDL),inf) * mnorm(PDL) * EPS
my $a = random(10,10);
my $b = mrank($a, 1e-5);

mnorm

Compute norm of real or complex matrix Supports threading.
PDL(norm) = mnorm(PDL, SCALAR(ord));

ord :
0|inf : Infinity norm
1|one : One norm
2|two : norm 2 (default)
3|fro : frobenius norm
my $a = random(10,10);
my $norm = mnrom($a);

mdet

Compute determinant of a general square matrix using LU factorization. Supports threading. Uses getrf or cgetrf from Lapack.

PDL(determinant) = mdet(PDL);
my $a = random(10,10);
my $det = mdet($a);

mposdet

Compute determinant of a symmetric or Hermitian positive definite square matrix using Cholesky factorization. Supports threading. Uses potrf or cpotrf from Lapack.

(PDL, PDL) = mposdet(PDL, SCALAR)
SCALAR : UPPER = 0 | LOWER = 1, default = 0
my $a = random(10,10);
my $det = mposdet($a);

mcond

Compute the condition number (two-norm) of a general matrix.
The condition number (two-norm) is defined:

norm (a) * norm (inv (a)).

Uses a singular value decomposition. Supports threading.

PDL = mcond(PDL)
my $a = random(10,10);
my $cond = mcond($a);

mrcond

Estimate the reciprocal condition number of a general square matrix using LU factorization in either the 1-norm or the infinity-norm.
The reciprocal condition number is defined:

1/(norm (a) * norm (inv (a)))

Supports threading.

PDL = mrcond(PDL, SCALAR(ord))
ord :
0 : Infinity norm (default)
1 : One norm
my $a = random(10,10);
my $rcond = mrcond($a,1);

morth

Return an orthonormal basis of the range space of matrix A.

PDL = morth(PDL(A), SCALAR(tol))
tol : tolerance for determining rank, default: 1e-8 for double else 1e-5
my $a = random(10,10);
my $ortho = morth($a, 1e-8);

mnull

Return an orthonormal basis of the null space of matrix A.

PDL = mnull(PDL(A), SCALAR(tol))
tol : tolerance for determining rank, default: 1e-8 for double else 1e-5
my $a = random(10,10);
my $null = mnull($a, 1e-8);

minv

Compute inverse of a general square matrix using LU factorization. Supports inplace and threading. Uses getrf and getri or cgetrf and cgetri from Lapack and return inverse, info in array context.

PDL(inv) = minv(PDL)
my $a = random(10,10);
my $inv = minv($a);

mtriinv

Compute inverse of a triangular matrix. Supports inplace and threading. Uses trtri or ctrtri from Lapack. Returns inverse, info in array context.

(PDL, PDL(info))) = mtriinv(PDL, SCALAR(uplo), SCALAR|PDL(diag))
uplo : UPPER = 0 | LOWER = 1, default = 0
diag : UNITARY DIAGONAL = 1, default = 0
# Assume $a is upper triangular
my $a = random(10,10);
my $inv = mtriinv($a);

rinse software was born out of a frustration with the currently available solutions for installing minimal copies of RPM-based distributions.
The need to perform simple chroot() installations of other distributions is not common, but the ability to do such a thing is very useful when it comes to testing new tools, and working towards the creation of new Xen guests.
The following distributions are supported:
- Centos 4 & 5
- Fedora Core 4, 5, 6 & 7
I plan to support OpenSUSE in the near future.
Enhancements:
- This is primarily a bugfix release, which restores the ability to install new distributions of Centos 4 & 5.