Free us zip codes software for linux

Zip is a compression and file packaging utility for Unix, VMS, DOS, OS/2, Windows 9x/NT, Amiga, Atari, Macintosh, BeOS, SMS/QDOS, MVS, VM/CMS, and others.
Zip is analogous to a combination of the Unix commands tar(1) and compress(1) and is compatible with PKWAREs PKZIP and Nico Maks WinZip. Its part of the Info-ZIP project.
Main features:
- creating zipfiles in a pipe or on a device
- VMS and OS/2 extended file attributes
- conversion between Unix, MS-DOS and Macintosh text file formats
- the ability to run on most of your favorite operating systems.
Enhancements:
- fixed -R operation to match the supplied file patterns in all recursed subdirectories, like PKZIP 2.04 "-p -r" (or PKZIPC 4+ "-recurse")
- handle cases where -x, -R, and -i patterns are mixed
- new example C-Sharp code for using DLLs
- added some directory-search speedups
- fixed bug when encrypting large uncompressible files
- fixed Windows NTFS time problem
- fixed VMS logical name parse problem
- added VMS DEBUG option
- updated VMS help
- fixed selection of files to delete by date
- added -MM option where each input file pattern must match at least one file and all input files must be readable
- added check for when Zip tries to exceed seek limit in output file
- minor changes to compile with Visual C++ 2005
- added support for Unix FIFOs (named pipes)
- other minor fixes

rubyzip is a Ruby module for reading and writing zip files.
Installation:
If you have rubygems you can install rubyzip directly from the gem repository
gem install rubyzip
Otherwise obtain the source (see below) and run
ruby install.rb
To run the unit tests you need to have test::unit installed
rake test
Enhancements:
- Symlink support was added along with support for Unix file permissions.
- Memory usage during decompression was reduced.
- Zip streams now model IO objects more closely.

Zipios++ project is a java.util.zip-like C++ library for reading and writing Zip files. Access to individual entries is provided through standard C++ iostreams. A simple read-only virtual file system that mounts regular directories and zip files is also provided.

Spanned archives are not supported, and support is not planned.

The library has been tested and appears to be working with:

FreeBSD stable and current / gcc 2.95.3
Red Hat Linux release 7.0 / gcc 2.96
Red Hat Linux release 6.2 (Zoot) / egcs-2.91.66
Linux Mandrake release 7.0 (Air) / gcc 2.95.2
SGI IRIX64 6.5 / gcc 2.95.2
SGI IRIX64 6.5 / MIPSpro Compilers: Version 7.30

Zip file access:

The two most important classes are ZipFile and ZipInputStream. ZipInputStream is an istream for reading zipfiles. It can be instantiated directly, without the use of ZipFile. A new ZipInputStream reads from the first entry, and the user can skip to the next entry by calling ZipInputStream::getNextEntry().

ZipFile scans the central directory of a zipfile and provides an interface to access that directory. The user may search for entries with a particular filename using ZipFile::getEntry(), or simply get the complete list of entries with ZipFile::entries(). To get an istream (ZipInputStream) to a particular entry simply use ZipFile::getInputStream().
example_zip.cpp demonstrates the central elements of Zipios++.

A Zip file appended to another file, e.g. a binary program, with the program appendzip, can be read with ZipFile::openEmbeddedZipFile().

libzip library can read, create, and modify zip archives. Files can be added from data buffers, files, or compressed data copied directly from other zip archives.
Changes made without closing the archive can be reverted.
Enhancements:
- New functions were added for adding directories to an archive and to clear the internal error state.
- Zip archives larger than 2 GB and streamed zip archives are now supported.

