Free york lottery software for linux

metaf2xml project parses and decodes aviation routine weather reports (METAR, SPECI), aerodrome forecasts (TAF), and synoptic observations (SYNOP) and stores the components in XML (all done in Perl). There are also XSLT style sheets to convert the XML to plain language (text, HTML), or XML with different schemas, and a command line and a web-based (CGI) user interface.
All parts of the messages are parsed, some common format errors are corrected or tolerated.
METAR and SPECI (weather observation) and TAF (weather forecast) information is essential for flight planning and in-flight decisions (real flight and simulation). It is regularily compiled by meteorologists at about 3,500 airports worldwide and distributed via reliable, non-public networks. Information for SYNOP is collected by more than 11,000 manned and unmanned meteorological stations around the world and is used for weather forecasting and climatic statistics. The raw format is abbreviated, some items are coded. Here are some METAR, TAF, and SYNOP messages from Rio (SBGL, 83746), New York (KJFK, 74486), and Tokyo (RJTT, 47662):
SBGL 300600Z 33002KT 9999 SCT015 BKN070 14/11 Q1027
SBGL 300300Z 300606 33005KT 8000 SCT020 BECMG 0810 5000 BR SCT013 BECMG 1113 27005KT
8000 NSW SCT018 BECMG 1517 21010KT SCT020 BECMG 2123 17005KT BECMG 0002 00000KT SCT015 TN17/09Z TX22/16Z RMK PGY
KJFK 300551Z 00000KT 5SM HZ BKN030 BKN048 OVC130 23/20 A2996
AMD KJFK 300255Z 300324 VRB04KT 5SM BR SCT020 BKN060 TEMPO 0406 BKN020 FM0600 VRB03KT
3SM BR OVC009 FM1300 VRB05KT 6SM HZ SCT025 BKN100 FM1700 17008KT P6SM SCT040CB BKN100
RJTT 300630Z 08012KT 9999 -SHRA FEW010 BKN040 23/20 Q1008
RJTT 300552Z 300615 05014KT 9000 FEW010 SCT030 TEMPO 1215 3000 TSRA FEW008 SCT010 FEW015CB BKN020
RJTT 300249Z 301206 04015KT 7000 FEW008 SCT020 BKN030 TEMPO 1218 3000 TSRA BKN008
BKN020 SCT020CB TEMPO 1821 4000 BR BECMG 0306 14006KT
AAXX 30034 83746 41462 73404 10136 20115 40291 58005 71022 84530
AAXX 30064 74486 31558 80000 10228 20200 30134 40144 58003 705// 90551 333 10250 20222 555 93006
AAXX 30064 47662 11/70 70706 10231 20180 30043 40085 50000 60151 70298 8527/
The intended users are flight simmers, private pilot (students) who want to extend their knowledge about the message formats, and everyone who just wants to know what the weather is/will be at some station in plain language.
Enhancements:
- This release brings changes to the user interface and a few smaller improvements and bugfixes.

JAL project is a rewrite of Wouter van Ooijens famous Just Another Language.
JAL adds the following enhancements to the original:
More variable types:
- BIT - 1 bit
- BYTE - 8 bit, unsigned
- SBYTE - 8 bit, signed
- WORD - 16 bit, unsigned
- SWORD - 16 bit, signed
- DWORD - 32 bit, unsigned
- SDWORD - 32 bit, signed
- user defined : [S]BYTE*n, creates an n-BYTE signed or unsigned
- Allow an index in FOR loops (FOR expr USING var...)
- Built-in multiply and divide
- Variables automatically placed on any page
- CASE statement for flow control
- Co-operative multi-tasking
Enhancements:
- 12 bit support was added.
- It can generate .COD files for use with MPLAB or others.
- Files for MPLAB 5.x integration are included.
- Flexible arrays are now supported.
- Numerous bugs were fixed.

GraphViz is a Perl interface to the GraphViz graphing tool.

SYNOPSIS

use GraphViz;

my $g = GraphViz->new();

$g->add_node(London);
$g->add_node(Paris, label => City ofnlurve);
$g->add_node(New York);

$g->add_edge(London => Paris);
$g->add_edge(London => New York, label => Far);
$g->add_edge(Paris => London);

print $g->as_png;

