Free intermediate value theorem software for linux

Servlet::ServletOutputStream is a servlet output stream interface.

SYNOPSIS

$stream->print($string);

$stream->println();
$stream->println($string);

$stream->write($string);
$stream->write($string, $length);
$stream->write($string, $length, $offset);

$stream->flush();

$stream->close();

Provides an output stream for writing binary data to a servlet response.
An output stream object is normally retrieved via "getOutputStream" in Servlet::ServletResponse.

NOTE: While this is an abstract class in the Java API, the Perl API provides it as an interface. The main difference is that the Perl version has no constructor. Also, it merges the methods declared in java.io.OutputStream and javax.servlet.ServletOutputStream into a single interface.

METHODS

close()

Closes the stream and releases any system resources associated with the stream.

Throws:

Servlet::Util::IOException

if an output exception occurred

flush()

Flushes this input stream and forces any buffered output bytes to be written out.

Throws:

Servlet::Util::IOException

if an output exception occurred

print($value)

Writes a scalar value to the client, with no carriage return-line feed (CRLF) character at the end.

Parameters:

$value

the value to send to the client

Throws:

Servlet::Util::IOException

if an output exception occurred

println([$value])

Writes a scalar value to the client, if specified, followed by a carriage return-line feed (CRLF) character.

Parameters:

$value

the (optional) value to send to the client

Throws:

Servlet::Util::IOException

if an output exception occurred

write($value)

write($value, $length)

write($value, $length, $offset)

Writes the scalar $value to the stream.

If no arguments are specified, functions exactly equivalently to print().

If $length is specified, writes that many bytes from $value. If $offset is specified, starts writing that many bytes from the beginning of $value. $offset and $length must not be negative, and $length must not be greater than the amount of data in $value starting from $offset.

Blocks until input data is available, the end of the stream is detected, or an exception is thrown.

Parameters:

$value

a scalar value to be written

$length

the maximum number of bytes to write

$offset

the location in $value where data is read from

Throws:

Servlet::Util::IOException

if an input exception occurs

Servlet::Util::IndexOutOfBoundsException

if $buffer is specified as undef

ipfmeta is used to simplify the maintenance of an IPfilter ruleset. It does this through the use of objects. A matching object gets replaced by its values at runtime. ipfmeta is specifically geared towards IPfilter. It is line oriented: if an object has multiple values, the line with the object is duplicated and substituted for each value. It is also recursive: an object may have another object as a value.

ipfmeta is a program written in Perl.

linSmith project is a Smith Charting program, mainly designed for educational use.
linSmith is a Smith Charting program, mainly designed for educational use. As such, there is an emphasis on capabilities that improve the showing the effect of-style of operation.
Main features:
- Definition of multiple load impedances (at different frequencies)
- Addition of discrete (L, C, series and parallel LC, and transformer) and line components (open and closed stubs, and line segments)
- Connection in series and parallel
- Easy experimenting with component values using scrollbars
- A virtual component switches from impedance to admittance to help explaining (or understanding) parallel components
- The chart works in real impedances (not normalized ones)
- Direct view of the result on the screen
- Ability to generate publication quality Postscript output
- A log file with textual results at each intermediate step
- Load and circuit configuration is stored separately, permitting several solutions without re-defining the other.

Race Timing lets you manage races by describing a race and the rules associated with it. You can time the racers and provide realtime standing of the race participants.

You can manage various race events (pilot changes, refuelling, laps, intermediate sprints, etc.) and broadcast various information to the participants. Race Timing is best used with transponders, but manual operation is also provided.

Hilbert II project is decentralised access to verified and readable mathematical knowledge. As its name already suggests, this project is in the tradition of Hilberts program.
Hilbert II wants to become a free, world wide mathematical knowledge base that contains mathematical theorems and proofs in a formal correct form. All belonging documents are published under the GNU Free Documentation License.
We aim to adapt the common mathematical argumentation to a formal syntax. That means, whenever in mathematics a certain kind of argumentation is often used we will look forward to integrate it into the formal language of Hilbert II. This formal language is called the qedeq format.
Hilbert II provides a program suite that enables a mathematician to put theorems and proofs into that knowledge base. These proofs are automatically verified by a proof checker. Also texts in "common mathematical language" can be integrated.
The mathematical axioms, definitions and propositions are combined to so called qedeq modules. Such a module could be seen as a mathematical textbook which includes formal correct proofs. Because this system is not centrally administrated and references to any location in the internet are possible, a world wide mathematical knowledge base could be build.
Any proof of a theorem in this "mathematical web" could be drilled down to the very elementary rules and axioms. Think of an incredible number of mathematical textbooks with hyperlinks and each of its proofs could be verified by Hilbert II. For each theorem the dependency of other theorems, definitions and axioms could be easily derived.
The basic concept of this project is published as PDF document: basic concept. This document is already generated out of the following XML file: qedeq_basic_concept.xml. The main project is in the first develompment phase, see under development.
There exists a working prototype called Principia Mathematica II. It is fully capable of first order predicate logic and shows the main features and functionality of Hilbert II. It can verify (prototype) qedeq module files located anywhere in the internet.
The prototype has a GUI and can transfer qedeq modules into HTML and LaTeX files. You can create and edit your own new qedeq module and publish it in the internet. In the web already existing qedeq modules could be used just by referencing them.
Enhancements:
- This release has a GUI window for transforming LaTeX formulas into QEDEQ XML.
- Behind the scenes a huge refactoring took place.
- The project has now a kernel structure.
- The kernel can be initialized and offers methods for loading a module from the file system or out of the Internet.
- The kernel buffers modules and keeps a log.
- The kernel is not finished yet but the basic structure is there.