The United States Postal Service (USPS) has on its web site an HTML form at http://www.usps.com/zip4/ for standardizing an address. Given a firm, urbanization, street address, city, state, and zip, it will put the address into standard form (provided the address is in their database) and display a page with the resulting address.
Scrape::USPS::ZipLookup Perl Module provides a programmatic interface to this service, so you can write a program to process your entire personal address book without having to manually type them all in to the form.
Because the USPS could change or remove this functionality at any time, be prepared for the possibility that this code may fail to function. In fact, as of this version, there is no error checking in place, so if they do change things, this code will most likely fail in a noisy way. If you discover that the service has changed, please email the author your findings.
If an error occurs in trying to standardize the address, then no array will be returned. Otherwise, a four-element array will be returned.
To see debugging output, call $zlu->verbose(1).
SYNOPSIS
#!/usr/bin/perl
use Scrape::USPS::ZipLookup::Address;
use Scrape::USPS::ZipLookup;
my $addr = Scrape::USPS::ZipLookup::Address->new(
Focus Research, Inc., # Firm
, # Urbanization
8080 Beckett Center Drive Suite 203, # Delivery Address
West Chester, # City
OH, # State
45069-5001 # ZIP Code
);
my $zlu = Scrape::USPS::ZipLookup->new();
my @matches = $zlu->std_addr($addr);
if (@matches) {
printf "n%d matches:n", scalar(@matches);
foreach my $match (@matches) {
print "-" x 39, "n";
print $match->to_string;
print "n";
}
print "-" x 39, "n";
}
else {
print "No matches!n";
}
exit 0;
Enhancements:
- Adapt to yet another round of changes to the USPS Zip Lookup web site, courtesy of Eric Parker.
- Copyright date updates.

