Free uml analysis model example software for linux

BASE is the Basic Analysis and Security Engine. It is based on the code from the Analysis Console for Intrusion Databases (ACID) project.
This application provides a web front-end to query and analyze the alerts coming from a SNORT IDS system.
BASE is a web interface to perform analysis of intrusions that snort has detected on your network. It uses a user authentication and role-base system, so that you as the security admin can decide what and how much information each user can see. It also has a simple to use, web-based setup program for people not comfortable with editing files directly.
BASE is supported by a group of volunteers. They are available to answer any questions you may have or help you out in setting up your system. They are also skilled in intrusion detection systems and make use of that knowledge in the development of BASE.
Enhancements:
- This release fixes a number of bugs with PHP 5.
- It also adds a number of new features.

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

Analysis of Reinforced Concrete Elements will assist its user to find out capacity of various Reinforced Concrete Structural Elements.

The following professionals are the target audience:

Structural Engineers
Civil Engineers
Architect
Builders

Installation:

The software is web-based, so you need web-server (Apache) running with PHP. The installaton is very simple. If your document root is /var/www/html , then on uncompressing downloaded compressed file in this "document root", the URL for ARCE application become: http://YourWebSite/arce/

Net::Analysis are modules for analysing network traffic.

SYNOPSIS

Using an existing analyser:

$ perl -MNet::Analysis -e main help
$ perl -MNet::Analysis -e main TCP,v=1 dump.tcp - basic TCP info
$ perl -MNet::Analysis -e main HTTP,v=1 dump.tcp - HTTP stuff
$ perl -MNet::Analysis -e main Example2,regex=img dump.tcp - run an example

Writing your own analyser:

package MyExample;
use base qw(Net::Analysis::Listener::Base);
# Listen to events from other modules
sub tcp_monologue {
my ($self, $args) = @_;
my ($mono) = $args->{monologue};
my $t = $mono->t_elapsed()->as_number();
my $l = $mono->length();
# Emit your own event
$self->emit(name => example_event,
args => { kb_sec => ($t) ? $l/($t*1024) : N/A }
);
}
# Process your own event
sub example_event {
my ($self, $args) = @_;
printf "Bandwidth: %10.2f KB/secn", $args->{kb_sec};
}
1;
__top

ABSTRACT

Net::Analysis is a suite of modules that parse tcpdump files, reconstruct TCP sessions from the packets, and provide a very lightweight framework for writing protocol anaylsers.
__top

I wanted a batch version of Ethereal in Perl, so I could:

- sift through parsed protocols with structured filters
- write custom reports that mixed events from multiple protocols

So here it is. Net::Analysis is a stack of protocol handlers that emit, and listen for, events.

UMMF::UML::MetaMetaModel is an implementation of the UML Meta-Meta-Model (M3).

SYNOPSIS

use UMMF::UML::MetaMetaModel;
my $factory = UMMF::UML::MetaMetaModel->factory;
my $model = $factory->create(Model);
$factory->create(Class, name => Foo, namespace => $model);
...

This package implements a meta-meta-model (M3) for generating the UML metamodel (M2).

UMMF::UML::MetaMetaModel is not an implementation of the MOF; It is actually a subset of the 1.5 Meta-model, as described in UML Spec. 1.5., p.2-13, but with a flattened package namespace.

It is the "Backbone" for generating the meta-model.

The UML 1.5 Meta-model is described in UMMF::UML::MetaModel package, in the ad-hoc language imported by UMMF::UML::Import::MetaMetaModel.

This meta-model is then used to generate the Perl (or Java) code for the classes in UMMF::UML::MetaModel::*.

The same exporters and importers can be used to process M* layers.

Thus, one description of the meta-model can generate multiple implementations.

Statistical Traffic Analysis Kit is a set of command-line traffic analysis tools, designed to help a network administrator to see what is happening at a router at the moment.

Unlike tcpdump (1), the stak set uses statistical and stream-oriented methods, and will rarely produce an output stream at a speed beyond human perception. The output is less accurate.

The kit consists of five different utilities, designed to perform the following tasks:
estimating overall traffic rates (stakrate),
determining network nodes generating the highest traffic (stakhosts)
monitoring the amount of traffic exchanged with particular autonomous
systems (stakasta),
extracting strings from packets (stakextract),
determining connections and flows generating the highest traffic
(stakstreams, experimental),

The Analysis & Reconstruction Sound Engine also known as ARSE, is a program that analyses a sound file into a spectrogram and is able to synthetise this spectrogram, or any other user-created image, back into a sound.
The ARSE consists in two main parts, a spectrographer with a base-2 logarithmic frequency scale, and a spectrogram synthetiser.
Unlike most spectrographers which are based on STFTs and perform the analysis by cutting the signal into small time slices to analyse these slices in the frequency domain, the ARSE is based on a filter bank followed by envelope detection, which means that the signal is cut into small frequency-domain slices, and then analysed in the time domain.
The filter bank is, as of now, made up with overlapping bandpass FIR filters defined logarithmically. Once the original signal is filtered with the filter bank, each resulting signal is sent to envelope detection.
Envelope detection in the ARSE isnt based on a Hilbert transform and peak detection, as its usually done. To achieve envelope detection, we first perform a FFT on the signal, zero-pad the beginning of the signal in the frequency domain according to a user-defined setting, then we perform an IFFT, and, now in the time domain, we turn every negative sample into a positive one, and we low-pass filter (and eventually decimate) the signal according to the same user-defined setting as we previously used.
For instance, lets say we have a signal with a sampling frequency of 44,100 Hz, and that we want to obtain an envelope for it which sampling frequency would be 100 Hz. Once we perform the FFT, we add enough zeroes in the frequency domain at the beginning of our signal so that every frequency component shifts by 50 Hz (100 Hz divided by two, it will later appear obvious why), and we perform an IFFT. Our signal now has a sampling frequency of 44,200 Hz (44,100 + 100 Hz), and the original signal which previously spanned from 0 Hz to 22,050 Hz now spans from 50 Hz to 22,100 Hz.
Now we turn every time-domain sample into its absolute value by turning every negative sample into a positive one. To perform this on a signal means that, for example, a sine wave of a certain frequency would become a signal which periodicity would be twice that frequency. Once we low-pass filter that signal to twice that frequency we obtain that signals envelope. In our case, now that we have obtained the absolute values for our signal, since the periodicity of a sine at the lowest frequency - 50 Hz - would now be 100 Hz, we only low-pass filter our signal at 100 Hz to obtain the original signals envelope. We can now decimate the signal to a sample rate of 100 Hz.
The resulting envelope for each frequency band makes the horizontal lines of the image representing the spectrogram. The amplitude of the envelopes translate linearly into intensity in the image.
The spectrogram synthetiser is based on modulation using horizontal lines of the image as envelopes. Each horizontal line is upsampled to the sampling rate of the desired final signals sampling rate, and is then modulated with, depending on the synthetisation mode chosen by the user, sines matching to the central frequency each horizontal line represents, or noise filtered through the filter bank.
Enhancements:
- Replaced fixed phase sine generation with random phase sine generation
- Changed the PRNG
- Removed the unused code
- Removed every call of nearbyint() due to compatibility issues
- Included the necessary files in order to make using ./configure && make && make install