Free result sets software for linux

Rauls classes for PHP is an OOP database abstraction layer for PHP 5.1 or greater. Rauls classes for PHP provides abstract classes to access database servers and traverse result sets.
There are several implementation classes to access different types of databases: SQLite, MySQL, PostgreSQL, and MSSQL.
The classes provide functions to establish connections, execute queries, traverse result sets with pagination support, and retrieve the list of databases, tables and fields. Any possible error is signaled by throwing exceptions with specific message and error code.
Enhancements:
- A quickref.txt file was added to the project.
- A totalRows get property was included for SQL result objects.
- A third optional parameter was added to the printPageSelect method in order to return the page < select > code as an string instead of printing it.

Fuzzy sets for Ada is a library providing implementations of confidence factors with the operations not, and, or, xor, +, and *, classical fuzzy sets with the set-theoretic operations and the operations of the possibility theory, intuitionistic fuzzy sets with the operations on them, fuzzy logic based on the intuitionistic fuzzy sets and the possibility theory; fuzzy numbers, both integer and floating-point with conventional arithmetical operations, and linguistic variables and sets of linguistic variables with operations on them. Fuzzy sets for Ada has support for string-oriented I/O.
Main features:
- Confidence factors with the operations not, and, or, xor, +, *;
- Classical fuzzy sets with the set-theoretic operations and the operations of the possibility theory;
- Intuitionistic fuzzy sets with the operations on them;
- Fuzzy logic based on the intuitionistic fuzzy sets and the possibility theory;
- Fuzzy numbers both integer and floating-point ones with conventional arithmetical operations;
- Dimensioned fuzzy numbers;
- Linguistic variables and sets of linguistic variables with operations on them;
- String-oriented I/O is supported.
Enhancements:
- The code was tested with GNAT Ada 2005 (GCC 4.0.2 20051125).
- A bug was fixed in Fuzzy.Linguistics.Sets.Defuzzify, which led to incorrect defuzzification with a descending membership function.

Magellan Metasearch is a modular meta search engine, enabling users to monitor as many search engines as they want.
Magellan Metasearch provides a complex query language with standard boolean operators, meta-operators (to search through pages metadata), and proximity operators.
This language enables users to perform far more complex queries than what common search engines currently support. It can be fed any custom sources, since its abstraction layer manages the search results and their meta tags in a uniform way.
In conjunction with the local process scheduler (such as "cron"), Magellan enables you to save your requests and replay them later automatically; new results are sent through email and RSS in realtime. Magellan also provides full anonymity through smart multi-proxy support.
Enhancements:
- This release enhances the automated parsing mechanism ; it also fixes a problem with small result sets that occasionally couldnt be extracted.
- Moreover, new virtual sources are automatically tested on creation / update to check their validity.

Religion::Islam::PrayerTimes is a Perl module that calculates Muslim Prayers Times and Sunrise.

SYNOPSIS

use Religion::Islam::PrayerTimes;

#create new object with default options
my $prayer = Religion::Islam::PrayerTimes->new();

#Juristic Methods:
# 1 = Standard (Imams Shafii, Hanbali, and Maliki),
#2 = Hanafi
#The difference is in the Aser time only
$prayer->JuristicMethod(1);

# Calculation Method
#1: Umm Al-Qura Committee
#2: Muslim World League
#3: Egyptian General Authority of Survey
#4: University Of Islamic Sciences, Karachi
#5: ISNA, Islamic Society of North America
$prayer->CalculationMethod(3);

# Q. What is daylight saving? Ans. Many countries try to adopt their work time by subtracting
# from their clocks one hour in the Fall and Winter seasons.
$prayer->DaylightSaving(1);
#print "DaylightSaving: ". $prayer->DaylightSaving() ."n";

# set the location to clculate prayer times for.
# for Cairo, Egypt:
# http://heavens-above.com/countries.asp
$prayer->PrayerLocation(
Latitude => 30.050,
Longitude => 31.250,
Altitude => 24,
TimeZone => 2
);