Kunzip is a free (but not opensource) library for decompressing ZIP archives. Kunzip started out as a test program I wrote for decompressing .zip files through a command line program.
I eventually added hooks to make it a DLL that can be used from Windows programs. It is also possible to compile it for Unix (and Unix-like OSs such as Linux) as a .so library.
My plan for the kunzip.dll was to make it as simple to use as possible so it can even be used from VisualBasic or such. It should be fully compatible with zipfiles created by InfoZip, PkZip, and WinZip. You can download it from the link below and view the prototypes for different languages that can call kunzip.dll.
I originally started this code to be able to decompress (and maybe even compress) PNG graphic files. Since this is the same algorithm used in gzip and zip (WinZip, InfoZip, etc), I decided to make it work with .zip files instead. Unfortunately, all the specs I had for this compression were for PNG and Zip is slightly different, so I had some problems getting it working :).
My first version kunzip (which built the huffman tables using arrays instead of trees and did a lot of fseeking) ran painfully slow, but my latest version runs quite well. One interesting thing I found, when I did static huffman decompression for TIFF, I did it using lookup tables instead of trees. This actually ran very fast, altho Im not sure of the speed difference if I used trees instead. On this project, I started out doing all 3 huffman sets using lookup tables.
After I saw how slow it ran, I switched the length huffman codes to a tree and the decompression ran almost double the speed. When I changed the distance huffman codes to trees, the decompression slowed down by a few seconds. So I left length/distance huffman codes as trees and kept the first huffman codes as lookup tables. I may try and improve on the speed even more later.
Not only can you download the source code which can be compiled on both Unix/Linux and Windows, but Ive also included a Windows DLL I built for doing unzipping. I think it is quite easy to use, so if you need an unzip library for Windows, feel free to use this (feel free to make a donation to my PayPal account too if you like.
Btw, this code was written to be compiled on Unix (Linux,FreeBSD,etc) systems. If you want to build the DLL, you can download the source code and type: make dll. The mingw C compiler needs to be used. Im 99% sure I did some things that dont work in Visual C++. I may make it compile to a Unix shared lib too for fun.
The original May 6, 2005 version of kunzip decompresses a 120meg file in about 3min40sec on my AMD Athlon XP box. Since then, I put some major optomizations in and it now decompresses the same file in 20 seconds.
Enhancements:
- The license has been changed to the LGPL.

Geo:Coder:US 1.00 offers a full-feature facility for geocoding US addresses, that is, estimating the latitude and longitude of any street address or intersection in the United States, using the TIGER/Line data set from the US Census Bureau. Geo:Coder:US uses Geo:TigerLine to parse this data, and DB_File to store a highly compressed distillation of it, and Geo:StreetAddress:US to parse addresses into normalized components suitable for looking up in its database.

You can find a live demo of this code at http://geocoder.us/. The demo.cgi script is included in eg/ directory distributed with this module, along with a whole bunch of other goodies. See Geo:Coder:US:Import for how to build your own Geo:Coder:US database.

Consider using a web service to access this geocoder over the Internet, rather than going to all the trouble of building a database yourself. See eg/soap-client.pl, eg/xmlrpc-client.pl, and eg/rest-client.pl for different examples of working clients for the rpc.geocoder.us geocoder web service.

Major Features:

1. Geo:Coder:US->geocode( $string )
   • Given a string containing a street address or intersection, return a list of specifiers including latitude and longitude for all matching entities in the database. To keep from churning over the entire database, the given address string must contain either a city and state, or a ZIP code (or both), or geocode() will return undef.
   • geocode() will attempt to normalize directional prefixes and suffixes, street types, and state abbreviations, as well as substitute TIGER/Line's idea of the "primary street name", if an alternate street name was provided instead.
   • If geocode() can parse the address, but not find a match in the database, it will return a hashref containing the parsed and normalized address or intersection, but without the "lat" and "long" keys specifying the location. If geocode() cannot even parse the address, it will return undef. Be sure to check for the existence of "lat" and "long" keys in the hashes returned from geocode() before attempting to use the values! This serves to distinguish between addresses that cannot be found versus addresses that are completely unparseable.
   • geocode() attempts to be as forgiving as possible when geocoding an address. If you say "Mission Ave" and all it knows about is "Mission St", then "Mission St" is what you'll get back. If you leave off directional identifiers, geocode() will return address geocoded in all the variants it can find, i.e. both "N Main St" and "S Main St".
   • Don't be surprised if geocoding an intersection returns more than one lat/long pair for a single intersection. If one of the streets curves greatly or doglegs even slightly, this will be the likely outcome.
   • geocode() is probably the method you want to use. See more in the following section on the structure of the returned address and intersection specifiers.
2. Geo:Coder:US->geocode_address( $string )
   • Works exactly like geocode(), but only parses addresses.
3. Geo:Coder:US->geocode_intersection( $string )
   • Works exactly like geocode(), but only parses intersections.
4. Geo:Coder:US->filter_ranges( $spec, @candidates )
   • Filters a list of address specifiers (presumably from the database) against a query specifier, filtering by prefix, type, suffix, or primary name if possible. Returns a list of matching specifiers. filter_ranges() will ignore a filtering step if it would result in no specifiers being returned. You probably won't need to use this.
5. Geo:Coder:US->find_ranges( $address_spec )
   • Given a normalized address specifier, return all the address ranges in the database that appear to cover that address. find_ranges() ignores prefix, suffix, and type fields in the specifier for search purposes, and then filters against them ex post facto. The intention for find_ranges() to find the closest match possible in preference to returning nothing. You probably want to use lookup_ranges() instead, which will call find_ranges() for you.
6. Geo:Coder:US->lookup_ranges( $address_spec, @ranges )
   • Given an address specifier and (optionally) some address ranges from the database, interpolate the street address into the street segment referred to by the address range, and return a latitude and longitude for the given address within each of the given ranges. If @ranges is not given, lookup_ranges() calls find_ranges() with the given address specifier, and uses those returned. You probably want to just use geocode() instead, which also parses an address string and determines whether it's a proper address or an intersection automatically.
7. Geo:Coder:US->find_segments( $intersection_spec )
   • Given a normalized intersection specifier, find all of the street segments in the database matching the two given streets in the given locale or ZIP code. find_segments() ignores prefix, suffix, and type fields in the specifier for search purposes, and then filters against them ex post facto. The intention for find_segments() to find the closest match possible in preference to returning nothing. You probably want to use lookup_intersection() instead, which will call find_segments() for you.
8. Geo:Coder:US->lookup_intersection( $intersection_spec )
   • Given an intersection specifier, return all of the intersections in the database between the two streets specified, plus a latitude and longitude for each intersection. You probably want to just use geocode() instead, which also parses an address string and determines whether it's a proper address or an intersection automatically.

Requirements: Perl

Resistor Color Code Calculator project calculates the value of a resistor (an electronic component).

The colors on the resistor are input into the program, and the result displays the resistance value of the resistor.

This is much easier than memorizing rhymes to remember colors.