Free set in software for linux

Set photo in Kopete is a really simple service menu that just sets the current photo as your photo in Kopete, nothing more, nothing less.

It doesnt handle directories containing space yet, if someone have a workaround so that KURL dont escapes all characters that would be nice=)

Just put this file in ~/.kde/share/apps/konqueror/servicemenus or use http://www.kde-look.org/content/show.php?content=11435 to install it.

Set::Partition is a Perl module that can enumerate all arrangements of a set in fixed subsets.

SYNOPSIS

use Set::Partition;

my $s = Set::Partition->new(
list => [qw(a b c d e)],
partition => [2, 3],
);
while (my $p = $s->next) {
print join( , map { "(@$_)" } @$p ), $/;
}
# produces
(a b) (c d e)
(a c) (b d e)
(a d) (b c e)
(a e) (b c d)
(b c) (a d e)
(b d) (a c e)
(b e) (a c d)
(c d) (a b e)
(c e) (a b d)
(d e) (a b c)

# or with a hash
my $s = Set::Partition->new(
list => { b => bat, c => cat, d => dog },
partition => [2, 1],
);
while (my $p = $s->next) {
...
}

Set::Partition takes a list or hash of elements and a list numbers that represent the sizes of the partitions into which the list of elements should be arranged.
The resulting object can then be used as an iterator which returns a reference to an array of lists, that represents the original list arranged according to the given partitioning. All possible arrangements are returned, and the object returns undef when the entire combination space has been exhausted.

st software is a simple XSL-stylesheet for converting some texts into PDF-files. It tooks a structured XML-file as input and produces with the help of a Formatting Objects Processor a PDF-file.
The st-stylesheet tries to support the most common used elements of modern text formatting.
Enhancements:
- This version implements some interactive elements for PDF files: Internet links can now be added to a document and PDF bookmarks are built when the tag "bookmarks" is set in the header of the document.
- Images can now have a width attribute: the image will be scaled proportional to that value.

Set::Array Perl module contains arrays as objects with lots of handy methods (including Set comparisons) and support for method chaining.

SYNOPSIS

my $sao1 = Set::Array->new(1,2,4,"hello",undef);
my $sao2 = Set::Array->new(qw(a b c a b c));
print $sao1->length; # prints 5
$sao2->unique->length->print; # prints 3

Set::Array allows you to create arrays as objects and use OO-style methods on them. Many convenient methods are provided here that appear in the FAQs, the Perl Cookbook or posts from comp.lang.perl.misc. In addition, there are Set methods with corresponding (overloaded) operators for the purpose of Set comparison, i.e. +, ==, etc.

The purpose is to provide built-in methods for operations that people are always asking how to do, and which already exist in languages like Ruby. This should (hopefully) improve code readability and/or maintainability. The other advantage to this module is method-chaining by which any number of methods may be called on a single object in a single statement.

OBJECT BEHAVIOR

The exact behavior of the methods depends largely on the calling context.
Here are the rules:

* If a method is called in void context, the object itself is modified.
* If the method called is not the last method in a chain (i.e. its called in object context), the object itself is modified by that method regardless of the final context or method call.
* If a method is called in list or scalar context, a list or list refererence is returned, respectively. The object itself is NOT modified.

Heres a quick example:

my $sao = Set::Array->new(1,2,3,2,3);
my @uniq = $sao->unique(); # Object unmodified. @uniq contains 3 values.
$sao->unique(); # Object modified, now contains 3 values

Here are the exceptions:

* Methods that report a value, such as boolean methods like exists() or other methods such as at() or as_hash(), never modify the object.
* The methods clear(), delete(), delete_at(), and splice will always modify the object. It seemed much too counterintuitive to call these methods in any context without actually deleting/clearing/substituting the items!
* The methods shift() and pop() will modify the object AND return the value that was shifted or popped from the array. Again, it seemed much too counterintuitive for something like $val = $sao->shift to return a value while leaving the objects list unchanged. If you really want the first or last value without modifying the object, you can always use the first() or last() method, respectively.
* The join() method always returns a string and is really meant for use in conjunction with the print() method.

BOOLEAN METHODS

exists(val) - Returns 1 if val exists within the array, 0 otherwise. If no value (or undef) is passed, then this method will test for the existence of undefined values within the array.
is_empty() - Returns 1 if the array is empty, 0 otherwise. Empty is defined as having a length of 0.

STANDARD METHODS

