reference
cb2Bib 1.3.1
The cb2Bib is a tool for rapidly extracting unformatted biblographic references from email alerts. more>>
The cb2Bib reads the clipboard text contents and process it against a set of predefined patterns. If this automatic detection is successful, cb2Bib formats the clipboard data according to the structured BibTeX reference standard.
Otherwise, if no predefined format pattern is found or if detection proves to be difficult, manual data extraction is greatly simplified by cb2Bib. In most cases, such manual data extraction will provide with a new, personalized pattern to be included within the predefined pattern set for future automatic extractions.
Once the bibliographic reference is correctly extracted, it is added to a specified BibTeX database file. Optionally, article PDF files, if available, are renamed to its citeID and moved to a desired directory as a personal article library
Major Features:
- Select the reference to import from the email or web browser: On Unix machines, cb2Bib automatically detects mouse selections and clipboard changes. On Windows machines, copy or Ctrl-C is necessary to activate cb2Bib automatic processing.
- cb2Bib automatic processing: Once text is selected cb2Bib initiates the automatic reference extraction. It uses the predefined patterns from file regexp.txt to attempt automatic extraction. See Configuring Files section for setting the user predefined pattern matching expression file. After a successful detection bibliographic fields appear on the cb2Bib item line edits. Manual editing is possible at this stage.
- cb2Bib manual processing: If no predefined format pattern is found or if detection proves to be difficult, a manual data extraction must be performed. Select individual reference items from the cb2Bib clipboard area. A popup menu will appear after selection is made. Choose the corresponding bibliographic field. See BiBTeX Entry Types available as cb2Bib fields. Selection is post-processed and added to the cb2Bib item line edit. cb2Bib field tags will show on the cb2Bib clipboard area. Once the manual processing is done, cb2Bib clipboard area will contain the matching pattern. The pattern can be further edited and stored to the regexp.txt file using Insert Regular Expression, Alt+I. See the Extracting Data from the Clipboard and The Regular Expression Editor sections.
- Download reference to cb2Bib: The cb2Bib has the built-in functionality to interact with publishers "Download reference to Citation Manager" service. Choose BibTeX format, or any other format that you can translate using External Clipboard Preparsing Command. See Additional, Keyboard Functionality, Alt C. Click "Download" from your browser. When asked "Open with..." select cb2Bib. The cb2Bib will be launched if no running instance is found. If already running, it will place the downloaded reference to the clipboard, and it will start processing. Make sure your running instance is aware of clipboard changes. See Buttons Functionality. For convenience, the shell script c2bimport, and the desktop config file c2bimport.desktop are also provided.
- Adding documents: PDF and other documents can be added to the BibTeX reference by dragging the file icon and dropping it into the cb2Bib's panel. Optionally, document files, are renamed to its citeID and moved to a desired directory as a personal article library (See Configuring Documents section). Linked to a reference documents correspond to the BibTeX tag file. Usual reference manager software will permit to retrieve and visualize these files. Download, copy and/or moving is scheduled and performed once the reference is accepted, e.g., once it is saved by pressing Save Reference button.
- Multiple retrieving from PDF files: Multiple PDF or convertible to text files can be sequentially processed by dragging a set of files into cb2Bib's PDFImport dialog. By starting the processing button, files are sequentially converted to text and send to cb2Bib clipboard panel for reference extraction. See PDF Reference Import for details.
- Journal-Volume-Page Queries: Takes input Journal, Volume, and first page from the corresponding edit lines and attempts to complete the reference. Additionally, queries consider Title, DOI, and an excerpt, which is a simplified clipboard panel contents. See Configuring Network section, the distribution file netqinf.txt, and Release Note cb2Bib 0.3.5 for customization and details.
- BibTeX Editor: cb2Bib includes a practical text editor suitable for corrections and additions. cb2Bib capabilities are readily available within the editor. E.g., the reference is first sent to cb2Bib by selecting it, and later retrieved from cb2Bib to the editor using 'right click' + 'Paste Current BibTeX'. Interconversions Unicode LaTeX, long abbreviated journal name, and adding/renaming PDF files are easily available. BibTeX Editor is also accessible through a shell command line.
- Advanced features, and processing and extraction details are described in the following sections:
- Extracting Data from the Clipboard
- Processing of author's names
- Processing of journal names
- Field Recognition Rules
- The Regular Expression Editor
- Configuration information is described in the following sections:
- Configuration
- Predefined cite ID placeholders
- Utilities and modules are described in the following sections:
- Search BibTeX files for references
- Embedded File Editor
- PDF Reference Import
- The cb2Bib Command Line
- Reading and writing bibliographic metadata
- The cb2Bib Annote
- The cb2Bib Citer
Enhancements:
- Added Check Repeated functionality for current reference
- Fixed parser not processing last field in inverted comma style BibTeX
- Set netqinf.txt to use internal XML parser for PubMed
- Fixed packaging, double copying scripts and initial external tool setting
- Fixed c2bciter script not passing all arguments (Thanks to F. Rusconi)
Requirements:
To compile cb2Bib, the following libraries must be present and accessible:
- Qt 4.4.0 or higher from Trolltech. On a Linux platform with Qt preinstalled, make sure that the devel packages and Qt tools are also present.
- WebKit library (optional) to compile cb2Bib Annote viewer. It is already included in Qt > 4.4.0 library. No special action/flag is needed during compilation.
- X11 header files if compiling on Unix platforms. Concretely, headers X11/Xlib.h and X11/Xatom.h are needed.
- The header files fcntl.h and unistd.h from glibc-devel package are also required. Otherwise compilation will fail with reference list.cpp:227: `close' undeclared.
Advanced Bash Scripting Guide 5.4
Complete ebook tutorial and reference on shell scripting with Bash in Linux/UNIX/BSD. This is the equivalent of a 918-page printed book. more>>
Complete ebook tutorial and reference on shell scripting with Bash in Linux/UNIX/BSD. This is the equivalent of a 918-page printed book. Includes shell scripts that emulate games, such as Perquackey and Nim. It is an official Linux Documentation Project (http://www.tldp.org) Guide. Some reviewers have named it the best book available on the subject.
Requirements: Web Browser or PDF viewer
Whats new in this version: New material, updates, bugfixes, stylistic revisions
<<lessMath::Amoeba 0.04
Math::Amoeba is a Multidimensional Function Minimization. more>>
SYNOPSIS
use Math::Amoeba qw(ConstructVertices EvaluateVertices Amoeba MinimiseND);
my ($vertice,$y)=MinimiseND(@guess,@scales,&func,$tol,$itmax,$verbose);
my @vertices=ConstructVertices(@vector,@offsets);
my @y=EvaluateVertices(@vertices,&func);
my ($vertice,$y)=Amoeba(@vertices,@y,&func,$tol,$itmax,$verbose);
This is an implementation of the Downhill Simpex Method in Multidimensions (Nelder and Mead) for finding the (local) minimum of a function. Doing this in Perl makes it easy for that function to actually be the output of another program such as a simulator.
Arrays and the function are passed by reference to the routines.
The simplest use is the MinimiseND function. This takes a reference to an array of guess values for the parameters at the function minimum, a reference to an array of scales for these parameters (sensible ranges around the guess in which to look), a reference to the function, a convergence tolerance for the minimum, the maximum number of iterations to be taken and the verbose flag (default ON). It returns an array consisting of a reference to the function parameters at the minimum and the value there.
The Amoeba function is the actual implementation of the Downhill Simpex Method in Multidimensions. It takes a reference to an array of references to arrays which are the initial n+1 vertices (where n is the number of function parameters), a reference to the function valuation at these vertices, a reference to the function, a convergence tolerance for the minimum, the maximum number of iterations to be taken and the verbose flag (default ON). It returns an array consisting of a reference to the function parameters at the minimum and the value there.
The ConstructVertices is used by MinimiseND to construct the initial vertices for Amoeba as the initial guess plus the parameter scale parameters as vectors along the parameter axis.
The EvaluateVertices takes these set of vertices, calling the function for each one and returning the vector of results.
EXAMPLE
use Math::Amoeba qw(MinimiseND);
sub afunc {
my ($a,$b)=@_;
print "$at$bn";
return ($a-7)**2+($b+3)**2;
}
my @guess=(1,1);
my @scale=(1,1);
($p,$y)=MinimiseND(@guess,@scale,&afunc,1e-7,100);
print "(",join(,,@{$p}),")=$yn";
produces the output
(6.99978191653352,-2.99981241563247)=1.00000008274829
KBib 0.6.2
KBib is a BibTex management program for KDE (Similar to KBibTex). more>>
Features include import from RIS/ISI/Endnote files, export to Endnote/RIS files, automatically generate citation keys, check and correct duplicated citation keys, check and remove duplicated references, cite references into Lyx/Kile.
Main features:
- Add/edit/remove references
- Support copy/paste/drag-drop of references (BibTex entries can be copied/pasted or dragged/dropped from another Kbib window or a text editor into KBib and vice versus)
- Create new reference from plain text
- Find/remove duplicated references
- Generate citation key automatically
- Check/correct duplicated citation keys
- Lock/unlock citation keys (to prevent unwanted change of citation keys)
- Sort references
- Search references(fairly simple)
- Cite selected references into Lyx/Kile (using Lyx pipe)
- Support string macros
- Import references from Bibtex/RIS/ISI/Endnote/COPAC/MODS XML/PubMed XML/Endnote exported Bibtex (without citation key) files
- Export to RIS/Endnote/MODS XML/HTML files
- Search references from Z39.50 servers, SRU servers and Pubmed server.
- Download references from remote reference database (opened with Konqueror, Firefox), such as IEEEXplore, ScienceDirect (RIS format), Web of Science (ISI format) into KBib (seescreenshot)
- Save selected references into a new file
- Maintain a list of existing authors/journals/keywords in the current document
- Support user defined reference types
- Add/Delete/Edit reference types
- Allow different view modes (view all/by reference type/selected references/unselected references)
- Group references by various properties. References can be grouped by Reference type/Author/Editor/Journal/Keywords. Group view can be disabled.
- Allow flexible displayed fields
- Generate bibliography from selected references
Enhancements:
- Configuration dialog: add options to change the order of datasource
- Remote search dialog: double click to import an entry, press enter to start searching
- Reference editing dialog: ask to save data if close dialog with modified data
- New reference from text dialog: add option to add selected text to multiple value fields (e.g. authors, keywords)
Bio::LiveSeq::Translation 1.4
Bio::LiveSeq::Translation is a translation class for LiveSeq. more>>
This stores informations about aminoacids translations of transcripts. The implementation is that a Translation object is the translation of a Transcript object, with different possibilities of manipulation, different coordinate system and eventually its own ranges (protein domains).
APPENDIX
The rest of the documentation details each of the object methods. Internal methods are usually preceded with a _
new
Title : new
Usage : $protein = Bio::LiveSeq::Translation->new(-transcript => $transcr);
Function: generates a new Bio::LiveSeq::Translation
Returns : reference to a new object of class Translation
Errorcode -1
Args : reference to an object of class Transcript
get_Transcript
Title : valid
Usage : $transcript = $obj->get_Transcript()
Function: retrieves the reference to the object of class Transcript (if any)
attached to a LiveSeq object
Returns : object reference
Args : none
aa_ranges
Title : aa_ranges
Usage : @proteinfeatures = $translation->aa_ranges()
Function: to retrieve all the LiveSeq AARange objects attached to a
Translation, usually created out of a SwissProt database entry
crossreferenced from an EMBL CDS feature.
Returns : an array
Args : none
libSpiff 0.7.2
libSpiff brings XSPF playlist reading and writing support to your C++ application. more>>
libSpiff uses Expat for XML parsing and CppTest for unit testing. libSpiff is the official reference implementation for XSPF of the Xiph.Org Foundation.
Devel::Pointer 1.00
Devel::Pointer is a Perl module that can fiddle around with pointers. more>>
SYNOPSIS
use Devel::Pointer;
$a = address_of($b); # a = &b;
$b = deref($a); # b = *a;
$a = unsmash_sv(0+$scalar_ref);
@a = unsmash_av(0+$array_ref);
%a = unsmash_hv(0+$hash_ref);
&a = unsmash_cv(0+$code_ref);
# OK, you cant do that, but you get the idea
$c = deref(-1); # *(-1), and the resulting segfault.
The primary purpose of this is to turn a smashed reference address back into a value. Once a reference is treated as a numeric value, you cant dereference it normally; although with this module, you can.
Be careful, though, to avoid dereferencing things that dont want to be dereferenced.
Objective Modula-2 1.00 (Reference Implementation)
Objective Modula-2 programming language is a hybrid between Smalltalk and Modula-2. more>>
The design is an example how native Cocoa/GNUstep support can be added to static imperative programming languages without implementing a bridge.
Objective Modula-2s scope encompasses the design of the Objective Modula-2 programming language and the implementation of a compiler to implement it. The initial compiler will generate Objective-C source code.
Enhancements:
- This code is used to verify ideas and concepts which come up in the course of defining the language.
- It is in an early stage, incomplete and subject to frequent changes.
Sunrise Data Dictionary 1.00
Sunrise Data Dictionary is a library for hashtable storage of arbitrary data objects. more>>
Sunrise Data Dictionary library can participate in external reference counting systems or use its own built-in reference counting. It comes with a variety of hash functions and allows the use of runtime supplied hash functions via callback mechanism. The source code is well documented.
The Sunrise Data Dictionary was specifically designed for use within the Afelio and Callweaver telephony servers, the implementation focuses on performance and scalability.
Enhancements:
- This is the initial release of the full API (all header files) and a developer snapshot of the implementation.
libmng 1.0.10
libmng is the reference library for the MNG image format. more>>
The project provides powerful animation features combined with PNGs robustness and patent freedom.
Enhancements:
- This release adds provisional support for mpNG and ANG animations.
- There are minor bugfixes.
OpenSCADA Project 0.8.0 (Atlantis)
The OpenSCADA project aims to create a full-featured and state-of-the-art SCADA system. more>>
The OpenSCADA project was started in order to create a common standard for SCADA applications. This includes specifications, interfaces and reference implementations.
Enhancements:
- This release has many new features and enhancements to existing functionality.
- The interfaces and the reference implementation were cleaned up a little bit.
- The new upstream version of Utgard was added.
ISC DHCP 3.0.6
ISC DHCP provides a freely redistributable reference implementation of all aspects of DHCP. more>>
- A DHCP server
- A DHCP client
- A DHCP relay agent
These tools all use a modular API which is designed to be sufficiently general that it can easily be made to work on POSIX-compliant operating systems and also non-POSIX systems like Windows NT and MacOS.
The DHCP server, client and relay agent are provided both as reference implementations of the protocol and as working, fully-featured sample implementations.
Both the client and the server provide functionality that, while not strictly required by the protocol, is very useful in practice. DHCP server also makes allowances for non-compliant clients which one might still like to support.
Devel::Monitor 0.9.0.7
Devel::Monitor is a Perl module that can monitor your variables/objects for memory leaks. more>>
You have memory leaks, and you want to remove it... You can use this tool to help you find which variables/objects that are not destroyed when they should be, and thereafter, you can visualise exactly where is the circular reference for some specific variables/objects.
WHAT IT CANT DO
Even if your modules are memory leak free, it doesnt mean that external modules that you are using dont have it. So, before running your application on mod_perl, you should be sure that EVERY modules are ok. (In particular those perl extensions calling C++ code)
SYNOPSIS
use Devel::Monitor qw(:all);
#-----------------------------------------------------------------------------
# Monitor scalars, arrays, hashes, references, constants
#-----------------------------------------------------------------------------
my ($a,$b) = (Foo::Bar->new(), Foo::Bar->new());
my ($c, @d, %e);
use constant F => [1,2];
monitor(name for a => $a,
name for b => $b,
name for c => $c,
name for d => @d,
name for e => %e,
name for F => &F); #NOTE : Dont add parentheses to the end of the constant (&F())
#-----------------------------------------------------------------------------
# Print circular references
#-----------------------------------------------------------------------------
# NOTE : You cannot use print_circular_ref on a monitored/tied variable
# (See "We cannot use tied objects references because it reuse memory space" doc)
print_circular_ref($a);
print_circular_ref($b);
print_circular_ref($c);
print_circular_ref(@d);
print_circular_ref(%e);
print_circular_ref(&F); #NOTE : Dont add parentheses to the end of the constant (&F())
USAGE : monitor
Example with a circular reference
+----------------------+
| Code |
+----------------------+
{
my @a;
monitor(a => @a);
$a[0] = @a; #Add a circular reference
print STDERR "Leaving scopen";
}
print STDERR "Scope leftn";
+----------------------+
| Output |
+----------------------+
MONITOR ARRAY a
Leaving scope
Scope left
DESTROY ARRAY a
+----------------------+
| Meaning |
+----------------------+
The line "DESTROY ARRAY a" should be between scope prints.
@a were deleted on program exit.
Example without a circular reference
+----------------------+
| Code |
+----------------------+
{
my @a;
monitor(a => @a);
print STDERR "Leaving scopen";
}
print STDERR "Scope leftn";
+----------------------+
| Output |
+----------------------+
MONITOR ARRAY a
Leaving scope
DESTROY ARRAY a
Scope left
+----------------------+
| Meaning |
+----------------------+
Everything is ok
Now that you know there is a circular reference, you can track it down using the print_circular_ref method
Perl6::Parameters 0.03
Perl6::Parameters is a module with Perl 6-style prototypes with named parameters. more>>
SYNOPSIS
use Perl6::Parameters;
sub mysub($foo, ARRAY $bar, *%rest) {
...
}
DETAILS
Perl6::Parameters is a Perl module which simulates Perl 6s named parameters. (When I talk about "named parameters" I mean something like the parameters youre used to from C, Java and many other languages--not pass-a-hash-with-the-parameters-in-it things.)
Like most other programming languages, Perl 6 will support subroutines with pre-declared variables the parameters are put into. (Using this will be optional, however.) This goes far beyond the "line-noise prototypes" available in Perl 5, which only allow you to control context and automatically take references to some parameters--lines like my($first, $second)=(@_) will no longer be necessary.
Although Perl 6 will have this, Perl 5 doesnt; this module makes it so that Perl 5 does. It uses some other Perl 6-isms too, notably the names for builtin types and the unary-asterisk notation for flattening a list.
Crafting Parameter Lists
Crafting parameter lists is simple; just declare your subroutine and put the parameters separated by commas or semicolons, in parenthesis. (Using a semicolon signifies that all remaining parameters are optional; this may not be available this way in Perl 6, but Im assuming it is until I hear otherwise.)
Most parameters are just variable names like $foo; however, more sophisticated behavior is possible. There are three ways to achieve this.
The first way is by specifying a type for the variable. Certain types make the actual parameters turn into references to themselves:
ARRAY $foo
This turns an array into a reference to itself and stores the reference into $foo.
HASH $foo
This turns a hash into a reference to itself and stores the reference into $foo.
CODE $foo
This turns a subroutine into a reference to itself and stores the reference into $foo.
SCALAR $foo
This turns a scalar into a reference to itself and stores the reference into $foo.
GLOB $foo
This turns a typeglob into a reference to itself and stores the reference into $foo. Typeglobs will be going away in Perl 6; this type exists in this module so that its useful for general use in Perl 5.
REF $foo
This turns any parameter into a reference to itself and stores it into $foo.
This only works in Perl 5.8. Otherwise, its treated the same as any other unrecognized type name.
AnythingElse $foo
This has no effect in this module; its treated as though youd typed $foo without the AnythingElse.
For example, if a subroutine had the parameters ($foo, HASH $bar, CODE $baz) and was called with ($scalar, %hash, &mysub) the subroutine would get the contents of $scalar, a reference to %hash and a reference to &mysub.
The second way is by supplying an actual array or hash as a parameter name. This requires an array or hash to be passed in for that parameter; it preserves the length of the array or hash.
The final way is only available for the last parameter: if an array or hash is prefixed with an asterisk, that array or hash will be filled with any additional parameters.
Scalar::Util 1.19
Scalar::Util is a selection of general-utility scalar subroutines. more>>
SYNOPSIS
use Scalar::Util qw(blessed dualvar isweak readonly refaddr reftype tainted
weaken isvstring looks_like_number set_prototype);
Scalar::Util contains a selection of subroutines that people have expressed would be nice to have in the perl core, but the usage would not really be high enough to warrant the use of a keyword, and the size so small such that being individual extensions would be wasteful.
By default Scalar::Util does not export any subroutines. The subroutines defined are
blessed EXPR
If EXPR evaluates to a blessed reference the name of the package that it is blessed into is returned. Otherwise undef is returned.
$scalar = "foo";
$class = blessed $scalar; # undef
$ref = [];
$class = blessed $ref; # undef
$obj = bless [], "Foo";
$class = blessed $obj; # "Foo"
dualvar NUM, STRING
Returns a scalar that has the value NUM in a numeric context and the value STRING in a string context.
$foo = dualvar 10, "Hello";
$num = $foo + 2; # 12
$str = $foo . " world"; # Hello world
isvstring EXPR
If EXPR is a scalar which was coded as a vstring the result is true.
$vs = v49.46.48;
$fmt = isvstring($vs) ? "%vd" : "%s"; #true
printf($fmt,$vs);
isweak EXPR
If EXPR is a scalar which is a weak reference the result is true.
$ref = $foo;
$weak = isweak($ref); # false
weaken($ref);
$weak = isweak($ref); # true
NOTE: Copying a weak reference creates a normal, strong, reference.
$copy = $ref;
$weak = isweak($ref); # false
looks_like_number EXPR
Returns true if perl thinks EXPR is a number. See "looks_like_number" in perlapi.
openhandle FH
Returns FH if FH may be used as a filehandle and is open, or FH is a tied handle. Otherwise undef is returned.
$fh = openhandle(*STDIN); # *STDIN
$fh = openhandle(*STDIN); # *STDIN
$fh = openhandle(*NOTOPEN); # undef
$fh = openhandle("scalar"); # undef
readonly SCALAR
Returns true if SCALAR is readonly.
sub foo { readonly($_[0]) }
$readonly = foo($bar); # false
$readonly = foo(0); # true
refaddr EXPR
If EXPR evaluates to a reference the internal memory address of the referenced value is returned. Otherwise undef is returned.
$addr = refaddr "string"; # undef
$addr = refaddr $var; # eg 12345678
$addr = refaddr []; # eg 23456784
$obj = bless {}, "Foo";
$addr = refaddr $obj; # eg 88123488
reftype EXPR
If EXPR evaluates to a reference the type of the variable referenced is returned. Otherwise undef is returned.
$type = reftype "string"; # undef
$type = reftype $var; # SCALAR
$type = reftype []; # ARRAY
$obj = bless {}, "Foo";
$type = reftype $obj; # HASH
set_prototype CODEREF, PROTOTYPE
Sets the prototype of the given function, or deletes it if PROTOTYPE is undef. Returns the CODEREF.
set_prototype &foo, $$;
tainted EXPR
Return true if the result of EXPR is tainted
$taint = tainted("constant"); # false
$taint = tainted($ENV{PWD}); # true if running under -T
weaken REF
REF will be turned into a weak reference. This means that it will not hold a reference count on the object it references. Also when the reference count on that object reaches zero, REF will be set to undef.
This is useful for keeping copies of references , but you dont want to prevent the object being DESTROY-ed at its usual time.
{
my $var;
$ref = $var;
weaken($ref); # Make $ref a weak reference
}
# $ref is now undef
Note that if you take a copy of a scalar with a weakened reference, the copy will be a strong reference.
my $var;
my $foo = $var;
weaken($foo); # Make $foo a weak reference
my $bar = $foo; # $bar is now a strong reference
This may be less obvious in other situations, such as grep(), for instance when grepping through a list of weakened references to objects that may have been destroyed already:
@object = grep { defined } @object;
This will indeed remove all references to destroyed objects, but the remaining references to objects will be strong, causing the remaining objects to never be destroyed because there is now always a strong reference to them in the @object array.