Free kernels baseball software for linux

NetStats Baseball project consists of a simulation of major league baseball.
NetStats Baseball is a simulation of major league baseball which will play single games and entire seasons.
It will keep statistics for the individual players and the teams. It will keep track of the season schedule as well as seasonal and lifetime records.
Enhancements:
- Separate two compound assignments where x and x++ were used; this technically isnt well-defined in C and could cause portability problems
- Fix a call of strncpy() to strcpy()
- Remove prototypes for string.h functions in editdata/glob.h; replace with an include of the standard header (causes potential portability problems since these arent declared the same way on all systems)
- correct possible segfault after the welcome screen
- code cleanup
- include current half inning on game-play display
- no parameters now acceptable with client (playbb) ..in this case client connects to localhost
- "help" is printable
- real-life season results are available
- implement autoconf

xlike Kernel Patchset is a patch collection for the Linux vanilla kernel. The project includes as many stable enhancements for the Linux kernel as possible.
These include code from Kernel Mode Linux, Rule Set Based Access Control, Novell AppArmor, Openswan, grsecurity, Linux VServer, Ndiswrapper, web100, Nefilters, Suspend2, Speakup, Amiga Smart File System, Cdemu, SquashFS, fbsplash, QuadDSP, and more. It also contains many drivers and fixes.
Enhancements:
- This version was updated to patch against Linux 2.6.20.
- User Mode Linux with Linux-PHC, LinuxIMQ, Web100, WANPIPE, WRR, ReiserFS4, SquashFS, UnionFS, Bootsplash, and Kernel Color Output were added.

Games::Baseball::Scorecard is a Perl module.

SYNOPSIS

my $score = Games::Baseball::Scorecard->new($dir, $name, {
color => [ .4, .4, .4 ], # grey
fonts => [ # Myriad Condensed regular/bold
[ myriadrcrrl => 9 ],
[ myriadrcbrl => 14 ],
[ myriadrcrrl => 14 ],
[ myriadrcbrl => 22 ],
],
});

# fill initial scorecard out
$s->init({
scorer => Pudge,
date => 2004-10-24, 20:05-23:25,
at => Fenway Park, Boston,
temp => 48 clear,
wind => 7 to RF,
att => 35,001,
home => {
team => Boston Red Sox,
starter => 38, # jersey number
lineup => [
# [ num, position ],
[ 18, 8 ], # Damon, starting at CF
# ...
],
roster => {
# num => name
18 => Damon, Johnny,
38 => Schilling, Curt,
# ...
},
},
away => {
team => St. Louis Cardinals,
# ...
}
});

# draw the game
$s->inn; # new inning / end of last inning

$s->ab; # new at-bat
# works to full count
$s->pitches(qw(s b s b b f));
# struck out looking
$s->out(!K);

$s->ab;
# home run to left-center
$s->hit(4, lc);

# calculate/draw stats
$self->totals;

# finish the job
$s->generate;

# open final PDF
$s->pdfopen;

