Free delayed shutdown 1.11 software for linux

Shatranj is an bitboard-based, Open-Source, interactive chess programming module which allows manipulation of chess positions and experimentation with search algorithms and evaluation techniques. Shatranjs goal is to write a toolkit to aid in implementing Shannon Type B chess programs.

As such, execution speed becomes less important then code clarity and expressive power of the implementation language. Having been written in an interpreted language, this module allows the chess programmer to manipulate bitboards in a natural, interactive manner much like signal processing toolkits allow communication engineers to manipulate vectors of sounds samples in MATLAB.

The module currenly implements a simple recursive minimax search with alphabeta pruning, iterative deepening, uses short algebraic notation, handles repetition check, and the 50 move rule. Features lacking are quiescent checks, transition tables, negascout and MTD searching.

The chess programming toolkit is available in the form of a Python module called shatranj.py. You will also likely need the opening book as well as some of the pre-built hash tables that are used throughout the module (these will be recalculated if the module cannot find the data file).

Place all three file in the same directory and simply run python on the python module ("python shatranj.py"). As far as requirements, all that is needed is a recent version of the interpreted, high level language called Python (anything after version 2.3 should work fine). If you would like a little bit of a speed boost, shatranj looks for the module Psyco and will use it if it is installed.

Until more documentation becomes available, here is a short sample session:
[Sam-Tannous-Computer:~/shatranj] stannous% python

>>> from shatranj import *
...reading startup data
...total time to read data 0.0774528980255
...found opening book shatranj-book.bin with 37848 positions
>>> position = Position("r1bqk2r/pppp1ppp/2n5/5N2/2B1n3/8/PPP1QPPP/R1B1K2R")
>>> all_pieces = position.piece_bb["b_occupied"] | position.piece_bb["w_occupied"]
>>> other_pieces = position.piece_bb["b_occupied"]
>>> from_square = c4
>>> wtm = 1
>>> mask = position.pinned(from_square,wtm)
>>> ne_pieces = diag_mask_ne[from_square] & all_pieces
>>> nw_pieces = diag_mask_nw[from_square] & all_pieces
>>> moves = ((diag_attacks_ne[from_square][ne_pieces] & other_pieces) |
... (diag_attacks_ne[from_square][ne_pieces] & ~all_pieces) |
... (diag_attacks_nw[from_square][nw_pieces] & other_pieces) |
... (diag_attacks_nw[from_square][nw_pieces] & ~all_pieces)) & mask
>>>
>>> moves
1275777090846720L
>>>
>>> tobase(moves,2)
100100010000101000000000000010100000000000000000000
>>> display(moves)

+---+---+---+---+---+---+---+---+
8 | | . | | . | | . | | . |
+---+---+---+---+---+---+---+---+
7 | . | | . | | . | 1 | . | |
+---+---+---+---+---+---+---+---+
6 | 1 | . | | . | 1 | . | | . |
+---+---+---+---+---+---+---+---+
5 | . | 1 | . | 1 | . | | . | |
+---+---+---+---+---+---+---+---+
4 | | . | | . | | . | | . |
+---+---+---+---+---+---+---+---+
3 | . | 1 | . | 1 | . | | . | |
+---+---+---+---+---+---+---+---+
2 | | . | | . | | . | | . |
+---+---+---+---+---+---+---+---+
1 | . | | . | | . | | . | |
+---+---+---+---+---+---+---+---+
a b c d e f g h

>>> position.show_moves(1)
[Rg1, O-O, f3, a3, Rb1, f4, Ba6,
Bh6, Bd3, Qg4, Qe3, Ne7, Be6, Nxg7,
Qxe4, Ne3, b4, Nh4, b3, Be3, Bg5,
g3, Kf1, Rf1, Nh6, a4, Ng3, Qh5,
Kd1, h4, h3, c3, Bxf7, Nd6, Bb5,
Nd4, Qf3, g4, Qf1, Bb3, Qd1, Qd3,
Qd2, Bd5, Bd2, Bf4]
>>>
>>> # now play a game!
>>> play()

