Free lingua phonology features software for linux

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.

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.

Bio::Graphics::Feature is a simple feature object for use with Bio::Graphics::Panel.

SYNOPSIS

use Bio::Graphics::Feature;

# create a simple feature with no internal structure
$f = Bio::Graphics::Feature->new(-start => 1000,
-stop => 2000,
-type => transcript,
-name => alpha-1 antitrypsin,
-desc => an enzyme inhibitor,
);

# create a feature composed of multiple segments, all of type "similarity"
$f = Bio::Graphics::Feature->new(-segments => [[1000,1100],[1500,1550],[1800,2000]],
-name => ABC-3,
-type => gapped_alignment,
-subtype => similarity);

# build up a gene exon by exon
$e1 = Bio::Graphics::Feature->new(-start=>1,-stop=>100,-type=>exon);
$e2 = Bio::Graphics::Feature->new(-start=>150,-stop=>200,-type=>exon);
$e3 = Bio::Graphics::Feature->new(-start=>300,-stop=>500,-type=>exon);
$f = Bio::Graphics::Feature->new(-segments=>[$e1,$e2,$e3],-type=>gene);

This is a simple Bio::SeqFeatureI-compliant object that is compatible with Bio::Graphics::Panel. With it you can create lightweight feature objects for drawing.

Gimp::Feature is a Perl module that can check for specific features to be present before registering the script.

SYNOPSIS

use Gimp::Feature;
or
use Gimp::Feature qw(feature1 feature2 ...);

This module can be used to check for specific features to be present. This can be used to deny running the script when neccessary features are not present. While some features can be checked for at any time, the Gimp::Fu module offers a nicer way to check for them.

gtk

checks for the presence of the gtk interface module.

gtk-1.1, gtk-1.2

checks for the presence of gtk-1.1 (1.2) or higher.

perl-5.005

checks for perl version 5.005 or higher.

pdl

checks for the presence of a suitable version of PDL (>=1.9906).

gnome

checks for the presence of the Gnome-Perl module.

gtkxmhtl

checks for the presence of the Gtk::XmHTML module.

unix

checks wether the script runs on a unix-like operating system. At the moment, this is every system except windows, macos, os2 and vms.

persistency

checks wether the Gimp::Data module (Gimp::Data) can handle complex persistent data structures, i.e. perl references in addition to plain strings.

The following features can only be checked after Gimp-main> has been called (usually found in the form exit main). See Gimp::Fu on how to check for these.
gimp-1.1, gimp-1.2

checks for the presense of gimp in at least version 1.1 (1.2).

FUNCTIONS

present(feature)

Checks for the presense of the single feature given as the argument. Returns true if the feature is present, false otherwise.

need(feature,[function-name])

Require a specific feature. If the required feature is not present the program will exit gracefully, logging an appropriate message. You can optionally supply a function name to further specify the place where this feature was missing.

This is the function used when importing symbols from the module.

missing(feature-description,[function-name])

Indicates that a generic feature (described by the first argument) is missing. A function name can further be specified. This function will log the given message and exit gracefully.

describe(feature)

Returns a string describing the given feature in more detail, or undef if there is no description for this feature.

list()

Returns a list of features that can be checked for. This list might not be complete.

Bio::DB::GFF::Feature is a relative segment identified by a feature type.

Bio::DB::GFF::Feature is a stretch of sequence that corresponding to a single annotation in a GFF database. It inherits from Bio::DB::GFF::RelSegment, and so has all the support for relative addressing of this class and its ancestors. It also inherits from Bio::SeqFeatureI and so has the familiar start(), stop(), primary_tag() and location() methods (it implements Bio::LocationI too, if needed).

Bio::DB::GFF::Feature adds new methods to retrieve the annotations type, group, and other GFF attributes. Annotation types are represented by Bio::DB::GFF::Typename objects, a simple class that has two methods called method() and source(). These correspond to the method and source fields of a GFF file.

Annotation groups serve the dual purpose of giving the annotation a human-readable name, and providing higher-order groupings of subfeatures into features. The groups returned by this module are objects of the Bio::DB::GFF::Featname class.

Bio::DB::GFF::Feature inherits from and implements the abstract methods of Bio::SeqFeatureI, allowing it to interoperate with other Bioperl modules.
Generally, you will not create or manipulate Bio::DB::GFF::Feature objects directly, but use those that are returned by the Bio::DB::GFF::RelSegment->features() method.
Important note about start() vs end()

If features are derived from segments that use relative addressing (which is the default), then start() will be less than end() if the feature is on the opposite strand from the reference sequence. This breaks Bio::SeqI compliance, but is necessary to avoid having the real genomic locations designated by start() and end() swap places when changing reference points.

To avoid this behavior, call $segment->absolute(1) before fetching features from it. This will force everything into absolute coordinates.

For example:

my $segment = $db->segment(CHROMOSOME_I);
$segment->absolute(1);
my @features = $segment->features(transcript);

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::Conjunction is Perl module convert Perl lists into linguistic conjunctions.

SYNOPSIS

use Lingua::Conjunction;

# emits "Jack"
$name_list = conjunction(Jack);

# emits "Jack and Jill"
$name_list = conjunction(Jack, Jill);

# emits "Jack, Jill, and Spot"
$name_list = conjunction(Jack, Jill, Spot);

# emits "Jack, a boy; Jill, a girl; and Spot, a dog"
$name_list = conjunction(Jack, a boy, Jill, a girl, Spot, a dog);

# emits "Jacques, un garcon; Jeanne, une fille; et Spot, un chien"
Lingua::Conjunction->lang(fr);
$name_list = conjunction(
Jacques, un garcon,
Jeanne, une fille,
Spot, un chien
);

Lingua::Conjunction exports a single subroutine, conjunction, that converts a list into a properly punctuated text string.

You can cause conjunction to use the connectives of other languages, by calling the appropriate subroutine:

Lingua::Conjunction->lang(en); # use and (default)
Lingua::Conjunction->lang(es); # use y

Supported languages in this version are English, Spanish, French, Italian, German, Portuguese, Norwegian, Danish, Dutch, Afrikaans, Swahili, and Latin. (Klingon is intentionally not supported.)

You can also set connectives individually:

Lingua::Conjunction->separator("...");
Lingua::Conjunction->separator_phrase("--");
Lingua::Conjunction->connector_type("or");

# emits "Jack... Jill... or Spot"
$name_list = conjunction(Jack, Jill, Spot);

The separator_phrase is used whenever the separator already appears in an item of the list. For example:

# emits "Doe, a deer; Ray; and Me"
$name_list = conjunction(Doe, a deer, Ray, Me);

You may use the penultimate routine to diable the separator after the next to last item. Generally this is bad English practice but the option is there if you want it:

# emits "Jack, Jill and Spot"
Lingua::Conjunction->penultimate(0);
$name_list = conjunction(Jack, Jill, Spot);

I have been told that the penultimate comma is not standard for some languages, such as Norwegian. Hence the defaults set in the %languages.