Free readability software for linux

AVL Array is an STL-like container for C++ that fills the gap between vector (or deque) and list, providing both fast random access and fast insertion/removal, all O(log n).
This is not a map; in an avl_array, the "keys" always range from 0 to size-1, and they automatically change on insertion or removal. As a sequence container, like vector and list, it respects the order of elements.
Enhancements:
- documentation
- source reorganized for readability
- compliance with higher standards
- performance improvements

Set::Array Perl module contains arrays as objects with lots of handy methods (including Set comparisons) and support for method chaining.

SYNOPSIS

my $sao1 = Set::Array->new(1,2,4,"hello",undef);
my $sao2 = Set::Array->new(qw(a b c a b c));
print $sao1->length; # prints 5
$sao2->unique->length->print; # prints 3

Set::Array allows you to create arrays as objects and use OO-style methods on them. Many convenient methods are provided here that appear in the FAQs, the Perl Cookbook or posts from comp.lang.perl.misc. In addition, there are Set methods with corresponding (overloaded) operators for the purpose of Set comparison, i.e. +, ==, etc.

The purpose is to provide built-in methods for operations that people are always asking how to do, and which already exist in languages like Ruby. This should (hopefully) improve code readability and/or maintainability. The other advantage to this module is method-chaining by which any number of methods may be called on a single object in a single statement.

OBJECT BEHAVIOR

The exact behavior of the methods depends largely on the calling context.
Here are the rules:

* If a method is called in void context, the object itself is modified.
* If the method called is not the last method in a chain (i.e. its called in object context), the object itself is modified by that method regardless of the final context or method call.
* If a method is called in list or scalar context, a list or list refererence is returned, respectively. The object itself is NOT modified.

Heres a quick example:

my $sao = Set::Array->new(1,2,3,2,3);
my @uniq = $sao->unique(); # Object unmodified. @uniq contains 3 values.
$sao->unique(); # Object modified, now contains 3 values

Here are the exceptions:

* Methods that report a value, such as boolean methods like exists() or other methods such as at() or as_hash(), never modify the object.
* The methods clear(), delete(), delete_at(), and splice will always modify the object. It seemed much too counterintuitive to call these methods in any context without actually deleting/clearing/substituting the items!
* The methods shift() and pop() will modify the object AND return the value that was shifted or popped from the array. Again, it seemed much too counterintuitive for something like $val = $sao->shift to return a value while leaving the objects list unchanged. If you really want the first or last value without modifying the object, you can always use the first() or last() method, respectively.
* The join() method always returns a string and is really meant for use in conjunction with the print() method.

BOOLEAN METHODS

exists(val) - Returns 1 if val exists within the array, 0 otherwise. If no value (or undef) is passed, then this method will test for the existence of undefined values within the array.
is_empty() - Returns 1 if the array is empty, 0 otherwise. Empty is defined as having a length of 0.

STANDARD METHODS

at(index) - Returns the item at the given index (or undef). A negative index may be used to count from the end of the array. If no value (or undef) is specified, it will look for the first item that is not defined.

clear() - Empties the array (i.e. length becomes 0). You may pass a 1 to this method to set each element of the array to undef rather than truly empty it.

compact() - Removes undefined elements from the array.

count(?val?) - Returns the number of instances of val within the array. If val is not specified (or is undef), the method will return the number of undefined values within the array.

delete(list) - Deletes all items within list from the array that match. This method will crash if list is not defined. If your goal is to delete undefined values from your object, use the compact() method instead.

delete_at(index, ?index?) - Deletes the item at the specified index. If a second index is specified, a range of items is deleted. You may use -1 or the string end to refer to the last element of the array.

duplicates - Returns a list of N-1 elements for each element N in the set. For example, if you have set "X X Y Y Y", this method would return a the list "X Y Y".

fill(val,?start?,?length?) - Sets the selected elements of the array (which may be the entire array) to val. The default value for start is 0. If length is not specified the entire array, however long it may be at the time of the call, will be filled. Alternatively, a quoted integer range may be used.

e.g. $sao->fill(x,3-5);

The array length/size may not be expanded with this call - it is only meant to fill in already-existing elements.

first() - Returns the first element of the array (or undef).