Shatranj version 1.10
g: switch sides m: show legal moves
n: new game l: list game record
d: display board b: show book moves
sd: change search depth (2-16) default=5
q: quit

Shatranj: d

+---+---+---+---+---+---+---+---+
8 | r | n | b | q | k | b | n | r |
+---+---+---+---+---+---+---+---+
7 | p | p | p | p | p | p | p | p |
+---+---+---+---+---+---+---+---+
6 | | . | | . | | . | | . |
+---+---+---+---+---+---+---+---+
5 | . | | . | | . | | . | |
+---+---+---+---+---+---+---+---+
4 | | . | | . | | . | | . |
+---+---+---+---+---+---+---+---+
3 | . | | . | | . | | . | |
+---+---+---+---+---+---+---+---+
2 | P | P | P | P | P | P | P | P |
+---+---+---+---+---+---+---+---+
1 | R | N | B | Q | K | B | N | R |
+---+---+---+---+---+---+---+---+
a b c d e f g h


Shatranj:

YAPE::HTML is Yet Another Parser/Extractor for HTML.

SYNOPSIS

use YAPE::HTML;
use strict;

my $content = "< html>...< /html>";
my $parser = YAPE::HTML->new($content);
my ($extor,@fonts,@urls,@headings,@comments);

# here is the tokenizing part
while (my $chunk = $parser->next) {
if ($chunk->type eq tag and $chunk->tag eq font) {
if (my $face = $chunk->get_attr(face)) {
push @fonts, $face;
}
}
}

# here we catch any errors
unless ($parser->done) {
die sprintf "bad HTML: %s (%s)",
$parser->error, $parser->chunk;
}

# here is the extracting part

# < A> tags with HREF attributes
# < IMG> tags with SRC attributes
$extor = $parser->extract(a => [href], img => [src]);
while (my $chunk = $extor->()) {
push @urls, $chunk->get_attr(
$chunk->tag eq a ? href : src
);
}

# < H1>, < H2>, ..., < H6> tags
$extor = $parser->extract(qr/^h[1-6]$/ => []);
while (my $chunk = $extor->()) {
push @headings, $chunk;
}

# all comments
$extor = $parser->extract(-COMMENT => []);
while (my $chunk = $extor->()) {
push @comments, $chunk;
}

YAPE MODULES

The YAPE hierarchy of modules is an attempt at a unified means of parsing and extracting content. It attempts to maintain a generic interface, to promote simplicity and reusability. The API is powerful, yet simple. The modules do tokenization (which can be intercepted) and build trees, so that extraction of specific nodes is doable.

This module is yet another parser and tree-builder for HTML documents. It is designed to make extraction and modification of HTML documents simplistic. The API allows for easy custom additions to the document being parsed, and allows very specific tag, text, and comment extraction.

Getopt::Declare is a Perl module with Declaratively Expressed Command-Line Arguments via Regular Expressions.

SYNOPSIS

use Getopt::Declare;

$args = Getopt::Declare->new($specification_string, $optional_source);

# or:

use Getopt::Declare $specification_string => $args;

Getopt::Declare is yet another command-line argument parser, one which is specifically designed to be powerful but exceptionally easy to use.

To parse the command-line in @ARGV, one simply creates a Getopt::Declare object, by passing Getopt::Declare::new() a specification of the various parameters that may be encountered:

use Getopt::Declare;
$args = Getopt::Declare->new($specification);

This may also be done in a one-liner:

use Getopt::Declare, $specification => $args;

The specification is a single string such as this:

