Free lingua ru charset 0.02 software for linux

MARC::Charset is a Perl module to convert MARC-8 encoded strings to UTF-8.

SYNOPSIS

# import the marc8_to_utf8 function
use MARC::Charset marc8_to_utf8;

# prepare STDOUT for utf8
binmode(STDOUT, utf8);

# print out some marc8 as utf8
print marc8_to_utf8($marc8_string);

MARC::Charset allows you to turn MARC-8 encoded strings into UTF-8 strings. MARC-8 is a single byte character encoding that predates unicode, and allows you to put non-Roman scripts in MARC bibliographic records.

MIME::Charset module contains charset information for MIME.

SYNOPSIS

Getting charset informations:

use MIME::Charset qw(:info);

$benc = body_encoding("iso-8859-2"); # "Q"
$cset = canonical_charset("ANSI X3.4-1968"); # "US-ASCII"
$henc = header_encoding("utf-8"); # "S"
$cset = output_charset("shift_jis"); # "ISO-2022-JP"

Translating text data:

use MIME::Charset qw(:trans);

($text, $charset, $encoding) =
header_encode(
"xc9xc2xc5xaaxc0xdexc3xefxc5xaa".
"xc7xd1xcaxaaxbdxd0xcexcfxb4xef",
"euc-jp");
# ...returns (< converted >, "ISO-2022-JP", "B");

($text, $charset, $encoding) =
body_encode(
"Collectioneur pathxe9tiquement ".
"xe9clectique de dxe9chets",
"latin1");
# ...returns (< original >, "ISO-8859-1", "QUOTED-PRINTABLE");

$len = encoded_header_len(
"Perlxe8xa8x80xe8xaax9e", "b", "utf-8"); # 28

Manipulating module defaults:

use MIME::Charset;

MIME::Charset::alias("csEUCKR", "euc-kr");
MIME::Charset::default("iso-8859-1");
MIME::Charset::fallback("us-ascii");

Lingua::EO::Supersignoj is a Perl module that can convert Esperanto characters.

SYNOPSIS

use Lingua::EO::Supersignoj;

my $transkodigilo = Lingua::EO::Supersignoj->nova(
de => fronte,
al => X,
u => u*
);
print $transkodigilo->transkodigu(Mia ^suoj estas ankau* en la ^cambro.);
# prints: Mia sxuoj estas ankaux en la cxambro.

my $transkodigilo = Lingua::EO::Supersignoj->nova(de => X);

for (qw(X x H h poste fronte apostrofoj iso unikodo)) {
$transkodigilo->al = $_;
print $transkodigilo->transkodigu(
Laux Ludoviko Zamenhof bongustas .
fresxa cxecxa mangxajxo kun spicoj.
);
}

Esperanto has 6 letters that ASCII doesnt have. These characters do exist in Unicode and ISO-8859-3. This object orientated module makes conversion easier.

Lingua::Phonology::Segment is a module to represent a segment as a bundle of feature values.

SYNOPSIS

use Lingua::Phonology;
$phono = new Lingua::Phonology;

# Define a feature set
$features = $phono->features;
$features->loadfile;

# Make a segment
$segment = $phono->segment;

# Set some values
$segment->labial(1);
$segment->continuant(0);
$segment->voice(1);
# Segment is now voiced labial stop, i.e. [b]

# Reset the segment
$segment->clear;

A Lingua::Phonology::Segment object provides a programmatic representation of a linguistic segment. Such a segment is associated with a Lingua::Phonology::Features object that lists the available features and the relationships between them. The segment itself is a list of the values for those features.

This module provides methods for returning and setting these feature values. A segment may also be associated with a Lingua::Phonology::Symbols object, which allows the segment to return the symbol that it best matches.

OVERLOADING

As of Lingua::Phonology v0.32 (Lingua::Phonology::Segment v0.4), string conversion of segments is overloaded. When you use a Lingua::Phonology::Segment in string context, the spell() method is automatically called, and the representation of the segment from the current symbolset is returned. String comparison operators (cmp eq ne lt le gt ge) are also overloaded. Therefore, the following work correctly, assuming that you have a Lingua::Phonology object correctly set up in $phono.

my ($b, $k) = $phono->symbols->segment(b, k);