flatten() - Causes a one-dimensional flattening of the array, recursively. That is, for every element that is an array (or hash, or a ref to either an array or hash), extract its elements into the array.

e.g. my $sa = Set::Array->new([1,3,2],{one=>a,two=>b},x,y,z);

$sao->flatten->join(,)->print; # prints "1,3,2,one,a,two,b,x,y,z"

foreach(sub ref) - Iterates over an array, executing the subroutine for each element in the array. If you wish to modify or otherwise act directly on the contents of the array, use $_ within your sub reference.

e.g. To increment all elements in the array by one...

$sao->foreach(sub{ ++$_ });

get - Alias for the indices() method.

index(val) - Returns the index of the first element of the array object that contains val. Returns undef if no value is found.

Note that there is no dereferencing here so if youre looking for an item nested within a ref, use the flatten method first.

indices(val1,?val2?, ?val...?) - Returns an array consisting of the elements at the specified indices or undef if the element is out of range.

A range may also be used. It must be a quoted string in 0..3 format.

join(?char?) - Joins the individual elements of the list into a single string with the elements separated by the value of char. Useful in conjunction with the print() method. If no character is specified, then char defaults to a comma.

e.g. $sao->join(-)->print;

last() - Returns the last element of the array (or undef).

length() - Returns the number of elements within the array.

max() - Returns the maximum value of an array. No effort is made to check for non-numeric data.

pack(template) - Packs the contents of the array into a string (in scalar context) or a single array element (in object or void context).

pop() - Removes the last element from the array. Returns the popped element.

print(?1?) - Prints the contents of the array. If a 1 is provided as an argument, the output will automatically be terminated with a newline.

This also doubles as a contents method, if you just want to make a copy of the array, e.g. my @copy = $sao->print;

Can be called in void or list context, e.g.

$sao->print(); # or... print "Contents of array are: ", $sao->print();

push(list) - Adds list to the end of the array, where list is either a scalar value or a list. Returns an array or array reference in list or scalar context, respectively. Note that it does not return the length in scalar context. Use the length method for that.

reverse() - Reverses the order of the contents of the array.

rindex(val) - Similar to the index() method, except that it returns the index of the last val found within the array.

set(index,value) - Sets the element at index to value, replacing whatever may have already been there.

shift() - Shifts the first element of the array and returns the shifted element.

sort(?coderef?) - Sorts the contents of the array in alphabetical order, or in the order specified by the optional coderef. Use your standard $a and $b variables within your calling program, e.g:

my $sao = Set::Array->new( { name => Berger, salary => 20000 }, { name => Berger, salary => 15000 }, { name => Vera, salary => 25000 }, );
my $subref = sub{ $b->{name} cmp $a->{name} || $b->{salary} $a->{salary} };
$sao14->sort($subref)->flatten->join->print(1);

splice(?offset?,?length?,?list?) - Splice the array starting at position offset up to length elements, and replace them with list. If no list is provided, all elements are deleted. If length is omitted, everything from offset onward is removed.

Returns an array or array ref in list or scalar context, respectively. This method always modifies the object, regardless of context. If your goal was to grab a range of values without modifying the object, use the indices method instead.

unique() - Removes/returns non-unique elements from the list.

unshift(list) - Prepends a scalar or list to array. Note that this method returns an array or array reference in list or scalar context, respectively. It does not return the length of the array in scalar context. Use the length method for that.

ODDBALL METHODS

as_hash() - Returns a hash based on the current array, with each even numbered element (including 0) serving as the key, and each odd element serving as the value. This can be switched by using the key_order option and setting it to odd, in which case the even values serve as the values, and the odd elements serve as the keys. The default is even.

Of course, if you dont care about insertion order, you could just as well do something like, $sao-reverse->as_hash;>

Carp::croaks if the array contains an odd number of elements. This method does not actually modify the object itself in any way. It just returns a plain hash in list context or a hash reference in scalar context. The reference is not blessed, therefore if this method is called as part of a chain, it must be the last method called.

impose(?append/prepend?,string) - Appends or prepends the specified string to each element in the array. Specify the method by using either the keyword append or prepend. The default is append.

randomize() - Randomizes the order of the elements within the array.

