Free list of most miss spelled words software for linux

List::MoreUtils is a Perl module that can provide the stuff missing in List::Util.

SYNOPSIS

use List::MoreUtils qw(any all none notall true false firstidx first_index
lastidx last_index insert_after insert_after_string
apply after after_incl before before_incl indexes
firstval first_value lastval last_value each_array
each_arrayref pairwise natatime mesh zip uniq minmax);

List::MoreUtils provides some trivial but commonly needed functionality on lists which is not going to go into List::Util.

All of the below functions are implementable in only a couple of lines of Perl code. Using the functions from this module however should give slightly better performance as everything is implemented in C. The pure-Perl implementation of these functions only serves as a fallback in case the C portions of this module couldnt be compiled on this machine.

any BLOCK LIST

Returns a true value if any item in LIST meets the criterion given through BLOCK. Sets $_ for each item in LIST in turn:

print "At least one value undefined"
if any { !defined($_) } @list;

Returns false otherwise, or undef if LIST is empty.

all BLOCK LIST

Returns a true value if all items in LIST meet the criterion given through BLOCK. Sets $_ for each item in LIST in turn:

print "All items defined"
if all { defined($_) } @list;

Returns false otherwise, or undef if LIST is empty.

none BLOCK LIST

Logically the negation of any. Returns a true value if no item in LIST meets the criterion given through BLOCK. Sets $_ for each item in LIST in turn:

print "No value defined"
if none { defined($_) } @list;

Returns false otherwise, or undef if LIST is empty.

notall BLOCK LIST

Logically the negation of all. Returns a true value if not all items in LIST meet the criterion given through BLOCK. Sets $_ for each item in LIST in turn:

print "Not all values defined"
if notall { defined($_) } @list;

Returns false otherwise, or undef if LIST is empty.

true BLOCK LIST

Counts the number of elements in LIST for which the criterion in BLOCK is true. Sets $_ for each item in LIST in turn:

printf "%i item(s) are defined", true { defined($_) } @list;

false BLOCK LIST

Counts the number of elements in LIST for which the criterion in BLOCK is false. Sets $_ for each item in LIST in turn:

printf "%i item(s) are not defined", false { defined($_) } @list;

firstidx BLOCK LIST

first_index BLOCK LIST

Returns the index of the first element in LIST for which the criterion in BLOCK is true. Sets $_ for each item in LIST in turn:

my @list = (1, 4, 3, 2, 4, 6);
printf "item with index %i in list is 4", firstidx { $_ == 4 } @list;
__END__
item with index 1 in list is 4

Returns -1 if no such item could be found.

first_index is an alias for firstidx.

Solving word problems is an area where elementary students overwhelmingly display difficulties. Master Math Word Problems program can help sharpen skills through practice. Third through fifth graders learn to watch for key words and translate those into mathematical operations.

Students can learn new math skills, practice logic, get extended practice with word problems, but most of all they learn that they must read the problem. With regular practice your students may become master math word problem solvers.

Download and try out Master Math Word Problems.

List::Comprehensions is a Perl module that allows for list comprehensions in Perl.

SYNOPSIS

use List::Comprehensions;
use warnings;

my @res = ();

@res = comp1 { [ @_ ] } [0..4], [0..4], [0..4];

no warnings once;
@res = comp2 { [$i, $j, $k] }
i => [0..4],
j => [0..4],
k => [0..4];

# if strict vars is on, use lexicals. eg:
use strict vars;

my ($i, $j, $k);
@res = comp2 { [$i, $j, $k] }
i => [0..4],
j => [0..4],
k => [0..4];

# each being less efficient but equivelant to

@res = ();
for $i ( 0..4 ) {
for $j ( 0..4 ) {
for $k ( 0..4 ) {
push @res, [$i, $j, $k];
}
}
}

List::Util Perl module contains a selection of general-utility list subroutines.

SYNOPSIS

use List::Util qw(first max maxstr min minstr reduce shuffle sum);

List::Util contains a selection of subroutines that people have expressed would be nice to have in the perl core, but the usage would not really be high enough to warrant the use of a keyword, and the size so small such that being individual extensions would be wasteful.

By default List::Util does not export any subroutines. The subroutines defined are

first BLOCK LIST

