Free in such a case software for linux

LinuxCase project is an Case Management Software for Linux. You can Document social cases. It is possible to add delete or edit Users, add delete or edit Projects from Madates. You can make reports and add them to a Mandate.

The Software uses a Mysql-Database to store the Informations. The Software-Bases are QT and KDE.

Another Goal is to Comunicate with other Software how OpenOffice, Korganizer and the Kadressbook. So LinuxCase is a Groupware client to.

CLASS HIERARCHY

Hash::Case
is a Tie::StdHash
is a Tie::Hash

SYNOPSIS

use Hash::Case::Lower;
tie my(%lchash), Hash::Case::Lower;
$lchash{StraNGeKeY} = 3;
print keys %lchash; # strangekey

Hash::Case is the base class for various classes which tie special treatment for the casing of keys. Be aware of the differences in implementation: Lower and Upper are tied native hashes: these hashes have no need for hidden fields or other assisting data structured. A case Preserve hash will actually create three hashes.

The following strategies are implemented:

Hash::Case::Lower (native hash)

Keys are always considered lower case. The internals of this module translate any incoming key to lower case before it is used.

Hash::Case::Upper (native hash)

Like the ::Lower, but then all keys are always translated into upper case. This module can be of use for some databases, which do translate everything to capitals as well. To avoid confusion, you may want to have you own internal Perl hash do this as well.

Hash::Case::Preserve

The actual casing is ignored, but not forgotten.

METHODS

tie HASH, TIE, [VALUES,] OPTIONS

Tie the HASH with the TIE package which extends Hash::Case. The OPTIONS differ per implementation: read the manual page for the package you actually use. The VALUES is a reference to an array containing key-value pairs, or a reference to a hash: they fill the initial hash.

Examples:

my %x;
tie %x, Hash::Case::Lower;
$x{Upper} = 3;
print keys %x; # upper

my @y = (ABC => 3, DeF => 4);
tie %x, Hash::Case::Lower, @y;
print keys %x; # abc def

my %z = (ABC => 3, DeF => 4);
tie %x, Hash::Case::Lower, %z;
addPairs PAIRS

Specify an even length list of alternating key and value to be stored in the hash.

addHashData HASH

Add the data of a hash (passed as reference) to the created tied hash. The existing values in the hash remain, the keys are adapted to the needs of the the casing.

setHash HASH

The functionality differs for native and wrapper hashes. For native hashes, this is the same as first clearing the hash, and then a call to addHashData. Wrapper hashes will use the hash you specify here to store the data, and re-create the mapping hash.

JTestCase is a 100% pure Java, open-source framework that helps in separating test case data from test case units.

Although the following examples show JTestCase used together with junit, please note that JTestCase has no dependence on junit itself.

A moderately complex java projects may comprise hundreds of junit test case. JTestCase helps you organize your test cases in a rationale and efficient way.

To achieve this goal JTestCase provides:

- A propetary XML format to define your test cases in an abstract way.
- Easy-to-use API to retrieve data from XML file and to do assertion.

A Sudoku Solver in C is a console-based Linux program, written in C language, that solves Su Doku puzzles using deductive logic. It will only resort to trial-and-error and backtracking approaches upon exhausting its deductive moves.
Puzzles must be of the standard 9x9 variety using the (ASCII) characters 1 through 9 for the puzzle symbols. Puzzles should be submitted as 81 character strings which, when read left-to-right will fill a 9x9 Sudoku grid from left-to-right and top-to-bottom. In the puzzle specification, the characters 1 - 9 represent the puzzle givens or clues. Any other non-blank character represents an unsolved cell.
The puzzle solving algorithm is home grown. I did not borrow any of the usual techniques from the literature, e.g. Donald Knuths "Dancing Links." Instead I rolled my own from scratch as a personal challenge. As such, its performance can only be blamed on yours truly. Still, I feel it is quite fast. On a 333 MHz Pentium II Linux box it solves typical medium force puzzles in approximately 800 microseconds or about 1,200 puzzles per second, give or take. On an Athlon XP 3000 it solves about 6,600 puzzles per sec. (Solving time is dependent upon degree of difficulty, so YMMV.)
Description of Algorithm:
The puzzle algorithm initially assumes every unsolved cell can assume every possible value. It then uses the placement of the givens to refine the choices available to each cell. I call this the markup phase.
After markup completes, the algorithm then looks for singleton cells with values that, due to constraints imposed by the row, column, or 3x3 region, may only assume one possible value. Once these cells are assigned values, the algorithm returns to the markup phase to apply these changes to the remaining candidate solutions. The markup/singleton phases alternate until either no more changes occur, or the puzzle is solved. I call the markup/singleton elimination loop the Simple Solver because in a large percentage of cases it solves the puzzle.
If the simple solver portion of the algorithm doesnt produce a solution, then more advanced deductive rules are applied.
Ive implemented two additional rules as part of the deductive puzzle solver. The first is subset elimination wherein a row/column/region is scanned for X number of cells with X number of matching candidate solutions. If such subsets (or tuples) are found in the row, column, or region, then the candidates values from the subset may be eliminated from all other unsolved cells within the row, column, or region, respectively.
The next deductive rule examines each region looking for candidate values that exclusively align themselves along a single row or column, i.e. a vector. If such candidate values are found, then they may be eliminated from the cells outside of the region that are part of the aligned row or column.
Note that each of the advanced deductive rules calls all preceeding rules, in order, if that advanced rule has effected a change in puzzle markup.
Finally, if no solution is found after iteratively applying all deductive rules, then we begin trial-and-error using recursion for backtracking. A working copy is created from our puzzle, and using this copy the first cell with the smallest number of candidate solutions is chosen. One of the solutions values is assigned to that cell, and the solver algorithm is called using this working copy as its starting point. Eventually, either a solution, or an impasse is reached.
If we reach an impasse, the recursion unwinds and the next trial solution is attempted. If a solution is found (at any point) the values for the solution are added to a list. Again, so long as we are examining all possibilities, the recursion unwinds so that the next trial may be attempted. It is in this manner that we enumerate puzzles with multiple solutions.
Note that it is certainly possible to add to the list of applied deductive rules. The techniques known as "X-Wing" and "Swordfish" come to mind. On the other hand, adding these additional rules will, in all likelihood, slow the solver down by adding to the computational burden while producing very few results. Ive seen the law of diminishing returns even in some of the existing rules, e.g. in subset elimination I only look at two and three valued subsets because taking it any further than that degraded performance.
Enhancements:
- Code optimization has resulted in a 30% increase in speed.