print "Segments: $b, $kn"; # Prints "Segments: b, k";
print "$b is greater than $kn" if $b gt $k; # Wont print
print "$b is less than $kn" if $b lt $k; # Prints b is less than k;
print "$b is equal to $kn" if $b eq $k; # Wont print

my $b2 = $b->duplicate;
print "$b is equal to $b2n" if $b eq $b2 # Prints b is equal to b;
Note that stringification is not overloaded if the symbolset is not properly set. However, it turns on as soon as a symbolset is available:
my $b = Lingua::Phonology::Segment->new($features);
$b->voice(1);
$b->labial(1);

print "$bn"; # Prints Lingua::Phonology::Segment=HASH(0x88af598)
# or something similar, because there is no symbolset
# defined for spelling the segment.

$b->symbolset($symbols);
print "$bn"; # Prints b
Number conversion is not overloaded.

Lingua::Phonology::Rules is a Perl module for defining and applying phonological rules.

SYNOPSIS

use Lingua::Phonology;
$phono = new Lingua::Phonology;

$rules = $phono->rules;

# Adding and manipulating rules is discussed in the "WRITING RULES"
# section

This module allows for the creation of linguistic rules, and the application of those rules to "words" of Segment objects. You, the user, add rules to a Rules object, defining various parameters and code references that actually perform the action of the rule. Lingua::Phonology::Rules will take care of the guts of applying and creating rules.

The rules you create may have the following parameters. This is just a brief description of the parameters--a more detailed discussion of their effect is in the "WRITING RULES" section.

domain

Defines the domain within which the rule applies. This should be the name of a feature in the featureset of the segments which the rule is applied to.

tier

Defines the tier on which the rule applies. Must be the name of a feature in the feature set for the segments of the word you pass in.

direction

Defines the direction that the rule applies in. Must be either leftward or rightward. If no direction is given, defaults to rightward.

filter

Defines a filter for the segments that the rule applies on. Must a code reference that returns a truth value.

linguistic

Defines a linguistic-style rule to be parsed. When you provide a linguistic-style rule, it is parsed into code references that take the place of the where and do properties listed below. The format of linguistic rules is described in "LINGUISTIC-STYLE RULES" in Lingua::Phonology::FileFormatPOD.

where - defines the condition or conditions where the rule applies. Must be a coderef that returns a truth value. If no value is given, defaults to always true.

do - defines the action to take when the where condition is met. Must be a code reference. If no value is given, does nothing.

result - EXPERIMENTAL. Defines a condition that must be true after the do code has applied. Must be a code reference that returns a truth value. NOTE: This parameter depends on the module Whatif (available from CPAN), and will behave differently if this module is not present. See "Using result".

Lingua::Phonology::Rules is flexible and powerful enough to handle any sequential type of rule system. It cannot handle Optimality Theory-style processes, because those require a fundamentally different kind of algorithm.

TechnoBar is an extension which provides the ultimate Technorati reverse browsing experience.

Techno(rati)Bar provides the ultimate "reverse" browsing experience by showing live Technorati content as sidebar on the web pages youre browsing.

TechnoBar will show blogs that link to the current site while browsing and open blogs by clicking on the sidebar entry.

Lingua::EN::WordsToNumbers is Perl module to convert numbers written in English to actual numbers.

This module is an OO wrapper for Lingua::EN::Words2Nums, which is very nice, but has an unfortunate name (which doesnt help when youre searching CPAN for modules that turn words into numbers).

SYNOPSIS

use Lingua::EN::WordsToNumbers;

my $numberizer = Lingua::EN::WordsToNumbers->new;

print $numberizer->parse("Forty-two"); # "42"

$numberizer->debug(1); # debug on
$numberizer->debug(undef); # debug off

$numberizer->billion(10**12); # use "English billion"

METHODS

new
my $numberizer = Lingua::EN::WordsToNumbers->new;
Gives you a new "object". Doesnt really do much.

parse
print $numberizer->parse("Forty-two"); # "42"
An alias for Lingua::EN::Words2Numss words2nums method. Read that modules documentation to see how it works. You can also call this method as words2nums if you really want to.

debug
$numberizer->debug(1);
Set Lingua::EN::Words2Nums debug mode. True values are on, anything else is off.

billion
$numberizer->billion(10**12);
Define the value of a billion ($Lingua::EN::Words2Nums::billion).