Similar to grep in that it evaluates BLOCK setting $_ to each element of LIST in turn. first returns the first element where the result from BLOCK is a true value. If BLOCK never returns true or LIST was empty then undef is returned.

$foo = first { defined($_) } @list # first defined value in @list
$foo = first { $_ > $value } @list # first value in @list which
# is greater than $value

This function could be implemented using reduce like this

$foo = reduce { defined($a) ? $a : wanted($b) ? $b : undef } undef, @list

for example wanted() could be defined() which would return the first defined value in @list

max LIST

Returns the entry in the list with the highest numerical value. If the list is empty then undef is returned.

$foo = max 1..10 # 10
$foo = max 3,9,12 # 12
$foo = max @bar, @baz # whatever

This function could be implemented using reduce like this

$foo = reduce { $a > $b ? $a : $b } 1..10

maxstr LIST

Similar to max, but treats all the entries in the list as strings and returns the highest string as defined by the gt operator. If the list is empty then undef is returned.

$foo = maxstr A..Z # Z
$foo = maxstr "hello","world" # "world"
$foo = maxstr @bar, @baz # whatever

This function could be implemented using reduce like this

$foo = reduce { $a gt $b ? $a : $b } A..Z

min LIST

Similar to max but returns the entry in the list with the lowest numerical value. If the list is empty then undef is returned.

$foo = min 1..10 # 1
$foo = min 3,9,12 # 3
$foo = min @bar, @baz # whatever

This function could be implemented using reduce like this

$foo = reduce { $a < $b ? $a : $b } 1..10

minstr LIST

Similar to min, but treats all the entries in the list as strings and returns the lowest string as defined by the lt operator. If the list is empty then undef is returned.

$foo = minstr A..Z # A
$foo = minstr "hello","world" # "hello"
$foo = minstr @bar, @baz # whatever

This function could be implemented using reduce like this

$foo = reduce { $a lt $b ? $a : $b } A..Z

reduce BLOCK LIST

Reduces LIST by calling BLOCK, in a scalar context, multiple times, setting $a and $b each time. The first call will be with $a and $b set to the first two elements of the list, subsequent calls will be done by setting $a to the result of the previous call and $b to the next element in the list.

Returns the result of the last call to BLOCK. If LIST is empty then undef is returned. If LIST only contains one element then that element is returned and BLOCK is not executed.

$foo = reduce { $a < $b ? $a : $b } 1..10 # min
$foo = reduce { $a lt $b ? $a : $b } aa..zz # minstr
$foo = reduce { $a + $b } 1 .. 10 # sum
$foo = reduce { $a . $b } @bar # concat
shuffle LIST

Returns the elements of LIST in a random order

@cards = shuffle 0..51 # 0..51 in a random order

sum LIST

Returns the sum of all the elements in LIST. If LIST is empty then undef is returned.

$foo = sum 1..10 # 55
$foo = sum 3,9,12 # 24
$foo = sum @bar, @baz # whatever

This function could be implemented using reduce like this

$foo = reduce { $a + $b } 1..10

MIME::Words is a Perl module to deal with RFC-1522 encoded words.

SYNOPSIS

Before reading further, you should see MIME::Tools to make sure that you understand where this module fits into the grand scheme of things. Go on, do it now. Ill wait.

Ready? Ok...

use MIME::Words qw(:all);

### Decode the string into another string, forgetting the charsets:
$decoded = decode_mimewords(
To: =?ISO-8859-1?Q?Keld_J=F8rn_Simonsen?= ,
);

### Split string into array of decoded [DATA,CHARSET] pairs:
@decoded = decode_mimewords(
To: =?ISO-8859-1?Q?Keld_J=F8rn_Simonsen?= ,
);

### Encode a single unsafe word:
$encoded = encode_mimeword("xABFranxE7oisxBB");

### Encode a string, trying to find the unsafe words inside it:
$encoded = encode_mimewords("Me and xABFranxE7oisxBB in town");

Fellow Americans, you probably wont know what the hell this module is for. Europeans, Russians, et al, you probably do.

For example, heres a valid MIME header you might get:

From: =?US-ASCII?Q?Keith_Moore?= < moore@cs.utk.edu>
To: =?ISO-8859-1?Q?Keld_J=F8rn_Simonsen?= < keld@dkuug.dk>
CC: =?ISO-8859-1?Q?Andr=E9_?= Pirard < PIRARD@vm1.ulg.ac.be>
Subject: =?ISO-8859-1?B?SWYgeW91IGNhbiByZWFkIHRoaXMgeW8=?=
=?ISO-8859-2?B?dSB1bmRlcnN0YW5kIHRoZSBleGFtcGxlLg==?=
=?US-ASCII?Q?.._cool!?=

The fields basically decode to (sorry, I can only approximate the Latin characters with 7 bit sequences /o and e):

From: Keith Moore < moore@cs.utk.edu>
To: Keld J/orn Simonsen < keld@dkuug.dk>
CC: Andre Pirard < PIRARD@vm1.ulg.ac.be>
Subject: If you can read this you understand the example... cool!

List::RewriteElements is a Perl module that can create a new list by rewriting elements of a first list.

SYNOPSIS

use List::RewriteElements;

Constructor

Simplest case: Input from array, output to STDOUT.

$lre = List::RewriteElements->new( {
list => @source,
body_rule => sub {
my $record = shift;
$record .= q{additional field};
},
} );
Input from file, output to STDOUT:
$lre = List::RewriteElements->new( {
file => "/path/to/source/file",
body_rule => sub {
my $record = shift;
$record .= q{,additional field};
},
} );
Provide a different rule for the first element in the list:
$lre = List::RewriteElements->new( {
file => "/path/to/source/file",
header_rule => sub {
my $record = shift;
$record .= q{,ADDITIONAL HEADER};
},
body_rule => sub {
my $record = shift;
$record .= q{,additional field};
},
} );
Input from file, output to file:
$lre = List::RewriteElements->new( {
file => "/path/to/source/file",
body_rule => sub {
my $record = shift;
$record .= q{additional field};
},
output_file => "/path/to/output/file",
} );
To name output file, just provide a suffix to filename:
$lre = List::RewriteElements->new( {
file => "/path/to/source/file",
body_rule => sub {
my $record = shift;
$record .= q{additional field};
},
output_suffix => .out,
} );
Provide criteria to suppress output of header or individual record.
$lre = List::RewriteElements->new( {
file => "/path/to/source/file",
header_suppress => sub {
my $record = shift;
return if $record =~ /$somepattern/;
},
body_suppress => sub {
my $record = shift;
return if $record ne somestring;
},
body_rule => sub {
my $record = shift;
$record .= q{additional field};
},
} );

Generate Output

$lre->generate_output();

Report Output Information

$path_to_output_file = $lre->get_output_path();

$output_file_basename = $lre->get_output_basename();

$output_row_count = $lre->get_total_rows();

$output_record_count = $lre->get_total_records();

$records_changed = $lre->get_records_changed();

$records_unchanged = $lre->get_records_unchanged();

$records_deleted = $lre->get_records_deleted();

$header_status = $lre->get_header_status();

It is common in many situations for you to receive a flat data file from someone else and have to generate a new file in which each row or record in the incoming file must either (a) be transformed according to some rule before being printing to the new file; or (b) if it meets certain criteria, not output to the new file at all.

List::RewriteElements enables you to write such rules and criteria, generate the file of transformed data records, and get back some basic statistics about the transformation.

List::RewriteElements is useful when the number of records in the incoming file may be large and you do not want to hold the entire list in memory. Similarly, the newly generated records are not held in memory but are immediately printed to STDOUT or to file.

On the other hand, if for some reason you already have an array of records in memory, you can use List::RewriteElements to apply rules and criteria to each element of the array and then print the transformed records (again, without holding the output in memory).

Faroese Spell Checking Dictionary is intended to be used with programs like aspell and ispell.
Installation:
After unpacking this package you can use it at least four ways:
Make and install a Faroese dictionary for aspell:
$ make aspell && su -c "make install-aspell"
Make and install a Faroese dictionary for ispell:
$ make ispell && su -c "make install-ispell"
Make and install Faroese dictionaries for aspell and ispell in a single run:
$ make all && su -c "make install"
Make a plain text list of Faroese words:
$ make words
Enhancements:
- Some words were added and some misspellings were removed.