rotate(direction) - Moves the last item of the list to the front and shifts all other elements one to the right, or vice-versa, depending on what you pass as the direction - ftol (first to last) or ltof (last to first). The default is ltof.

e.g. my $sao = Set::Array->new(1,2,3);

$sao->rotate(); # order is now 3,1,2

$sao->rotate(ftol); # order is back to 1,2,3

jscl-meditor is a java symbolic computing library and mathematical editor.
Main features:
- polynomial system solving
- vectors and matrices
- factorization
- derivatives
- integrals (rational functions)
- boolean algebra
- simplification
- MathML output
- Java code generation
- geometric algebra
Regarding readability, the goal is to produce a code as nice and short as the pseudo-code found in textbooks or research papers. As an illustration, here is what the Euclidean algorithm would look like:
Polynomial gcd(Polynomial p, Polynomial q) {
while(q.signum()!=0) {
Polynomial r=p.remainder(q);
p=q;
q=r;
}
return p;
}
It entails a dedicated development effort. This choice of clear coding, enabled by java, may have consequences in terms of performance compared to other software. But it could be worth the commitment, in the respect that understanding an algorithm just by looking at the code is made possible. For instance, object-orientation allows to hide ugly optimizations behind a clean, easy to use interface.
Some may doubt however that java will ever be as clear as C++ because it doesnt provide operator overloading, which means that a+b is written a.add(b), and will remain as such. The interested reader can look at the ongoing discussion on the matter at Sun.
As for portability, it means that a lot of platforms are available at no cost, from powerful unix workstations or servers to handheld devices. To make it possible, the project is split in two parts : the engine (jscl) and the mathematical editor front-end (meditor). The engine is usable interactively or in batch mode from a java shell interpreter (like BeanShell for instance), or as a java library in any third-party application.
The front-end has currently two implementations (see below). Among others, it is intended for taking course notes. With it, a student can perform the calculations asked by their teacher fast and reliably. The plain text format should make the exchange of notes easy. The produced worksheets can be published on-line thanks to the MathML output feature, for instance on meditorworld (MathML capable browser needed, tested to work with Mozilla).

Danga::Socket is an event loop and event-driven async socket base class.

SYNOPSIS

package My::Socket
use Danga::Socket;
use base (Danga::Socket);
use fields (my_attribute);

sub new {
my My::Socket $self = shift;
$self = fields::new($self) unless ref $self;
$self->SUPER::new( @_ );

$self->{my_attribute} = 1234;
return $self;
}

sub event_err { ... }
sub event_hup { ... }
sub event_write { ... }
sub event_read { ... }
sub close { ... }

$my_sock->tcp_cork($bool);

# write returns 1 if all writes have gone through, or 0 if there
# are writes in queue
$my_sock->write($scalar);
$my_sock->write($scalarref);
$my_sock->write(sub { ... }); # run when previous data written
$my_sock->write(undef); # kick-starts

# read max $bytecount bytes, or undef on connection closed
$scalar_ref = $my_sock->read($bytecount);

# watch for writability. not needed with ->write(). write()
# will automatically turn on watch_write when you wrote too much
# and turn it off when done
$my_sock->watch_write($bool);

# watch for readability
$my_sock->watch_read($bool);

# if you read too much and want to push some back on
# readable queue. (not incredibly well-tested)
$my_sock->push_back_read($buf); # scalar or scalar ref

Danga::Socket->AddOtherFds(..);
Danga::Socket->SetLoopTimeout($millisecs);
Danga::Socket->DescriptorMap();
Danga::Socket->WatchedSockets(); # count of DescriptorMap keys
Danga::Socket->SetPostLoopCallback($code);
Danga::Socket->EventLoop();

This is an abstract base class for objects backed by a socket which provides the basic framework for event-driven asynchronous IO, designed to be fast. Danga::Socket is both a base class for objects, and an event loop.

Callers subclass Danga::Socket. Danga::Sockets constructor registers itself with the Danga::Socket event loop, and invokes callbacks on the object for readability, writability, errors, and other conditions.

Because Danga::Socket uses the "fields" module, your subclasses must too.

Dev is powerful and very flexible content management system for web portals. Dev is powerful and very flexible content management system for web portals. System is licensed as freeware under the terms of GNU/GPL licence. Its absolutely free for non-commercial and commercial use.

