Free foot pedal faucet software for linux

Overslack is a slackline simulator/game. A configurable model world containing a slackline, a slacker and ground is visualized and its time evolution is calculated while the user controls the slacker using the mouse. Just like with real slacklining there is no predefined goal, but it keeps track of the time you stand on the line.

The simulated world has only two dimensions. Although the forward direction offers many possibilities on a real slackline, it has very little to do with balancing and is quite uninteresting to simulate. Slow speeds are assumed, so the air resistance is neglected. The time evolution is calculated by applying Newtonian physics numerically as many times per second as the machine can handle.

The speed of the simulated world is configurable, making it run five times as slow as the real world makes it slow enough to be manageable and fast enough to keep the attention up. Unlike normal grass ground, the ground in the simulation is bouncy and doesnt cause injuries. It is (unfortunately) a bit unrealistic, but makes it more fun.

The simulated line behaves according to a quite simple model. An ideal spring between the lines point of equilibrium and the slackers feet makes a good approximation, but an ideal spring gives back all energy it stores, which would cause you to bounce forever without helping with your legs. To simulate some friction, it has a somewhat different spring constant depending on whether its extending or compressing. It is of course fully configurable, so anything from an ideal spring to an old, tired and non-elastic line are possible to simulate.

The slacker is controlled with the mouse. Move the mouse down to extend the legs, and move it up to crouch. Move the mouse to the right to lower your right arm and raise your left, and to the left to do the opposite. This is pretty much all you can do on a real slackline too, except that you can move more than just your arms, but thats just a question of terminology.

The slacker is infinitely fast and strong, if you move the mouse the slacker will move instantly to the new position regardless of the force and energy required.
It is possible to jump off the line and land on it again, with or without bouncing on the ground in between, but to make it simpler the slacker is moved to a perfectly balanced position whenever you press the right mouse button.

In addition to the line, slacker and some on-screen numerical physical information, vectors visualizing location (white), speed (green) and acceleration (red), both translational and rotational, are shown.

Frink is a practical calculating tool and programming language designed to help us all to better understand the world around us, to help us get calculations right without getting bogged down in the mechanics, and to make a tool thats really useful in the real world.
Perhaps youll get the best idea of what Frink can do if you skip down to the Sample Calculations further on this document. Come back up to the top when youre done.
Frink language was named after one of my personal heroes, and great scientists of our time, the brilliant Professor John Frink.
Main features:
- Tracks units of measure (feet, meters, tons, dollars, watts, etc.) through all calculations and allows you to add, subtract, multiply, and divide them effortlessly, and makes sure the answer comes out correct, even if you mix units like gallons and liters.
- Arbitrary-precision math, including huge integers and floating-point numbers, rational numbers (that is, fractions like 1/3 are kept without loss of precision,) and complex numbers.
- Advanced mathematical functions including trigonometric functions (even for complex numbers,) factoring and primality testing, and base conversions.
- Unit Conversion between thousands of unit types with a huge built-in data file.
- Date/time math (add offsets to dates, find out intervals between times,) timezone conversions, and user-modifiable date formats.
- Translates between several human languages, including English, French, German, Spanish, Portuguese, Dutch, Korean, Japanese, Russian, Chinese, Swedish, and Arabic.
- Calculates historical buying power of the U.S. dollar and British pound.
- Calculates exchange rates between most of the worlds currencies.
- Powerful Perl-like regular expression capabilities and text processing.
- Supports Unicode throughout, allowing processing of almost all of the worlds languages.
- Reads HTTP and FTP-based URLs as easily as reading local files, allowing fetching of live web-based data.
- Runs on most major operating systems (anything with Java 1.1 or later,) as an applet, through a web-based interface, on a wireless Palm VII, on an HDML- or WML-based webphone, and on many mobile phones and hand-held devices.
- Installs itself on your system in seconds using Java Web Start and automatically keeps itself updated when new versions of Frink are released.
- Runs with a Graphical User Interface (both Swing and AWT) or a command-line interface.
- User interface has a Programming Mode which allows you to write, edit, save, and run extremely powerful programs even on a handheld device.
- Powers Frink Server Pages, a system for providing dynamic web pages powered by Frink.
- Frink is a full-fledged programming language with arrays, dictionaries, functions, loops, even object-oriented programming and self-evaluation.
- Frink allows Object-Oriented Programming, which allows you to create complex data structures that are still easy to use.
- Java Introspection layer allows you to call any Java code from within Frink.
- Frink can also be embedded in a Java program, giving your Java programs all the power of Frink.
- Did I mention its free? If you find it useful, please donate something. Id really appreciate it!
Enhancements:
- This release fixes a problem in break statements that might lead to a "Break statement used outside a loop" error.

