Free chemistry classes online software for linux

Gnome Chemistry Utils software provides C++ classes and Gtk+-2 widgets related to chemistry. They are used in both Gnome Crystal and GChemPaint.

To compile and use the Gnome Chemistry Utils, you need libglade-2, and GtkGLExt, and their own dependencies. Everything except GtkGLExt is available from the Gnome repository or one of its mirrors.

The GtkChem3DViewer widget also needs Gnome-vfs and OpenBabel to be built.

GChemistry Utils are distributed under the LGPL license.

Gnome Chemistry Utils are in an early development stage.

Three widgets:

- a periodic table,
- a crystal structure viewer,
- a 3D molecular structure viewer.

The last widget is also accesible as a Bonobo control.

The Gnome Chemistry Utils are the basis for the development of both GChemPaint and Gnome Crystal

Chemistry::Mol is a molecule object toolkit.

SYNOPSIS

use Chemistry::Mol;

$mol = Chemistry::Mol->new(id => "mol_id", name => "my molecule");
$c = $mol->new_atom(symbol => "C", coords => [0,0,0]);
$o = $mol->new_atom(symbol => "O", coords => [0,0,1.23]);
$mol->new_bond(atoms => [$c, $o], order => 3);

print $mol->print;

This package, along with Chemistry::Atom and Chemistry::Bond, includes basic objects and methods to describe molecules.
The core methods try not to enforce a particular convention. This means that only a minimal set of attributes is provided by default, and some attributes have very loosely defined meaning.

This is because each program and file type has different idea of what each concept (such as bond and atom type) means. Bonds are defined as a list of atoms (typically two) with an arbitrary type. Atoms are defined by a symbol and a Z, and may have 3D and internal coordinates (2D coming soon).

Perl6::Classes project contains first class classes in Perl 5.

SYNOPSIS

use Perl6::Classes;

class Composer {
submethod BUILD { print "Giving birth to a new composern" }
method compose { print "Writing some music...n" }
}

class ClassicalComposer is Composer {
method compose { print "Writing some muzak...n" }
}

class ModernComposer is Composer {
submethod BUILD($) { $.length = shift }
method compose() { print((map { int rand 10 } 1..$.length), "n") }
has $.length;
}

my $beethoven = new ClassicalComposer;
my $barber = new ModernComposer 4;
my $mahler = ModernComposer->new(400);

$beethoven->compose; # Writing some muzak...
$barber->compose # 7214
compose $mahler; # 89275869347968374698756....

Perl6::Classes allows the creation of (somewhat) Perl 6-style classes in Perl 5. The following features are currently supported:

subs, methods, and submethods
And their respective scoping rules.

Attributes
Which are available through the has keyword, and look like $.this.

Inheritance
Both single and multiple inheritance are available through the is keyword.

Signatures
Signatures on methods, subs, and submethods are supported, but just the Perl 5 kind.

Data hiding
Using the public, protected, and private traits, you can enforce (run-time) data hiding. This is not supported on attributes, which are always private.

Anonymous classes
That respect closures. You can now nest them inside methods of other classes, even other anonymous ones!

The Perl6::Classes module augments Perls syntax with a new declarator: class. It offers the advantage over Perls standard OO mechanism that it is conceptually easier to see (especially for those from a C++/Java background). It offers the disadvantage, of course, of being less versatile.

Chemistry Development Kit classes are Java utitility classes for ChemoInformatics and Computational chemistry, written in Java. They are developed constantly developed parallel to other projects that make use of them.
They are a complete re-write of the CompChem classes that were the basis of JChemPaint, a Java Editor for 2D chemical structures, and of JMDraw, a Java package for the graphical layout of 2D chemical structures.
The CDK project was started in September 2000 to replace the CompChem libraries used by JChemPaint, Jmol and SENECA. It no longer is in its initial stage, but is slowly getting a solid state.
The people involved in setting up the project are Christoph Steinbeck then at the Chemoinformatics Group at the Max Planck Institute of Chemical Ecology in Jena, as well as Egon Willighagen from the University of Nijmegen, The Netherlands, who is also involved with JChemPaint and many other Java Chemoinformatics programs, and Dan Gezelter from Notre Dame University, South Bend, USA, the initiator of Jmol, a 3D viewer and analyzer for molecules .
Now, the rewrite of these CompChem/CDK library classes do somehow effect all of our projects. All of our code relies to some extend on the so-called CompChem classes for computational chemistry.
Christoph Steinbeck started this chemistry library when he started programming SENECA, a system for Computer Assisted Structure Elucidation. It turned out that some of the code had design flaws that prevented others, like the authors of (Jmol) to use it.
Enhancements:
- This release consists of mostly some bugfixes, but also solves a few Java 1.4.2 compile problems and adds more functionality to the SMARTS parser.

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.

Dynamic Probe Class Library (DPCL) is an object-based C++ class library that provides the necessary infrastructure to allow tool developers and sophisticated tool users to build parallel and serial tools through technology called dynamic instrumentation.
Dynamic Probe Class Library takes the basic components needed by tool developers and encapsulates them into C++ classes. Each of these classes provide the member functions necessary to interact and dynamically instrument a running application with software patches called probes.
Dynamic instrumentation provides the flexibility for tools to insert probes into applications as the application is running and only where it is needed.
Enhancements:
- This version is a minor update to DPCL that fixes a couple problems that have been reported since the v3.4.2 release

Chemistry::Artificial::Graphics is a graphic plot for artificial with database support.

SYNOPSIS

use strict;
use Chemistry::SQL;
use Chemistry::Artificial::Graphics;

my $dbname = $ARGV[0];
my $chaname = $ARGV[1];
my $file = $ARGV[2];
my $mode = $ARGV[3];

if (scalar(@ARGV)!=4)
{ print "Error in parameter number n";
print "perl chaplot.pl DB_NAME
CHA_NAME FILE_NAME MODE (svg | svg_static | text)n";
exit;
}
my $db1 =
Chemistry::SQL->new(db_host=>"127.0.0.1",db_user=>"root",db_port=>"3306",sb_pwd=>"",db_name=>"$dbname",db_driver=>"mysql");
$db1->connect_db;
my $pcha = Chemistry::Artificial::Graphics->new(db => $db1, width=> "800",height=>"600",radius=> "10",distanceh=>"200",file=> $file,
mode=> $mode);
$pcha->ch_plot("$chaname");

This package, along with Chemistry::SQL, includes all the necessary to generate graphics of the artificial chemistry in database.