This module provides an interface to layout and image generation of directed and undirected graphs in a variety of formats (PostScript, PNG, etc.) using the "dot", "neato", "twopi", "circo" and "fdp" programs from the GraphViz project (http://www.graphviz.org/ or http://www.research.att.com/sw/tools/graphviz/).

What is a graph?

A (undirected) graph is a collection of nodes linked together with edges.
A directed graph is the same as a graph, but the edges have a direction.

What is GraphViz?

This module is an interface to the GraphViz toolset (http://www.graphviz.org/). The GraphViz tools provide automatic graph layout and drawing. This module simplifies the creation of graphs and hides some of the complexity of the GraphViz module.

Laying out graphs in an aesthetically-pleasing way is a hard problem - there may be multiple ways to lay out the same graph, each with their own quirks. GraphViz luckily takes part of this hard problem and does a pretty good job in a couple of seconds for most graphs.

Why should I use this module?

Observation aids comprehension. That is a fancy way of expressing that popular faux-Chinese proverb: "a picture is worth a thousand words".
Text is not always the best way to represent anything and everything to do with a computer programs. Pictures and images are easier to assimilate than text. The ability to show a particular thing graphically can aid a great deal in comprehending what that thing really represents.

Diagrams are computationally efficient, because information can be indexed by location; they group related information in the same area. They also allow relations to be expressed between elements without labeling the elements.
A friend of mine used this to his advantage when trying to remember important dates in computer history. Instead of sitting down and trying to remember everything, he printed over a hundred posters (each with a date and event) and plastered these throughout his house. His spatial memory is still so good that asked last week (more than a year since the experiment) when Lisp was invented, he replied that it was upstairs, around the corner from the toilet, so must have been around 1958.

Spreadsheets are also a wonderfully simple graphical representation of computational models.

System.FilePath is a Haskell library from Yhc originally, now with added tweaks. Pure Haskell 98 (with Hierarchical libraries), no preprocessor. It has a nice interface for doing file manipulations, and works portably between Windows and Unix. [Not the same as http://darcs.haskell.org/~lemmih/FilePath/]

The interface is still changing, for that reason please use System.FilePath.Version_0_10 or System.FilePath.Version_0_11 which will be guaranteed to work unmodified in future releases.

I have written a System.FilePath module in part based on the one in
Yhc, and in part based on the one in Cabal (thanks to Lemmih). The aim
is to try and get this module into the base package, as FilePaths are
something many programs use, but its all too easy to hack up a little
function that gets it right most of the time on most platforms, and
there lies a source of bugs.

This module is Posix (Linux) and Windows capable - just import
System.FilePath and it will pick the right one. Of course, if you
demand Windows paths on all OSs, then System.FilePath.Windows will
give you that (same with Posix). Written in Haskell 98 + Heirarchical
Modules.

Haddock:
http://www-users.cs.york.ac.uk/~ndm/projects/filepath/System-FilePath.html
Darcs: darcs get http://www.cs.york.ac.uk/fp/darcs/filepath
Source: http://www.cs.york.ac.uk/fp/darcs/filepath/System/FilePath.hs
Homepage: http://www-users.cs.york.ac.uk/~ndm/projects/libraries.php

If you go to the haddock page there are a few little examples at the
top of the file.

Acknowledgements

Thanks to Marc Webber, shapr, David House, Lemmih, others...

Competitors

System.FilePath from Cabal, by Lemmih
FilePath.hs and NameManip.hs from MissingH

The one from Cabal and FilePath.hs in MissingH are both very similar, I
stole lots of good ideas from those two.

NameManip seems to be more unix specific, but all functions in that module
have equivalents in this new System.FilePath module.

Hopefully this new module can be used without noticing any lost functions,
and certainly adds new features/functions to the table.

Should FilePath by an abstract data type?

The answer for this library is no. This is a deliberate design decision.

In Haskell 98 the definition is type FilePath = String, and all functions
operating on FilePaths, i.e. readFile/writeFile etc take FilePaths. The
only way to introduce an abstract type is to provide wrappers for these
functions or casts between Strings and FilePathAbstracts.

There are also additional questions as to what constitutes a FilePath, and
what is just a pure String. For example, "/path/file.ext" is a FilePath. Is
"/" ? "/path" ? "path" ? "file.ext" ? ".ext" ? "file" ?

With that being accepted, it should be trivial to write
System.FilePath.ByteString which has the same interface as System.FilePath
yet operates on ByteStrings.

libxnm project is a library for parsing and retrieving data from the XNM file format.
The prevailing meta-format used today for serialization is XML. XML was originally written as a markup language, and as such its original intent was to add additional information to free flowing text.
This is indeed what is needed in the context of text markup, e.g. for a web page or a word processor program. But using XML for general purpose object serialization generates very verbose serialization that are way larger than necessary.
Another shortcoming of XML is that there still is no support for binary objects. This again is partly based in its markup roots.
Main features:
- Recursively defined.
- Map to the scalar/table/hash structures of perl/python/ruby
- Not limited by preexisting language formats (JSON).
- Short, consise, visually appealing. Low signal to noise.
- No need to quote keys or one word values.
- Support binary data.
- Tables are enclosed by { } , arrays by [ ].
Examples of XNM
The following example shows a simple program configuration file:
fontsize: 16
fonts: { roman: Sans
italic: "Sans Italic"
bold: "Sans bold"
}
path: ["/usr/bin" "/bin" "/usr/local/bin"]
Here is another example copied from the wikipedia json page:
firstName: John
lastName: Smith
address: {
city: "New York, NY"
zipCode: 10021
streetAddress: "21 2nd Street"
}
phoneNumbers: [
"212 732-1234"
"646 123-4567"
]
The main (only) differences to JSON are:
Single words dont need quotes
Commas are not used between key/value pairs
Here is a third example translated from the gaim prefs file:
core => {
away => {
idle_reporting=>system
away_when_idle=>0
mins_before_way=>10
auto_reply=>awayidle
report_idle=>1
}
buddies => {}
contact => {
last_match => 0
offline_score => 2
away_score => 2
idle_score => 1
}
gaim => {
gtk=> {
browsers=> {
place=>F
command=>"xterm -e lynx %s"
browser=>firefox
new_window=>F
}
plugins => [
/usr/lib/gaim/gaimrc.so
/usr/lib/gaim/ssl-nss.so
/usr/lib/gaim/ssl.so
]
}
}
}
Note that the separater character used between keys and values is => combination like in perl.

xword project is a GTK AcrossLite crossword puzzle application.

xword is a crossword puzzle application that allows users to open and solve AcrossLite puzzle format files (such as The New York Times and The Washington Post).

PHPlottery project is a script for running a simple lottery without requiring users to register. This is simply done by creating a key-pair.

This pair is then known by the user and by the application for later use. To prevent simple abuse, the script can use IP-store/block and cookies. When the lottery should decide the winner, a key-pair will selected out of the database.

The public key of this pair will be sent out to everybody who is supposed to know the result of the lottery. Winners have to submit the correct private key to prove their identity.

X-word is a GTK program for doing crosswords.

Xword is a GTK crossword puzzle program. It reads and writes puzzles in the AcrossLite format used by The New York Times.

It has printing, a clock, a word list, auto-saving, and options to check and reveal letters of the puzzle.