Free alizee j en ai marre software for linux

Games::Euchre::AI is a Player API for Euchre card game.

This class implements a skeletal Euchre player programming interface. Subclasses can be created quite easily as interactive interfaces or AI computer players.
If you wish to write your own computer player, I recommend you start with Games::Euchre::AI::Simple. If you wish to write your own human interface, I recommend you start with Games::Euchre::AI::Human.

CLASS METHODS

new

Create and initialize a new Euchre AI. This object is implemented as an empty hash. Subclasses may wish to use this hash for state storage.

INSTANCE METHODS

Actions

The following methods are called in the course of the game where the AI (or human) has to make a decision. The state of the game is always passed in a hashreference. The following fields are always available:

name is the name of the current player. This is useful for output messages.
names is a hash relating player number to player name for all four players.
debug is a boolean indicating if we are debugging game or the AIs. Your AI may wish to provide verbose output if debugging is going on.

bid STATEHASH

Choose trump or pass. The relevent details of the current state of the game are provided in a hash reference. Here is an example of that data structure:

{
name => Player 1,
names => {1 => Player 1, 2 => P2, 3 => P3, 4 => Fred},
number => 1,
turnedUp => KH,
passes => 1,
ourScore => 2,
theirScore => 4,
winScore => 10,
hangdealer => false,
notrump => false,
hand => [JS, QH, 9S, KC, AD],
debug => false,
}

turnedUp is the suit and value of the card on the top of the blind. This will be undef on the second round of bidding.

passes says how many people have passed so far
hangdealer is a boolean saying whether the hang-the-dealer optional rule is in effect

notrump is a boolean saying whether the no trump optional rule is in effect
This function must return one of: H, D, C, S, N, HA, DA, CA, SA, NA, or undef
N means no trump, A means alone, undef means pass. Not all of these are legal at any given round! Use the isLegalBid() method below if you are unsure.

pickItUp STATEHASH

If this is called, you are the dealer and someone called trump. Choose which card from your hand to discard in exchange for the top card of the blind. The relevent details of the current state of the game are provided in a hash reference. Here is an example of that data structure:

{
name => Player 1,
names => {1 => Player 1, 2 => P2, 3 => P3, 4 => Fred},
number => 1,
turnedUp => KH,
trump => H,
bidder => 2,
weBid => false,
usAlone => false,
themAlone => false,
hand => [JS, QH, 9S, KC, AD],
debug => false,
}

This method should return the 0-based index of the card to trade for the turnedUp card. Namely, this in the index of the hand array for the card that you choose.

playCard STATEHASH

Choose which card from your hand to play on this trick. The relevent details of the current state of the game are provided in a hash reference. Here is an example of that data structure:

{
name => Player 1,
names => {1 => Player 1, 2 => P2, 3 => P3, 4 => Fred},
number => 1,
trump => H,
bidder => 2,
weBid => true,
usAlone => false,
themAlone => false,
trick => 2,
ourTricks => 0,
theirTricks => 1,
ourScore => 2,
theirScore => 4,
winScore => 10,
played => [10H, 9H, QC],
playedBy => [2, 3, 4, 1],
hand => [JH, AH, AS, KS],
debug => false,
}

playedBy is an arrayref of numbers of the players in the order they will play. Without this, the alone possibility makes it hard to tell who played what.

Any needed information not stored here (like who was the dealer, what was the turn-up card, what happened in the first trick) is YOUR responsibility to collect and store in your instance.

This method should return the 0-based index of the card to play. Namely, this in the index of the hand array for the card that you choose.

Attal: Lords of Doom is a strategy game still in development.

Its a turn-based strategy game, that can be played alone (against AI) or against other through a network (local or internet). Attal is available under Linux and Windows.

AI::Categorizer::Learner::Weka is a Perl module to pass-through wrapper to Weka system.

SYNOPSIS

use AI::Categorizer::Learner::Weka;

# Here $k is an AI::Categorizer::KnowledgeSet object

my $nb = new AI::Categorizer::Learner::Weka(...parameters...);
$nb->train(knowledge_set => $k);
$nb->save_state(filename);

... time passes ...

$nb = AI::Categorizer::Learner->restore_state(filename);
my $c = new AI::Categorizer::Collection::Files( path => ... );
while (my $document = $c->next) {
my $hypothesis = $nb->categorize($document);
print "Best assigned category: ", $hypothesis->best_category, "n";
}