DEV contains many modules required for system:

Articles
Dev provides easy way to publish articles for everyone visitor after registration. As site administrator, you have to check every article, and decide, if the article content is valid for publication. Only superusers can add articles directly without administrators check. DEV supports structuring articles into Zones and Sections
Articles equipment
Each article can be separately commented and discussed. Each article has a private statistics of readability. You can evaluate article by taking the poll.
News
You can also publish short news and create back-ends in xml format
Forums and Discussion boars
DEV provides a versatile spectrum of forums and discussion boards.
Polls
As each CMS system, DEV provides a polls too. Polls can be managed using the control panel.
Gallery
With DEV w.m.s., you are able to publish your multimedia files (videos, photos, pictures, etc...) quickly and easily using the Gallery module. This module supports creating thumbnails of your files. You can organize and categorize your multimedia stuff in sections. System can automatically scan selected directory with all subdirectories and add all multimedia content into gallery.
Download manager
Organize your files in "download section" this module allows you to manage download lists, each file has a separate download counter, etc ...
Advertisement
Manage advertisement on your site using this module.
Notification
Be informed about events on your site by wide range of notification functions.
Reports
System allows you to create system reports and export them into MS Excel or XML format.
Security
You can revoke access from some IP addresses. This is the good way to avoid sniper activitity of flooders, spammers, etc ... Note: Also, you can use broadcast addresses to wide range banning.
Control panel
You are allowed to administrate system by remote access using web-browser based control panel. Control panel provides you wide range of settings. Its optional for routine administration from any computer connected to the internet. All settings can be exported into file for backup or future use.
Design customizer
DEV w.m.s. allows you to change design using special user-friendly tool (contained in control panel) without editing html code! Using this tool, you are able to create variuos design schemes and share it with your friends. Also, if you dont want to use design customizer, there is way to create design manually by editing html and css sources.

CSSTidy is an opensource CSS parser and optimizer. The project is available as executeable file (available for Windows, Linux and OSX) which can be controlled per command line and as PHP script (both with almost the same functionality).
In opposite to most other CSS parsers, no regular expressions are used and thus CSSTidy has full CSS2 support and a higher reliability.
Main features:
- colours like "black" or rgb(0,0,0) are converted to #000000 or rather #000 if possible. Some hex-codes are replaced by their colour names if they are shorter.
- a{property:x;property:y;} becomes a{property:y;} (all duplicate properties are merged)
- margin:1px 1px 1px 1px; becomes margin:1px;
- margin:0px; becomes margin:0;
- a{margin-top:10px; margin-bottom:10px; margin-left:10px; margin-right:10px;} becomes a{margin:10px;}
- margin:010.0px; becomes margin:10px;
- all unnecessary whitespace is removed, depending on the compression-level
- all background-properties are merged
- all comments are removed
- the last semicolon in every block can be removed
- missing semicolons are added, incorrect newlines in strings are fixed, missing units are added, bad colors (and color names) are fixed
- property:value ! important; becomes property:value !important.
Why optimise?
If you optimise your CSS code you have faster loading pages and lower traffic costs. So both you and your visitors benefit from an optimisation. If you are interested in a faster loading webpage, websiteoptimization.com might also be an interesting resource.
Compression ratio
The compression ratio mostly depends on the level of whitespace-removal. Using standard whitespace-removal (which preserves the readability) the compression ratio often is 30% and more. In theory the compression ratio can be 99,99% but only very "stupid" stylesheets will allow those ratios. Also have a look at the examples.
Apart from compression
If a high compression is not important for you, you can also use CSSTidy to format or fix CSS code for a higher browser compatibility. Apart from the 4 default templates you can specify custom templates so that you can easily format a lot of CSS code using your own coding style. Other features are sorting and changing the case of selectors and properties.
Enhancements:
- Note: This is the last version of CSSTidy. If youd like continue maintaining it, let me know.
- FS#146 - Quotes
- FS#147 - Universal selector before classes, IDs and attribute selectors
- FS#150 - Wrong trasformation of a big integer value
- FS#144 ? !important rule
- FS#140: Fixing Values of Invalid properties
- [ 1745894 ] @media merge strangeness (cssTidy.exe version)
- FS#143: Save some more bytes