my ($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime(time);
$mon++; $year += 1900;

#Adjust the Gregorian Dates by making sure that the month lengths
#are correct if not so take the extra days to next month or year.
my ($yg0, $mg0, $dg0) = $prayer->GDateAjust($year, $mon, $mday);
# Now calculate the prayer times. Times returns in hours decimal format

#%result = $prayer->PrayerTimes($year, $mon, $mday);
%result = $prayer->PrayerTimes($yg0, $mg0, $dg0);

#print "Fajr: " . $result{Fajr} . "n";
#print "Sunrise: " . $result{Sunrise} . "n";
#print "Zohar: " . $result{Zohar} . "n";
#print "Aser: " . $result{Aser} . "n";
#print "Maghrib: " . $result{Maghrib} . "n";
#print "Isha: " . $result{Isha} . "n";
#print "Fajir Rabita: " . $result{FajirRabita} . "n"; #Fajer using exact Rabita method for places >48
#print "Isha Rabita: " . $result{IshaRabita} . "n"; #Ash using exact Rabita method for places >48
#print "Eid Prayer Time: " . $result{Eid} . "n"; #Eid Prayer Time
#print "n";

# set time mode for 12 or 24 hour for FormatTime function.
$prayer->TimeMode(1);
#print time formated
#print "TimeMode: " . $prayer->TimeMode() ."n";

my ($h, $m, $ap);

($h, $m, $ap) = $prayer->FormatTime($result{Fajr});
print "Fajr: $h:$m $apn";

($h, $m, $ap) = $prayer->FormatTime($result{Sunrise});
print "Sunrise: $h:$m $apn";

($h, $m, $ap) = $prayer->FormatTime($result{Zohar});
print "Zohar: $h:$m $apn";

($h, $m, $ap) = $prayer->FormatTime($result{Aser});
print "Aser: $h:$m $apn";

($h, $m, $ap) = $prayer->FormatTime($result{Maghrib});
print "Maghrib: $h:$m $apn";

($h, $m, $ap) = $prayer->FormatTime($result{Isha});
print "Isha: $h:$m $apn";

#($h, $m, $ap) = $prayer->FormatTime($result{FajirRabita});
#print "Fajir Rabita: $h:$m $apn"; #Fajer using exact Rabita method for places >48

#($h, $m, $ap) = $prayer->FormatTime($result{IshaRabita});
#print "Isha Rabita: $h:$m $apn"; #Ash using exact Rabita method for places >48

#($h, $m, $ap) = $prayer->FormatTime($result{Eid});
#print "Eid Prayer Time: $h:$m $apn"; #Eid Prayer Time

Rose::Class::MakeMethods::Set is a Perl module to create class methods to manage sets.

SYNOPSIS

package MyClass;

use Rose::Class::MakeMethods::Set
(
inheritable_set =>
[
required_name =>
{
add_implies => add_valid_name,
test_method => name_is_required,
},
],

inherited_set =>
[
valid_name =>
{
test_method => name_is_valid,
},
],
);

...

package MySubClass;
our @ISA = qw(MyClass);
...

MyClass->add_valid_names(A, B, C);
MyClass->add_required_name(D);

$v1 = join(,, MyClass->valid_names); # A,B,C,D;
$r1 = join(,, MyClass->required_names); # D

$v2 = join(,, MySubClass->valid_names); # A,B,C,D;
$r2 = join(,, MySubClass->required_names); # D

MySubClass->add_required_names(X, Y);

$v2 = join(,, MySubClass->valid_names); # A,B,C,D,X,Y;
$r2 = join(,, MySubClass->required_names); # D,X,Y

MySubClass->delete_valid_names(B, X);

$v1 = join(,, MyClass->valid_names); # A,B,C,D;
$r1 = join(,, MyClass->required_names); # D

$v2 = join(,, MySubClass->valid_names); # A,C,D,Y;
$r2 = join(,, MySubClass->required_names); # D,X,Y

MySubClass->delete_required_name(D);

$v1 = join(,, MyClass->valid_names); # A,B,C,D;
$r1 = join(,, MyClass->required_names); # D

$v2 = join(,, MySubClass->valid_names); # A,C,D,Y;
$r2 = join(,, MySubClass->required_names); # X,Y

Text::Yats is Yet Another Template System.

SYNOPSIS

use Text::Yats;

my $template = < < ENDHTML;
< html >
< head >
< title >$title - $version< /title >
< /head >
< body >
< form >
< select name="names" >< !--{1}-- >
< option $selected >$list< /option >
< !--{2}-- >< /select >
< /form >
< /body >
< /html >
ENDHTML

my $result = "";
my $tpl = Text::Yats- >new(
level = > 1,
text = > $template);

$result .= $tpl- >section- >[0]- >replace(
title = > "Yats",
version = > "Development", );

$result .= $tpl- >section- >[1]- >replace(
list = > [hdias,anita,cubitos],
selected = > { value = > "selected",
array = > "list",
match = > "anita", } );

$result .= $tpl- >section- >[2]- >text;
print $result;

Php Object Generator on short POG is an open source PHP code generator which automatically generates clean & tested Object Oriented code for your PHP4/PHP5 application.
Over the years, we realized that a large portion of a PHP programmers time is wasted on repetitive coding of the Database Access Layer of an application simply because different applications require different objects.
By generating PHP objects with integrated CRUD methods, POG gives you a head start in any project and saves you from writing and testing SQL queries. The time you save can be spent on more interesting areas of your project. But dont take our word for it, give it a try!
Main features:
- Generates clean & tested code
- Generates CRUD methods
- Compatible with PHP4 & PHP5
- Compatible with PDO
- Free for personal use
- Free for commercial use
- Open Source
Enhancements:
- POG now fetches result set arrays where possible (which provides a big performance boost).
- Data encoding is handled within the database.
- A new plugin interface is used.
- A data encoding sanity check was added to setup.
- Siblings can be deleted without deleting children.
- Getlist() accepts column names as filters.
- Getlist(), GetChild(), and GetSibling() return all results if no arguments are passed.
- A database wrapper class for PDO was added.
- The PDO performance was improved.
- The plugin API, POG base API, and database API were made uniform to prevent plugin versioning.

Search::Tools are tools for building search applications.

SYNOPSIS

use Search::Tools;

my $re = Search::Tools->regexp(query => the quick brown fox);

my $snipper = Search::Tools->snipper(query => $re);

my $hiliter = Search::Tools->hiliter(query => $re);

for my $result (@search_results)
{
print $hiliter->light( $snipper->snip( $result->summary ) );
}

Search::Tools is a set of utilities for building search applications. Rather than adhering to a particular search application, the goal of Search::Tools is to provide general-purpose methods for common search application features. Think of Search::Tools like a toolbox rather than a hammer.

Examples include:

Parsing search queries for the meaningful keywords
Rich regular expressions for locating keywords in the original indexed documents
Contextual snippets showing query keywords
Highlighting of keywords in context

Search::Tools is derived from some of the features in HTML::HiLiter and SWISH::HiLiter, but has been re-written with an eye to accomodating more general purpose features.