This class doesnt implement any machine learners of its own, it merely passes the data through to the Weka machine learning system (http://www.cs.waikato.ac.nz/~ml/weka/). This can give you access to a collection of machine learning algorithms not otherwise implemented in AI::Categorizer.

Currently this is a simple command-line wrapper that calls java subprocesses. In the future this may be converted to an Inline::Java wrapper for better performance (faster running times). However, if youre looking for really great performance, youre probably looking in the wrong place - this Weka wrapper is intended more as a way to try lots of different machine learning methods.

Five Chess is a connect-five board game. Five Chess is released under the terms of GNU General Public License version 2.
It was initially developed from a qt Tic-Tac-Toe example.
Main features:
- 4 ways to play -- Human vs Human, AI vs Human, Human vs AI, AI vs AI
- 6 board sizes available -- 9X9 to 19X19
- Save Played games
- View played games
- Not so smart AI

Lingua::EN::Inflect is a Perl module that can convert singular to plural. Select "a" or "an".

SYNOPSIS

use Lingua::EN::Inflect qw ( PL PL_N PL_V PL_ADJ NO NUM
PL_eq PL_N_eq PL_V_eq PL_ADJ_eq
A AN
PART_PRES
ORD NUMWORDS
inflect classical
def_noun def_verb def_adj def_a def_an );


# UNCONDITIONALLY FORM THE PLURAL

print "The plural of ", $word, " is ", PL($word), "n";


# CONDITIONALLY FORM THE PLURAL

print "I saw $cat_count ", PL("cat",$cat_count), "n";


# FORM PLURALS FOR SPECIFIC PARTS OF SPEECH

print PL_N("I",$N1), PL_V("saw",$N1),
PL_ADJ("my",$N2), PL_N("saw",$N2), "n";


# DEAL WITH "0/1/N" -> "no/1/N" TRANSLATION:

print "There ", PL_V("was",$errors), NO(" error",$errors), "n";


# USE DEFAULT COUNTS:

print NUM($N1,""), PL("I"), PL_V(" saw"), NUM($N2), PL_N(" saw");
print "There ", NUM($errors,), PL_V("was"), NO(" error"), "n";


# COMPARE TWO WORDS "NUMBER-INSENSITIVELY":

print "samen" if PL_eq($word1, $word2);
print "same nounn" if PL_eq_N($word1, $word2);
print "same verbn" if PL_eq_V($word1, $word2);
print "same adj.n" if PL_eq_ADJ($word1, $word2);


# ADD CORRECT "a" OR "an" FOR A GIVEN WORD:

print "Did you want ", A($thing), " or ", AN($idea), "n";


# CONVERT NUMERALS INTO ORDINALS (i.e. 1->1st, 2->2nd, 3->3rd, etc.)

print "It was", ORD($position), " from the leftn";

# CONVERT NUMERALS TO WORDS (i.e. 1->"one", 101->"one hundred and one", etc.)
# IN A SCALAR CONTEXT: GET BACK A SINGLE STRING...

$words = NUMWORDS(1234); # "one thousand, two hundred and thirty-four"
$words = NUMWORDS(ORD(1234)); # "one thousand, two hundred and thirty-fourth"


# IN A LIST CONTEXT: GET BACK A LIST OF STRINGSi, ONE FOR EACH "CHUNK"...

@words = NUMWORDS(1234); # ("one thousand","two hundred and thirty-four")


# OPTIONAL PARAMETERS CHANGE TRANSLATION:

$words = NUMWORDS(12345, group=>1);
# "one, two, three, four, five"

$words = NUMWORDS(12345, group=>2);
# "twelve, thirty-four, five"

$words = NUMWORDS(12345, group=>3);
# "one twenty-three, forty-five"

$words = NUMWORDS(1234, and=>);
# "one thousand, two hundred thirty-four"

$words = NUMWORDS(1234, and=>, plus);
# "one thousand, two hundred, plus thirty-four"

$words = NUMWORDS(555_1202, group=>1, zero=>oh);
# "five, five, five, one, two, oh, two"

$words = NUMWORDS(555_1202, group=>1, one=>unity);
# "five, five, five, unity, two, oh, two"

$words = NUMWORDS(123.456, group=>1, decimal=>mark);
# "one two three mark four five six"


# REQUIRE "CLASSICAL" PLURALS (EG: "focus"->"foci", "cherub"->"cherubim")

classical; # USE ALL CLASSICAL PLURALS

classical 1; # USE ALL CLASSICAL PLURALS
classical 0; # USE ALL MODERN PLURALS (DEFAULT)

classical zero; # "no error" INSTEAD OF "no errors"
classical zero=>1; # "no error" INSTEAD OF "no errors"
classical zero=>0; # "no errors" INSTEAD OF "no error"

classical herd; # "2 buffalo" INSTEAD OF "2 buffalos"
classical herd=>1; # "2 buffalo" INSTEAD OF "2 buffalos"
classical herd=>0; # "2 buffalos" INSTEAD OF "2 buffalo"

classical persons; # "2 chairpersons" INSTEAD OF "2 chairpeople"
classical persons=>1; # "2 chairpersons" INSTEAD OF "2 chairpeople"
classical persons=>0; # "2 chairpeople" INSTEAD OF "2 chairpersons"

classical ancient; # "2 formulae" INSTEAD OF "2 formulas"
classical ancient=>1; # "2 formulae" INSTEAD OF "2 formulas"
classical ancient=>0; # "2 formulas" INSTEAD OF "2 formulae"



# INTERPOLATE "PL()", "PL_N()", "PL_V()", "PL_ADJ()", A()", "AN()"
# "NUM()" AND "ORD()" WITHIN STRINGS:

print inflect("The plural of $word is PL($word)n");
print inflect("I saw $cat_count PL("cat",$cat_count)n");
print inflect("PL(I,$N1) PL_V(saw,$N1) PL(a,$N2) PL_N(saw,$N2)");
print inflect("NUM($N1,)PL(I) PL_V(saw) NUM($N2,)PL(a) PL_N(saw)");
print inflect("I saw NUM($cat_count) PL("cat")nNUM()");
print inflect("There PL_V(was,$errors) NO(error,$errors)n");
print inflect("There NUM($errors,) PL_V(was) NO(error)n";
print inflect("Did you want A($thing) or AN($idea)n");
print inflect("It was ORD($position) from the leftn");


# ADD USER-DEFINED INFLECTIONS (OVERRIDING INBUILT RULES):

def_noun "VAX" => "VAXen"; # SINGULAR => PLURAL

def_verb "will" => "shall", # 1ST PERSON SINGULAR => PLURAL
"will" => "will", # 2ND PERSON SINGULAR => PLURAL
"will" => "will", # 3RD PERSON SINGULAR => PLURAL

def_adj "hir" => "their", # SINGULAR => PLURAL

def_a "h" # "AY HALWAYS SEZ HAITCH!"

def_an "horrendous.*" # "AN HORRENDOUS AFFECTATION"

The exportable subroutines of Lingua::EN::Inflect provide plural inflections, "a"/"an" selection for English words, and manipulation of numbers as words

Plural forms of all nouns, most verbs, and some adjectives are provided. Where appropriate, "classical" variants (for example: "brother" -> "brethren", "dogma" -> "dogmata", etc.) are also provided.

Pronunciation-based "a"/"an" selection is provided for all English words, and most initialisms.
It is also possible to inflect numerals (1,2,3) to ordinals (1st, 2nd, 3rd) and to english words ("one", "two", "three).

In generating these inflections, Lingua::EN::Inflect follows the Oxford English Dictionary and the guidelines in Fowlers Modern English Usage, preferring the former where the two disagree.
The module is built around standard British spelling, but is designed to cope with common American variants as well. Slang, jargon, and other English dialects are not explicitly catered for.

Where two or more inflected forms exist for a single word (typically a "classical" form and a "modern" form), Lingua::EN::Inflect prefers the more common form (typically the "modern" one), unless "classical" processing has been specified (see "MODERN VS CLASSICAL INFLECTIONS").

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.

AI::NeuralNet::Kohonen is a Perl module with Kohonens Self-organising Maps.

SYNOPSIS

$_ = AI::NeuralNet::Kohonen->new(
map_dim_x => 39,
map_dim_y => 19,
epochs => 100,
table =>
"3
1 0 0 red
0 1 0 yellow
0 0 1 blue
0 1 1 cyan
1 1 0 yellow
1 .5 0 orange
1 .5 1 pink"
);

$_->train;
$_->save_file(mydata.txt);
exit;

An illustrative implimentation of Kohonens Self-organising Feature Maps (SOMs) in Perl. Its not fast - its illustrative. In fact, its slow: but it is illustrative....