at(index) - Returns the item at the given index (or undef). A negative index may be used to count from the end of the array. If no value (or undef) is specified, it will look for the first item that is not defined.

clear() - Empties the array (i.e. length becomes 0). You may pass a 1 to this method to set each element of the array to undef rather than truly empty it.

compact() - Removes undefined elements from the array.

count(?val?) - Returns the number of instances of val within the array. If val is not specified (or is undef), the method will return the number of undefined values within the array.

delete(list) - Deletes all items within list from the array that match. This method will crash if list is not defined. If your goal is to delete undefined values from your object, use the compact() method instead.

delete_at(index, ?index?) - Deletes the item at the specified index. If a second index is specified, a range of items is deleted. You may use -1 or the string end to refer to the last element of the array.

duplicates - Returns a list of N-1 elements for each element N in the set. For example, if you have set "X X Y Y Y", this method would return a the list "X Y Y".

fill(val,?start?,?length?) - Sets the selected elements of the array (which may be the entire array) to val. The default value for start is 0. If length is not specified the entire array, however long it may be at the time of the call, will be filled. Alternatively, a quoted integer range may be used.

e.g. $sao->fill(x,3-5);

The array length/size may not be expanded with this call - it is only meant to fill in already-existing elements.

first() - Returns the first element of the array (or undef).

flatten() - Causes a one-dimensional flattening of the array, recursively. That is, for every element that is an array (or hash, or a ref to either an array or hash), extract its elements into the array.

e.g. my $sa = Set::Array->new([1,3,2],{one=>a,two=>b},x,y,z);

$sao->flatten->join(,)->print; # prints "1,3,2,one,a,two,b,x,y,z"

foreach(sub ref) - Iterates over an array, executing the subroutine for each element in the array. If you wish to modify or otherwise act directly on the contents of the array, use $_ within your sub reference.

e.g. To increment all elements in the array by one...

$sao->foreach(sub{ ++$_ });

get - Alias for the indices() method.

index(val) - Returns the index of the first element of the array object that contains val. Returns undef if no value is found.

Note that there is no dereferencing here so if youre looking for an item nested within a ref, use the flatten method first.

indices(val1,?val2?, ?val...?) - Returns an array consisting of the elements at the specified indices or undef if the element is out of range.

A range may also be used. It must be a quoted string in 0..3 format.

join(?char?) - Joins the individual elements of the list into a single string with the elements separated by the value of char. Useful in conjunction with the print() method. If no character is specified, then char defaults to a comma.

e.g. $sao->join(-)->print;

last() - Returns the last element of the array (or undef).

length() - Returns the number of elements within the array.

max() - Returns the maximum value of an array. No effort is made to check for non-numeric data.

pack(template) - Packs the contents of the array into a string (in scalar context) or a single array element (in object or void context).

pop() - Removes the last element from the array. Returns the popped element.

print(?1?) - Prints the contents of the array. If a 1 is provided as an argument, the output will automatically be terminated with a newline.

This also doubles as a contents method, if you just want to make a copy of the array, e.g. my @copy = $sao->print;

Can be called in void or list context, e.g.

$sao->print(); # or... print "Contents of array are: ", $sao->print();

push(list) - Adds list to the end of the array, where list is either a scalar value or a list. Returns an array or array reference in list or scalar context, respectively. Note that it does not return the length in scalar context. Use the length method for that.

reverse() - Reverses the order of the contents of the array.

rindex(val) - Similar to the index() method, except that it returns the index of the last val found within the array.

set(index,value) - Sets the element at index to value, replacing whatever may have already been there.

shift() - Shifts the first element of the array and returns the shifted element.

sort(?coderef?) - Sorts the contents of the array in alphabetical order, or in the order specified by the optional coderef. Use your standard $a and $b variables within your calling program, e.g:

my $sao = Set::Array->new( { name => Berger, salary => 20000 }, { name => Berger, salary => 15000 }, { name => Vera, salary => 25000 }, );
my $subref = sub{ $b->{name} cmp $a->{name} || $b->{salary} $a->{salary} };
$sao14->sort($subref)->flatten->join->print(1);

splice(?offset?,?length?,?list?) - Splice the array starting at position offset up to length elements, and replace them with list. If no list is provided, all elements are deleted. If length is omitted, everything from offset onward is removed.

Returns an array or array ref in list or scalar context, respectively. This method always modifies the object, regardless of context. If your goal was to grab a range of values without modifying the object, use the indices method instead.

unique() - Removes/returns non-unique elements from the list.

