3 effective methods
Sponsored Links
Sponsored Links
Secleted [ 0 ] software to compare
Results 1 - 15 of about 6311
Class::Method::hash 2.08
Class::Method::hash is a Perl module that helps you create methods for handling a hash value. more>>
Class::Method::hash is a Perl module that helps you create methods for handling a hash value.
SYNOPSIS
use Class::MethodMaker
[ hash => [qw/ x /] ];
$instance->x; # empty
$instance->x(a => 1, b => 2, c => 3);
$instance->x_count == 3; # true
$instance->x = (b => 5, d => 8); # Note this *replaces* the hash,
# not adds to it
$instance->x_index(b) == 5; # true
$instance->x_exists(c); # false
$instance->x_exists(d); # true
Creates methods to handle hash values in an object. For a component named x, by default creates methods x, x_reset, x_clear, x_isset, x_count, x_index, x_keys, x_values, x_each, x_exists, x_delete, x_set, x_get.
<<lessSYNOPSIS
use Class::MethodMaker
[ hash => [qw/ x /] ];
$instance->x; # empty
$instance->x(a => 1, b => 2, c => 3);
$instance->x_count == 3; # true
$instance->x = (b => 5, d => 8); # Note this *replaces* the hash,
# not adds to it
$instance->x_index(b) == 5; # true
$instance->x_exists(c); # false
$instance->x_exists(d); # true
Creates methods to handle hash values in an object. For a component named x, by default creates methods x, x_reset, x_clear, x_isset, x_count, x_index, x_keys, x_values, x_each, x_exists, x_delete, x_set, x_get.
Download (0.087MB)
Added: 2007-07-05 License: Perl Artistic License Price:
841 downloads
Archimedes 0.0.4
GNU Archimedes is the GNU package for the design and simulation of submicron semiconductor devices. more>>
GNU Archimedes is the GNU package for the design and simulation of submicron semiconductor devices. Archimedes is a 2D Fast Monte Carlo simulator which can take into account all the relevant quantum effects, thank to the implementation of the Bohm effective potential method.
The physics and geometry of a general device is introduced by typing a simple script, which makes, in this sense, GNU Archimedes a powerfull tool for the simulation of quite general semiconductor devices.
In the present release, GNU Archimedes is able to simulate electrons and heavy holes in Silicon and GaAs (Gamma and L-valleys) devices (holes are simulated by means of a simplified MEP model), and in the next release, which is in preparation, it will be able to make simulations in 1D, 2D and 3D (this release will be delivered as soon as possible).
The Scientifical and Industrial Motivations
In today semiconductor technology, the miniaturization of devices is more and more progressing. In this context, it is easy to see that numerical simulations play an important role at every level of device manufacture. In fact, the cost of designing and physically constructing prototypes for VLSI semiconductor devices is very high and without the availability of advanced simulators the efforts for devices miniaturization would, likely, be brought to a halt. From assessing the performance of individual transistors, to circuits and systems, and, consequently, with the promise of improved device performance, industries are encouraged to keep on miniaturizing with lower manufacture costs.
But, unfortunately, such simulations are not whithout their challenges... A first consequence of device miniaturization is that simulations of submicron semicondutor devices requires advanced transport models. Because of the presence of very high and rapidly varying electric field, phenomena occur which cannot be described by means of the well-known drift-diffusion models, which do not incorporate energy as a dynamical variable.
That is why some generalization has been sought in order to obtain more physically accurate models, like energy-transport and hydrodynamical models. The energy-transport models which are implemented in commercial simulators are based on phenomenological constitutive equations for the particle flux and energy flux depending on a set of parameters which are fitted to homogeneous bulk material Monte Carlo simulations. So, this is not, certainly, a satisfactory physical description of the internal electronic dynamics in a semiconductor device.
As current device technologies quickly approach the scales whereby quantum effects due to strong confinement of carriers and direct source-drain tunneling will begin to dominate, new simulation techniques are required in order to fully understand and acurately simulate the physics behind the technology operation.
Of all the simulation methods currently employed, ensemble Monte Carlo has always been, both in the accademic and industrial community, the most vigorous and trusted method for device simulation, as it is proven to be reliable and predictive, as one can easily see from the vast bibliography on this subject.
However, as Monte Carlo relies on the particle nature of the electron (in fact we consider an electron like a biliard ball), quantum effects associated with the wave-like nature of electrons cannot fully incorporated into the actual simulators, i.e. the ensemble Monte Carlo have to be lightly (or strongly, it depends on the point of view and on the methods implemented...) modified to take into account the quantum effects, at least at a first order of approximation, which is certainly enough to take into account correctly all the relevant quantum effects present in the present-day semiconductor devices (till 2015 probably...). In order to take into account the wave-like nature of electrons we use a recently introduced quantum theory, the so-called Bohm effective potential theory.
So it is challenging and very interesting to develop such a code for 2D quantum submicron semiconductor devices. This is why I have decided to implement this code, but these are not the only motivations...
The Ethical Motivations
The very sad situation you quickly observe working in a semiconductor industry, but also in all places in which researches about semiconductor devices are made, the only codes for simulation you can find are not free and are proprietary codes.
That is a very bad situation because, at the present time, if you need to develop your own code for the purpose of simulating a device it is IMPOSSIBLE to obtain an advanced one in a short time, and, trust me, this is EXTREMELY BAD for scientific research... (Immagine if you had to re-discover the Newtonian laws every time you need them...) So, you can find a huge amount of papers describing a lot of numerical methods for simulating, in a very advanced way, semiconductor devices (even in the quantum case), but nobody will give you a code on which you can construct your own method (with the unlikely exception that at least one of the programmers is a friend of yours :) ).
Even worst, if you are a semiconductor device designer and you want to simulate "realistically" a new device, you have to pay (trust me, at very high costs!) a BINARY (just a binary and not the code!) from some well-known software industry. This binary will certainly have some bugs (because it is coded by humans which are not perfect...) and you will never have the possibility of fix them on your own. Of course, you can write to the software house and tell them that there is a bug, but, how many time do you will wait for a new release without those bugs? I dont think it will be a short time...
My impression is that, after a long research on the Web for a Free Software dealing with advanced 2D semiconductor device simulation, there was not a free code for the purpose of semiconductor devices simulation (i mean under GPL license). To be sure about it, I asked to the great Richard Stallman (by mail) if it will be worth to do a code like this and he encouraged me to code it, because there wasnt a code like this as free. So I decided to write this code..
<<lessThe physics and geometry of a general device is introduced by typing a simple script, which makes, in this sense, GNU Archimedes a powerfull tool for the simulation of quite general semiconductor devices.
In the present release, GNU Archimedes is able to simulate electrons and heavy holes in Silicon and GaAs (Gamma and L-valleys) devices (holes are simulated by means of a simplified MEP model), and in the next release, which is in preparation, it will be able to make simulations in 1D, 2D and 3D (this release will be delivered as soon as possible).
The Scientifical and Industrial Motivations
In today semiconductor technology, the miniaturization of devices is more and more progressing. In this context, it is easy to see that numerical simulations play an important role at every level of device manufacture. In fact, the cost of designing and physically constructing prototypes for VLSI semiconductor devices is very high and without the availability of advanced simulators the efforts for devices miniaturization would, likely, be brought to a halt. From assessing the performance of individual transistors, to circuits and systems, and, consequently, with the promise of improved device performance, industries are encouraged to keep on miniaturizing with lower manufacture costs.
But, unfortunately, such simulations are not whithout their challenges... A first consequence of device miniaturization is that simulations of submicron semicondutor devices requires advanced transport models. Because of the presence of very high and rapidly varying electric field, phenomena occur which cannot be described by means of the well-known drift-diffusion models, which do not incorporate energy as a dynamical variable.
That is why some generalization has been sought in order to obtain more physically accurate models, like energy-transport and hydrodynamical models. The energy-transport models which are implemented in commercial simulators are based on phenomenological constitutive equations for the particle flux and energy flux depending on a set of parameters which are fitted to homogeneous bulk material Monte Carlo simulations. So, this is not, certainly, a satisfactory physical description of the internal electronic dynamics in a semiconductor device.
As current device technologies quickly approach the scales whereby quantum effects due to strong confinement of carriers and direct source-drain tunneling will begin to dominate, new simulation techniques are required in order to fully understand and acurately simulate the physics behind the technology operation.
Of all the simulation methods currently employed, ensemble Monte Carlo has always been, both in the accademic and industrial community, the most vigorous and trusted method for device simulation, as it is proven to be reliable and predictive, as one can easily see from the vast bibliography on this subject.
However, as Monte Carlo relies on the particle nature of the electron (in fact we consider an electron like a biliard ball), quantum effects associated with the wave-like nature of electrons cannot fully incorporated into the actual simulators, i.e. the ensemble Monte Carlo have to be lightly (or strongly, it depends on the point of view and on the methods implemented...) modified to take into account the quantum effects, at least at a first order of approximation, which is certainly enough to take into account correctly all the relevant quantum effects present in the present-day semiconductor devices (till 2015 probably...). In order to take into account the wave-like nature of electrons we use a recently introduced quantum theory, the so-called Bohm effective potential theory.
So it is challenging and very interesting to develop such a code for 2D quantum submicron semiconductor devices. This is why I have decided to implement this code, but these are not the only motivations...
The Ethical Motivations
The very sad situation you quickly observe working in a semiconductor industry, but also in all places in which researches about semiconductor devices are made, the only codes for simulation you can find are not free and are proprietary codes.
That is a very bad situation because, at the present time, if you need to develop your own code for the purpose of simulating a device it is IMPOSSIBLE to obtain an advanced one in a short time, and, trust me, this is EXTREMELY BAD for scientific research... (Immagine if you had to re-discover the Newtonian laws every time you need them...) So, you can find a huge amount of papers describing a lot of numerical methods for simulating, in a very advanced way, semiconductor devices (even in the quantum case), but nobody will give you a code on which you can construct your own method (with the unlikely exception that at least one of the programmers is a friend of yours :) ).
Even worst, if you are a semiconductor device designer and you want to simulate "realistically" a new device, you have to pay (trust me, at very high costs!) a BINARY (just a binary and not the code!) from some well-known software industry. This binary will certainly have some bugs (because it is coded by humans which are not perfect...) and you will never have the possibility of fix them on your own. Of course, you can write to the software house and tell them that there is a bug, but, how many time do you will wait for a new release without those bugs? I dont think it will be a short time...
My impression is that, after a long research on the Web for a Free Software dealing with advanced 2D semiconductor device simulation, there was not a free code for the purpose of semiconductor devices simulation (i mean under GPL license). To be sure about it, I asked to the great Richard Stallman (by mail) if it will be worth to do a code like this and he encouraged me to code it, because there wasnt a code like this as free. So I decided to write this code..
Download (0.57MB)
Added: 2006-06-07 License: GPL (GNU General Public License) Price:
712 downloads
sentinel 1.0
sentinel project is an implementation of effective remote promiscuous detection techniques. more>>
sentinel project is an implementation of effective remote promiscuous detection techniques. For portability purposes, the sentinel application uses the libpcap and libnet libraries.
Sentinel usage:
./sentinel [options] [methods] [-c < x.x.x >] [-f < filename >] [host] methods:
-a arp test
-d dns test
-e icmp etherping test
Options:
-c < x.x.x > class c to scan
-f < file > file of ip addresses
-i < device > network interface
-n < number > number of packets to send
Example usage:
# ./sentinel -aed -c 10.2.2
sentinel will scan the class c 10.2.2 and test each machine against the arp,
etherping and dns tests.
# ./sentinel -aed -f ./ips
sentinel will read ip addresses from the ips file and test each machine
against the arp, etherping and dns tests.
# ./sentinel -aed 1.1.1.1
sentinel will test 1.1.1.1 for the arp, etherping and dns tests.
<<lessSentinel usage:
./sentinel [options] [methods] [-c < x.x.x >] [-f < filename >] [host] methods:
-a arp test
-d dns test
-e icmp etherping test
Options:
-c < x.x.x > class c to scan
-f < file > file of ip addresses
-i < device > network interface
-n < number > number of packets to send
Example usage:
# ./sentinel -aed -c 10.2.2
sentinel will scan the class c 10.2.2 and test each machine against the arp,
etherping and dns tests.
# ./sentinel -aed -f ./ips
sentinel will read ip addresses from the ips file and test each machine
against the arp, etherping and dns tests.
# ./sentinel -aed 1.1.1.1
sentinel will test 1.1.1.1 for the arp, etherping and dns tests.
Download (0.006MB)
Added: 2006-03-10 License: GPL (GNU General Public License) Price:
10702 downloads
Method::Declarative 0.03
Method::Declarative is a Perl module to create methods with declarative syntax. more>>
Method::Declarative is a Perl module to create methods with declarative syntax.
SYNOPSIS
use Method::Declarative
(
--defaults =>
{
precheck =>
[
[ qw(precheck1 arg1 arg2) ],
# ...
],
postcheck =>
[
[ qw(postcheck1 arg3 arg4) ],
# ...
],
init =>
[
[ initcheck1 ],
# ...
],
end =>
[
[ endcheck1 ],
# ...
],
once =>
[
[ oncecheck1 ],
] ,
package => __CALLER__::internal,
},
method1 =>
{
ignoredefaults => [ qw(precheck end once) ],
code => __method1,
},
) ;
The Method::Declarative module creates methods in a using class namespace. The methods are created using a declarative syntax and building blocks provided by the using class. This class does not create the objects themselves.
The using class invokes Method::Declarative, passing it list of key-value pairs, where each key is the name of a method to declare (or the special key --default) and a hash reference of construction directives. The valid keys in the construction hash refs are:
code
The value corresponding to code key is a method name or code reference to be executed as the method. It is called like this:
$obj->$codeval(@args)
where $obj is the object or class name being used, $codeval is the coresponding reference or method name, and @args are the current arguments for the invocation. If $codeval is a method name, it needs to be reachable from $obj.
A code key in a method declaration will override any code key set in the --defaults section.
end
The value corresponding to the end key is an array reference, where each entry of the referenced array is another array ref. Each of the internally referenced arrays starts with a code reference or method name. The remaining elements of the array are used as arguments.
Each method declared by the arrays referenced from end are called on the class where the declared method resides in an END block when Method::Declarative unloads.
Each method is called like this:
$pkg->$codeval($name[, @args]);
where $pkg is the package or class name for the method, $name is the method name, and @args is the optional arguments that can be listed in each referenced list.
end blocks are run in the reverse order of method declaration (for example, if method1 is declared before method2, method2s end declaration will be run before method1s), and for each method they are run in the order in which they are declared.
Note that this is not an object destructor, and no objects of a particular class may still exist when these methods are run.
ignoredefaults
The value corresponding to the ignoredefaults key is an array reference pointing to a list of strings. Each string must corespond to a valid key, and indicates that any in-force defaults for that key are to be ignored. See the section on the special --defaults method for details.
init
The value corresponding to the init key is identical in structure to that corresponding to the end key. The only difference is that the declared methods/code refs are executed as soon as the method is available, rather than during an END block.
once
The value corresponding to the once key is identical in structure to that corresponding to the end key. The values are used when the method is invoked, however.
If the method is invoked on an object based on a hash ref, or on the class itself, and it has not been invoked before on that object or hash ref, the methods and code refs declared by this key are executed one at a time, like this:
$obj->$codeval($name, $isscalar, $argsref[, @args ]);
where $obj is the object or class on which the method is being invoked, $codeval is the method name or code reference supplied, $name is the name of the method, $isscalar is a flag to specify if the declared method itself is being executed in a scalar context, $argsref is a reference to the method arguments (@_, in other words), and @args are any optional arguments in the declaration.
The return value of each method or code reference call is used as the new arguments array for successive iterations or the declared method itself (including the object or class name). Yes, that means that these functions can change the the object or class out from under successive operations.
Any method or code ref returning an empty list will cause further processing for the method to abort, and an empty list or undefined value (as appropriate for the context) will be returned as the declared methods return value.
package
The value coresponding to the package key is a string that determines where the declared method is created (which is the callers package by default, unless modified with a --defaults section). The string __CALLER__ can be used to specify the callers namespace, so constructions like the one in the synopsis can be used to create methods in a namespace based on the calling package namespace.
postcheck
The value coresponding to the postcheck key is identical in structure to that coresponding to the end key. The postcheck operations are run like this:
$obj->$codeval($name, $isscalar, $vref[, @args ]);
where $obj is the underlying object or class, $codeval is the method or code ref from the list, $name is the name of the declared method, $isscalar is the flag specifying if the declared method was called in a scalar context, $vref is an array reference of the currently to-be-returned values, and @args is the optional arguments from the list.
Each method or code reference is expected to return the value(s) it wishes to have returned from the method. Returning a null list does NOT stop processing of later postcheck declarations.
precheck
The precheck phase operates similarly to the once phase, except that its triggered on all method calls (even if the underlying object is not a hash reference or a class name).
Any illegal or unrecognized key will cause a warning, and processing of the affected hashref will stop. This means a --defaults section will be ineffective, or a declared method wont be created.
<<lessSYNOPSIS
use Method::Declarative
(
--defaults =>
{
precheck =>
[
[ qw(precheck1 arg1 arg2) ],
# ...
],
postcheck =>
[
[ qw(postcheck1 arg3 arg4) ],
# ...
],
init =>
[
[ initcheck1 ],
# ...
],
end =>
[
[ endcheck1 ],
# ...
],
once =>
[
[ oncecheck1 ],
] ,
package => __CALLER__::internal,
},
method1 =>
{
ignoredefaults => [ qw(precheck end once) ],
code => __method1,
},
) ;
The Method::Declarative module creates methods in a using class namespace. The methods are created using a declarative syntax and building blocks provided by the using class. This class does not create the objects themselves.
The using class invokes Method::Declarative, passing it list of key-value pairs, where each key is the name of a method to declare (or the special key --default) and a hash reference of construction directives. The valid keys in the construction hash refs are:
code
The value corresponding to code key is a method name or code reference to be executed as the method. It is called like this:
$obj->$codeval(@args)
where $obj is the object or class name being used, $codeval is the coresponding reference or method name, and @args are the current arguments for the invocation. If $codeval is a method name, it needs to be reachable from $obj.
A code key in a method declaration will override any code key set in the --defaults section.
end
The value corresponding to the end key is an array reference, where each entry of the referenced array is another array ref. Each of the internally referenced arrays starts with a code reference or method name. The remaining elements of the array are used as arguments.
Each method declared by the arrays referenced from end are called on the class where the declared method resides in an END block when Method::Declarative unloads.
Each method is called like this:
$pkg->$codeval($name[, @args]);
where $pkg is the package or class name for the method, $name is the method name, and @args is the optional arguments that can be listed in each referenced list.
end blocks are run in the reverse order of method declaration (for example, if method1 is declared before method2, method2s end declaration will be run before method1s), and for each method they are run in the order in which they are declared.
Note that this is not an object destructor, and no objects of a particular class may still exist when these methods are run.
ignoredefaults
The value corresponding to the ignoredefaults key is an array reference pointing to a list of strings. Each string must corespond to a valid key, and indicates that any in-force defaults for that key are to be ignored. See the section on the special --defaults method for details.
init
The value corresponding to the init key is identical in structure to that corresponding to the end key. The only difference is that the declared methods/code refs are executed as soon as the method is available, rather than during an END block.
once
The value corresponding to the once key is identical in structure to that corresponding to the end key. The values are used when the method is invoked, however.
If the method is invoked on an object based on a hash ref, or on the class itself, and it has not been invoked before on that object or hash ref, the methods and code refs declared by this key are executed one at a time, like this:
$obj->$codeval($name, $isscalar, $argsref[, @args ]);
where $obj is the object or class on which the method is being invoked, $codeval is the method name or code reference supplied, $name is the name of the method, $isscalar is a flag to specify if the declared method itself is being executed in a scalar context, $argsref is a reference to the method arguments (@_, in other words), and @args are any optional arguments in the declaration.
The return value of each method or code reference call is used as the new arguments array for successive iterations or the declared method itself (including the object or class name). Yes, that means that these functions can change the the object or class out from under successive operations.
Any method or code ref returning an empty list will cause further processing for the method to abort, and an empty list or undefined value (as appropriate for the context) will be returned as the declared methods return value.
package
The value coresponding to the package key is a string that determines where the declared method is created (which is the callers package by default, unless modified with a --defaults section). The string __CALLER__ can be used to specify the callers namespace, so constructions like the one in the synopsis can be used to create methods in a namespace based on the calling package namespace.
postcheck
The value coresponding to the postcheck key is identical in structure to that coresponding to the end key. The postcheck operations are run like this:
$obj->$codeval($name, $isscalar, $vref[, @args ]);
where $obj is the underlying object or class, $codeval is the method or code ref from the list, $name is the name of the declared method, $isscalar is the flag specifying if the declared method was called in a scalar context, $vref is an array reference of the currently to-be-returned values, and @args is the optional arguments from the list.
Each method or code reference is expected to return the value(s) it wishes to have returned from the method. Returning a null list does NOT stop processing of later postcheck declarations.
precheck
The precheck phase operates similarly to the once phase, except that its triggered on all method calls (even if the underlying object is not a hash reference or a class name).
Any illegal or unrecognized key will cause a warning, and processing of the affected hashref will stop. This means a --defaults section will be ineffective, or a declared method wont be created.
Download (0.008MB)
Added: 2006-10-18 License: Perl Artistic License Price:
1101 downloads
YAPE::Regex::Element 3.03
YAPE::Regex::Element contains sub-classes for YAPE::Regex elements. more>>
YAPE::Regex::Element contains sub-classes for YAPE::Regex elements.
SYNOPSIS
use YAPE::Regex MyExt::Mod;
# this sets up inheritence in MyExt::Mod
# see YAPE::Regex documentation
YAPE MODULES
The YAPE hierarchy of modules is an attempt at a unified means of parsing and extracting content. It attempts to maintain a generic interface, to promote simplicity and reusability. The API is powerful, yet simple. The modules do tokenization (which can be intercepted) and build trees, so that extraction of specific nodes is doable.
Methods for YAPE::Regex::Element
This class contains fallback methods for the other classes.
my $str = $obj->text;
Returns a string representation of the content of the regex node itself, not any nodes contained in it. This is undef for non-text nodes.
my $str = $obj->string;
Returns a string representation of the regex node itself, not any nodes contained in it.
my $str = $obj->fullstring;
Returns a string representation of the regex node, including any nodes contained in it.
my $quant = $obj->quant;
Returns a string with the quantity, and a ? if the node is non-greedy. The quantity is one of *, +, ?, {M,N}, or an empty string.
my $ng = $obj->ngreed;
Returns a ? if the node is non-greedy, and an empty string otherwise.
Methods for YAPE::Regex::anchor
This class represents anchors. Objects have the following methods:
my $anchor = YAPE::Regex::anchor->new($type,$q,$ng);
Creates a YAPE::Regex::anchor object. Takes three arguments: the anchor (^, A, $, Z, z, B, b, or G), the quantity, and the non-greedy flag. The quantity should be an empty string.
my $anc = YAPE::Regex::anchor->new(A, , ?);
# /A?/
my $type = $anchor->type;
Returns the string anchor.
Methods for YAPE::Regex::macro
This class represents character-class macros. Objects have the following methods:
my $macro = YAPE::Regex::macro->new($type,$q,$ng);
Creates a YAPE::Regex::macro object. Takes three arguments: the macro (w, W, d, D, s, or S), the quantity, and the non-greedy flag.
my $macro = YAPE::Regex::macro->new(s, {3,5});
# /s{3,5}/
my $text = $macro->text;
Returns the macro.
print $macro->text; # s
my $type = $macro->type;
Returns the string macro.
Methods for YAPE::Regex::oct
This class represents octal escapes. Objects have the following methods:
my $oct = YAPE::Regex::oct->new($type,$q,$ng);
Creates a YAPE::Regex::oct object. Takes three arguments: the octal number (as a string), the quantity, and the non-greedy flag.
my $oct = YAPE::Regex::oct->new(040);
# / 40/
my $text = $oct->text;
Returns the octal escape.
print $oct->text; # 40
my $type = $oct->type;
Returns the string oct.
Methods for YAPE::Regex::hex
This class represents hexadecimal escapes. Objects have the following methods:
my $hex = YAPE::Regex::hex->new($type,$q,$ng);
Creates a YAPE::Regex::hex object. Takes three arguments: the hexadecimal number (as a string), the quantity, and the non-greedy flag.
my $hex = YAPE::Regex::hex->new(20,{2,});
# /x20{2,}/
my $text = $hex->text;
Returns the hexadecimal escape.
print $hex->text; # x20
my $type = $hex->type;
Returns the string hex.
Methods for YAPE::Regex::utf8hex
This class represents UTF hexadecimal escapes. Objects have the following methods:
my $hex = YAPE::Regex::utf8hex->new($type,$q,$ng);
Creates a YAPE::Regex::utf8hex object. Takes three arguments: the hexadecimal number (as a string), the quantity, and the non-greedy flag.
my $utf8hex = YAPE::Regex::utf8hex->new(beef,{0,4});
# /x{beef}{2,}/
my $text = $utf8hex->text;
Returns the hexadecimal escape.
print $utf8hex->text; # x{beef}
my $type = $utf8hex->type;
Returns the string utf8hex.
Methods for YAPE::Regex::backref
This class represents back-references. Objects have the following methods:
my $bref = YAPE::Regex::bref->new($type,$q,$ng);
Creates a YAPE::Regex::bref object. Takes three arguments: the number of the back-reference, the quantity, and the non-greedy flag.
my $bref = YAPE::Regex::bref->new(2,,?);
# /2?/
my $text = $bref->text;
Returns the backescape.
print $bref->text; # 2
my $type = $bref->type;
Returns the string backref.
Methods for YAPE::Regex::ctrl
This class represents control character escapes. Objects have the following methods:
my $ctrl = YAPE::Regex::ctrl->new($type,$q,$ng);
Creates a YAPE::Regex::ctrl object. Takes three arguments: the control character, the quantity, and the non-greedy flag.
my $ctrl = YAPE::Regex::ctrl->new(M);
# /cM/
my $text = $ctrl->text;
Returns the control character escape.
print $ctrl->text; # cM
my $type = $ctrl->type;
Returns the string ctrl.
Methods for YAPE::Regex::named
This class represents named characters. Objects have the following methods:
my $ctrl = YAPE::Regex::named->new($type,$q,$ng);
Creates a YAPE::Regex::named object. Takes three arguments: the name of the character, the quantity, and the non-greedy flag.
my $named = YAPE::Regex::named->new(GREEK SMALL LETTER BETA);
# /N{GREEK SMALL LETTER BETA}/
my $text = $named->text;
Returns the character escape text.
print $named->text; # N{GREEK SMALL LETTER BETA}
my $type = $named->type;
Returns the string named.
<<lessSYNOPSIS
use YAPE::Regex MyExt::Mod;
# this sets up inheritence in MyExt::Mod
# see YAPE::Regex documentation
YAPE MODULES
The YAPE hierarchy of modules is an attempt at a unified means of parsing and extracting content. It attempts to maintain a generic interface, to promote simplicity and reusability. The API is powerful, yet simple. The modules do tokenization (which can be intercepted) and build trees, so that extraction of specific nodes is doable.
Methods for YAPE::Regex::Element
This class contains fallback methods for the other classes.
my $str = $obj->text;
Returns a string representation of the content of the regex node itself, not any nodes contained in it. This is undef for non-text nodes.
my $str = $obj->string;
Returns a string representation of the regex node itself, not any nodes contained in it.
my $str = $obj->fullstring;
Returns a string representation of the regex node, including any nodes contained in it.
my $quant = $obj->quant;
Returns a string with the quantity, and a ? if the node is non-greedy. The quantity is one of *, +, ?, {M,N}, or an empty string.
my $ng = $obj->ngreed;
Returns a ? if the node is non-greedy, and an empty string otherwise.
Methods for YAPE::Regex::anchor
This class represents anchors. Objects have the following methods:
my $anchor = YAPE::Regex::anchor->new($type,$q,$ng);
Creates a YAPE::Regex::anchor object. Takes three arguments: the anchor (^, A, $, Z, z, B, b, or G), the quantity, and the non-greedy flag. The quantity should be an empty string.
my $anc = YAPE::Regex::anchor->new(A, , ?);
# /A?/
my $type = $anchor->type;
Returns the string anchor.
Methods for YAPE::Regex::macro
This class represents character-class macros. Objects have the following methods:
my $macro = YAPE::Regex::macro->new($type,$q,$ng);
Creates a YAPE::Regex::macro object. Takes three arguments: the macro (w, W, d, D, s, or S), the quantity, and the non-greedy flag.
my $macro = YAPE::Regex::macro->new(s, {3,5});
# /s{3,5}/
my $text = $macro->text;
Returns the macro.
print $macro->text; # s
my $type = $macro->type;
Returns the string macro.
Methods for YAPE::Regex::oct
This class represents octal escapes. Objects have the following methods:
my $oct = YAPE::Regex::oct->new($type,$q,$ng);
Creates a YAPE::Regex::oct object. Takes three arguments: the octal number (as a string), the quantity, and the non-greedy flag.
my $oct = YAPE::Regex::oct->new(040);
# / 40/
my $text = $oct->text;
Returns the octal escape.
print $oct->text; # 40
my $type = $oct->type;
Returns the string oct.
Methods for YAPE::Regex::hex
This class represents hexadecimal escapes. Objects have the following methods:
my $hex = YAPE::Regex::hex->new($type,$q,$ng);
Creates a YAPE::Regex::hex object. Takes three arguments: the hexadecimal number (as a string), the quantity, and the non-greedy flag.
my $hex = YAPE::Regex::hex->new(20,{2,});
# /x20{2,}/
my $text = $hex->text;
Returns the hexadecimal escape.
print $hex->text; # x20
my $type = $hex->type;
Returns the string hex.
Methods for YAPE::Regex::utf8hex
This class represents UTF hexadecimal escapes. Objects have the following methods:
my $hex = YAPE::Regex::utf8hex->new($type,$q,$ng);
Creates a YAPE::Regex::utf8hex object. Takes three arguments: the hexadecimal number (as a string), the quantity, and the non-greedy flag.
my $utf8hex = YAPE::Regex::utf8hex->new(beef,{0,4});
# /x{beef}{2,}/
my $text = $utf8hex->text;
Returns the hexadecimal escape.
print $utf8hex->text; # x{beef}
my $type = $utf8hex->type;
Returns the string utf8hex.
Methods for YAPE::Regex::backref
This class represents back-references. Objects have the following methods:
my $bref = YAPE::Regex::bref->new($type,$q,$ng);
Creates a YAPE::Regex::bref object. Takes three arguments: the number of the back-reference, the quantity, and the non-greedy flag.
my $bref = YAPE::Regex::bref->new(2,,?);
# /2?/
my $text = $bref->text;
Returns the backescape.
print $bref->text; # 2
my $type = $bref->type;
Returns the string backref.
Methods for YAPE::Regex::ctrl
This class represents control character escapes. Objects have the following methods:
my $ctrl = YAPE::Regex::ctrl->new($type,$q,$ng);
Creates a YAPE::Regex::ctrl object. Takes three arguments: the control character, the quantity, and the non-greedy flag.
my $ctrl = YAPE::Regex::ctrl->new(M);
# /cM/
my $text = $ctrl->text;
Returns the control character escape.
print $ctrl->text; # cM
my $type = $ctrl->type;
Returns the string ctrl.
Methods for YAPE::Regex::named
This class represents named characters. Objects have the following methods:
my $ctrl = YAPE::Regex::named->new($type,$q,$ng);
Creates a YAPE::Regex::named object. Takes three arguments: the name of the character, the quantity, and the non-greedy flag.
my $named = YAPE::Regex::named->new(GREEK SMALL LETTER BETA);
# /N{GREEK SMALL LETTER BETA}/
my $text = $named->text;
Returns the character escape text.
print $named->text; # N{GREEK SMALL LETTER BETA}
my $type = $named->type;
Returns the string named.
Download (0.15MB)
Added: 2007-08-17 License: Perl Artistic License Price:
799 downloads
Free Finite Element Package 0.8.3
Free Finite Element Package is a modular collection of C libraries which contain numerical methods. more>>
Free Finite Element Package is a modular collection of C libraries which contain numerical methods required when working with linear and quadratic finite elements in two dimensions.
FFEP works on GNU/Linux and is portable to every system where MEML (i.e. LAPACK and BLAS) are available. The goal of FFEP is to provide basic functions for approximating the solution of elliptic and parabolic partial differential equation in two dimensions with Dirichlet and Neumann boundary conditions.
<<lessFFEP works on GNU/Linux and is portable to every system where MEML (i.e. LAPACK and BLAS) are available. The goal of FFEP is to provide basic functions for approximating the solution of elliptic and parabolic partial differential equation in two dimensions with Dirichlet and Neumann boundary conditions.
Download (0.33MB)
Added: 2006-04-27 License: BSD License Price:
1282 downloads
Teamspeak 0.3
Teamspeak is a Perl interface to administrate Teamspeak-Server. more>>
Teamspeak is a Perl interface to administrate Teamspeak-Server.
SYNOPSIS
use Teamspeak;
my $t = Teamspeak->new(
timeout => ,
port => ,
host =>
);
You can connect to a Teamspeak-Server in four different Connection-Types: 1. Telnet 2. MySQL or MySQL::Lite 3. Web-Frontend 4. Teamspeak-Client is using UDP
Every Connection-Type can only use a part of all available Methods.
<<lessSYNOPSIS
use Teamspeak;
my $t = Teamspeak->new(
timeout => ,
port => ,
host =>
);
You can connect to a Teamspeak-Server in four different Connection-Types: 1. Telnet 2. MySQL or MySQL::Lite 3. Web-Frontend 4. Teamspeak-Client is using UDP
Every Connection-Type can only use a part of all available Methods.
Download (0.026MB)
Added: 2007-05-25 License: Perl Artistic License Price:
895 downloads
WWW::Facebook::API::REST::Client::Photos 0.0.3
WWW::Facebook::API::REST::Client::Photos is a Perl module with Photos methods for Client. more>>
WWW::Facebook::API::REST::Client::Photos is a Perl module with Photos methods for Client.
SYNOPSIS
use WWW::Facebook::API::REST::Client;
Methods for accessing photos with WWW::Facebook::API::REST::Client
SUBROUTINES/METHODS
base
The WWW::Facebook::API::REST::Client::Base object to use to make calls to the REST server
get_of_user
The photos.getOfUser method of the Facebook API
get_albums
The photos.getAlbums method of the Facebook API
get_from_album
The photos.getFromAlbum method of the Facebook API
get_comment_count
The photos.getCommentCount method of the Facebook API
DIAGNOSTICS
This module is used by WWW::Facebook::API::REST::Client and right now does not have any unique error messages.
CONFIGURATION AND ENVIRONMENT
WWW::Facebook::API::REST::Client::Photos requires no configuration files or environment variables.
<<lessSYNOPSIS
use WWW::Facebook::API::REST::Client;
Methods for accessing photos with WWW::Facebook::API::REST::Client
SUBROUTINES/METHODS
base
The WWW::Facebook::API::REST::Client::Base object to use to make calls to the REST server
get_of_user
The photos.getOfUser method of the Facebook API
get_albums
The photos.getAlbums method of the Facebook API
get_from_album
The photos.getFromAlbum method of the Facebook API
get_comment_count
The photos.getCommentCount method of the Facebook API
DIAGNOSTICS
This module is used by WWW::Facebook::API::REST::Client and right now does not have any unique error messages.
CONFIGURATION AND ENVIRONMENT
WWW::Facebook::API::REST::Client::Photos requires no configuration files or environment variables.
Download (0.011MB)
Added: 2007-01-26 License: Perl Artistic License Price:
1007 downloads
Timestamp::Simple 1.01
Timestamp::Simple is a Perl module with simple methods for timestamping. more>>
Timestamp::Simple is a Perl module with simple methods for timestamping.
SYNOPSIS
use Timestamp::Simple qw(stamp);
print stamp, "n";
This module provides a simple method for returning a stamp to mark when an event occurs.
METHODS
stamp()
This method returns a timestamp in the form yyyymmddHHMMSS.
<<lessSYNOPSIS
use Timestamp::Simple qw(stamp);
print stamp, "n";
This module provides a simple method for returning a stamp to mark when an event occurs.
METHODS
stamp()
This method returns a timestamp in the form yyyymmddHHMMSS.
Download (0.010MB)
Added: 2007-04-27 License: Perl Artistic License Price:
912 downloads
Jaggregate 3.2
Jaggregate is a Java collections library that is modeled after the ANSI Smalltalk collection protocols. more>>
Jaggregate is a Java collections library that is modeled after the ANSI Smalltalk collection protocols.
It only works with J2SE 5.
Enhancements:
- A bug with SortedCollections produced by the zero-argument Collection.toSortedCollection() was fixed.
- Such collections could not be serialized, because the Comparator they use was not itself Serializable.
- This has been remedied.
- *From and *With methods were added to Dictionary and IdentityDictionary, despite compiler warnings about generic array creation.
<<lessIt only works with J2SE 5.
Enhancements:
- A bug with SortedCollections produced by the zero-argument Collection.toSortedCollection() was fixed.
- Such collections could not be serialized, because the Comparator they use was not itself Serializable.
- This has been remedied.
- *From and *With methods were added to Dictionary and IdentityDictionary, despite compiler warnings about generic array creation.
Download (0.54MB)
Added: 2007-03-26 License: Other/Proprietary License Price:
945 downloads
ExtUtils::ModuleMaker::StandardText 0.47
ExtUtils::ModuleMaker::StandardText are methods used within ExtUtils::ModuleMaker. more>>
ExtUtils::ModuleMaker::StandardText are methods used within ExtUtils::ModuleMaker.
The methods described below are quasi-private methods which are called by the publicly available methods of ExtUtils::ModuleMaker and ExtUtils::ModuleMaker::Interactive. They are quasi-private in the sense that they are not intended to be called by the everyday user of ExtUtils::ModuleMaker. Nothing prevents a user from calling these methods, but they are documented here primarily so that users writing plug-ins for ExtUtils::ModuleMakers standard text will know what methods need to be subclassed.
The methods below are called in ExtUtils::ModuleMaker::complete_build() but not in that same packages new(). For methods called in new(), please see ExtUtils::ModuleMaker::Initializers.
The descriptions below are presented in hierarchical order rather than alphabetically. The order is that of how close to the surface can a particular method called?, where surface means being called within ExtUtils::ModuleMaker::complete_build().
So methods called within complete_build() are described before methods which are only called within other quasi-private methods. Some of the methods described are also called within ExtUtils::ModuleMaker::Interactive methods. And some quasi-private methods are called within both public and other quasi-private methods. Within each heading, methods are presented more or less as they are first called within the public or higher-order quasi-private methods.
<<lessThe methods described below are quasi-private methods which are called by the publicly available methods of ExtUtils::ModuleMaker and ExtUtils::ModuleMaker::Interactive. They are quasi-private in the sense that they are not intended to be called by the everyday user of ExtUtils::ModuleMaker. Nothing prevents a user from calling these methods, but they are documented here primarily so that users writing plug-ins for ExtUtils::ModuleMakers standard text will know what methods need to be subclassed.
The methods below are called in ExtUtils::ModuleMaker::complete_build() but not in that same packages new(). For methods called in new(), please see ExtUtils::ModuleMaker::Initializers.
The descriptions below are presented in hierarchical order rather than alphabetically. The order is that of how close to the surface can a particular method called?, where surface means being called within ExtUtils::ModuleMaker::complete_build().
So methods called within complete_build() are described before methods which are only called within other quasi-private methods. Some of the methods described are also called within ExtUtils::ModuleMaker::Interactive methods. And some quasi-private methods are called within both public and other quasi-private methods. Within each heading, methods are presented more or less as they are first called within the public or higher-order quasi-private methods.
Download (0.14MB)
Added: 2006-10-24 License: Perl Artistic License Price:
1095 downloads
OneStroke 0.8.3
OneStroke project is a freehand gesture recognition system for Tablet PCs. more>>
OneStroke project is a freehand gesture recognition system for Tablet PCs.
OneStroke is designed as a keyboard replacement for Linux tablet mode Tablet PCs. Single-stroke gestures drawn on the main window generate X11 keyboard events in the currently-focused window.
All configuration and setup is done via a user-friendly GTK GUI. The program supports multiple recognition methods.
<<lessOneStroke is designed as a keyboard replacement for Linux tablet mode Tablet PCs. Single-stroke gestures drawn on the main window generate X11 keyboard events in the currently-focused window.
All configuration and setup is done via a user-friendly GTK GUI. The program supports multiple recognition methods.
Download (0.025MB)
Added: 2006-09-05 License: GPL (GNU General Public License) Price:
1145 downloads
Yahoo::Marketing::KeywordRejectionReasons 0.08
Yahoo::Marketing::KeywordRejectionReasons is an object to represent a Yahoo Marketing KeywordRejectionReasons. more>>
Yahoo::Marketing::KeywordRejectionReasons is an object to represent a Yahoo Marketing KeywordRejectionReasons.
SYNOPSIS
See http://ysm.techportal.searchmarketing.yahoo.com/docs/reference/dataObjects.asp for documentation of the various data objects.
new
Creates a new instance
METHODS
get/set methods
alternateTextRejectionReasons
keywordID
keywordRejectionReasons
phraseSearchTextRejectionReasons
textRejectionReasons
urlRejectionReasons
get (read only) methods
<<lessSYNOPSIS
See http://ysm.techportal.searchmarketing.yahoo.com/docs/reference/dataObjects.asp for documentation of the various data objects.
new
Creates a new instance
METHODS
get/set methods
alternateTextRejectionReasons
keywordID
keywordRejectionReasons
phraseSearchTextRejectionReasons
textRejectionReasons
urlRejectionReasons
get (read only) methods
Download (0.066MB)
Added: 2006-12-08 License: Perl Artistic License Price:
1050 downloads
WWW::Facebook::API::REST::Client::Events 0.0.3
WWW::Facebook::API::REST::Client::Events is a Perl module with events for Client. more>>
WWW::Facebook::API::REST::Client::Events is a Perl module with events for Client.
SYNOPSIS
use WWW::Facebook::API::REST::Client;
Methods for accessing events with WWW::Facebook::API::REST::Client
SUBROUTINES/METHODS
base
The WWW::Facebook::API::REST::Client::Base object to use to make calls to the REST server
get_in_window
The events.getInWindow method of the Facebook API
DIAGNOSTICS
This module is used by WWW::Facebook::API::REST::Client and right now does not have any unique error messages.
<<lessSYNOPSIS
use WWW::Facebook::API::REST::Client;
Methods for accessing events with WWW::Facebook::API::REST::Client
SUBROUTINES/METHODS
base
The WWW::Facebook::API::REST::Client::Base object to use to make calls to the REST server
get_in_window
The events.getInWindow method of the Facebook API
DIAGNOSTICS
This module is used by WWW::Facebook::API::REST::Client and right now does not have any unique error messages.
Download (0.011MB)
Added: 2007-01-25 License: Perl Artistic License Price:
1003 downloads
Rsync::Config::Comment 0.3.1
Rsync::Config::Comment is a Perl module with comments as objects. more>>
Rsync::Config::Comment is a Perl module with comments as objects.
SYNOPSIS
my $com1 = new Rsync::Config::Comment(value => this module is private);
$com1->to_string();
prints:
< TAB >#this module is private
SUBROUTINES/METHODS
new
This class inherits from Rsync::Config::Blank. Please read Rsync::Config::Blank documentations for more details.
to_string
returns a stringified version of the comment.
<<lessSYNOPSIS
my $com1 = new Rsync::Config::Comment(value => this module is private);
$com1->to_string();
prints:
< TAB >#this module is private
SUBROUTINES/METHODS
new
This class inherits from Rsync::Config::Blank. Please read Rsync::Config::Blank documentations for more details.
to_string
returns a stringified version of the comment.
Download (0.022MB)
Added: 2007-01-18 License: Perl Artistic License Price:
1009 downloads
Secleted [ 0 ] software to compare
Copyright Notice:
Software piracy is theft, Using crack, password, serial numbers, registration codes, key generators is illegal and prevent future software development. The above 3 effective methods search only lists software in full, demo and trial versions for free download. Download links are directly from our mirror sites or publisher sites, torrent files or links from rapidshare.com, yousendit.com or megaupload.com are not allowed
