Free platform bed frames software for linux

SIMD Cross-platform headers is a cross- platform, cross-compiler, cross CPU C/C++ header collection that aids the creation portable vectorized (SIMD) C/C++ code.
SIMD Cross-platform headerst supports (or partially supports) x86 (MMX/SSE/SSE2) GCC and MSVC, PPC Altivec GCC and CodeWarrior, ARM GCC, and software-emulated SIMD.
NOTE: Code must be 16-byte aligned. Align to 16 when allocating memory.
X86/XSCALE (Intel) vs. PowerPC/MIPS
While the PowerPC and MIPS SIMD instructions take 2 source vectors and a destination vector, the Intel platforms only take a source and destination. Example:
PPC/MIPS can do:
C = A + B
X86 can only do:
A = A + B (or A+=B)
Code written either way will work on the X86, and still be faster than 387 math, but preserving the registers takes significant overhead (Disassemble the test program for an example. The prints preserve, the disassembly test does not.) For the fastest code between systems, write your SIMD math as the X86 expects, manually preserving SIMD variables.
At least GCC for PPC doesnt seem to have any issues figuring out how to deal with a source and destination memory address being the same.
Enhancements:
- Created file with some i386, GCC dialect

RawFrames provides an utility for sending crafted Ethernet frames.
RawFrames is a program written in c++ that allows you to send various types of ethernet frames from the command line. At the datalink layer, RawFrames supports Ethernet II, 802.3, LLC (802.2), LLC/SNAP and 802.1Q.
At the Network layer, RawFrames can send IP packets, but thats not really the point ;) I do however intend to increase the support for layer 3 and 4 protocols. The code used for encapsulating with these types is included as interfacable C++ Class Modules, in case youre writing an network implementation.
Should work on most versions of Linux. If you want to help port it, let me know.
Compiled on the following platforms:
.Redhat-7.2
.Redhat-7.3
.Redhat-9.0
.Slackware-7.0
Enhancements:
- Added IEEE 802.1q support

Platform Independent Petri Net Editor project (PIPE) creates and analyses Petri Nets quickly, efficiently, and effectively.

A key design feature is the modular approach adopted for analysis, enabling new modules to be written easily and powerfully, using built-in data layer methods for standard calculations.

Six analysis modules are provided, including Invariant Analysis, State-Space Analysis (deadlock, etc.), and Simulation Analysis and Classification.

PIPE adheres to the XML Petri net standard (PNML). The file format for saving and loading Petri Nets is extensible through the use of XSLT, the default being PNML.

Eclipse Web Tools Platform Project is a top-level Eclipse project that contains tools for developing Java Web applications.
The WTP project includes the following tools: source editors for HTML, Javascript, CSS, JSP, SQL, XML, DTD, XSD, and WSDL; graphical editors for XSD and WSDL; J2EE project natures, builders, and models and a J2EE navigator; a Web service wizard and explorer, and WS-I Test Tools; and database access and query tools and models.
Main features:
- Extension of the Eclipse value proposition The Eclipse Project has set a high standard for technical excellence, functional innovation and overall extensibility within the Java IDE domain. We intend to apply these same standards to the Web/J2EE application-tooling domain.
- Vendor ecosystem A major goal of this project is to support a vital application development tools market. Its exemplary functionality will be useful on its own but it will be designed from the start to be extensible so commercial vendors can use what this project delivers as a foundation for their own product innovation and development efficiency.
- Vendor neutrality Vendor neutrality will be at the core of this project. We aim to encourage Eclipse participation and drive Eclipse market acceptance by strengthening the long-term product value propositions of the widest possible range of application development vendors.
- Standards-based innovation This project will deliver an extensible, standards-based tooling foundation on which the widest possible range of vendors can create value-added development products for their customers and end-users. Where standards exist, we will adhere to them. At least, at first, where standards are emerging, we will wait for them to emerge; this can be re-evaluated later according to user needs and contributor availability. Where multiple technologies are widely used for a given functional need, we will attempt to support each, subject only to technical feasibility and our goal of providing the most capable and extensible foundation long term.
- Agile development Our aim is to incorporate into our planning process the innovations that arise once a project is underway, and the feedback from our user community on our achievements to date. We think an agile development and planning process, in which progress is incremental, near-term deliverables are focused, and long-term planning is flexible, will be the best way to achieve this.
- Inclusiveness & diversity We aim to assimilate the best ideas from the largest number of participants representing the needs of the widest range of end-users. So we will encourage organizations across a broad range of technical, market and geographical domains to participate in this project.