unshift(list) - Prepends a scalar or list to array. Note that this method returns an array or array reference in list or scalar context, respectively. It does not return the length of the array in scalar context. Use the length method for that.

ODDBALL METHODS

as_hash() - Returns a hash based on the current array, with each even numbered element (including 0) serving as the key, and each odd element serving as the value. This can be switched by using the key_order option and setting it to odd, in which case the even values serve as the values, and the odd elements serve as the keys. The default is even.

Of course, if you dont care about insertion order, you could just as well do something like, $sao-reverse->as_hash;>

Carp::croaks if the array contains an odd number of elements. This method does not actually modify the object itself in any way. It just returns a plain hash in list context or a hash reference in scalar context. The reference is not blessed, therefore if this method is called as part of a chain, it must be the last method called.

impose(?append/prepend?,string) - Appends or prepends the specified string to each element in the array. Specify the method by using either the keyword append or prepend. The default is append.

randomize() - Randomizes the order of the elements within the array.

rotate(direction) - Moves the last item of the list to the front and shifts all other elements one to the right, or vice-versa, depending on what you pass as the direction - ftol (first to last) or ltof (last to first). The default is ltof.

e.g. my $sao = Set::Array->new(1,2,3);

$sao->rotate(); # order is now 3,1,2

$sao->rotate(ftol); # order is back to 1,2,3

netEasy project allows easy and fast configuration of ethernet interfaces in Linux.
With netEasy, its possible to change network parameters such as IP address, netmask, and gateway in an easy, fast, and interactive way. The use of a DHCP server is also possible.
The settings may also be saved in a template file, allowing the use of templates for different situations like work, home, or school.
Installation:
as root:
- chmod +x neteasy
- mv neteasy /usr/bin/
Uninstallation:
as root:
- rm -f /usr/bin/neteasy
Usage:
Usage: neteasy [-c < template >] [-m < interface > [-s < template >]] [-d < interface > [-s < template >]]
-c < template > Config intefaces as set in the given templatefile.
-m < interface > Configure the interface manually.
-s < template > Save the configuration in the given templatefile.
-d < interface > Configure the interface via dhcp
Arguments:
< template > A full path to a templatefile.
< interface > The interface to configure.
Examples:
neteasy -c /path/to/a/templace.conf
The interfaces will be configured as set in the given templatefile.
neteasy -m eth0
Set the interface eth0 manually. No configuration will be saved.
neteasy -m eth0 -s /path/to/my/new/template.conf
Set the interface eth0 manually. The configuration will be saved in the given templatefile. If the file already exists, the file will be overwritten, and all previous settings saved in the templatefile will deleted.
neteasy -d eth0
The interface eth0 will be configured via dhcp.
neteasy -d eth0 -s /path/to/another/template.conf
The interface eth0 will be configured via dhcp. The use of dhcp will be set in the given templatefile. If the file already exists, the file will be overwritten, and all previous settings saved in the templatefile will deleted.
Enhancements:
- A GUI was added to make the program easier to use.

SlpTK is an ANSI C library, a set of utilities, and scripts for natural language processing. It provides data structures and treatments related to lexical and syntactic levels.

Jet Set Willy X is a game for Sinclair ZX Spectrum computer, playable on emulators. Jet Set Willy X is heavily inspired by Jet Set Willy.
There are no guardians and ropes, but the animation is twice as fast, absolutely smooth, and there is a 2-channel background tune.
The rooms are 20 characters high instead of 16, and can have a more complicated combination of graphics characters. There are 69 rooms and over 390 items to collect.
Differences from Jet Set Willy
- There are no guardians, however there are places where you are probably going to swear even without them.
- The guy walks twice as fast, the animation is smooth 50Hz instead of 25Hz, the guy has twice as much positions and the sprites are a bit different
- There are no ropes
- There is a 2-channel tune instead of 1-channel
- The guy can fall through a 1-character hole
- The rooms are 20 chars high instead of 16
- There are much more available different characters in one room
- The attributes in the room are not used to encode meaning of the characters, they can be set arbitrarily
- What happens after the game is completed is a bit more fun
- The jump looks a bit different
- When the guy enters a room from sideways, he doesnt start 1 character away from the edge, but at the edge
- The kill and collect sounds are different
- The kill and collect events generate an effect in the border
- The main voice of the tune continues playing during the kill or collect sound
- The initial scrolling of text is pixel-smooth
- There are 69 rooms and over 390 items to collect
The screenshot and the description are released under the terms of GFDL license.