Data::Diver is a simple, ad-hoc access to elements of deeply nested structures.

SUMMARY

Data::Diver provides the Dive() and DiveVal() functions for ad-hoc access to elements of deeply nested data structures, and the DiveRef(), DiveError(), DiveClear(), and DiveDie() support functions.

SYNOPSIS

use Data::Diver qw( Dive DiveRef DiveError );

my $root= {
top => [
{ first => 1 },
{ second => {
key => [
0, 1, 2, {
three => {
exists => yes,
},
},
],
},
},
],
};

# Sets $value to yes
# ( $root->{top}[1]{second}{key}[3]{three}{exists} ):
my $value= Dive( $root, qw( top 1 second key 3 three exists ) );

# Sets $value to undef() because "missing" doesnt exist:
$value= Dive( $root, qw( top 1 second key 3 three missing ) );

# Sets $value to undef() because
# $root->{top}[1]{second}{key}[4] is off the end of the array:
$value= Dive( $root, qw( top 1 second key 4 ... ) );

# Sets $value to undef() because
# $root->{top}[1]{second}{key}[-5] would be a fatal error:
$value= Dive( $root, qw( top 1 second key -5 ... ) );

# Sets $ref to $root->{top}[9]{new}{sub} (which grows
# @{ $root->{top} } and autovifies two anonymous hashes):
my $ref= DiveRef( $root, qw( top 9 new sub ) );

# die()s because "other" isnt a valid number:
$ref= DiveRef( $root, qw( top other ... ) );

# Does: $root->{num}{1}{2}= 3;
# (Autovivifies hashes despite the numeric keys.)
DiveVal( $root, ( qw( num 1 2 ) ) ) = 3;
# Same thing:
${ DiveRef( $root, num, 1, 2 ) } = 3;

# Retrieves above value, $value= 3:
$value= DiveVal( $root, num, 1, 2 );
# Same thing:
$value= ${ DiveRef( $root, ( qw( num 1 2 ) ) ) };

# Tries to do $root->{top}{1} and dies
# because $root->{top} is an array reference:
DiveRef( $root, top, 1 );

# To only autovivify at the last step:
$ref= DiveRef(
Dive( $root, qw( top 1 second key 3 three ) ),
missing );
if( $ref ) {
$$ref= me too
} else {
my( $nestedRef, $svKey, $errDesc )= DiveError();
die "Couldnt dereference $nestedRef via $$svKey: $errDescn";
}

The libdisasm library provides basic disassembly of Intel x86 instructions from a binary stream. The intent is to provide an easy to use disassembler which can be called from any application; the disassembly can be produced in AT&T syntax and Intel syntax, as well as in an intermediate format which includes detailed instruction and operand type information.

This disassembler is derived from libi386.so in the bastard project; as such it is x86 specific and will not be expanded to include other CPU architectures. Releases for libdisasm are generated automatically alongside releases of the bastard; it is not a standalone project, though it is a standalone library.

The recent spate of objdump output analyzers has proven that many of the people [not necessarily programmers] interested in writing disassemblers have little knowledge of, or interest in, C programming; as a result, these "disassemblers" have been written in Perl.

Usage

The basic usage of the library is:

1. initialize the library, using disassemble_init()
2. disassemble stuff, using disassemble_address()
3. un-initialize the library, using disassemble_cleanup

These routines have the following prototypes:

int disassemble_init(int options, int format);
int disassemble_cleanup(void);
int disassemble_address(char *buf, int buf_len, struct instr *i);

Instructions are disassembled to an intermediate format:

struct instr {
char mnemonic[16];
char dest[32];
char src[32];
char aux[32];
int mnemType; /* type of instruction */
int destType; /* type of dest operand */
int srcType; /* type of source operand */
int auxType; /* type of 3rd operand */
int size; /* size of insn in bytes */
};

The sprint_address() can be used in place of the disassemble_address() routine in order to generate a string representation instead of an intermediate one:

int sprint_address(char *str, int len, char *buf, int buf_len);

...so that a simple disassembler can be implemented in C with the following code:

#include

char buf[BUF_SIZE]; /* buffer of bytes to disassemble */
char line[LINE_SIZE]; /* buffer of line to print */
int pos = 0; /* current position in buffer */
int size; /* size of instruction */

disassemble_init(0, INTEL_SYNTAX);

while ( pos > BUF_SIZE ) {
/* disassemble address to buffer */
size = sprint_address(buf + pos, BUF_SIZE - pos, line, LINE_SIZE);
if (size) {
/* print instruction */
printf("%08X: %sn", pos, line);
pos += size;
} else {
printf("%08X: Invalid instructionn");
pos++;
}
}

disassemble_cleanup();

Alternatively, one can print the address manually using the intermediate format:

#include

char buf[BUF_SIZE]; /* buffer of bytes to disassemble */
int pos = 0; /* current position in buffer */
int size; /* size of instruction */
struct instr i; /* representation of the code instruction */

disassemble_init(0, INTEL_SYNTAX);

while ( pos > BUF_SIZE ) {
disassemble_address(buf + pos, BUF_SIZE - pos, &i);
if (size) {
/* print address and mnemonic */
printf("%08X: %s", pos, i.mnemonic);
/* print operands */
if ( i.destType ) {
printf("t%s", i.dest);
if ( i.srcType ) {
printf(", %s", i.src);
if ( i.auxType ) {
printf(", %s", i.aux);
}
}
}
printf("n");
pos += size;
} else {
/* invalid/unrecognized instruction */
pos++;
}
}

disassemble_cleanup();

This is the recommended usage of libdisasm: the instruction type and operand type fields allow analyzing of the disassembled instruction, and can provide cues for xref generation, syntax hi-lighting, and control flow tracking.