Free genius babies software for linux

Geo::Distance is a Perl module that can calculate distances and closest locations.

SYNOPSIS

use Geo::Distance;
my $geo = new Geo::Distance;
$geo->formula(hsin);
$geo->reg_unit( toad_hop, 200120 );
$geo->reg_unit( frog_hop => 6 => toad_hop );
my $distance = $geo->distance( unit_type, $lon1,$lat1 => $lon2,$lat2 );
my $locations = $geo->closest(
dbh => $dbh,
table => $table,
lon => $lon,
lat => $lat,
unit => $unit_type,
distance => $dist_in_unit
);

This perl library aims to provide as many tools to make it as simple as possible to calculate distances between geographic points, and anything that can be derived from that. Currently there is support for finding the closest locations within a specified distance, to find the closest number of points to a specified point, and to do basic point-to-point distance calculations.

METHODS

new

my $geo = new Geo::Distance;
my $geo = new Geo::Distance( no_units=>1 );

Returns a blessed Geo::Distance object. The new constructor accepts one optional argument.

no_units - Whether or not to load the default units. Defaults to 0 (false).
kilometer, kilometre, meter, metre, centimeter, centimetre, millimeter,
millimetre, yard, foot, inch, light second, mile, nautical mile,
poppy seed, barleycorn, rod, pole, perch, chain, furlong, league,
fathom

formula

if($geo->formula eq hsin){ ... }
$geo->formula(cos);

Allows you to retrieve and set the formula that is currently being used to calculate distances. The availabel formulas are hsin, polar, cos, and mt. hsin is the default and mt/cos are depreciated in favor of hsin. polar should be used when calculating coordinates near the poles.

reg_unit
$geo->reg_unit( $radius, $key );
$geo->reg_unit( $key1 => $key2 );
$geo->reg_unit( $count1, $key1 => $key2 );
$geo->reg_unit( $key1 => $count2, $key2 );
$geo->reg_unit( $count1, $key1 => $count2, $key2 );

This method is used to create custom unit types. There are several ways of calling it, depending on if you are defining the unit from scratch, or if you are basing it off of an existing unit (such as saying 12 inches = 1 foot ). When defining a unit from scratch you pass the name and rho (radius of the earth in that unit) value.

So, if you wanted to do your calculations in human adult steps you would have to have an average human adult walk from the crust of the earth to the core (ignore the fact that this is impossible). So, assuming we did this and we came up with 43,200 steps, youd do something like the following.

# Define adult step unit.
$geo->reg_unit( 43200, adult step );
# This can be read as "It takes 43,200 adult_steps to walk the radius of the earth".

Now, if you also wanted to do distances in baby steps you might think "well, now I gotta get a baby to walk to the center of the earth". But, you dont have to! If you do some research youll find (no research was actually conducted) that there are, on average, 4.7 baby steps in each adult step.

# Define baby step unit.
$geo->reg_unit( 4.7, baby step => adult step );
# This can be read as "4.7 baby steps is the same as one adult step".

And if we were doing this in reverse and already had the baby step unit but not the adult step, you would still use the exact same syntax as above.
distance

my $distance = $geo->distance( unit_type, $lon1,$lat1 => $lon2,$lat2 );

Calculates the distance between two lon/lat points.
closest

my $locations = $geo->closest(
dbh => $dbh,
table => $table,
lon => $lon,
lat => $lat,
unit => $unit_type,
distance => $dist_in_unit
);

This method finds the closest locations within a certain distance and returns an array reference with a hash for each location matched.

The closest method requires the following arguments:

dbh - a DBI database handle
table - a table within dbh that contains the locations to search
lon - the longitude of the center point
lat - the latitude of the center point
unit - the unit of measurement to use, such as "meter"
distance - the distance, in units, from the center point to find locations

The following arguments are optional:

lon_field - the name of the field in the table that contains the longitude, defaults to "lon"
lat_field - the name of the field in the table that contains the latitude, defaults to "lat"
fields - an array reference of extra field names that you would like returned with each location
where - additional rules for the where clause of the sql
bind - an array reference of bind variables to go with the placeholders in where
sort - whether to sort the locations by their distance, making the closest location the first returned
count - return at most these number of locations (implies sort => 1)

This method uses some very simplistic calculations to SQL select out of the dbh. This means that the SQL should work fine on almost any database (only tested on MySQL and SQLite so far) and this also means that it is fast. Once this sub set of locations has been retrieved then more precise calculations are made to narrow down the result set. Remember, though, that the farther out your distance is, and the more locations in the table, the slower your searches will be.

Acme::Time::Baby - tell time little children can understand.

SYNOPSIS

use Acme::Time::Baby;
print babytime; # Prints current time.

use Acme::Time::Baby language => du;
print babytime "10:15"; # Prints a quarter past ten in a way
# little Dutch children can understand.

Using this module gives you the function babytime, which will return the time in the form The big hand is on the ten and the little hand is on the three. If no argument to babytime is given, the current time is used, otherwise a time of the form hh:mm can be passed. Both 12 and 24 hour clocks are supported.

When using the module, various options can be given. The following options can be passed:

language LANG

The language the time should be told in. The following languages are currently supported:

en English (this is the default)
br Brazilian Portuguese.
ceb Cebuano (Filipine dialect)
de German.
de_ch Swiss German.
du Dutch.
es Spanish.
fr French.
it Italian.
no Norwegian.
se Swedish.
swedish chef Swedish Chef (from the Muppets).
warez l44+.

If no language argument is given, English is used.
Note that some languages use accented letters. The returned sentences are correct for an ISO 8859-1 platform.