BlogTrader Platform is a free, open source stock technical analysis platform with a pluggable architecture that is ideal for extensions such as indicators and charts. BlogTrader Platform is built on pure java.
It supports parallel quote data retrieval from Yahoo! or ASCII text files, historical, intra-day, and real-time charts, and candle, bar, and line charts. It has a natural date/trading date view model. "MACD", "OBV", "ROC", "KD", "BIAS", "DMI", "RSI", "MTM", and "WMS" indicators and drawing of "Line", "Parallel", "Gann Angle", and "Fibonacci Line" are supported. You can easily write your own indicators.
Main features:
- Retrieve quote data in parallel from Yahoo! Finance, netfonds.se, or CSV files.
- Save quote data to local database (hsqldb).
- Adjust quote chart for splits and dividents if possibale (Yahoo! quote data only).
- Daily, Weekly, Monthly charts (Weekly, Monthly data are composed automatically from Daily data)
- Historical/Intra-Day/Real-Time Chart
- Real-time Ticker Board
- Update Daily, Weekly, Monthly Charts and their indicators automatically according to the newest tickers.
- Multiple quote-charts comparison
- Candle/Bar/Line
- Calendar/Trading date view
- Define indicators parameters separately for Daily, Weekly and Monthly charts, parameters can be saved as default or apply to all
- Add layer drawings separately for Daily, Weekly and Monthly. Save/Restore drawings.
- Carefully design for writing your own indicator easy, but in java (maybe will support scripts some day)
- Supports multiple platforms, includes windows, linux, macos, solaris, etc. (Java JRE 1.5 required)
- More to be come ...
Enhancements:
- Minor bugfixes

CGI::AppBuilder::Frame is a configuration initializer.

SYNOPSIS

use CGI::AppBuilder::Frame;

my $ab = CGI::AppBuilder::Frame- >new(
ifn, my_init.cfg, opt, vhS:a:);
my ($q, $ar, $ar_log) = $ab- >start_app($0, %ARGV);
print $ab- >disp_form($q, $ar);

This class provides methods for reading and parsing configuration files.
new (ifn = > file.cfg, opt = > hvS:)

This is a inherited method from CGI::AppBuilder. See the same method in CGI::AppBuilder for more details.

frame_set ($fr, $pr)

Input variables:

$fr - frame set definiton array reference. The $fr contains two
elements [$hr, $ar]:
$hr - a hash ref containing the frame set attributes
$ar - a array ref containing hash references defining each
frames in the frame set.
$pr - tag attribute array ref. It contains three elements:
class - CSS class name
attr - attribute string such as width=5 onChange=js_func
hr - hash ref with key and value pairs. This will be obtained
from $fr for each frame set and frame.
pretty - whether to add line breaks

Variables used or methods called:

CGI::AppBuilder::Table
html_tag - generate HTML tags
CGI::AppBuilder::Message
echo_msg - display message

How to use:

The following shows how to define the frame array ($fr):

+-+----+ The following defines the left layout:
| | T |
| +----+ [{cols= >"150,*"},[
| | | {src= >"left.htm",name= >"L"},
|L| C | [{rows= >"100,*,50"},[
| | | {src= >"top.htm",name= >"T"},
| |----| {src= >"main.htm",name= >"C"},
| | B | {src= >"bottom.htm",name= >"B"}]]]
+-+----+ ]

In YAML, here is how it looks like:

---
cols: 150,*
- src: left.htm
name: L
- rows: 100,*,50
- src: top.htm
name: T
- src: main.htm
name: C
- src: bottom.htm
name: B
...

+-+------+ The following defines the left layout:
| | T |
| +----+-+ [{cols= >"150,*"},[
| | | | {src= >"left.htm",name= >"L"},
|L| C |R| [{rows= >"100,*,50"},[
| | | | {src= >"top.htm",name= >"T"},
| | | | [{cols= >"*,100"},[
| |----+-+ {src= >"main.htm",name= >"C"},
| | | {src= >"right.htm",name= >"R"}] ] ],
| | B | {src= >"bottom.htm",name= >"B"}]]
+-+----+-+ ]
In YAML, here is how it looks like:
---
cols: 150,*
- src: left.htm
name: L
- rows: 100,*,50
- src: top.htm
name: T
- cols: *,100
- src: main.htm
name: C
- src: right.htm
name: R
- src: bottom.htm
name: B
...
Here is the testing codes:
my $fr = [{cols= >"150,*"},[
{src= >"left.htm",name= >"L"},
[{rows= >"100,*,50"},[
{src= >"top.htm",name= >"T"},
{src= >"main.htm",name= >"C"},
{src= >"bottom.htm",name= >"B"}]
]]
];
my $pr = {pretty= >1};
print $obj- >frame_set($fr,$pr);
# the following is the result:

< FRAMESET cols=150,* >
< FRAME src=left.htm name=L >
< FRAMESET rows=100,*,50 >
< FRAME src=top.htm name=T >
< FRAME src=main.htm name=C >
< FRAME src=bottom.htm name=B >
< / FRAMESET >
< / FRAMESET >

$pr- >{_frameset_count} = 0; # reset frame set counter
my $f2 = [ {cols= >"150,*"},[
{src= >"left.htm",name= >"L"},
[{rows= >"100,*,50"},[
{src= >"top.htm",name= >"T"},
[{cols= >"*,100"},[
{src= >"main.htm",name= >"C"},
{src= >"right.htm",name= >"R"}]
],
{src= >"bottom.htm",name= >"B"}]
]]
];
print $obj- >frame_set($f2,$pr);
# the following is the result:

< FRAMESET cols=150,* >
< FRAME src=left.htm name=L >
< FRAMESET rows=100,*,50 >
< FRAME src=top.htm name=T >
< FRAMESET cols=*,100 >
< FRAME src=main.htm name=C >
< FRAME src=right.htm name=R >
< / FRAMESET >
< FRAME src=bottom.htm name=B >
< / FRAMESET >
< / FRAMESET >

Return: HTML codes.

This method generates HTML codes based on the information provided. This method is also called < I >frameset< / I >.