$specification = q(

-a Process all data

-b < N:n > Set mean byte length threshold to
{ bytelen = $N; }

+c < FILE > Create new file

--del Delete old file
{ delold() }

delete [ditto]

e < H:i >x< W:i > Expand image to height < H > and width < W >
{ expand($H,$W); }

-F < file >... Process named file(s)
{ defer {for (@file) {process()}} }

=getrand [< N >] Get a random number
(or, optionally, < N > of them)
{ $N = 1 unless defined $N; }

-- Traditionally indicates end of arguments
{ finish }

DirSync is a directory synchronizer. It takes two arguments: the source directory and the destination directory.
It recursively makes the two directories identical. DirSync can be used to make an incremental copy of large data. For example, if your file server is in the /data you can make a copy in /backup with the command dirsync /data /backup.
The first time, all data will be copied, but when you issue the command again, only the changed files are copied.
Enhancements:
- This release fixes a bug, compiles on Sun, and adds support for symbolic links.

libdnet provides a simplified, portable interface to several low-level networking routines.
Main features:
- network address manipulation
- kernel arp(4) cache and route(4) table lookup and manipulation
- network firewalling (IP filter, ipfw, ipchains, pf, PktFilter, ...)
- network interface lookup and manipulation
- IP tunnelling (BSD/Linux tun, Universal TUN/TAP device)
- raw IP packet and Ethernet frame transmission
Supported languages:
- C, C++
- Python
- Perl, Ruby (see below)
Supported platforms:
- BSD (OpenBSD, FreeBSD, NetBSD, BSD/OS)
- Linux (Redhat, Debian, Slackware, etc.)
- MacOS X
- Windows (NT/2000/XP)
- Solaris
- IRIX
- HP-UX
- Tru64

Unicode::MapUTF8 is a Perl module with conversions to and from arbitrary character sets and UTF8.

SYNOPSIS

use Unicode::MapUTF8 qw(to_utf8 from_utf8 utf8_supported_charset);

# Convert a string in ISO-8859-1 to UTF8
my $output = to_utf8({ -string => An example, -charset => ISO-8859-1 });

# Convert a string in UTF8 encoding to encoding ISO-8859-1
my $other = from_utf8({ -string => Other text, -charset => ISO-8859-1 });

# List available character set encodings
my @character_sets = utf8_supported_charset;

# Add a character set alias
utf8_charset_alias({ ms-japanese => sjis });

# Convert between two arbitrary (but largely compatible) charset encodings
# (SJIS to EUC-JP)
my $utf8_string = to_utf8({ -string =>$sjis_string, -charset => sjis});
my $euc_jp_string = from_utf8({ -string => $utf8_string, -charset => euc-jp })

# Verify that a specific character set is supported
if (utf8_supported_charset(ISO-8859-1) {
# Yes
}

Provides an adapter layer between core routines for converting to and from UTF8 and other encodings. In essence, a way to give multiple existing Unicode modules a single common interface so you dont have to know the underlaying implementations to do simple UTF8 to-from other character set encoding conversions. As such, it wraps the Unicode::String, Unicode::Map8, Unicode::Map and Jcode modules in a standardized and simple API.

This also provides general character set conversion operation based on UTF8 - it is possible to convert between any two compatible and supported character sets via a simple two step chaining of conversions.

As with most things Perlish - if you give it a few big chunks of text to chew on instead of lots of small ones it will handle many more characters per second.

By design, it can be easily extended to encompass any new charset encoding conversion modules that arrive on the scene.
This module is intended to provide good Unicode support to versions of Perl prior to 5.8. If you are using Perl 5.8.0 or later, you probably want to be using the Encode module instead. This module does work with Perl 5.8, but Encode is the preferred method in that environment.

GNU libiconv provides an iconv() implementation for use on systems which dont have one or whose implementation cannot convert from/to Unicode.
libiconv supports all the important encodings in use today.
Enhancements:
- The iconv program now supports substitutions for unconvertible characters.
- The encodings BIG5-2003 and AtariST have been added.
- Mappings of private area characters have been improved.

xl2tpd a Layer 2 Tunneling Protocol (L2TP) daemon.
Our version contains many patches that have not yet been integrated into the mainstream release. These patches are needed to run on modern distributions with DEVFS, or to support L2TP over IPsec, when used in conjunction with Openswan.
We also offer 3rd level support for this L2TP implementation. If you are a vendor including Openswan in your products, or a company who depends on Openswan for critical systems, and need L2TP support as well, please see our support page.
Enhancements:
- Support for passwordfd, a workaround for some Cisco routers, and extended logging.