format STRING

This is the format used to represent the time. It will be passed to sprintf, and it should have two %s formatting codes. The other two arguments to sprintf are the position of the minute hand (the big hand) and the hour hand (the little hand). If you have perl 5.8 or above, you could use %2$s and %1$s to reverse the order.

number ARRAYREF

An array with the names of the numbers one to twelve, to be used in the formatted time.

noimport EXPR

By default, the sub babytime will be exported to the calling package. If for some reason the calling package does not want to import the sub, there are two ways to prevent this. Either use use Acme::Time::Baby (), which will prevent Acme::Time::Baby::import to be called, or pass noimport followed by a true value as arguments to the use statement.

HTML::ElementSuper is a Perl extension for HTML::Element(3).

SYNOPSIS

use HTML::ElementSuper;

### Positional extension
$e = new HTML::ElementSuper font;
$sibling_number = $e->addr();
$e2 = new HTML::ElementSuper p;
$e2->push_content($e);
#
@coords = $e->position();
$depth_in_pos_tree = $e->depth();

### Replacer extension
$er = new HTML::ElementSuper font;
# Tree beneath $er, if present, is dropped.
$er->replace_content(new HTML::Element p);

### Wrapper extension
$ew = new HTML::ElementSuper;
$ew->push_content("Tickle me, baby");
$ew->wrap_content(new HTML::Element font, color => pink);
print $ew->as_HTML();

### Maskable extension
$em = new HTML::ElementSuper td;
$em->mask(1);
print $em->as_HTML; # nada
$em->mask(0);
print $em->as_HTML; # $e and its children are visible

### Cloning of own tree or another elements tree
### (is this the correct clomenature? :-)
$a = new HTML::ElementSuper font, size => 2;
$b = new HTML::ElementSuper font, color => red;
$a_clone = $a->clone;
$b_clone = $a->clone($b);
# Multiple elements can be cloned
@clone_clones = $a_clone->clone($a_clone, $b_clone);

Boolball is a game where you have to drop balls in a field of obstacles to score points.

Two players each have a row of balls located at the top of the screen, which can be dropped into a field of obstacles. Players take turns dropping one of their balls. The lower the balls fall, the higher the score. Get to the bottom of the field for maximum points. Outsmart your opponent by blocking their balls.

Features easy, medium and difficult computer players to play against, or play head to head with your friends.

Objective

The objective, as with many games, is to score more points than your opponent. Each player has a row of balls, located at the top of the screen, which can be dropped into a field of obstacles. Players take turns dropping one of their balls. The lower the balls fall, the higher the score (2 points per row). The bottom of the field is worth even more: 60 points.

Obstacles

There are various obstacles in the playing field:

Arrows- Left or right arrows make your balls move one square in the way the arrow is pointed The arrow flips the other way as soon as your ball has passed it.
Gray blocks- These babies block any ball instantly. Rest assured though, the gray blocks are removed at the end of the round for instant bonus points.
Teleporters- For that added element of surprise, teleporters randomly teleport your ball to another teleporter.
Bonus blocks- 10 points. Free. Its only there for one player, so grab it before your opponent does.

Strategy and tips

Keep balls that will reach the bottom no matter what for last. They are not very interesting for strategic purposes, see below.

Try to drop those balls which will have a negative effect on your opponents score first, and those balls which will perhaps score better after your opponents balls last.

Go for the bonus blocks, of course, but dont worship them. Balls that hit the bottom of the field are worth far more than a bonus block.

End of the game

The game is over when neither player can drop any more balls; either because they are out of balls or because all the balls are blocked by the opponent. The gray blocks are removed and all balls than can fall do so, scoring more points for their owners in the process. The scores are counted, and the player with the highest score wins!

Volume.app is a small graphical software utility enabling quick and convenient control of a computers audio volume level. Volume.app is intended for use on Linux/Unix systems in conjunction with an X window manager that supports dockable applications ("dockapps") such as AfterStep, BlackBox, or Window Maker.

It is a refinement of an idea that first appeared in Timecops WMix: a user interface comprising a "knob" that can be interactively "turned" by clicking and dragging the mouse. I found this approach quite appealing, both from an aesthetic viewpoint, and (more importantly) from a user-interface perspective.

A handful of other dockapp volume control programs are out there, and I have tried many of them. An interface element present in most of these is some form of "slider" as the primary means of adjusting the volume. (A fictitious example may be seen at right). To my dismay, with this kind of interface, volume adjustments tended to be large and abrupt. Because the slider was so small, raising or lowering the volume "just a bit" required extremely careful control of the mouse-- a slip of the hand had the potential to spike the volume to full blast. (I have a set of Altec-Lansing ACS48 speakers which make this a rather unpleasant experience). This approach left much to be desired.

I longed for an alternative, and upon playing with WMix (pictured at left) I had found it. The knob was genius in that it provided a means of graphically adjusting the volume, as a slider would, without tying itself directly to the motion of the mouse. The basic mode of usage is identical: you click on the thing and drag the mouse up or down. However, with the knob, the range of motion need not be confined to the postage-stamp-sized area of the dockapp. The mouse travel needed to cover the entire range of volume settings can be made longer, on the order of the full height of the screen-- almost like a much larger, easier-to-use slider. No longer were precise movements needed to make volume adjustments!

Still, I found WMixs interface to be a bit busy (never was a fan of tiny little buttons) and the all-important knob was yet a rather small target to find with the mouse. So, I grabbed a copy of the WMix source code, and rebuilt it into a dockapp that had a much larger knob as its sole interface element. I dubbed it Volume.app, and have placed it here for the benefit of everyone.