The normal desktop calculators seem counter-intuitive to me. Why emulate the limited interface (ie a numeric pad) of a pocket calculator, when youve got the power of a desktop computer and keyboard at your finger tips.

SuperKaramba Calculator is a very simple calculator theme, with a lot of hidden power. It uses the google calculator as its engine, which means that it can do complex calculations from a very simple interface. If the calculation is a simple mathematical expression, the theme will use the bc program, rather than going online. It does unit conversions and currency conversions as well.

You can enter an equation in mathematical notation, or in everyday language. For example:

four plus five
4+5
2000 kilometers per hour in feet per year

The theme stores the last 10 queries, so that you can go back over them.

The theme checks for invalid characters, and parentheses mismatches.

The theme also allows you to use the keyword "ans" in your query, which will substitute the last result into your current query. This could save typing a lot of text if youre chaining queries together.

How to use it ...

This is so simple to use, it doesnt really need a manual. The theme consists of three elements. A text entry box, a text display and a button.

To run a calculation, put your query in the text box. Then left click the button. The theme will go off and do its magic, and come back with an answer that will be displayed as text underneath the text box.

Sometimes what you enter may not be able to be processed, either because youve typed it wrong, or it doesnt understand you, or because youre asking it to do too much. If that is the case, then the theme will tell you.

To access previous queries, middle click on the button, and select the relevant query from the dropdown list.

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.

Versatile Cursors for GNUemacs is a set of emacs commands managing an "item" cursor (e.g. a word, expression, sentence, or defun).
Versatile Cursors for GNUemacs quickly re-assigns the cursor keys between these as needed. Built on this are high-level actions such as converting code blocks to separate functions.
This provides elegant and concise editing, and is pedal- and voice-friendly.
Main features:
- A block (or region) cursor, with motion and text selection by semantically significant units e.g. statements, statement parts, sentences, phrases, table rows and cells
- Editing in terms of these (e.g. ``Make the selected code conditional or ``Delete the selected text)
- Easy access to these through flexible, dynamic, rebinding of the arrow keys and others, with easy ways to navigate the space of possible navigation spaces
- High-level editing operations such as:
- Converting an expression to a local variable initialized to that value
- Converting a block of code to a procedure/function, working out automatically what parameters are required
- Means to access these (and other) navigation and editing commands through a narrow-channel interface such as footswitches (suitable for disability access, including RSI)
- Voice access setup for use with emacs-vr-mode
Enhancements:
- Mostly bug fixes, including a long-standing one for the mode changing wrongly on coming out of the minibuffer.

Push Puppet Toy is a computer-controlled puppet that stands to attention when a friend joins an IRC channel, and collapses when he leaves.
Push Puppet Toy project was inspired by the Availabot from Schulze and Webb (http://schulzeandwebb.com/2006/availabot/). The Availabot is a puppet guy that rises to its feet when a friend comes online on IM, and falls over when the friend disappears. Its a cool little toy, but it has 3 shortcomings:
- It doesnt exist yet
- It apparently wont work in Linux
- The puppet guy looks menacing, although I understand it will be customizable
But the Availabot is obviously only a push puppet with a servo. So its easy to make a similar device with a push puppet of your liking.
Enhancements:
- A Pidgin version of the Gaim plugin was added.

Live Loops is a audio looping software for live music production. You need to have allegro library installed to compile/run this:
Download the latest Work in Progress version from here: http://sunsite.dk/allegro/wip.html

NOTICE: This program wont run unless you create a sub-directory where you are executing it called samples with all of your samples in it (wav format).

This program will attempt to run in a window. If that fails it will attempt to use framebuffer (under linux).

Essentially i wrote this for my own purposes and i wanted a very simple way of putting loops together, and outputting them through existing soundcard hardware into an external mixer.

To do in the following versions:

1) put in some code to send a pulse to the parallel port to control the timing of my Commodore64 computer (running custom music software found on this server in /dev/aSid/current/) This functionality was present in v0.1 before I ported to linux.

2) Put in some audio-input functionality so that a user could record a bar of say, guitar, and that bar would be looped over whilst they played other stuff over the top. Nice for making very live sounding looped music. Sort of like a delay pedal.