Free examples of thesis statements software for linux

Regular Statement String (RSS) provides several libraries in C, Java, and COM to implement and demonstrate the key-value development method using well-designed "strings" (RSS) as the media. Regular Statement String also shows a way to write "Process Oriented" applications.
Enhancements:
- This release adds an implementation for SUN Solaris (SPARC).

SQL::Statement::Embed can embed a SQL engine in a DBD or module.

SQL::Statement is designed to be easy to embed in other modules and to be especially easy to embed in DBI drivers. It provides a SQL Engine and the other module needs to then provide a data source and a storage mechanism. For example, the DBD::CSV module uses SQL::Statement as an embedded SQL engine by implementing a file-based data source and by using DBI as the user interface. Similarly DBD::Amazon uses SQL::Statement as its SQL engine, provides its own extensions to the supported SQL syntax, and uses on-the-fly searches of Amazon.com as its data source.

SQL::Statement is the basis for eight existing DBDs (DBI database drivers). If you have a new data source, you too can create a DBD without having to reinvent the SQL wheel. Its fun, its easy, become a DBD author today!

SQL::Statement can be also be embedded without DBI. Well explore that first since developing a DBD uses most of the same methods and techniques.

The role of SQL::Statement subclasses

SQL::Statement provides a SQL parsing and execution engine. It does not provide a data source or storage mechanism other than in-memory tables. The DBD::File module is a subclass of SQL::Statement that provides access to file-based storage mechanisms. Its quite possible to use things other than files as data souces, in which case we wouldnt use DBD::File, instead wed replace DBD::Files methods with our own. In the examples below, well use DBD::File, replacing only a few methods.

SQL::Statement provides SQL parsing and evaluation and DBD::File provides file-based storage. The only thing missing is a data source - what we actually want to store and query. As an example suppose we are going to create a subclass called Foo that will provide as a data source a simple file similar to a passwd file - one record per line, fields separated by colons, with only three fields "username, uid, gid".

Consider what needs to happen to perform a SELECT query on our Foo data:

* recieve a SQL string
* parse the SQL string into a request structure
* open the table(s) specified in the request
* define column names and postions for the table
* read rows from the table
* convert the rows from colon-separated format into perl arrays
* match the columns and rows against the requested selection criteria
* return requested rows and columns to the user

To perform operations like INSERT and DELETE, we also need to:

* convert rows from perl arrays into colon-separated format
* write rows
* delete rows

SQL::Statement takes care of all of the SQL parsing and evaluation. DBD::File takes care of file opening, reading, writing, and deleting. So the only things Foo is really responsible for are:

* define column names and postions for the table
* convert rows from colon-separated format into perl arrays
* convert rows from perl arrays into colon-separated format

In SQL::Statement subclasses these responsibilities are assigned to two objects, a ::Statement object is responsible for opening the table, defining the column names and positions, and for creating new ::Table objects. A ::Table object is responsible for reading, converting, writing, and deleting data.

GCJ::Cni::Examples is a Perl module with examples of how to use GCJs CNI interface to write Perl Modules in Java.

EXAMPLES

Writing Treaded modules in Java

One benefit of using GCJ is that it takes advantage of POSIX threading. This is nice since Perls threading model is, shall we say, less than ideal. Now, you could theoretically write a module in C or C++ and and use the standard POSIX library to do your threaded work for you, however, why not take advantage of the nice Threading interface that Java provides to you by default. This may also come in handy if you have a massively threaded Java library that youd like to call from Perl.

For this example assume that I want to do matrix multiplication, albeit in a very crazy manner. Therefore, I will write a Java class, Matrix, and a method, multiply, which will take another matrix to perform the operation between. Heres the crazy part, for each cell in the resulting matrix I will spawn a new thread, as an internal class, and give it a row and a column from which they will derive the result. I know this is a little wierd but the point is that Ill be spawning a lot of new threads. To multiply two 10x10 matrices we will have to spawn 100 threads (one thread per cell in the resulting 10x10 matrix). Imagine doing this in Perl, then imagine doing it in Java; natively compiled Java. Much faster and a lot less headaches.

The Java Interface/pseudocode is as follows:

public class Matrix {
public Matrix ( int numRows, int numCols ) {
...Constructor stuff...
}

public void set ( int row, int col, int val ) {
...set an element...
}

public int get ( int row, int col ) {
...get an element...
}

public Matrix multiply ( Matrix times ) {
...set it up...
for ( int i = 0; i < rows; i++ ) {
for ( int j = 0; j < times.getCols(); j++ ) {
//GO NUTS!!!!
ArrayMultiplier multiplier = new ArrayMultiplier(this, times, result, i, j);
multiplier.start();
...etc...
}
}
...wait for the threads to exit and return the new matrix...
}

public int getRows ( ) {
...get number of rows...
}

public int getCols ( ) {
...get number of columns...
}

public void print ( ) {
...print the matrix to stdout...
}

private class ArrayMultiplier extends Thread {
public ArrayMultiplier ( Matrix a, Matrix b, Matrix result, int row, int col ) {
...Construct this bad boy...
}

public void run ( ) {
int sum = 0;
for ( int i = 0; i < a.getCols(); i++ ) {
sum += (a.get(row, i) * b.get(i, col));
}
result.set(row, col, sum);
}

}
}
Now, we want to call this class from Perl. My perferred manner is through SWIG so thats what were going to use. However, you do not need to use SWIG, you can use whatever method you prefer when wrapping C++ classes. We begin by creating a C++ header file from our above class. This is done by using GCJs gcjh utility. First we need to class compile Matrix.java

gcj -C Matrix.java

Then we go ahead and create the header file:

gcjh Matrix

Easy enough. We can then extract the interface we want to have available in Perl from the generated header file and from it create a i file to be used as input to SWIG. I usually start by copying my header file to the same named file but with an i extension instead. I then remove all of the grimy C++ gruff, private methods and variables, slap a module directive on it and call it done. It wont always be this easy though. When youre done an interface file for the above class should look something like this:

%module Matrix;

typedef int jint;

class Matrix
{
public:
Matrix (jint, jint);
virtual void set (jint, jint, jint);
virtual jint get (jint, jint);
virtual ::Matrix *multiply (::Matrix *);
virtual jint getRows ();
virtual jint getCols ();
virtual void print ();
};
We then put SWIG to work and generate our C++ wrapper for Perl:

swig -perl -c++ Matrix.i

After the above command we now will see two new files in our current directory, Matrix.pm and Matrix_wrap.cxx; these correspond the module directive we gave in Matrix.i.

At this point all we have left to do is compile, and use.

gcj -c Matrix.java
gcc -c -I -include Matrix.h Matrix_wrap.cxx
gcc -shared -lgcj -lstdc++ Matrix.o Matrix_wrap.o -oMatrix.so

A simple Perl file using this module might look something like:

sub populate_matrix {
my $matrix = shift;
for ( my $i = 0; $i < $matrix->getRows(); $i++ ) {
for ( my $j = 0; $j < $matrix->getCols(); $j++ ) {
$matrix->set($i, $j, $i * $j);
}
}
}

use GCJ::Cni;
use Matrix;

GCJ::Cni::JvCreateJavaVM(undef);
GCJ::Cni::JvAttachCurrentThread(undef, undef);

my $matrix = new Matrix::Matrix(10, 10);
populate_matrix($matrix);
my $matrix2 = new Matrix::Matrix(10, 10);
populate_matrix($matrix2);
$matrix3 = $matrix->multiply($matrix2);
$matrix3->print();

GCJ::Cni::JvDetachCurrentThread();

Ill leave it up to the reader to write a Perl module that does the same thing, that is, spawns 100 threads. In my own personal fiddling I found that just spawning that many threads (never mind doing any kind of work) was over 3 time slower in Perl. In this situation we at least get to use our favorite language, Perl, and offload some of the heavy hitting to a language more suited for it.

Where this really comes in handy is when you have an existing multi-threaded Java library that you would like to expose to Perl. You could theoretically natively compile various components of your library and then generate Perl bindings to access it. In this way, you get a little extra speed and efficiency as well as code reuse and binding.

[COPRIGHT=1]

EXAMPLES

General

#!/usr/bin/perl -w
use strict;
use DBIx::Simple;

# Instant database with DBD::SQLite
my $db = DBIx::Simple->connect(dbi:SQLite:dbname=file.dat)
or die DBIx::Simple->error;

# Connecting to a MySQL database
my $db = DBIx::Simple->connect(
DBI:mysql:database=test, # DBI source specification
test, test, # Username and password
{ RaiseError => 1 } # Additional options
);

# Using an existing database handle
my $db = DBIx::Simple->connect($dbh);

# Abstracted example: $db->query($query, @variables)->what_you_want;

$db->commit or die $db->error;

Simple Queries

$db->query(DELETE FROM foo WHERE id = ?, $id) or die $db->error;

for (1..100) {
$db->query(
INSERT INTO randomvalues VALUES (?, ?),
int rand(10),
int rand(10)
) or die $db->error;
}

$db->query(
INSERT INTO sometable VALUES (??),
$first, $second, $third, $fourth, $fifth, $sixth
);
# (??) is expanded to (?, ?, ?, ?, ?, ?) automatically

Single row queries

my ($two) = $db->query(SELECT 1 + 1)->list;
my ($three, $four) = $db->query(SELECT 3, 2 + 2)->list;

my ($name, $email) = $db->query(
SELECT name, email FROM people WHERE email = ? LIMIT 1,
$mail
)->list;

Or, more efficiently:

$db->query(SELECT 1 + 1)->into(my $two);
$db->query(SELECT 3, 2 + 2)->into(my ($three, $four));

$db->query(
SELECT name, email FROM people WHERE email = ? LIMIT 1,
$mail
)->into(my ($name, $email));

SYNOPSIS

Plenty of people have learned WWW::Mechanize, and now, you can too!
Following are user-supplied samples of WWW::Mechanize in action.

You can also look at the t/*.t files in the distribution.

Please note that these examples are not intended to do any specific task. For all I know, theyre no longer functional because the sites they hit have changed. Theyre here to give examples of how people have used WWW::Mechanize.

Note that the examples are in reverse order of my having received them, so the freshest examples are always at the top.

Starbucks Density Calculator, by Nat Torkington

Heres a pair of scripts from Nat Torkington, editor for OReilly Media and co-author of the Perl Cookbook.

Rael [Dornfest] discovered that you can easily find out how many Starbucks there are in an area by searching for "Starbucks". So I wrote a silly scraper for some old census data and came up with some Starbucks density figures. Theres no meaning to these numbers thanks to errors from using old census data coupled with false positives in Yahoo search (e.g., "Dodie Starbuck-Your Style Desgn" in Portland OR). But it was fun to waste a night on.

Here are the top twenty cities in descending order of population, with the amount of territory each Starbucks has. E.g., A New York NY Starbucks covers 1.7 square miles of ground.

New York, NY 1.7
Los Angeles, CA 1.2
Chicago, IL 1.0
Houston, TX 4.6
Philadelphia, PA 6.8
San Diego, CA 2.7
Detroit, MI 19.9
Dallas, TX 2.7
Phoenix, AZ 4.1
San Antonio, TX 12.3
San Jose, CA 1.1
Baltimore, MD 3.9
Indianapolis, IN 12.1
San Francisco, CA 0.5
Jacksonville, FL 39.9
Columbus, OH 7.3
Milwaukee, WI 5.1
Memphis, TN 15.1
Washington, DC 1.4
Boston, MA 0.5

Learn HTML By Example is a sweet little JavaScript / HTML program that allows you to see the HTML you input into on side displayed as a web page on the other.
To install the program, just download it from Web Design Factory, and upload it to your web site.
Main features:
- Easy installation. Just upload to your web site and youre done!
- Immediate feedback on testing HTML and CSS code
- Several examples of commonly used HTML and CSS elements
- No page refreshing required
- Easy to expand by adding new examples

dANN library can help create artificial neural networks within other programs. It is currently written in Java, C++, and C#. However, C++ and C# versions can only be obtained through the SVN at the moment.
Also, the C++ and C# versions are not properly documented and cleaned up, although they work. The Java version of the library is well documented and packaged in binary and source form.
The intent is to provide a powerful interface for programs to include artificial neural network technology into their code. It will also act as a testing ground for research and development of new AI concepts.
Enhancements:
- This release was updated to work with the new library layout.

Jifty::DBI::SchemaGenerator is a Perl module to generate table schemas from Jifty::DBI records.

This module turns a Jifty::Record object into an SQL schema for your chosen database. At the moment, your choices are MySQL, SQLite, or PostgreSQL. Oracle might also work right, though its untested.

SYNOPSIS

The Short Answer

See below for where we get the $handle and $model variables.

use Jifty::DBI::SchemaGenerator;
...
my $s_gen = Jifty::DBI::SchemaGenerator->new( $handle );
$s_gen->add_model($model);

my @statements = $s_gen->create_table_sql_statements;
print join("n", @statements, );
...
The Long Version
See Jifty::DBI for details about the first two parts.
MyModel
package MyModel;
# lib/MyModel.pm

use warnings;
use strict;

use base qw(Jifty::DBI::Record);
# your custom code goes here.
1;
MyModel::Schema
package MyModel::Schema;
# lib/MyModel/Schema.pm

use warnings;
use strict;

use Jifty::DBI::Schema;

column foo => type is text;
column bar => type is text;

1;
myscript.pl
#!/usr/bin/env perl
# myscript.pl

use strict;
use warnings;

use Jifty::DBI::SchemaGenerator;

use Jifty::DBI::Handle;
use MyModel;
use MyModel::Schema;

my $handle = Jifty::DBI::Handle->new();
$handle->connect(
driver => SQLite,
database => testdb,
);

my $model = MyModel->new($handle);
my $s_gen = Jifty::DBI::SchemaGenerator->new( $handle );
$s_gen->add_model($model);

# heres the basic point of this module:
my @statements = $s_gen->create_table_sql_statements;
print join("n", @statements, );

# this part is directly from Jifty::Script::Schema::create_all_tables()
$handle->begin_transaction;
for my $statement (@statements) {
my $ret = $handle->simple_query($statement);
$ret or die "error creating a table: " . $ret->error_message;
}
$handle->commit;