Free foot pedal software for linux

Text::Typography can markup ASCII text with correct typography for HTML.

SYNOPSIS

use Text::Typography qw(typography);

print typography($text);

This module is a thin wrapper for John Grubers SmartyPants plugin for various CMSs.

SmartyPants is a web publishing utility that translates plain ASCII punctuation characters into "smart" typographic punctuation HTML entities. SmartyPants can perform the following transformations:

Straight quotes ( " and ) into "curly" quote HTML entities
Backticks-style quotes (``like this) into "curly" quote HTML entities

Dashes (-- and ---) into en- and em-dash entities

Three consecutive dots (...) into an ellipsis entity
SmartyPants does not modify characters within < pre >, < code >, < kbd >, < script >, or < math > tag blocks. Typically, these tags are used to display text where smart quotes and other "smart punctuation" would not be appropriate, such as source code or example markup.

typography($text[, $attributes])

Returns a string marked up with the proper HTML entities for proper typography.

For fine grain control over what gets converted, use the $attributes option. The default value is 3.

The following numeric values set a group of options:

0 : do nothing
1 : set all
2 : set all, using old school en- and em- dash shortcuts (-- and ---)
3 : set all, using inverted old school en- and em- dash shortcuts (--- and --)

For even finer control, specify a string of one or more of the following characters:

q : quotes
b : backtick quotes (``double only)
B : backtick quotes (``double and `single)
d : dashes
D : old school dashes
i : inverted old school dashes
e : ellipses
w : convert " entities to " for Dreamweaver users

Backslash Escapes

If you need to use literal straight quotes (or plain hyphens and periods), SmartyPants accepts the following backslash escape sequences to force non-smart punctuation. It does so by transforming the escape sequence into a decimal-encoded HTML entity:

Escape Value Character
------ ----- ---------
\
" " "

. . .
- - -
` ` `

This is useful, for example, when you want to use straight quotes as foot and inch marks: 62" tall; a 17" iMac.

Algorithmic Shortcomings

One situation in which quotes will get curled the wrong way is when apostrophes are used at the start of leading contractions. For example:

Twas the night before Christmas.

In the case above, SmartyPants will turn the apostrophe into an opening single-quote, when in fact it should be a closing one. I dont think this problem can be solved in the general case -- every word processor Ive tried gets this wrong as well. In such cases, its best to use the proper HTML entity for closing single-quotes (’) by hand.

LilyPond is an automated engraving system. LilyPond formats music beautifully and automatically and has a friendly syntax for its input files. It is Free Software (?open source?).
Main features:
Music language input.
- The input is done in the form of a textual music language.
- Entry may be done with the text editor of your choice, and using the national language of your choice.
- The ASCII input language can integrate with TeX, HTML and Texinfo, thus allowing musicological treatises to be written from a single source.
- The music and its layout are strictly separated, so score and parts (possibly in different styles and keys) and scores can be generated from the same source, and changes always take effect in both places.
- The output can be improved by upgrading the program.
- Pieces can be printed in different (typographical) house styles, or according to different notational conventions.
Automated high-quality formatting.
- Automatic spacing, line breaking and page breaking.
- Handling of polyphonic collisions for notes, dots, and rests.
- Automatic placement of accidentals, beams, slurs.
- Users dont need typographical expertise to produce good notation.
- No user interaction necessary during running, Running the program can be automated, which is convenient for mass converting databases of digitized music, and printing algorithmic compositions.
- The Feta font has been tailored especially for LilyPond, and was designed carefully mimicking the finest hand-engraved scores. It is available as a scalable font, but also as a Metafont.
- Support for many notation constructs.
Special notation
- Chord names.
- Drum notation.
- Figured bass.
- Grace notes.
- Fret diagrams.
- Basic tablature notation.
- Cluster notation and rhythmic grouping signs.
- Tremolos, both for single notes and chords.
- Tuplets in arbitrary ratios.
- Polymetric notation.
- Mensural notation.
- Automatic cue-notes,.
- Automatic part combining for orchestral scores.
- Quarter tone accidentals.
- Ambituses.
- Metronome markings.
- Harmonics.
- Measure repeats (?Percent style?).
- EasyNotation note heads.
- Blanking arbitrary notation elements.
- Arpeggio signs.
- Ottava brackets.
- Nested analysis brackets.
- Piano pedals.
- Starting and stopping staves anywhere
- System separators
Robust design
- Lyrics in any language.
- Output in PostScript, PDF, PNG, MIDI, SVG.
- No limits on the number of staves, voices, measures, lengths of texts, etc.
- Extensible with built-in LISP interpreter.
Excellent support
- Runs on Unix, including MacOS X and Linux, and Windows.
- Active user community.
- Extensive documentation.
- Supported by many other programs,
- RoseGarden NoteEdit and PowerTab and Denemo. Imports ABC, ETF and MIDI.

CheeseTracker is a software sampler and step-based sequencer. It allows a musician to turn single-note samples into instruments capable of covering three or four octaves (by playing the samples at different speeds, resulting in different pitches). In addition, it is possible to take a collection of samples that are recorded at different octaves, and combine them into a single "instrument," allowing for even more octaves without sampling artifacts.
Using the Pattern Editor, it is possible to compose songs with these instruments that the computer plays automatically. The Pattern Editor allows the user to arrange samples in several independant channels, so that many samples can play simultaneously. These songs, and the samples which comprise their instruments, can be saved together in one-file archives called modules.
CheeseTracker imposes no limits on the length of the samples used. As a result, it can be used as a mixer as well as a sampler/sequencer. Effects such as reverb can be applied to each sample individually, eliminating the need for expensive pedals.
It is distributed under the terms of the GNU General Public License.
CheeseTracker is modeled after a DOS-based freeware program called Impulse Tracker (which has been abandonware since the late 1990s). It is mostly compatible with Impulse Tracker, being able to load Impulse Tracker files.
Main features:
- Unlimited sample size
- Keymaps: Build instruments that use a range of samples, just like a hardware sampler.
- LADSPA sound effect filters with near-analog quality
- Built-in effect filters:
- Amplifier
- Reverb
- Stereo Chorus
- Echo
- Equalizers: 6, 10, 21, and 31 bands
- Distortion
- Pitch Shift
- Effect filters can be combined.
- Up to 64 simultaneous voices
- Volume, pan, and pitch envelopes with sustain loop
- Built-in sample editor
- Sample loops with forward and ping-pong modes
- Compatible with JACK, ALSA, and OSS audio architectures
- Most functions are accessible from the keyboard
- Plays samples at different pitches to create notes
- Simulated live musical keyboard (using a QWERTY keyboard) can play alongside programmed songs

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.

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.

MIDI::Simple is a procedural/OOP interface for MIDI composition.

SYNOPSIS

use MIDI::Simple;
new_score;
text_event http://www.ely.anglican.org/parishes/camgsm/bells/chimes.html;
text_event Lord through this hour/ be Thou our guide;
text_event so, by Thy power/ no foot shall slide;
set_tempo 500000; # 1 qn => .5 seconds (500,000 microseconds)
patch_change 1, 8; # Patch 8 = Celesta

noop c1, f, o5; # Setup
# Now play
n qn, Cs; n F; n Ds; n hn, Gs_d1;
n qn, Cs; n Ds; n F; n hn, Cs;
n qn, F; n Cs; n Ds; n hn, Gs_d1;
n qn, Gs_d1; n Ds; n F; n hn, Cs;

write_score westmister_chimes.mid;

This module sits on top of all the MIDI modules -- notably MIDI::Score (so you should skim MIDI::Score) -- and is meant to serve as a basic interface to them, for composition. By composition, I mean composing anew; you can use this module to add to or modify existing MIDI files, but that functionality is to be considered a bit experimental.

This module provides two related but distinct bits of functionality: 1) a mini-language (implemented as procedures that can double as methods) for composing by adding notes to a score structure; and 2) simple functions for reading and writing scores, specifically the scores you make with the composition language.

The fact that this modules interface is both procedural and object-oriented makes it a definite two-headed beast. The parts of the guts of the source code are not for the faint of heart.