altgraph is a fork of graphlib: a graph (network) package for
constructing graphs, BFS and DFS traversals, topological sort, shortest
paths, etc. with graphviz output.
ok aja@
Hyena is a C# library used to make awesome applications. It contains a
lot of random things, including useful data structures, a Sqlite-based
db layer, cool widgets, a JSON library, a smart job/task scheduler, a
user-query/search parser, and much more. It's particularly useful for
Gtk# applications, though only the Hyena.Gui assembly requires Gtk#.
ok jasper@ robert@ (2 months ago...)
The Simulavr program is a simulator for the Atmel AVR family of
microcontrollers. Simulavr can be used either standalone or as a remote
target for gdb. When used in gdbserver mode, the simulator is used as a
backend so that gdb can be used as a source level debugger for AVR
programs.
ok aja@
file from www/mozilla-firefox, so remove old instances of that file that
weren't updated with last commits (and were unused anyway)
While here bump all REVISIONs after LIB_DEPENDS change.
ok naddy@
Tcl/Tk script library providing multi-entry/label widgets for
display and editing of real numbers in fixed point format,
IPv4 and IPv6 addresses, dates, times, etc.
Ok landry@.
Tcl/Tk script library providing enhanced functionality for Tk or Ttk
entries, BWidget Entries, Mentry widgets, Tk or Ttk spinboxes,
Ttk comboboxes, text or ctext widgets, listboxes and tablelist widgets.
* Restrict the set or number of characters that can be entered
into a widget.
* Manipulate the input characters before inserting into a widget:
change the color, font, etc.
* Protect parts of a widgets data from being modified or selected.
* Setup callbacks for data modification, insertion cursor movement
and selection change.
Ok landry@.
In-circuit programming (ISP) tool for the NXP (Philips) LPC1300 /
LPC1700 / LPC2000 series ARM7 / M0 / M3 microcontrollers.
from Alexander Shiryaev (MAINTAINER) with tweaks by me
ok landry@
repositories. It allows most bzr commands to work directly against
Subversion repositories, as if you were using bzr with a native bzr
repository.
The plugin can at the moment be used to commit to, pull from, merge
from, push to and view logs of Subversion branches from Bazaar.
ok jasper@
This module is for use in test scripts: A block eval on steroids,
configurable and extensible, but by default trapping (Perl) STDOUT,
STDERR, warnings, exceptions, would-be exit codes, and return values
from boxed blocks of test code.
ok benoit@
update to ghc-7.0.2. Unfortunately, there are some other ports
that don't build with mtl-2 yet, so in the worst case i've to
include mtl-1 within the ghc package and mtl-2 in this new port.
Not yet linked to the build, of course.
Your Boilerplate' papers (http://www.cs.uu.nl/wiki/GenericProgramming/SYB).
It defines the Data class of types permitting folding and unfolding
of constructor applications, instances of this class for primitive
types, and a variety of traversals.
Needed by some ports after an update to ghc-7.0.2, not yet linked to the build.
Reads good to landry@
or versioning. You can see how a model looked at any stage in its lifecycle,
revert it to any version, and even undelete it after it's been destroyed.
OK jeremy@ jasper@
working with OLE2 structured storage files, such as those produced by
Microsoft Office - eg *.doc, *.msg etc.
Dependency for ruby-spreadsheet.
OK jeremy@
Perl extension for Munkres' solution to classical Assignment problem for
square and rectangular matrices This module extends the solution of
Assignment problem for square matrices to rectangular matrices by
padding zeros. Thus a rectangular matrix is converted to square matrix
by padding necessary zeros.
ok sthen@
Class::Std::Fast allows you to use the beautiful API of Class::Std in a
faster way than Class::Std does. You can get the object's ident via
scalarifiyng your object. Getting the objects ident is still possible
via the ident method, but it's faster to scalarify your object.
ok sthen@
This module provides both a C and pure ruby simple subset sum problem
solver. The subset sum problem is, given a set of numbers, can the sum
of any subset of those numbers equal a given number. This problem is
NP-complete.
Both the C and pure ruby versions implement a fairly simple
meet-in-the-middle algorithm. The C version uses an AVL tree to store
the data, while the pure ruby version uses a ruby hash. For the C
version to be used, the sum of the positive numbers and the sum of the
negative numbers in the set, as well as the wanted number, must all be
Fixnums. Additionally, max_seconds should be nil or a Fixnum.
ruby-prof is a fast code profiler for Ruby. Its features include:
* Speed - it is a C extension and therefore many times faster than the
standard Ruby profiler.
* Modes - Ruby prof can measure a number of different parameters,
including call times, memory usage and object allocations.
* Reports - can generate text and cross-referenced html reports
o Flat Profiles - similar to the reports generated by the standard
Ruby profiler
o Graph profiles - similar to GProf, these show how long a method
runs, which methods call it and which methods it calls.
o Call tree profiles - outputs results in the calltree format
suitable for the KCacheGrind profiling tool.
* Threads - supports profiling multiple threads simultaneously
* Recursive calls - supports profiling recursive method calls
home_run is an implementation of ruby's Date/DateTime classes in C, with
much better performance (20-200x) than the version in the standard
library, while being almost completely compatible.
MSpec is a specialized framework that is syntax-compatible with RSpec
for basic things like describe, it blocks and before, after actions.
MSpec contains additional features that assist in writing the RubySpecs
used by multiple Ruby implementations. Also, MSpec attempts to use the
simplest Ruby language features so that beginning Ruby implementations
can run it.
With ffi-inliner you can run C code within your ruby script:
* Mix C snippets in your Ruby code and gulp it on the fly!
* It's based on Ruby-FFI so the C code you inject is portable across
Ruby implementations!
* Yep, it means that you can run it on JRuby too!
* Fast compilation through tcc
* But it can use the system's compiler (e.g. gcc) on those platforms
that don't support tcc (e.g. OSX) or that don't have it installed
Ruby-FFI is a ruby extension for programmatically loading dynamic
libraries, binding functions within them, and calling those functions
from Ruby code. Moreover, a Ruby-FFI extension works without changes on
Ruby and JRuby.
* It has a very intuitive DSL
* It supports all C native types
* It supports C structs (also nested), enums and global variables
* It supports callbacks
* It has smart methods to handle memory management of pointers and
structs
rake-compiler aims to help Gem developers deal with Ruby extensions,
simplifying code and reducing duplication.
It follows convention over configuration and sets a standardized
structure to build and package both C and Java extensions in your gems.
This is the result of experiences dealing with several Gems that
required native extensions across platforms and different user
configurations where details like portability and clarity of code were
lacking.
allow keyword access to array instances. arrayfields works by adding
only a few methods to arrays, namely #fields= and fields, but the
#fields= method is hooked to extend an array on a per object basis. in
otherwords __only__ those arrays whose fields are set will have
auto-magical keyword access bestowed on them - all other arrays remain
unaffected. arrays with keyword access require much less memory when
compared to hashes/objects and yet still provide fast lookup and
preserve data order.
Bustle draws sequence diagrams of D-Bus activity, showing signal
emissions, method calls and their corresponding returns, with timestamps
for each individual event and the duration of each method call. This can
help you check for unwanted D-Bus traffic, and pinpoint why your
D-Bus-based application isn't performing as well as you like.
<...>
ok kili@ jasper@
This library provides an abstraction of buffered output of byte streams
and several convenience functions to exploit it. For example, it allows
to efficiently serialize Haskell values to lazy bytestrings with a large
average chunk size. The large average chunk size allows to make good use
of cache prefetching in later processing steps (e.g. compression) and
reduces the sytem call overhead when writing the resulting lazy
bytestring to a file or sending it over the network.
ok kili@
