Result:
found more than 658 distributions - search limited to the first 2001 files matching your query
( run in 0.518 )
Color-Similarity-HCL
view release on metacpan or search on metacpan
lib/Color/Similarity/HCL.pm view on Meta::CPAN
L<http://w3.uqo.ca/missaoui/Publications/TRColorSpace.zip>
Corrected the RGB -> HCL transformation (see C<rgb2hcl>) as per the
research report by the same authors (thanks to David Hoerl for finding
the document with the corrected formula).
L<Color::Similarity>, L<Color::Similarity::RGB>, L<Color::Similarity::Lab>
=head1 AUTHOR
Color-TupleEncode
view release on metacpan or search on metacpan
lib/Color/TupleEncode/2Way.pm view on Meta::CPAN
If C<rmin> is set and C<power = 0>, then saturation will be C<min> for C<r E<lt>= rmin> and C<max> for C<r E<gt> rmin>.
=head2 Value
The value is calculated using the same formula as for saturation.
By setting different C<rmin> values for saturation and value components, you can control the range of C<r> over which the encoding acts. For example,
$convert->set_options(-saturation=>{rmin=>0},-value=>{rmin=>1})
Compress-LZ4
view release on metacpan or search on metacpan
/*-************************************
* Tuning parameter
**************************************/
/*!
* LZ4_MEMORY_USAGE :
* Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
* Increasing memory usage improves compression ratio
* Reduced memory usage can improve speed, due to cache effect
* Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache
*/
#ifndef LZ4_MEMORY_USAGE
Compress-LZ4Frame
view release on metacpan or search on metacpan
/*-************************************
* Tuning parameter
**************************************/
/*!
* LZ4_MEMORY_USAGE :
* Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
* Increasing memory usage improves compression ratio
* Reduced memory usage can improve speed, due to cache effect
* Default value is 14, for 16KB, which nicely fits into Intel x86 L1 cache
*/
#ifndef LZ4_MEMORY_USAGE
Compress-Raw-Zlib
view release on metacpan or search on metacpan
zlib-src/adler32.c view on Meta::CPAN
/* for negative len, return invalid adler32 as a clue for debugging */
if (len2 < 0)
return 0xffffffffUL;
/* the derivation of this formula is left as an exercise for the reader */
MOD63(len2); /* assumes len2 >= 0 */
rem = (unsigned)len2;
sum1 = adler1 & 0xffff;
sum2 = rem * sum1;
MOD(sum2);
Compress-Stream-Zstd
view release on metacpan or search on metacpan
ext/zstd/doc/educational_decoder/zstd_decompress.c view on Meta::CPAN
val = val & lower_mask;
} else if (val > lower_mask) {
val = val - threshold;
}
// "Probability is obtained from Value decoded by following formula :
// Proba = value - 1"
const i16 proba = (i16)val - 1;
// "It means value 0 becomes negative probability -1. -1 is a special
// probability, which means "less than 1". Its effect on distribution
Compress-Zopfli
view release on metacpan or search on metacpan
zopflib/src/zopflipng/lodepng/lodepng.cpp view on Meta::CPAN
case 57: return "invalid CRC encountered (checking CRC can be disabled)";
case 58: return "invalid ADLER32 encountered (checking ADLER32 can be disabled)";
case 59: return "requested color conversion not supported";
case 60: return "invalid window size given in the settings of the encoder (must be 0-32768)";
case 61: return "invalid BTYPE given in the settings of the encoder (only 0, 1 and 2 are allowed)";
/*LodePNG leaves the choice of RGB to greyscale conversion formula to the user.*/
case 62: return "conversion from color to greyscale not supported";
case 63: return "length of a chunk too long, max allowed for PNG is 2147483647 bytes per chunk"; /*(2^31-1)*/
/*this would result in the inability of a deflated block to ever contain an end code. It must be at least 1.*/
case 64: return "the length of the END symbol 256 in the Huffman tree is 0";
case 66: return "the length of a text chunk keyword given to the encoder is longer than the maximum of 79 bytes";
Compress-Zstd
view release on metacpan or search on metacpan
ext/zstd/contrib/linux-kernel/0002-lib-Add-zstd-modules.patch view on Meta::CPAN
+
+/* **************************************************************
+* Tuning parameters
+****************************************************************/
+/*!MEMORY_USAGE :
+* Memory usage formula : N->2^N Bytes (examples : 10 -> 1KB; 12 -> 4KB ; 16 -> 64KB; 20 -> 1MB; etc.)
+* Increasing memory usage improves compression ratio
+* Reduced memory usage can improve speed, due to cache effect
+* Recommended max value is 14, for 16KB, which nicely fits into Intel x86 L1 cache */
+#ifndef FSE_MAX_MEMORY_USAGE
+#define FSE_MAX_MEMORY_USAGE 14
Config-LotusNotes
view release on metacpan or search on metacpan
lib/Config/LotusNotes.pm view on Meta::CPAN
=head2 The Lotus Notes environment
The Lotus Notes environment is often used to store local user preferences
and to share information between separate parts of an application.
The Lotus Notes formula language has the C<@Environment> and C<@SetEnvironment>
functions and the C<ENVIRONMENT> keyword to access the program's environment.
Lotus script uses the C<GetEnvironmentValue>, C<GetEnvironmentString>,
C<SetEnvironmentVar> and C<Environ> functions for that purpose.
The Lotus Notes environment is stored in the F<notes.ini> file, which is
instantly updated after each change to the environment.
lib/Config/LotusNotes.pm view on Meta::CPAN
If a F<notes.ini> file cannot be parsed at all, a warning will be issued and the
corresponding installation will be skipped by all_configurations()Z<>.
default_configuration() will throw an "Error parsing ..." exception in that case.
Malformed F<notes.ini> files can be reproduced by writing multiline values to the
environment, e.g. with Notes formula code like this:
C<@SetEnvironment("testvalue"; "A"+@Char(10)+"B")>, which produces two lines,
the second one just containing "B".
A successive read of testvalue will return just "A".
In my environment lines like
Config-Model-CursesUI
view release on metacpan or search on metacpan
lib/Config/Model/CursesUI.pm view on Meta::CPAN
-text => "Enum values are taken from:"
) ;
foreach my $c_obj ($leaf->reference_object->compute_obj) {
my $button ;
my $path = $c_obj -> user_formula ;
if (defined $path) {
my $target = $leaf->grab($path) ;
my $p_target = $target->parent ;
my $n_target = $target->element_name ;
my $go = sub { $self->scan('element',$p_target, $n_target) ; } ;
Config-Model-Itself
view release on metacpan or search on metacpan
data/models/MasterModel.pl view on Meta::CPAN
'new_from_deprecated' => {
type => 'leaf',
value_type => 'enum',
choice => [qw/cds_file perl_file ini_file custom/],
migrate_from => {
formula => '$replace{$old}',
variables => { old => '- deprecated_p' },
replace => {
perl => 'perl_file',
ini => 'ini_file',
cds => 'cds_file',
data/models/MasterModel.pl view on Meta::CPAN
},
'host' => {
type => 'leaf',
value_type => 'uniline',
migrate_from => {
formula => '$old =~ m!http://([\w\.]+)!; $1 ;',
variables => { old => '- old_url' },
use_eval => 1,
},
},
'reference_stuff' => {
data/models/MasterModel.pl view on Meta::CPAN
},
'Source' => {
'value_type' => 'string',
'migrate_from' => {
'use_eval' => '1',
'formula' => '$old || $older ;',
undef_is => "''",
'variables' => {
'older' => '- Original-Source-Location',
'old' => '- Upstream-Source'
}
Config-Model-Systemd
view release on metacpan or search on metacpan
contrib/parse-man.pl view on Meta::CPAN
# put migration in place for the other element
my $new = $meta_root->grab(
step => "class:$config_class element:$supersedes",
autoadd => 1
);
$new->load(steps => qq!migrate_from variables:old="- $element" formula="\$old"!);
}
$obj->load(step => [@load, @load_extra]);
say "class $config_class element $element:\n\t".join("\n\t", @log) if @log;
return $obj;
contrib/parse-man.pl view on Meta::CPAN
# from Service class (where it's deprecated) and copy them to the new
# $from element in Unit class in a service file (hence this migration
# instruction is done only in ServiceUnit class)
$meta_root->load( steps => [
qq!class:Systemd::Section::ServiceUnit element:$to!,
qq!migrate_from variables:service="- - Service $from" formula="\$service"!
]);
}
my $data = parse_xml([@list, @service_list], \%map) ;
contrib/parse-man.pl view on Meta::CPAN
# handle migration from both service and unit
$meta_root->load( steps => [
qq!class:Systemd::Section::ServiceUnit element:StartLimitIntervalSec!,
qq!migrate_from variables:unit="- StartLimitInterval"!,
# $service variable is defined in move_deprecated element function
q!use_eval=1 formula="$unit || $service"!
]);
# renamed element in Unit
say "Handling move of OnFailureIsolate to OnFailureJobMode in unit";
$meta_root->load( steps => [
'class:Systemd::Section::Unit',
q!element:OnFailureIsolate type=leaf value_type=uniline status=deprecated!,
q!warn="OnFailureIsolate is now OnFailureJobMode." -!,
q!element:OnFailureJobMode!,
q!migrate_from variables:unit="- OnFailureIsolate"!,
q!formula="$unit"!
]);
say "Saving systemd model...";
$rw_obj->write_all;
Config-Model-TkUI
view release on metacpan or search on metacpan
t/lib/Config/Model/models/Master.pl view on Meta::CPAN
compute_int => {
type => 'leaf',
class => 'Config::Model::Value',
value_type => 'integer',
compute => {
formula => '$a + $b',
variables => { a => '- compute_av', b => '- compute_bv' }
},
min => -4,
max => 4,
},
Config-Model-Xorg
view release on metacpan or search on metacpan
lib/Config/Model/models/Xorg/Screen/Display.pl view on Meta::CPAN
'800x600',
'720x400',
'640x480'
],
'computed_refer_to' => {
'formula' => '! Modes:"$my_monitor_use_modes" + ! Monitor:"$my_monitor" Mode ',
'variables' => {
'my_monitor' => '- - Monitor',
'my_monitor_use_modes' => '! Monitor:"$my_monitor" UseModes'
}
},
Config-Model
view release on metacpan or search on metacpan
lib/Config/Model.pm view on Meta::CPAN
) if $legacy_logger->is_debug;
$self->show_legacy_issue([ "$config_class_name->$elt_name: specifying compute info with ",
"an array ref is deprecated" ]);
my ( $user_formula, %var ) = @$compute_info;
my $replace_h;
foreach ( keys %var ) { $replace_h = delete $var{$_} if ref( $var{$_} ) };
# cleanup user formula
$user_formula =~ s/\$(\w+)\{/\$replace{/g;
# cleanup variable
foreach ( values %var ) { s/\$(\w+)\{/\$replace{/g };
# change the hash *in* the info structure
$info->{$new_name} = {
formula => $user_formula,
variables => \%var,
};
$info->{$new_name}{replace} = $replace_h if defined $replace_h;
$legacy_logger->debug(
lib/Config/Model.pm view on Meta::CPAN
#
sub get_migrate_doc {
my ( $self, $elt_name, $desc, $migr ) = @_;
my $mv = $migr->{variables};
my $mform = $migr->{formula};
if ( $mform =~ /\n/) { $mform =~ s/^/ /mg; $mform = "\n\n$mform\n\n"; }
else { $mform = "'C<$mform>' " }
my $mdoc = "Note: $elt_name $desc ${mform}and with: \n\n=over\n\n=item *\n\n"
ConstantCalculus-CircleConstant
view release on metacpan or search on metacpan
lib/ConstantCalculus/CircleConstant.pm view on Meta::CPAN
The circle constant is a mathematical constant. There are two variants of the
circle constant. Most common is the use of Pi (Ï€) for the circle constant. More
uncommon is the use of Tau (Ï„) for the circle constant. The relation between
them is τ = 2 π. There can be found other denotations for the well known name
Pi. The names are Archimedes's constant or Ludolph's constant. The circle
constant is used in formulas across mathematics and physics.
The circle constant is the ratio of the circumference C of a circle to its
diameter d, which is π = C/d or τ = 2 C/d. It is an irrational number, which
means that it cannot be expressed exactly as a ratio of two integers. In
consequence of this, the decimal representation of a circle constant never
ends in there decimal places having a infinite number of places, nor enters
a permanently repeating pattern in the decimal places. The circle constant is
also a not algebraic transcendental number.
Over the centuries scientists developed formulas for approximating the circle
constant Pi. Chudnovsky's formula is one of them. A algorithm based on Chudnovsky's
formula can be used to calculate an approximation for Pi and also for Tau. The
advantage of the Chudnovsky formula is the good convergence. In contradiction
the convergence of the Leibniz formula is quit bad.
The challenge in providing an algorithm for the circle constant is that all
decimal places must be correct in terms of the formula. Based on the desired decimal
place number or precision, the number of places must be correct. The provided
algorithm takes care of this. At the moment the result of the implemented algorithm
was checked against the known decimal places of Pi up to 10000 places.
=head1 APPROXIMATIONS OF PI AND TAU
Fractions such as 22/7 or 355/113 can be used to approximate the circle constant
Pi, whereas 44/7 or 710/113 represent the approximation of the circle constant
Tau.
At the moment Chudnovsky's formula is fully implemented in the module to calculate
Pi as well as Tau. The algorithm from Borwein from 1989 is implemented for experimental
purposes. The most popular formula for calculating the circle constant is the Leibniz
formula.
=head1 IMPLEMENTATION
To be able to deal with large numbers pre decimal point and after the decimal point
as needed, the Perl module C<bignum> is used. The main subroutine argument is the
lib/ConstantCalculus/CircleConstant.pm view on Meta::CPAN
=head2 Main Methods
=head3 chudnovsky_algorithm()
Implementation of the Chudnovsky formula.
=head3 borwein25_algorithm()
Implementation of the Borwein 25 formula.
=head3 pi_borwein25()
Calculate Pi with the Borwein 25 algorithm.
lib/ConstantCalculus/CircleConstant.pm view on Meta::CPAN
The implemented chudnovsky algorithm is used in a representation where the
well known terms are optimised for calculation.
It seems that the Perl builtin function C<sqrt()> cannot used in general for
determining the value of Pi or Tau with respect to some calculation formulas.
Chudnovsky's formula is working using the Perl builtin function C<sqrt()>. In
contradiction Borwein25's formula fails in calculation using the Perl builtin
function C<sqrt()>.
Using a coded user defined subroutine for calculating of a square root,
Borwein25's could be used for the calculation.
lib/ConstantCalculus/CircleConstant.pm view on Meta::CPAN
=item * Sources w.r.t. the circle constant Pi
=item * Sources w.r.t. the circle constant Tau
=item * Resources about the Leibniz formula
=item * Resources about the Chudnovsky formula
=item * Resources about Borwein's formulas
=back
=head2 Bibliography
=over 4
=item * David H. Bailey, The BBP Algorithm for Pi, September 17, 2006
=item * David H. Bailey, A catalogue of mathematical formulas involving π, with analysis, December 10, 2021
=item * David H. Bailey, Jonathan M. Borwein, Peter B. Borwein and Simon Plouffe, The Quest for Pi, June 25, 1996
=back
Convert-Color-XTerm
view release on metacpan or search on metacpan
lib/Convert/Color/XTerm.pm view on Meta::CPAN
my $c_tmp = Convert::Color->new( $colnames[$index] );
$color[$index] = __PACKAGE__->SUPER::new( $c_tmp->as_rgb8->rgb8 );
$color[$index]->[3] = $index;
}
# These descriptions and formulae from xterm's 256colres.pl
# Next is a 6x6x6 color cube, with an attempt at a gamma correction
foreach my $red ( 0 .. 5 ) {
foreach my $green ( 0 .. 5 ) {
foreach my $blue ( 0 .. 5 ) {
Convert-TBX-Basic
view release on metacpan or search on metacpan
<termNote type="termType"/>
<termNote type="administrativeStatus">Preferred</termNote>
<termNote type="pronunciation"/>
<note>The phonology, grammar and vocabulary of an artificial language have been consciously devised for human or human-like communication, and have not been developed naturally.</note>
<note/>
<descrip type="context">In [[natural language]], concepts can take the form of terms, appellations, definitions or other linguistic forms; they may also take the form of symbols; in artificial language, they can take the form of codes or ...
<admin type="source">ISO 00704: 2009</admin>
<descrip type="context">Tokenization is applicable to text in [[natural language]] as well as text in artificial language.</descrip>
<admin type="source">ISO/CD 24614-1</admin>
</tig>
<tig>
<termNote type="termType"/>
<termNote type="administrativeStatus"/>
<termNote type="pronunciation"/>
<note/>
<note/>
<descrip type="context">Characteristics shall be used in the analysis of concepts, the modelling of concept systems, in the formulation of definitions and, as often as possible, in the formation of designations.</descrip>
<admin type="source">ISO 00704 : 2000</admin>
<descrip type="context">A definition shall define the concept as a unit with a unique intension and extension. The unique combination of characteristics creating the intension shall identify the concept and differentiate it from other con...
<admin type="source">ISO 00704 : 2000</admin>
<descrip type="context">Definitions shall reflect the concept system; the relations within the system shall be established primarily by analysing the characteristics of each concept included in its respective definition, if a formal defin...
<admin type="source">ISO 00704 : 2000</admin>
<termNote type="termType"/>
<termNote type="administrativeStatus"/>
<termNote type="pronunciation"/>
<note/>
<note/>
<descrip type="context">Extensional definitions shall be formulated with reference to the position of the defined concept within its respective generic concept system. This means that an extensional definition is structured as a list of s...
<admin type="source">ISO 00704: 2009</admin>
<descrip type="context">Extensional definitions are to be used only when intensional definitions are difficult to elaborate. Extensional definitions shall be used only if the number of concepts to be enumerated is limited, the list of con...
<admin type="source">ISO 00704 : 2000</admin>
<descrip type="context">An extensional definition must list all the subordinate concepts corresponding to objects in the extension.</descrip>
<admin type="source">ISO 00704 : 2000</admin>
<termNote type="pronunciation"/>
<note/>
<note/>
<descrip type="context">In some ways more critically, subject field information can help the translator to determine which target language equivalent to use where equivalents may vary, for example, from industry to industry.</descrip>
<admin type="source">ISO 12616 : 2002</admin>
<descrip type="context">4.4 Implementation phase This phase consists of collecting and recording terminological data. It involves identifying documentation in which relevant terms and conceptual information may be found, evaluating th...
<admin type="source">ISO 15188 : 2001</admin>
</tig>
</langSet>
<langSet xml:lang="fr" id="cid1642">
<descrip type="definition"/>
<termNote type="termType"/>
<termNote type="administrativeStatus"/>
<termNote type="pronunciation"/>
<note/>
<note/>
<descrip type="context">ISO 690 and ISO 690-2 are intended for use by authors and editors in the compilation of references for inclusion in a bibliography, and in the formulation of citations within the text corresponding to the entries i...
<admin type="source">ISO 12615 : 2004 (E)</admin>
</tig>
</langSet>
</termEntry>
<termEntry id="aid492">
<termNote type="termType"/>
<termNote type="administrativeStatus">Proposed</termNote>
<termNote type="pronunciation"/>
<note/>
<note>masculine</note>
<descrip type="context">La formulation « récepteur stéroïde » est fautive : c'est un calque erroné de l'anglais steroid receptor. La traduction mot-à -mot aboutit à un non-sens : ce n'est pas le récepteur qui est un stéroïde, ma...
<admin type="source">Researchhttp://fr.wikipedia.org/wiki/R%C3%A9cepteur_des_st%C3%A9ro%C3%AFdes</admin>
<descrip type="context">Dans le deuxième exemple, on perçoit d’emblée une maladresse ('aujourd’hui' est restrictif par rapport à 'current'), un calque erroné, mais classique ('decade' en anglais désigne une période de 10 ans, e...
<admin type="source">Researchhttp://www.jostrans.org/issue08/art_prioux_rochard.php.</admin>
<descrip type="context">Je me dirigeai vers : est un contresens / Je me dirigeai à est une erreur de construction, calque erroné de l’espagnol.</descrip>
<admin type="source">Researchftp://trf.education.gouv.fr/pub/edutel/siac/siac2/jury/2006/capes_ext/esp02.pdf.</admin>
<termNote type="termType"/>
<termNote type="administrativeStatus"/>
<termNote type="pronunciation"/>
<note/>
<note/>
<descrip type="context">Implementation of a [[linguistic policy]] is by means of the adoption and putting into practice of a linguistic development plan. This is found in the strategies and methods to be implemented to attain the objectiv...
<admin type="source">ISO/DTR 22134</admin>
</tig>
</langSet>
</termEntry>
<termEntry id="aid529">
<termNote type="termType"/>
<termNote type="administrativeStatus"/>
<termNote type="pronunciation"/>
<note/>
<note/>
<descrip type="context">Extensional definitions shall be formulated with reference to the position of the defined concept within its respective [[generic concept system]]. This means that an extensional definition is structured as a list ...
<admin type="source">ISO 00704: 2009</admin>
</tig>
</langSet>
</termEntry>
<termEntry id="aid1125">
<descrip type="subjectField">0 General - Terminology and other language resources</descrip>
<note/>
<langSet xml:lang="en" id="cid1416">
<descrip type="definition">strategy formulated at the level of decision-making in a language, domain or professional community, with the aim of developing or regulating emerging or existing terminologies for an array of purposes.</descrip>
<admin type="source">ISO/WD 29383 - 1</admin>
<descrip type="definition">Alt.def: </descrip>
<admin type="source"/>
<note/>
<note/>
<termNote type="termType"/>
<termNote type="administrativeStatus"/>
<termNote type="pronunciation"/>
<note/>
<note/>
<descrip type="context">Encyclopedic descriptions found in existing sources often serve as the basis for formulating formal definitions since they often include all the characteristics needed for definition writing.</descrip>
<admin type="source">ISO 00704: 2009</admin>
</tig>
</langSet>
<langSet xml:lang="fr" id="cid1569">
<descrip type="definition"/>
<termNote type="termType"/>
<termNote type="administrativeStatus"/>
<termNote type="pronunciation"/>
<note/>
<note/>
<descrip type="context">Terminology planning focussing on the development and use of (scientific-technical) domain knowledge representation and knowledge organization has to comply with additional needs and requirements of the respective ...
<admin type="source">ISO TC 37/SC 1 N 601</admin>
<descrip type="context">Its objectives may also be across more than one language, or even aiming at international communication, e.g. restricted languages, Interlinguistics.</descrip>
<admin type="source">ISO/WD 29383 - 1</admin>
</tig>
</langSet>
<langSet xml:lang="en" id="cid1941">
<descrip type="definition">annotation that provides linguistic information about the segments in the primary data</descrip>
<admin type="source">ISO/FDIS 24612:2012</admin>
<descrip type="definition">Alt.def: </descrip>
<admin type="source"/>
<note>ISO/CD 24623-1 CQLF includes the following note: Note to entry: See ISO 24615-1:2014(en), def. 3.9 for a more specific but non-conflicting formulation</note>
<note/>
<note/>
<transacGrp>
<transac type="transactionType">origination</transac>
<transacNote type="responsibility">Lupe Aguado (lupe)</transacNote>
Cookie
view release on metacpan or search on metacpan
lib/Cookie/public_suffix_list.txt view on Meta::CPAN
mil.pe
org.pe
com.pe
net.pe
// pf : http://www.gobin.info/domainname/formulaire-pf.pdf
pf
com.pf
org.pf
edu.pf
Crypt-Bear
view release on metacpan or search on metacpan
src/ec/ec_p256_m15.c view on Meta::CPAN
*/
static void
p256_double(p256_jacobian *Q)
{
/*
* Doubling formulas are:
*
* s = 4*x*y^2
* m = 3*(x + z^2)*(x - z^2)
* x' = m^2 - 2*s
* y' = m*(s - x') - 8*y^4
* z' = 2*y*z
*
* These formulas work for all points, including points of order 2
* and points at infinity:
* - If y = 0 then z' = 0. But there is no such point in P-256
* anyway.
* - If z = 0 then z' = 0.
*/
src/ec/ec_p256_m15.c view on Meta::CPAN
*/
static uint32_t
p256_add(p256_jacobian *P1, const p256_jacobian *P2)
{
/*
* Addtions formulas are:
*
* u1 = x1 * z2^2
* u2 = x2 * z1^2
* s1 = y1 * z2^3
* s2 = y2 * z1^3
src/ec/ec_p256_m15.c view on Meta::CPAN
*/
static uint32_t
p256_add_mixed(p256_jacobian *P1, const p256_jacobian *P2)
{
/*
* Addtions formulas are:
*
* u1 = x1
* u2 = x2 * z1^2
* s1 = y1
* s2 = y2 * z1^3
Crypt-Diceware
view release on metacpan or search on metacpan
lib/Crypt/Diceware/Wordlist/Common.pm view on Meta::CPAN
footless footloose footprint footrest foppery foppish foray forby forces
forcible fore forearm forebear forebode forecast foreclose forecourt forego
forehead foreign foreigner forejudge foreman forepeak foreplay forerun
foresail foresee foreshore foresight forestry forests foretell foretold
forever foreword forfeit forfend forger forgery forget forgiving forgo fork
forkful forklift format formation former formula forsakes forswear fort
forte forth fortify fortitude fortnight forum forwards fostered fourfold
foursome fourth fracture fragile frail frailty frame franchise frantic frat
fraternal fraud fraught fray frazzle freak freaking freakish freaks free
freed freelance freely freemason freeplay freesia freezer freight frenetic
frequency fresco freshness fret fretful fries frigging fright frighten
Crypt-HSXKPasswd
view release on metacpan or search on metacpan
lib/Crypt/HSXKPasswd.pm view on Meta::CPAN
permutations, C<HH>, C<HT>, C<TH>, and C<TT>. If you made a three-character
password in this way there would be 16 permutations, a five character one
would have 32 permutations, and so forth.
So, for a coin toss, which has two possible values for each character, the
formula for the number of permutations C<P> for a given length of password C<L>
is:
P = 2^L
Or, two to the power of the length of the password.
lib/Crypt/HSXKPasswd.pm view on Meta::CPAN
per letter, to six possible values per letter. For one dice roll there would
be six permutations, for two there would be 36, for three there would be 108
and so on.
This means that for a dice, the number of permutations can be calculated with
the formula:
P = 6^L
When talking about passwords, the set of possible symbols used for each
character in the password is referred to as the password's I<alphabet>. So,
for the coin toss the alphabet was just C<H> and C<T>, and for the dice it
was C<1>, C<2>, C<3>, C<4>, C<5>, and C<6>. The actual characters used in
the alphabet make no difference to the strength of the password, all that
matters is the size of the alphabet, which we'll call C<A>.
As you can probably infer from the two examples above, the formula for the
number of possible permutations C<P> for a password of length C<L> created from
an alphabet of size C<A> is:
P = A^L
lib/Crypt/HSXKPasswd.pm view on Meta::CPAN
so big most people couldn't say it (what do you call something a thousand times
bigger than a trillion?).
Because the numbers get so astronomically big so quickly, computer scientists
use bits of entropy to measure password strength rather than the number of
permutations. The formula to turn permutations into bits of entropy C<E> is very
simple:
E = Log(2)P
In other words, the entropy is the log to base two of the permutations. For our
lib/Crypt/HSXKPasswd.pm view on Meta::CPAN
entropy depends on both the settings and the dictionary file used.
Calculating the bind entropy C<Eb> is quite straightforward, we just need to
know the size of the alphabet resulting from the configuration C<A>, and the
minimum length of passwords generated with the configuration C<L>, and plug
those values into this formula:
Eb = Log(2)(A^L)
Calculating C<A> simply involves determining whether or not the configuration
results in a mix of letter cases (26 or 52 characters), the inclusion of at
lib/Crypt/HSXKPasswd.pm view on Meta::CPAN
basis for the password, it then chooses two pairs of random digits as extra
words to go front and back, before separating each word with a copy of a
randomly chosen symbol, and padding the front and back of the password with
a copy of a different randomly chosen symbol. This results in passwords that
contain a mix of cases, digits, and symbols, and are between 27 and 31
characters long. If we add these values into the formula we find that the
blind entropy for passwords created with this preset is:
Eb = Log(2)(95^27) = 163 bits
This is spectacularly secure! And, this is the most likely kind of attack for
Crypt-RHash
view release on metacpan or search on metacpan
librhash/sha256.c view on Meta::CPAN
#define Sigma0(x) (ROTR32((x), 2) ^ ROTR32((x), 13) ^ ROTR32((x), 22))
#define Sigma1(x) (ROTR32((x), 6) ^ ROTR32((x), 11) ^ ROTR32((x), 25))
#define sigma0(x) (ROTR32((x), 7) ^ ROTR32((x), 18) ^ ((x) >> 3))
#define sigma1(x) (ROTR32((x),17) ^ ROTR32((x), 19) ^ ((x) >> 10))
/* Recalculate element n-th of circular buffer W using formula
* W[n] = sigma1(W[n - 2]) + W[n - 7] + sigma0(W[n - 15]) + W[n - 16]; */
#define RECALCULATE_W(W,n) (W[n] += \
(sigma1(W[(n - 2) & 15]) + W[(n - 7) & 15] + sigma0(W[(n - 15) & 15])))
#define ROUND(a,b,c,d,e,f,g,h,k,data) { \
Crypt-Rhash
view release on metacpan or search on metacpan
librhash/sha256.c view on Meta::CPAN
#define Sigma0(x) (ROTR32((x), 2) ^ ROTR32((x), 13) ^ ROTR32((x), 22))
#define Sigma1(x) (ROTR32((x), 6) ^ ROTR32((x), 11) ^ ROTR32((x), 25))
#define sigma0(x) (ROTR32((x), 7) ^ ROTR32((x), 18) ^ ((x) >> 3))
#define sigma1(x) (ROTR32((x),17) ^ ROTR32((x), 19) ^ ((x) >> 10))
/* Recalculate element n-th of circular buffer W using formula
* W[n] = sigma1(W[n - 2]) + W[n - 7] + sigma0(W[n - 15]) + W[n - 16]; */
#define RECALCULATE_W(W,n) (W[n] += \
(sigma1(W[(n - 2) & 15]) + W[(n - 7) & 15] + sigma0(W[(n - 15) & 15])))
#define ROUND(a,b,c,d,e,f,g,h,k,data) { \
Crypt-XkcdPassword
view release on metacpan or search on metacpan
lib/Crypt/XkcdPassword/Words/EN.pm view on Meta::CPAN
marrow
lined
implying
hatred
grill
formula
esther
en
efforts
corpse
clues
Crypt-xxHash
view release on metacpan or search on metacpan
ext/xxHash/xxhash.h view on Meta::CPAN
*
* Optimized implementations are provided for AVX512, AVX2, SSE2, NEON, POWER8,
* ZVector and scalar targets. This can be controlled via the XXH_VECTOR macro.
*
* XXH3 implementation is portable:
* it has a generic C90 formulation that can be compiled on any platform,
* all implementations generage exactly the same hash value on all platforms.
* Starting from v0.8.0, it's also labelled "stable", meaning that
* any future version will also generate the same hash value.
*
* XXH3 offers 2 variants, _64bits and _128bits.
CtrlO-Crypt-XkcdPassword
view release on metacpan or search on metacpan
lib/CtrlO/Crypt/XkcdPassword/Wordlist/en_gb.pm view on Meta::CPAN
format
formation
formative
former
formerly
formula
formulae
formulate
forsake
forsaken
forsook
forswear
forswore
Curses-Devkit
view release on metacpan or search on metacpan
fulldemo/help/menu.help view on Meta::CPAN
The variable </B>$returnValue<!B> is an integer value which represents the
selected item. The calculation of this value is determined as follows:
(100 * Current Title ) + Current Subtitle
To extract the correct menu item from this value use the following formula:
$menuList = int ( $returnValue / 100 );
$menuItem = ($returnValue % 100 );
You can then dereference the string value from the array using the above two
calculations.
DB-Object
view release on metacpan or search on metacpan
lib/DB/Object/Fields/Unknown.pm view on Meta::CPAN
v0.1.0
=head1 DESCRIPTION
This class represents an unknown field. This happens when L<DB::Object::Fields> cannot find a given field used in a SQL query. Instead of returning an error (undef), it returns this object, which is then ignored when he query is formulated.
A warning is issued by L<DB::Object::Fields> when a field is unknown, so make sure to check your error output or your error log.
=head1 METHODS
( run in 0.518 second using v1.01-cache-2.11-cpan-3cd7ad12f66 )