Free expression software for linux

regular expression parser is a C++ regexp parser that accomplishes The Open Group specification Issue 6, IEEE Std 1003.1, 2004 Edition.

regular expression parser allows you to parse input using regular expressions, and to retrieve parsed sub-expression matches in a few steps.

Language::Basic::Expression is a Perl package to handle string, numeric, and boolean expressions.

SYNOPSIS

See Language::Basic for the overview of how the Language::Basic module works. This pod page is more technical.
# Given an LB::Token::Group, create an expression I parse it
my $exp = new LB::Expression::Arithmetic $token_group;
# Whats the value of the expression?
print $exp->evaluate;
# Perl equivalent of the BASIC expression
print $exp->output_perl;

Expressions are basically the building blocks of Statements, in that every BASIC statement is made up of keywords (like GOTO, TO, STEP) and expressions. So expressions include not just the standard arithmetic and boolean expressions (like 1 + 2), but also lvalues (scalar variables or arrays), functions, and constants. See Language::Basic::Syntax for details on the way expressions are built.

BASIC expressions are represented by various objects of subclasses of Language::Basic::Expression. Most LB::Expressions are in turn made up of other LB::Expressions. For example an LBE::Arithmetic may be made up of two LBE::Multiplicative and a "plus". "Atoms" (indivisible LBEs) include things like LBE::Constants and LBE::Lvalues (variables).

Regular Expression Graphing Program project is a regular expression graphing program.
This program is designed to take a regular expression and produce a graph of the state machine that is used to parse the regular expression.
It is useful for teaching regular expressions and state machines.
The program comes with a built-in tutorial and sample set of regular expressions.
Main features:
- This will not graph all the regular expressions. Some of the more advanced features of the engine are just not handled.
- We currently ``graph the ``group, no $1 (?:..) operator by displaying nothing. A box should be put around the expression.
- The boxes drawn by the program are a fixed with not related to the size of the text they contain. Text can easily overflow the box.
- The system is UNIX/Linux specific. This is caused by only one small section of code should anyone want to port this to a braindamaged operating system.
- Better use of color can be made. Specifically all the nodes do not have to be green. Come to think of it they call dont have to be rectangles either.
- Sometimes the lines connecting one section to another take some strange twists.

exmats goal is to provide an easy to use, yet very efficient matrix library. Overloaded operators allow to write algebraic expressions like v=A*u +u in C++, instead of bunch of boring functions.
This syntactic sugar comes with runtime cost, one way to eliminate the overhead is to use Expression Templates (ET).
Using ET, we can further boost up the efficient by analyzing the expression at compile time and generate the most efficient code for that expression.
This library is still under early development.
Main features:
Generic:
- The element type of the matrix is generic, it can be any type of the C++ build-in type like int, float, double.
- Other types like complex or arbitrary precision type can also be used as the element type.
- Matrix expression can be make up of any element type, that is, an integer matrix can be added to a float matrix and then assign to a double matrix.
Easy to use:
- You can write matrix expression using +, -, *, / operators as usual mathematic notation.
Safe:
- There are 3 levels of error checking policy you can apply on each class of matrix.
Efficient:
- Specialized, hand made comparable optimized code can be generated for different expressions.
- SIMD code can be used on small size matrix.
- Provide a interface to use BLAS as the math kernel, which is highly optimized for out of cache operations.
Enhancements:
- Cross product bug fixed
- Added determinant, minor view, cofactor view and adjoint view for matrix
- Added support for column major memory layout
- Helper macro for deriving ET enabled sub-class from exmat::Mat easily
- Array version for approximated math

Bio::SAGE::DataProcessing module processes raw serial analysis of gene expression (SAGE) data.

SYNOPSIS

use Bio::SAGE::DataProcessing;
$sage = Bio::SAGE::DataProcessing->new();

# open sequence and quality files
open( READS, "library.fasta" );
open( QUAL, "library.qual.fasta" );

# collect ditags and statistics from reads
$sage->process_library( *READS, *QUAL );

# close files
close( READS );
close( QUAL );

# output tags in descending order of expression
my %tags = %{$sage->get_tagcounts()};
open( TAGS, ">library.tags" );
map { print TAGS join( "t", $_, $tags{$_} ) . "n" } sort { $tags{$b} $tags{$a} } keys %tags;
close( TAGS );

# tag AAACCGGGTT matches two different genes
# so 15th base pair may help resolve this
$sage->print_extra_base_calculation( $sage->get_extract_base_calculation( "AAACCGGGTT" ) );

This module provides several tools for processing and analyzing serial analysis of gene expression (SAGE) libraries.

Serial analysis of gene expression (SAGE) is a molecular technique for generating a near-global snapshot of a cell population’s transcriptome. Briefly, the technique extracts short sequences at defined positions of transcribed mRNA. These short sequences are then paired to form ditags. The ditags are concatamerized to form long sequences that are then cloned. The cloned DNA is then sequenced. Bioinformatic techniques are then employed to determine the original short tag sequences, and to derive their progenitor mRNA. The number of times a particular tag is observed can be used to quantitate the amount of a particular transcript. The original technique was described by Velculescu et al. (1995) and utilized an ~14bp sequence tag. A modified protocol was introduced by Saha et al. (2002) that produced ~21bp tags.

PURPOSE

This module facilitates the processing of SAGE data. Specifically:

1. extracting ditags from raw sequence reads.
2. extracting tags from ditags, with the option to
exclude tags if the Phred scores (described by
Ewing and Green, 1998a and Ewing et al., 1998b)
do not meet a minimum cutoff value.
3. calculating descriptive values
4. statistical analysis to determine, where possible,
additional nucleotides to extend the length of the
SAGE tag (thus facilitating more accurate tag to
gene mapping).

Both regular SAGE (14mer tag) and LongSAGE (21mer tag) are supported by this module. Future protocols should be configurable with this module.

PCRE library is a set of functions that implement regular expression pattern matching using the same syntax and semantics as Perl 5, with just a few differences.
The current implementation corresponds to Perl 5.005. PCRE is used by many programs, including Exim, Postfix, and PHP.
Enhancements:
- Some more features from Perl 5.10 have been added.
- A few bugs were fixed.
- A couple of performance enhancing refactorings were done.

perlrebackslash is a module with Perl Regular Expression Backslash Sequences and Escapes.

The top level documentation about Perl regular expressions is found in perlre.
This document describes all backslash and escape sequences. After explaining the role of the backslash, it lists all the sequences that have a special meaning in Perl regular expressions (in alphabetical order), then describes each of them.

Most sequences are described in detail in different documents; the primary purpose of this document is to have a quick reference guide describing all backslash and escape sequences.

The backslash

In a regular expression, the backslash can perform one of two tasks: it either takes away the special meaning of the character following it (for instance, | matches a vertical bar, its not an alternation), or it is the start of a backslash or escape sequence.

The rules determining what it is are quite simple: if the character following the backslash is a punctuation (non-word) character (that is, anything that is not a letter, digit or underscore), then the backslash just takes away the special meaning (if any) of the character following it.

If the character following the backslash is a letter or a digit, then the sequence may be special; if so, its listed below. A few letters have not been used yet, and escaping them with a backslash is safe for now, but a future version of Perl may assign a special meaning to it. However, if you have warnings turned on, Perl will issue a warning if you use such a sequence.

It is however garanteed that backslash or escape sequences never have a punctuation character following the backslash, not now, and not in a future version of Perl 5. So it is safe to put a backslash in front of a non-word character.
Note that the backslash itself is special; if you want to match a backslash, you have to escape the backslash with a backslash: // matches a single backslash.