Games::Baseball::Scorecard is a frontend to a PDF scorecard written in Metapost by Christopher Swingley (http://www.frontier.iarc.uaf.edu/~cswingle/baseball/scorecards.php). That scorecard is drawn out, and has a nice API for actually drawing out the elements of the game: all the ball, strikes, outs, etc.

Being Metapost, it is laborious to do all this. So this module provides a nice frontend, that also keeps track of balls and strikes and hits and runs and outs and more, making input of the game quite simple and efficient.

This module does not include the entire API, but most of it. Patches and ideas welcome. Feel free to call output directly if you want to generate Metapost on your own, or to modify the $SCORECARD variable (which contains the base Metapost code), or the $TEX (single page) and $TEXD (duplex) TeX files.

I wont give a tutorial on scoring baseball games, or on Metapost, below. Seek other resources (Swingleys URL above has a nice tutorial on scoring baseball games, using the scorecard he designed, which is what were using here).

POE::Kernel is an event driven threaded application kernel in Perl.

SYNOPSIS

POE comes with its own event loop, which is based on select() and written entirely in Perl. To use it, simply:

use POE;

POE can adapt itself to work with other event loops and I/O multiplex systems. Currently it adapts to Gtk, Tk, Event.pm, or IO::Poll when one of those modules is used before POE::Kernel.

use Gtk; # Or Tk, Event, or IO::Poll;
use POE;

or

use POE qw(Loop::Gtk);

or

use POE::Kernel { loop => "Gtk" };
use POE::Session;

Methods to manage the process global Kernel instance:

# Retrieve the kernels unique identifier.
$kernel_id = $kernel->ID;

# Run the event loop, only returning when it has no more sessions to
# dispatch events to. Supports two forms.
$poe_kernel->run();
POE::Kernel->run();

FIFO event methods:

# Post an event to an arbitrary session.
$kernel->post( $session, $event, @event_args );

# Post an event back to the current session.
$kernel->yield( $event, @event_args );

# Call an event handler synchronously. Bypasses POEs event queue
# and returns the handlers return value.
$handler_result = $kernel->call( $session, $event, @event_args );

Original alarm and delay methods:

# Post an event which will be delivered at a given Unix epoch time.
# This clears previous timed events with the same state name.
$kernel->alarm( $event, $epoch_time, @event_args );

# Post an additional alarm, leaving existing ones in the queue.
$kernel->alarm_add( $event, $epoch_time, @event_args );

# Post an event which will be delivered after a delay, specified in
# seconds hence. This clears previous timed events with the same
# name.
$kernel->delay( $event, $seconds, @event_args );

# Post an additional delay, leaving existing ones in the queue.
$kernel->delay_add( $event, $seconds, @event_args );

Rule Set Based Access Control (RSBAC) is a Free Software security extension for current Linux kernels. Rule Set Based Access Control is based on the Generalized Framework for Access Control (GFAC) by Abrams and LaPadula and provides a flexible system of access control based on several modules.
All security relevant system calls are extended by security enforcement code. This code calls the central decision component, which in turn calls all active decision modules and generates a combined decision. This decision is then enforced by the system call extensions.
Main features:
- Free Open Source (GPL) Linux kernel security solution
- Independent of governments and big companies
- Several well-known and new security models, like MAC, ACL and RC
- On-access virus scanning with the Dazuko interface
- Detailed control over individual user and program network accesses
- Fully access controlled kernel level user management
- Any combination of security models possible
- Easily extensible: write your own model for runtime registration
- Support for latest kernels and stable for production use
Enhancements:
- This release relates to kernel 2.4.34.5 and 2.6.22.1.
- There are important fixes with some compilation errors and an important bug with User Management password hashing, introduced with the newer 2.6 kernel crypto API.
- Some security has been added with safety measures against null pointers.

Install Kernel interfaces with the Linux operating system by running a series of functions or groups of commands that automate the compiling or recompiling and installation process.
Install Kernel project consists of three groups of functions: building the kernel and moving files, checking dependencies, and editing the boot loader configuration file. Grouping all of the functions in these three groups makes maintaining and altering the script much easier.
Install Kernel can also be considered a program, because a program does checking and makes choices accordingly. A script is usually a file, which contains a certain number of commands with no logic in mind. Therefore, while ik is technically a script, it can also be called a program.
Dependency checks are to make sure the current system configuration and settings are properly setup before proceeding with the kernel build. There are seven dependency checks, they are: a root check, space check, link check, boot check, boot loader check, configuration check, and a module check.
First, the root check makes sure the user is a super user; which means they are capable of editing important system files only accessible to the root account. The space check makes sure there is at least 200 megabytes available.
The kernel source these days is around 150 megabytes just for the source code. When one compiles the kernel, it may increase the size to 50 megabytes or more. Therefore, ik
checks for at least 200MB available in order to successfully compile the kernel without running out of space. Next, it is not required, but it is standard to have a symbolic link of /usr/src/linux pointing to /usr/src/linux-x.y.z.
The fourth check makes sure the user has a /boot directory, this is where the Linux kernel files will be installed to. The fifth check determines the bootloader that will be used. There are two main boot loaders in Linux. LILO and GRUB are the two most popular for booting the operating system.
This check accurately finds whether the kernel was booted from either LILO or GRUB by checking which bootloader was used last. It then tells the rest of the script to edit the correct one accordingly. The sixth configuration check is to make sure users have created a proper kernel configuration file, which is used in the process of building the Linux kernel.
The final check is a module check, if modules are turned off, the script will determine this and alter the installation process to install with no module support. The main idea behind the depdency checks is to make sure the user cannot damage his or her system if they do not do something right.
The installation process also contains seven functions. The installation process is usually several commands. However, because of the differences that can occur in a users configuration file, each part of the building process must be checked and the building process may need to be altered.
The first function makes sure the dependencies are setup correctly for all files in the kernel source tree. The second function deletes stale object files and or old kernel files. Next, the third function is the kernel build function; this function runs a command to build the Linux kernel. Next, functions four and five make and install modules if the user had specified module support in his or her kernel configuration file.
The sixth function moves the Linux kernel and its System dependency map to the boot partition. The last function of the build process sets up module dependencies for the new kernel if modules were defined. The installation process also includes a small error check for each part of the kernel build process.
If any part of the kernel build process fails; the script will abort, not modifying any boot loader configuration files. This is important; because if it did not abort, it may alter the boot loader configuration files, thus rendering the system unbootable. It is important to support every Linux configuration possible because of the wide use of this script.
The boot loader configuration and setup process is probably the most important aspect of installing a new kernel. An improper boot loader configuration may leave one with system that does not boot; or simply does not boot the new kernel.
It is also important, as some systems may have two or more boot loaders installed. There are four functions defined for this process. The first function uses the boot loader, which was defined during the configuration checks. The second function defines where the LILO or GRUB configuration files are located.
Next, depending on which boot loader is found, either LILO or GRUB configuration files are edited automatically by sed. Sed is a stream editor, which edits a file with no user intervention. If user intervention were required, the user would have to be present between certain parts of the kernel installation. With ik, it makes efficient use of a users time because only one command needs to be entered to complete the entire installation and setup process.
Install Kernel is a useful tool for those who are new to Linux, rebuild their kernel often, or value their time. It reduces the commands for installing the kernel from about thirteen to one. Users new to Linux may find this attractive.
This is because the entire process is automated; and if something is not correct, in most cases ik will notify the user what is incorrect, and how to fix the error. On the other side, for experienced users who do not wish to spend valuable time installing a new kernel, this is also very handy. Install Kernel is efficient by requiring no user intervention and reducing time spent on kernel installs, and effective by giving new to Linux the option for an easy kernel upgrade.
Enhancements:
- Updated to work with the newer version of coreutils for head and tail.
- The MAKE_JOBS directive has been removed in favor of make -j2 to prevent make from spawning hundreds of jobs if /proc/cpuinfo did not exist.

Kernel Version Monitor is a Superkaramba theme that creates a widget displaying the current version information of the Linux kernel as put forth by the kernel.org RSS feed here: http://kernel.org/kdist/rss.xml . Kernel Version Monitor uses the Tux icon from the nuoveXT icon theme found at http://nuovext.pwsp.net

Kudos and thanks to Richard "Ricardo" Szlachta for his advice on refining the aesthetics of this theme.

This is my first Superkaramba theme and a work in progress. I would love to hear comments, opinions and suggestions in order to improve this theme.

Baseball::Sabermetrics is a baseball statistics module.

SYNOPSIS

Baseball::Sabermetrics provides an easy interface for calculating baseball statistics, given a data importer. In this package, Ive written CPBL.pm for (Chinese Professional Baseball League, http://www.cpbl.com.tw).

use Baseball::Sabermetrics;
use Baseball::Sabermetrics::CPBL;

my $league = Baseball::Sabermetrics->new(league => CPBL);

# Actually these are predefined.
# Those data with p_ or _allowed here are for seperating pitchers
# and batters.

$league->define(
rc => ab * obp,
babip => (h_allowed - hr_allowed) / (p_pa - h_allowed - p_so - p_bb - hr_allowed,
# what started with $ will be reserved.
# Players have team and league predefined, and team has league.
formula1 => hr / $_->team->hr;
formula2 => hr / $_->league->hr;
complex => sub {
print "You can write a sub directlyn";
$_->slg - $_->ba;
},
...
);

# Some formulas can be applied to players, teams, and league, depend on what
# columns are used in the formula. For example, ab and obp are defined for
# players, teams, and league, so that rc is available for all of them.

# top 5 obp of teams
$_->print qw/ team name ba obp slg isop / for $league->top(teams, 5, obp);

# top 10 obp of players
$_->print qw/ team name ba obp slg isop / for $league->top(players, 10, obp);

# show a players information
$league->players(Chien-Ming Wang)->print qw/ win lose ip so bb whip go_ao /;
$league->teams(Yankees)->players(Chien-Ming Wang)->print qw/ win lose ip so bb whip go_ao /;

# show team statistics data (accumulated from players)
$league->{Yankees}->print qw/ win lose ip so bb whip go_ao /;

# give a brief report for pitchers/batters of the team
$league->{Yankees}->report_pitchers qw/ name ip p_so p_bb whip go_ab /;
$league->{Yankees}->report_batters qw/ name ba obp slg isop /;

$league->report_teams qw/ name win lose era obp /;

# show all available formula
print join , $league->formula_list;

Data Structure

Baseball::Sabermetrics is aimed for providing a base class of your interested teams (a league, for example). Youll need to provide a data retriever to pull data out. The following example shows how you have to fill data into this structure.

$league = {
teams => {
Yankees => {
players => {
"Chien-Ming Wang" => {
bio => {
bats => right, # coule be left, switch
throws => right,
},
ip => 57.33333333333,
game => 9,
...
fielding => {
p => {
tc => 43,
pop => 4,
...
},
# b1 => { }, b2 => { }, b3 => { },
# first, second and thrid baseman should be
# b1, b2, and b3 respectively for convenient in
# fielding context. Because the initial of the
# name of subroutine cant be a number in perl.
},
};
...
}
},
Athletics => {
...
},
},
};

TERMS

Available terms of players (including teams and league, which are accumulated from players and could be treated as an abstract player) are:

# pitching
p_game win lose tie gs sv bs hld cg sho ip p_pa np h_allowed
hr_allowed sh_allowed sf_allowed p_bb p_ibb hb p_so wp bk ra er

# batting
pa ab rbi r h 1b 2b 3b hr tb dp sh sf ibb bb hbp so sb cs
tc po a e f_dp ppo tp pb c_cs c_sb

# fielding
pos fgame tc po a e f_dp tp pb c_cs c_sb

And there are additional terms for team:

game win lose tie