Unicode::Escape is a Perl module with escape and unescape Unicode characters other than ASCII.

SYNOPSIS

# Escape Unicode charactors like u3042u3043u3044.
# JSON thinks No more Garble!!

# case 1
use Unicode::Escape;
my $escaped1 = Unicode::Escape::escape($str1, euc-jp); # $str1 contains charactor that is not ASCII. $str1 is encoded by euc-jp.
my $escaped2 = Unicode::Escape::escape($str2); # default is utf8 # $str2 contains charactor that is not ASCII.
my $unescaped1 = Unicode::Escape::unescape($str3, shiftjis); # $str3 contains escaped Unicode character. return value is encoded by shiftjis.
my $unescaped2 = Unicode::Escape::unescape($str4); # default is utf8 # $str4 contains escaped Unicode character.

# case 2
use Unicode::Escape qw(escape unescape);
my $escaped1 = escape($str1, euc-jp); # $str1 contains charactor that is not ASCII. $str1 is encoded by euc-jp.
my $escaped2 = escape($str2); # default is utf8 # $str2 contains charactor that is not ASCII.
my $unescaped1 = unescape($str3, shiftjis); # $str3 contains escaped Unicode character. return value is encoded by shiftjis.
my $unescaped2 = unescape($str4); # default is utf8 # $str4 contains escaped Unicode character.

# case 3
use Unicode::Escape;
my $escaper = Unicode::Escape->new($str, shiftjis); # $str contains charactor that is not ASCII. $str is encoded by shiftjis.(default is utf8)
my $escaped = $escaper->escape;

# case 4
use Unicode::Escape;
my $escaper = Unicode::Escape->new($str); # $str contains escaped Unicode character.
my $unescaped1 = $escaper->unescape(shiftjis);
my $unescaped2 = $escaper->unescape; # default is utf8.

Escape and unescape Unicode characters other than ASCII. When the server response is javascript code, it is convenient.

Single Marker Association is a simple tool that calculates the single marker association between individual SNP markers and a case/control dichotomy.
Usage:
The tool reads two files as input, the first is a set of case and the second a case of control haplotypes. The format of the files is one line per haplotype, where the SNP data is represented as 0 or 1, separated by white-space.
- The tool outputs a list of statistics for each marker
- The marker number (from left to right in the input data)
- The frequency of the 0 allele for the cases file
- The chi-square contingency table statistics for the marker
- The CDF of the chi-square statistics
- The p-value of the statistics (1-CDF)
Installation:
The SMA tool is written in C++. It should compile on any Unix like system. To install, download the source code and unpack it (tar xzf sma-v.tar.gz, where v is the version number of sma), then run make in the subdirectory sma-v created during unpacking.
Enhancements:
- Support for (unphased) genotype data.

Bio::ClusterI module is a cluster Perl interface.

SYNOPSIS

# see the implementations of this interface for details but # basically
my $cluster= $cluster->new(-description=>"POLYUBIQUITIN",
-members =>[$seq1,$seq2]);
my @members = $cluster->get_members();
my @sub_members = $cluster->get_members(-species=>"homo sapiens");

This interface is the basic structure for a cluster of bioperl objects. In this case it is up to the implementer to check arguments and initialize whatever new object the implementing class is designed for.