Maths : : Le module de Perl de NumberCruncher contient une collection de fonctionnements math-relatifs utiles.

SYNTHÈSE

Il convient noter qu'en date de v4.0, il y a maintenant une surface adjacente d'OO aux maths : : NumberCruncher. Pour ascendant la compatibilité, cependant, le type précédent et fonctionnel sera toujours supporté.

# type d'OO

maths d'utilisation : : NumberCruncher ;

$ref = maths : : NumberCruncher->new () ;

# à partir de ce moment là, toutes les sous-routines montrées ci-après seront procurables # par $ref (c.-à-d., ($high, $low) = $ref->Range (@array)). Dans l'intéret # de la brièveté, consulter la documentation fonctionnelle (ci-dessous) pour l'usage # des fonctionnements particuliers.

# type fonctionnel

maths d'utilisation : : NumberCruncher ;

($high, $low) = maths : : NumberCruncher : : Gamme (@array) ;
$mean = maths : : NumberCruncher : : Moyen (@array) ;
$median = maths : : NumberCruncher : : Médiane (@array [, $decimal_places]) ;
$odd_median = maths : : NumberCruncher : : OddMedian (@array) ;
$mode = maths : : NumberCruncher : : Mode (@array) ;
$covariance = maths : : NumberCruncher : : Covariance (@array1, @array2) ;
$correlation = maths : : NumberCruncher : : Corrélation (@array1, @array2) ;
($slope, $y_intercept) = maths : : NumberCruncher : : De l'ajustement normal (@array1, @array2 [, $decimal_places]) ;
$distance = maths : : NumberCruncher : : Distance ($x1, $y1, $z1, $x2, $y2, $z2 [, $decimal_places]) ;
$distance = maths : : NumberCruncher : : Distance ($x1, $y1, $x1, $x2 [, $decimal_places]) ;
$distance = maths : : NumberCruncher : : ManhattanDistance ($x1, $y1, $x2, $y2) ;
$probAll = maths : : NumberCruncher : : AllOf (0.3, 0.25, 0.91, 0.002) ;
$probNone = maths : : NumberCruncher : : NoneOf (0.4, 0.5772, 0.212) ;
$probSome = maths : : NumberCruncher : : SomeOf (0.11, 0.56, 0.3275) ;
$factorial = maths : : NumberCruncher : : Factoriel ($some_number) ;
$permutations = maths : : NumberCruncher : : Permutation (ccn) ;
$permutations = maths : : NumberCruncher : : Permutation (ccn, $k) ;
$roll = maths : : NumberCruncher : : Matrices (3.12.4) ;
$randInt = maths : : NumberCruncher : : RandInt (10.50) ;
$randomElement = maths : : NumberCruncher : : RandomElement (@array) ;
Maths : : NumberCruncher : : ShuffleArray (@array) ;
@unique = maths : : NumberCruncher : : Seul (@array) ;
@a_only = maths : : NumberCruncher : : Comparer (@a, @b) ;
@union = maths : : NumberCruncher : : Syndicat (@a, @b) ;
@intersection = maths : : NumberCruncher : : Intersection (@a, @b) ;
@difference = maths : : NumberCruncher : : Différence (@a, @b) ;
$gaussianRand = maths : : NumberCruncher : : GaussianRand () ;
$ways = maths : : NumberCruncher : : Choisir (ccn, $k) ;
$binomial = maths : : NumberCruncher : : Binomial ($attempts, $successes, $probability) ;
$gaussianDist = maths : : NumberCruncher : : GaussianDist ($x, $mean, $variance) ;
$StdDev = maths : : NumberCruncher : : StandardDeviation (@array [, $decimal_places]) ;
$variance = maths : : NumberCruncher : : Variance (@array [, $decimal_places]) ;
@scores = maths : : NumberCruncher : : StandardScores (@array [, $decimal_places]) ;
$confidence = maths : : NumberCruncher : : SignSignificance ($trials, $hits, $probability) ;
$e = maths : : Numbercruncher : : EMC2 (« m512 », « milles » [, $decimal_places]) ;
$m = maths : : NumberCruncher : : EMC2 (« e987432 » « kilomètre » [, $decimal_places]) ;
$force = maths : : NumberCruncher : : FMA (« m12 », « a73.5 » [, $decimal_places]) ;
$mass = maths : : NumberCruncher : : FMA (« a43 », « f1324 » [, $decimal_places]) ;
$acceleration = maths : : NumberCruncher : : FMA (« f53512 », « m356 » [, $decimal_places]) ;
$predicted_value = maths : : NubmerCruncher : : Prévoir ($slope, $y_intercept, $proposed_x [, $decimal_places]) ;
$area = maths : : NumberCruncher : : TriangleHeron ($a, $b, $c [, $decimal_places]) ;
$area = maths : : NumberCruncher : : TriangleHeron (1.3, 5.7, 8.2 [, $decimal_places]) ;
$perimeter = maths : : NumberCruncher : : PolygonPerimeter ($x0, $y0, $x1, $y1, $x2, $y2,… [, p$decimal_places]) ;
$direction = maths : : NumberCruncher : : Dans le sens horaire ($x0, $y0, $x1, $y1, $x2, $y2) ;
$collision = maths : : NumberCruncher : : InPolygon ($x, $y, @xy) ;
@points = maths : : NumberCruncher : : BoundingBox_Points ($d, @p) ;
$in_triangle = maths : : NumberCruncher : : InTriangle ($x, $y, $x0, $y0, $x1, $y1, $x2, $y2) ;
$area = maths : : NumberCruncher : : PolygonArea (0, 1, 1, 0, 2, 0, 3, 2, 2, 3 [, p$decimal_places]) ;
$area = maths : : NumberCruncher : : CircleArea ($diameter [, $decimal_places]) ;
$circumference = maths : : NumberCruncher : : Circonférence ($diameter [, $decimal_places]) ;
$volume = maths : : NumberCruncher : : SphereVolume ($radius [, $decimal_places]) ;
$surface_area = maths : : NumberCruncher : : SphereSurface ($radius [, $decimal_places]) ;
$years = maths : : NumberCruncher : : RuleOf72 ($interest_rate [, $decimal_places]) ;
$volume = maths : : NumberCruncher : : CylinderVolume ($radius, $height [, $decimal_places]) ;
$volume = maths : : NumberCruncher : : ConeVolume ($lowerBaseArea, $height [, $decimal_places]) ;
$radians = maths : : NumberCruncher : : deg2rad ($degrees [, $decimal_places]) ;
$degrees = maths : : NumberCruncher : : rad2deg ($radians [, $decimal_places]) ;
$Fahrenheit = maths : : NumberCruncher : : C2F (Celsius [, $decimal_places]) ;
Celsius = maths : : NumberCruncher : : F2C ($Fahrenheit [, $decimal_places]) ;
$cm = maths : : NumberCruncher : : in2cm ($inches [, $decimal_places]) ;
$inches = maths : : NumberCruncher : : cm2in ($cm [, $decimal_places]) ;
$ft = maths : : NumberCruncher : : m2ft ($m [, $decimal_places]) ;
$m = maths : : NumberCruncher : : ft2m ($ft [, $decimal_places]) ;
$miles = maths : : NumberCruncher : : km2miles ($km [, $decimal_places]) ;
$km = maths : : NumberCruncher : : miles2km ($miles [, $decimal_places]) ;
$lb = maths : : NumberCruncher : : kg2lb ($kg [, $decimal_places]) ;
$kg = maths : : NumberCruncher : : lb2kg ($lb [, $decimal_places]) ;
$RelativeStride = maths : : NumberCruncher : : RelativeStride ($stride_length, $leg_length [, $decimal_places]) ;
$RelativeStride = maths : : NumberCruncher : : RelativeStride_2 ($DimensionlessSpeed [, $decimal_places]) ;
$DimensionlessSpeed = maths : : NumberCruncher : : DimensionlessSpeed ($RelativeStride [, $decimal_places]) ;
$DimensionlessSpeed = maths : : NumberCruncher : : DimensionlessSpeed_2 ($ActualSpeed, $leg_length [, $decimal_places]) ;
$ActualSpeed = maths : : NumberCruncher : : ActualSpeed ($leg_length, $DimensionlessSpeed [, $decimal_places]) ;
$eccentricity = maths : : NumberCruncher : : Excentricité ($half_major_axis, $half_minor_axis [, $decimal_places]) ;
$LatusRectum = maths : : NumberCruncher : : LatusRectum ($half_major_axis, $half_minor_axis [, $decimal_places]) ;
$EllipseArea = maths : : NumberCruncher : : EllipseArea ($half_major_axis, $half_minor_axis [, $decimal_places]) ;
$OrbitalVelocity = maths : : NumberCruncher : : OrbitalVelocity ($r, $a, $M [, $decimal_places]) ;
$sine = maths : : NumberCruncher : : péché ($x [, $decimal_places]) ;
$cosine = maths : : NumberCruncher : : cos ($x [, $decimal_places]) ;
$tangent = maths : : NumberCruncher : : tan ($x [, $decimal_places]) ;
$arcsin = maths : : NumberCruncher : : asin ($x [, $decimal_places]) ;
$arccos = maths : : NumberCruncher : : acos ($x [, $decimal_places]) ;
$arctan = maths : : NumberCruncher : : atan ($x [, $decimal_places]) ;
$cotangent = maths : : NumberCruncher : : lit de camp ($x [, $decimal_places]) ;
$arccot = maths : : NumberCruncher : : acot ($x [, $decimal_places]) ;
$secant = maths : : NumberCruncher : : sec ($x [, $decimal_places]) ;
$arcsec = maths : : NumberCruncher : : asec ($x [, $decimal_places]) ;
$cosecant = maths : : NumberCruncher : : csc ($x [, $decimal_places]) ;
$arccosecant = maths : : NumberCruncher : : acsc ($x [, $decimal_places]) ;
$exsecant = maths : : NumberCruncher : : exsec ($x [, $decimal_places]) ;
$versine = maths : : NumberCruncher : : vers ($x [, $decimal_places]) ;
$coversine = maths : : NumberCruncher : : caches ($x [, $decimal_places]) ;
$haversine = maths : : NumberCruncher : : hav ($x [, $decimal_places]) ;
$grouped = maths : : NumberCruncher : : Virgules ($number) ;
$SqrRoot = maths : : NumberCruncher : : SqrRoot ($number [, $decimal_places]) ;
$square_root = maths : : NumberCruncher : : racine carrée ($x [, $decimal_places]) ;
$root = maths : : NumberCruncher : : Fond (55, 3 [, $decimal_places]) ;
$root = maths : : NumberCruncher : : Root2 (55, 3 [, $decimal_places]) ;
$log = maths : : NumberCruncher : : Ln (100 [, $decimal_places]) ;
$log = maths : : NumberCruncher : : logarithme naturel ($num [, $decimal_places]) ;
$num = maths : : NumberCruncher : : Exp (0.111 [, $decimal_places]) ;
$num = maths : : NumberCruncher : : exp ($log [, $decimal_places]) ;
$Pi = maths : : NumberCruncher : : PICONST ($decimal_places) ;
$E = maths : : NumberCruncher : : ECONST ($decimal_places) ;
($A, $B, C) = maths : : NumberCruncher : : PythagTriples ($x, $y [, $decimal_places]) ;
$z = maths : : NumberCruncher : : PythagTriplesSeq ($x, $y [, $decimal_places]) ;
@nums = maths : : NumberCruncher : : SIS ([$start, $numbers, $increment]) ;
$inverse = maths : : NumberCruncher : : Inverse ($number [, $decimal_places]) ;
@constants = maths : : NumberCruncher : : CONSTANTES (toutes [, $decimal_places]) ;
$bernoulli = maths : : NumberCruncher : : Bernoulli ($num [, $decimal_places]) ;
@bernoulli = maths : : NumberCruncher : : Bernoulli ($num) ;

Maths : : Nombres raisonnables arbitraires d'ensemble de mesures de BigRat grands.

SYNTHÈSE

maths d'utilisation : : BigRat ;

mon $x = maths : : BigRat->new (3/7) ; $x += 5/9 ;

impression $x->bstr (), « n » ;
impression $x ** 2, « n » ;

mon $y = maths : : BigRat->new (FNI) ;
impression « $y », ($y->is_inf ? est : n'est pas), le « infinityn » ;

mon $z = maths : : BigRat->new (144) ; $z->bsqrt () ;

Maths : : BigRat complète des maths : : BigInt et maths : : BigFloat en fournissant le support pour de grands nombres raisonnables arbitraires.

BIBLIOTHÈQUE MATHÉMATIQUE

Vous pouvez changer le module en-dessous qui fait les fonctionnements à basse altitude de maths par l'emploi :

maths d'utilisation : : => GMP d'essai de BigRat ;

Note : Ceci a besoin de maths : : BigInt : : GMP monté.
Ce qui suit essayerait la première fois de trouver des maths : : BigInt : : Foo, puis maths : : BigInt : : La barre, et quand ceci défaille également, retournent aux maths : : BigInt : : CALC :

maths d'utilisation : : => Foo, maths d'essai de BigRat : : BigInt : : Barre ;

Si vous voulez obtenir averti quand le recul se produit, remplacer le « essai » par la « bibliothèque » :

maths d'utilisation : : => Foo, maths de bibliothèque de BigRat : : BigInt : : Barre ;

Si vous voulez que le code meurt au lieu, remplacer le « essai » par « seulement » :

maths d'utilisation : : => Foo, maths de BigRat seulement : : BigInt : : Barre ;

Maths : : Vec est des méthodes orientées objets des maths de vecteur dans le Perl.

SYNTHÈSE

maths d'utilisation : : Vec ;
$v = maths : : Vec->new (0.1.2) ;

ou

maths d'utilisation : : Qw de Vec (NewVec) ;
$v = NewVec (0.1.2) ;
@res = $v->Cross ([1.2.5, 0]) ;
$p = NewVec (@res) ;
$q = $p->Dot ([0.1.0]) ;

ou

maths d'utilisation : : Qw de Vec (: laconique) ;
$v = V (0.1.2) ;
$q = ($v X [1.2.5, 0]) * [0.1.0] ;

NOTIFICATION

Ce module est toujours quelque peu inachevé. Si un fonctionnement ne fait rien, il y a susceptible réellement une bonne raison. Veuillez aller voir le code si vous essayez d'employer ceci dans un environnement de production.

Maths : : GMPz est une surface adjacente de Perl aux fonctionnements de nombre entier de librarys de GMP (mpz).

Un module de bignum utilisant la bibliothèque de MP de Gnu (GMP). Fondamentalement ce module enveloppe simplement presque tous les fonctionnements de nombre entier fournis par cette bibliothèque. La documentation ci-dessous plagie considérable la documentation chez http://swox.com/gmp/manual.

Voir les maths : : Suite de test de GMPz pour des exemples d'usage.

SYNTHÈSE

maths d'utilisation : : Qw de GMPz (: mpz : amorce : suppl.) ;

mon $string = fa9eeeeeeeeeeeeea1234dcbaef1 ;
mon $base = 16 ;

# produire les maths : : Objectif de GMPz
mon $bn1 = Rmpz_init_set_str ($string, $base) ;

# produire des autres maths : : Objectif de GMPz qui se maintient
# une valeur initiale de zéro, mais a assez
# mémoire allouée pour enregistrer un nombre de bits 131.
# si 131 bits s'avère être insuffisants, il
# n'importe pas - de la mémoire supplémentaire est allouée
# automatiquement aux maths : : Objectifs de GMPz comme nécessaires
# par la bibliothèque de GMP.
mon $bn2 = Rmpz_init2 (131) ;

# produire des autres maths : : Objectif de GMPz initialisé à 0.
mon $bn3 = Rmpz_init () ;

# ou employer () le fonctionnement neuf :
mon $bn4 = maths : : GMPz->new (12345) ;

# exécuter quelques fonctionnements… voient des FONCTIONNEMENTS ci-dessous.

.
.

# impression à l'extérieur que la valeur s'est maintenue par $bn1 (dans octal) :
impression Rmpz_get_str ($bn1, 8), « n » ;

# impression à l'extérieur que la valeur s'est maintenue par $bn1 (dans la décimale) :
impression Rmpz_get_str ($bn1, 10) ;

# impression à l'extérieur que la valeur s'est maintenue par $bn1 (dans base 29)
# using le Rmpz_out_str (alternatif) ()
# fonctionnement. (Ce fonctionnement n'estampe pas un saut de ligne.)
Rmpz_out_str ($bn1, 29) ;

Maths : : Le module de chaîne de caractères contient des nombres entiers classés arbitraires ayant les charsets arbitraires pour prévoir avec les salles principales.

SYNTHÈSE

maths d'utilisation : : Chaîne de caractères ;
maths d'utilisation : : Chaîne de caractères : : Charset ;

$a = maths neuves : : Cafebabe de chaîne de caractères ; # a-z de défaut
$b = maths neuves : : Deadbeef de chaîne de caractères ; # a-z
impression $a + $b ; # maths : : "" De chaîne de caractères

$a = maths neuves : : Chaîne de caractères aa ; # a-z de défaut
$b = $a ;
$b++ ;
impression « $b > $a » si ($b > $a) ; # montrer que ++ le rend plus grand
$b--;
estamper le « == $a de $b » si (== de $b $a) ; # et ce ++ et -- être inverse

$d = maths : : String->bzero ([0… 9]) ; # comme des maths : : Bigint
maths de $d += : : String->new (9999, [0..9]) ;
# maths : : Chaîne de caractères « 9999 »

impression « $dn » ; # chaîne de caractères « 00000n »
impression $d->as_number (), « n » ; # maths : : BigInt « +11111 »
impression $d->last (5), « n » ; # chaîne de caractères « 99999 »
impression $d->first (3), « n » ; # chaîne de caractères « 111 »
impression $d->length (), « n » ; # plus rapidement que la longueur (« $d ») ;

$d = maths : : String->new (, maths : : Chaîne de caractères : : Charset->new ({
minlen le => 2, le => de début [a.z],}) ;

estamper $d->minlen (), « n » ; # impression 2
impression ++$d, « n » ; # impression aa

Maths : : NoCarry est une prolonge de Perl pour l'aucun transportent l'arithmétique.

SYNTHÈSE

maths d'utilisation : : NoCarry ;

mon $sum = maths : : NoCarry : : ajouter (123, 456) ;

mon $difference = maths : : NoCarry : : soustraire (123, 456) ;

mon $product = maths : : NoCarry : : se multiplier (123, 456) ;

Aucun transporter l'arithmétique ne vous permet pas à transportent des chiffres à la colonne suivante. Par exemple, si vous additionnez 8 et 4, vous vous attendez à ce que normalement la réponse soit 12, mais ce 1 chiffre est un transporter. Dans l'aucun transporter l'arithmétique que vous biseauté faites que, ainsi le montant de 8 et de 4 est juste 2. en vigueur, ceci est le modulo 10 d'ajout dans chaque fléau. Je jette le tout les transporte des chiffres dans cet exemple :

1234
+ 5678
------
6802

Pour la multiplication, le résultat par paires de la multiplication des chiffres est la valeur du modulo 10 de leur multiplication normale et journalière.

123
X 456
-----
8 6 x 3
2 6 x 2
6 6 x 1

5 5 x 3
0 5 x 2
5 5 x 1

2 4 x 3
8 4 x 2
+ 4 4 x 1
-------
43878
Depuis la multiplication et la soustraction sont réellement les types d'ajouts, vous pouvez se multiplier et soustraire comme ceci aussi bien.

Aucun transporter l'arithmétique est associatif et commutatif.

Maths : : BaseCalc est un module de Perl qui peut convertir des numéros entre de diverses bases.

SYNTHÈSE

maths d'utilisation : : BaseCalc ;

mon $calc = maths neuves : : BaseCalc (=> de chiffres [0.1]) ; #Binary
mon $bin_string = $calc->to_base (465) ; # converti 465 à la binaire

$calc->digits (oct.) ; # octal
mon $number = $calc->from_base (1574) ; # converti 1574 octal à la décimale

Ce module facilite la conversion des numéros entre de diverses bases de numération. Vous pouvez définir vos propres jeux de chiffre, ou employer n'importe lequel de plusieurs les jeux prédéfinis de chiffre.

Le to_base () et les méthodes de from_base () convertissent entre les numéros de Perl et les chaînes de caractères qui représentent ces numéros dans d'autres bases. Par exemple, si youre using le jeu de chiffre binaire [0.1], $calc->to_base (5) renverra la chaîne de caractères « 101 ». $calc->from_base (« 101 ») renverra le numéro 5.
Pour convertir entre par exemple la base 7 et la base 36, employer le procédé de 2 opérations d'abord de la conversion en numéro de Perl, alors en base désirée pour le résultat :

$calc7 = maths neuves : : BaseCalc (digits=> [0..6]) ;
$calc36 = maths neuves : : BaseCalc (digits=> [0..9, a.z] ;

$in_base_36 = $calc36->to_base ($calc7->from_base (3506)) ;

Si vous devez juste traiter les chaînes de caractères octales et hexdecimal régulières, vous n'avez pas besoin probablement de ce module. Voir le sprintf (), oct. (), et () les fonctionnements hex de Perl.

Maths : : Le composé est un module de Perl avec des nombres complexes et des fonctionnements mathématiques associés.

SYNTHÈSE

maths d'utilisation : : Complexe ;

$z = maths : : Complex->make (5, 6) ;
$t = 4 - 3*i + $z ;
$j = cplxe (1, 2*pi/3) ;

Maths : : BigInt est un progiciel mathématique arbitraire de nombre entier de taille/flotteur.

SYNTHÈSE

maths d'utilisation : : BigInt ;

# ou le rendre plus rapide : monter les maths (optionnelles) : : BigInt : : GMP
# et toujours utilisation (elle retombera au Perl pur si
# la bibliothèque de GMP n'est pas montée) :

# avertira si des maths : : BigInt : : Le GMP ne peut pas être trouvé
maths d'utilisation : : => GMP de bibliothèque de BigInt ;

# pour supprimer l'utilisation d'avertissement ceci :
# maths d'utilisation : : => GMP d'essai de BigInt ;

mon $str = 1234567890 ;
mes @values = (64.74.18) ;
mon ccn = 1 ; mon $sign = - ;

# création de numéro
mon $x = maths : : BigInt->new ($str) ; # défauts à 0
mon $y = $x->copy () ; # tirer une copie vraie
mon $nan = maths : : BigInt->bnan () ; # produire un NotANumber
mon $zero = maths : : BigInt->bzero () ; # produire des +0
mon $inf = maths : : BigInt->binf () ; # produire un +inf
mon $inf = maths : : BigInt->binf (-) ; # produire a - FNI
mon $one = maths : : BigInt->bone () ; # produire des +1
mon $mone = maths : : BigInt->bone (-) ; # produire A-1

mon $pi = maths : : BigInt->bpi () ; # renvois 3
# voir les maths : : BigFloat : : BPI ()

$h = maths : : BigInt->new (0x123) ; # de l'hexadécimal
$b = maths : : BigInt->new (0b101) ; # de la binaire
$o = maths : : BigInt->from_oct (0101) ; # d'octal

# contrôle (ne pas modifier leurs arguments)
# (renvoyer si la condition est remplie, autrement trompeur vrai)

$x->is_zero () ; # si $x est +0
$x->is_nan () ; # si $x est NaN
$x->is_one () ; # si $x est +1
$x->is_one (-) ; # si $x est -1
$x->is_odd () ; # si $x est impair
$x->is_even () ; # si $x est régulier
$x->is_pos () ; # si >= 0 de $x
$x->is_neg () ; # si $x < 0
$x->is_inf ($sign) ; # si $x est +inf, ou - FNI (le signe est défaut +)
$x->is_int () ; # si $x est un nombre entier (pas un flotteur)

# extraction de comparer et de chiffre/signe
$x->bcmp ($y) ; # comparer les numéros (undef, <0, =0, >0)
$x->bacmp ($y) ; # comparer absolument (undef, <0, =0, >0)
$x->sign () ; # renvoi le signe, +, - ou NaN
$x->digit (ccn) ; # renvoi le nième chiffre, comptant de la droite
$x->digit (- $n) ; # renvoi le nième chiffre, comptant de la gauche

# tout ce qui suit modifie leur premier argument. Si vous voulez préserver
# $x, utilisation $z = >bXXX de $x->copy () - ($y) ; Voir sous L pour pourquoi c'est
# nécessaire en se mélangeant affectations de $a = de $b aux maths non-surchargées.

$x->bzero () ; # régler $x à 0
$x->bnan () ; # régler $x à NaN
$x->bone () ; # régler $x à +1
$x->bone (-) ; # régler $x à -1
$x->binf () ; # régler $x aux FNI
$x->binf (-) ; # régler $x - aux FNI

$x->bneg () ; # inversion
$x->babs () ; # valeur absolue
$x->bnorm () ; # normaliser (l'ineffectif dans BigInt)
$x->bnot () ; # complément deux (sage mordu pas)
$x->binc () ; # échelon $x par 1
$x->bdec () ; # décroissance $x par 1

$x->badd ($y) ; # ajout (ajouter $y à $x)
$x->bsub ($y) ; # soustraction (soustraire $y de $x)
$x->bmul ($y) ; # multiplication (multiplier $x par $y)
$x->bdiv ($y) ; # la ligne de partage, a réglé $x au quotient
# retourner (quo, rem) ou quo si grandeur scalaire

$x->bmuladd ($y, $z) ; # $x = $x * $y + $z

$x->bmod ($y) ; # module (% de x y)
$x->bmodpow ($exp, $mod) ; # exponentation modulaire (($num ** $exp) % de $mod))
$x->bmodinv ($mod) ; # l'inverse de $x dans le module donné $mod

$x->bpow ($y) ; # pouvoir des arguments (x ** y)
$x->blsft ($y) ; # déplacement gauche dans la base 2
$x->brsft ($y) ; # shift droit dans la base 2
# renvois (quo, rem) ou quo si dans le contexte scalaire
$x->blsft ($y, ccn) ; # déplacement gauche par des places de $y dans la base ccn
$x->brsft ($y, ccn) ; # shift droit par des places de $y dans la base ccn
# renvois (quo, rem) ou quo si dans le contexte scalaire

$x->band ($y) ; # au niveau du bit et
$x->bior ($y) ; # au niveau du bit inclus ou
$x->bxor ($y) ; # au niveau du bit exclusivité ou
$x->bnot () ; # au niveau du bit pas (complément deux)

$x->bsqrt () ; # prévoient le grand dos-fond
$x->broot ($y) ; # fond de $yth de $x (par exemple fond cubique de => de == 3 de $y)
$x->bfac () ; # factoriel de $x (1*2*3*4*. $x)

$x->bnok ($y) ; # x au-dessus de y (coefficient binomial n au-dessus de k)

$x->blog () ; # logarithme de $x pour baser e (numéro d'Eulers)
$x->blog ($base) ; # logarithme de $x pour baser $base (f.i. 2)
$x->bexp () ; # prévoir e ** $x où e est numéro d'Eulers

$x->round ($A, $P, $mode) ; # rond à l'exactitude ou à la précision using le mode $mode
$x->bround (ccn) ; # exactitude : chiffres de la conserve ccn
$x->bfround (ccn) ; # rond au chiffre de $nth, ineffectif pour BigInts

# ce qui suit ne modifie pas leurs arguments dans BigInt (sont les ineffectif),
# mais faire ainsi dans BigFloat :

$x->bfloor () ; # nombre entier de renvoi moins ou égale que $x
$x->bceil () ; # nombre entier de renvoi plus grand ou égal que $x

# ce qui suit ne modifie pas leurs arguments :

# le diviseur courant le plus grand (aucun type d'OO)
mon $gcd = maths : : BigInt : : bgcd (@values) ;
# le plus bas multiplicateur courant (aucun type d'OO)
mon $lcm = maths : : BigInt : : blcm (@values) ;

$x->length () ; # numéro de renvoi des chiffres en nombre
($xl, $f) = $x->length () ; # longueur de numéro et longueur de pièce de fraction,
# ce dernier est toujours les chiffres 0 longtemps pour BigInts

$x->exponent () ; # exposant de renvoi comme BigInt
$x->mantissa () ; # mantisse de renvoi (signé) comme BigInt
$x->parts () ; # renvoi (mantisse, exposant) comme BigInt
$x->copy () ; # tirer une copie vraie de $x (à la différence de $y = $x ;)
$x->as_int () ; # renvoi comme BigInt (dans BigInt : mêmes que la copie ())
$x->numify () ; # renvoi en tant que grandeur scalaire (pourrait déborder !)

# conversation à la chaîne de caractères (ne pas modifier leur argument)
$x->bstr () ; # ont normalisé la chaîne de caractères (par exemple 3)
$x->bsstr () ; # norme. chaîne de caractères dans la notation scientifique (par exemple 3E0)
$x->as_hex () ; # en tant que chaîne de caractères hexadécimale signée avec 0x préfixé
$x->as_bin () ; # en tant que chaîne de caractères de binaire signée avec 0b préfixé
$x->as_oct () ; # en tant que chaîne de caractères octale signée avec 0 préfixé


# précision et exactitude (voir le chapitre au sujet de l'arrondissage pour plus)
$x->precision () ; # P de $x (ou mondial de renvoi, si P d'undef de $x)
$x->precision (ccn) ; # régler P de $x au ccn
$x->accuracy () ; # renvoi A de $x (ou mondial, si A d'undef de $x)
$x->accuracy (ccn) ; # régler A $x au ccn

# méthodes mondiales
Maths : : BigInt->precision () ; # obtenir/régler P mondial pour tous les objectifs de BigInt
Maths : : BigInt->accuracy () ; # obtenir/régler A mondial pour tous les objectifs de BigInt
Maths : : BigInt->round_mode () ; # obtenir/régler le mode rond mondial, un de
# même, impair, +inf, - FNI, zéro, trunc ou terrain communal
Maths : : BigInt->config () ; # informations parasites de renvoi contenant la configuration

Maths : : CDF est un module de Perl pour produire des probabilités et des quantiles de plusieurs fonctionnements de probabilité statistique.

SYNTHÈSE

maths d'utilisation : : CDF ;

$prob = &Math : : CDF : : pnorm (1.96) ;

si (non défini ($z = &Math : : CDF : : qnorm (0.975)) ) {mourir le « qnorm () a défailli » ; }

ou

maths d'utilisation : : Qw de CDF (: tous) ;

$prob = pnorm (1.96) ;

Ce module fournit une surface adjacente de Perl au DCDFLIB. Voir le chapitre sur DCDFLIB pour plus d'information.

Les fonctionnements sont procurables pour 7 distributions continues (bêtas, Chi-grand dos, F, gamma, normale, Poisson et T-distribution) et pour deux répartitions discrètes (binôme binomial et négatif). Les paramètres optionnels de non-centralité sont procurables pour le Chi-grand dos, le F et les T-distributions. Les probabilités cumulées sont procurables pour chacune des 9 distributions et les fonctionnements de quantile sont procurables pour les 7 distributions continues.

Tous les noms de fonctionnement de probabilité cumulée commencent par le caractère « p ». Ils donnent la probabilité d'être inférieur ou égal à la valeur donnée [P (<= de X x)]

Tous les noms de fonctionnement de quantile commencent par le caractère Q. Ils donnent à une valeur de x tels que P (<= de X x) = p où la valeur de p est fournie au fonctionnement.

les paramètres de Non-centralité sont toujours le dernier argument de fonctionnement si procurables. Vous n'avez pas besoin de fournir le paramètre de non-centralité dans ce cas on supposera qu'est 0.

Tous les fonctionnements renverront une valeur non définie si les défaillir de fonctionnement (probablement dues aux paramètres étant hors de la gamme permise) mais ne produiront pas autrement d'un message d'erreur. L'usager devrait vérifier la sortie admissible des maths : : CDF fonctionne avec () le fonctionnement défini comme expliqué dans le chapitre de SYNTHÈSE.

Maths : : MagicSquare est un contrôleur et un créateur de grand dos magique.

SYNTHÈSE

maths d'utilisation : : MagicSquare ;

maths de $a= : : MagicSquare - > neuf ([numérique,…, numérique],
…,
[numérique,…, numérique]) ;
$a->print (« chaîne de caractères ») ;
$a->printhtml () ;
$a->printimage () ;
$a->check () ;
$a->rotation () ;
$a->reflection () ;

Les méthodes suivantes sont procurables :

neuf

Les arguments de constructeur sont une liste de références aux choix de la même longueur.

$a = maths : : MagicSquare - > neuf ([numérique,…, numérique],
…,
[numérique,…, numérique]) ;

vérification

Ce fonctionnement peut renvoyer la valeur 4

0 : le grand dos n'est pas magique
1 : le grand dos est à angle droit de Semimagic (le montant des rangées et des fléaux est égal)
2 : le grand dos est à angle droit magique (le montant des rangées, des fléaux et des diagonales est égal)
3 : le grand dos carré de Panmagic d'ia (le montant des rangées, des fléaux, des diagonales et des diagonales cassées est égal)

impression

Estampe le grand dos sur STDOUT. Si la méthode a des paramètres supplémentaires, ceux-ci sont estampés avant que le grand dos magique soit estampé.

printhtml

Estampe le grand dos sur STDOUT dans un format HTML (exact a à l'intérieur d'un TABLEAU)

printimage

Estampe le grand dos sur STDOUT dans le format de png.

rotation

Tourne le grand dos magique de 90 degrés dans le sens horaire

réflexion

Réfléchir le grand dos magique

Maths : : La combinatoire est un module de Perl qui peut exécuter des combinaisons et des permutations sur des listes.

SYNTHÈSE

Procurable comme api orienté objets.

maths d'utilisation : : Combinatoire ;

mon @n = qw (un b c) ;
mon $combinat = maths : : Combinatorics->new (=> 2 de compte,
=> de caractéristiques [@n],
) ;

combinaisons d'impression « de 2 de :  » .join (« « , @n). « n » ;
impression « ------------------------ » .("-- » grandeur scalaire de x (@n)). « n » ;
tandis que (mon @combo = $combinat->next_combination) {
l'impression se joignent (, @combo). « n » ;
}

impression « n » ;

permutations d'impression « de 3 de :  » .join (« « , @n). « n » ;
impression « ------------------------ » .("-- » grandeur scalaire de x (@n)). « n » ;
tandis que (mon @permu = $combinat->next_permutation) {
l'impression se joignent (, @permu). « n » ;
}

sortie :

Ou procurable par l'intermédiaire des fonctionnements exportés permuter, combiner, et factoriel.

maths d'utilisation : : Combinatoire ;

mon @n = qw (un b c) ;
combinaisons d'impression « de 2 de :  » .join (« « , @n). « n » ;
impression « ------------------------ » .("-- » grandeur scalaire de x (@n)). « n » ;
l'impression se joignent (« n », cartel de carte {joindre » « , @$_} (2, @n)), « n » ;
estamper « n » ;
estamper les « permutations de 3 de :  » .join (« « , @n). « n » ;
impression « ------------------------ » .("-- » grandeur scalaire de x (@n)). « n » ;
l'impression se joignent (« n », carte {joindre » « , @$_} permutent (@n)), « n » ;

Sortie :

combinaisons de 2 de : un b c
------------------------------
un b
AC
b c

permutations de 3 de : un b c
------------------------------
un b c
AC b
AC de b
b c a
c un b
c b a

La sortie des deux types d'appels est identique, mais l'approche orientée objets absorbe beaucoup moins de mémoire pour de grands jeux.

Maths : : HashSum peut additionner une liste de paires de clavette-valeur sur une base de selon-clavette.

SYNTHÈSE

maths d'utilisation : : Qw de HashSum (hashsum) ;

mon %hash1 = (a=>.1, b=>.4) ;
mon %hash2 = (a=>.2, b=>.5) ;
mon %sum = hashsum (%hash1, %hash2) ;

impression « $sum {a} n » ; # impressions .3
impression « $sum {b} n » ; # impressions .9

Ce module te permet d'additionner une liste de paires de clavette-valeur sur une base de selon-clavette. Il ajoute toutes les valeurs liées à chaque clavette dans la liste donnée et renvoie des informations parasites contenant le montant lié à chaque clavette.

L'exemple dans la synthèse devrait expliquer l'usage du module effectivement.

Maths : : Expr est un module de Perl qui analyse des expressions mathématiques.

SYNTHÈSE

exiger les maths : : Expr ;

maths de $p=new : : Expr ;
$e=$p->Parse (« a+4*b-d/log+f (d, e) ») ;

Analyse des expressions mathématiques dans une structure arborescente. Les expressions peuvent contenir des nombres entiers, nombres réels, noms de la variable alphanumériques, noms de fonctionnement alphanumériques et la plupart des autres caractères pourraient être employés comme conducteurs. Les conducteurs peuvent même être plus longs qu'un caractère ! La seule limitation est qu'un nom de variable ou de fonctionnement peut ne pas commencer sur un chiffre, et pas tous les chars sont reçus comme fonctionnements. Pour être exact, voici le grammatic (dans la notation de regexp de Perl) :

< Expr > = - ? < Elem > (< >< Elem d'OpChr >) *
< Elem > = < numéro >|< distributeur intégrant son logiciel au matériel >|< fonctionnement >|(< Expr >)
< numéro > = < nombre entier >|< flotteur >
< nombre entier > = d+
< flotteur > = d*.d+
< distributeur intégrant son logiciel au matériel > = [a-zA-Z] [a-zA-Z0-9] * (: [a-zA-Z] [a-zA-Z0-9] *) ?
< fonctionnement > = [a-zA-Z] [a-zA-Z0-9] * (< Expr > (, < Expr >) *)
< OpChr > = [^a-zA-Z0-9 (). :]+

Si - le signe est présent au début d'un < Expr > qu'il est analysé dans l'exact la même structure que 0< Expr >. C'est de permettre des constructions comme « - a*b » ou « b+3* (- 7) ».

Une variable se compose de deux parts séparées par a : - char. Les premières parties sont le nom de la variable, et la deuxième partie optionnelle est son type. Le type de défaut est réel.

MÉTHODES

$p = maths neuves : : Expr

C'est le constructeur, il produit un objectif qui plus tard peut être employé pour analyser les chaînes de caractères.

$e=$p->Parse ($str)

Ceci analysera la chaîne de caractères $str et renverra un arbre d'expression, sous forme de maths : : Expr : : Objectif d'Opp (ou dans des cas simples seulement des maths : : Expr : : Distributeur intégrant son logiciel au matériel ou maths : : Expr : : Objectif numérique).

$p->Priority ({^=>50,/=>40, *=>30, - =>20, +=>10})

Ceci fixera la priorité de TOUS LES opérandes (il n'y a actuel aucune voie de changer seulement un d'entre eux). La priorité décide ce qui devrait être construit si plusieurs opérandes est coté sans séparateurs. Par exemple si a+b*c est traité comme (a+b)*c ou a+ (b*c). (Le défaut est indiqué dans l'en-tête).

$p->SetOppDB ($db)

Règle l'OpperationDB à employer à $db. Voir les maths : : Expr : : OpperationDB pour plus d'information. Ceci sera réussi vers le bas à tous les objectifs retournés par l'aswell de programme d'analyse syntaxique.

Maths : : TotalBuilder est un module de Perl pour établir un total entier hors des pièces évaluées.

SYNTHÈSE

maths d'utilisation : : TotalBuilder ;

mon %lsd = (=> de livre 240, => de shilling 20, => de penny 1) ;

# ensembles pour 952 penny
mon %tender = construction (%lsd, 952) ;

# valeur totale de 3, 21, 98
mon $wealth = total (%lsd, {=> 3 de livre, => 21 de shilling, => 98 de penny}) ;

# améliorer mieux la représentation de 18, 6, 40
mon %moolah = construction (%lsd,
total (%lsd, {=> 18 de livre, => 6 de shilling, => 40 de penny}));

Ce module fournit deux sous-routines, constructions et totaux, qui peuvent être employés pour traiter des quantités d'organes évalués. Ceux-ci peuvent être employés pour établir l'offre appropriée pour représenter une quantité d'argent, pour composer une masse des poids unifiés, pour convertir une différence des secondes en ensemble d'ensembles de temps, ou d'autres calculs assimilés.

Maths : : Cephes est une surface adjacente de Perl à la bibliothèque mathématique de cephes.

SYNTHÈSE

maths d'utilisation : : Qw de Cephes (: tous) ;

Ce module fournit une surface adjacente à plus de 150 fonctionnements de
bibliothèque mathématique de cephes de Stephen Moshier. Aucun fonctionnement n'est exporté
par défaut, mais plutôt doit être importé expressément, en tant que dedans

maths d'utilisation : : Qw de Cephes (péché cos) ;

Il y a un certain nombre d'étiquettes d'exportation définies qui laissent
importation des groupes de fonctionnements :
maths d'utilisation : : Qw de Cephes (: constantes) ;
importe les variables

$PI : 3.14159265358979323846 # pi
$PIO2 : 1.57079632679489661923 # pi/2
$PIO4 : 0.785398163397448309616 # pi/4
$SQRT2 : 1.41421356237309504880 # racine carrée (2)
$SQRTH : 0.707106781186547524401 # racine carrée (2)/2
$LOG2E : 1.4426950408889634073599 # 1/log (2)
$SQ2OPI : 0.79788456080286535587989 # racine carrée (2/pi)
$LOGE2 : 0.693147180559945309417 # logarithme naturel (2)
$LOGSQ2 : 0.346573590279972654709 # logarithme naturel (2)/2
$THPIO4 : 2.35619449019234492885 # 3*pi/4
$TWOOPI : 0.636619772367581343075535 # 2/pi

Aussi bien, il y a 4 numéros propres à une machine procurables :

$MACHEP : erreur d'approximation de machine
$MAXLOG : procédure de connexion maximum la machine
$MINLOG : procédure de connexion minimum la machine
$MAXNUM : le plus grand numéro a représenté
maths d'utilisation : : Qw de Cephes (: trigs) ;
importations

acos : Cosinus circulaire inverse
asin : Sinus circulaire inverse
atan : Tangente circulaire inverse (arctangente)
atan2 : Tangente circulaire inverse correcte de bloc-manettes
cos : Cosinus circulaire
cosdg : Cosinus circulaire de cornière en degrés
lit de camp : Cotangent circulaire
cotdg : Cotangent circulaire d'argument en degrés
hypot : la hypoténuse s'est associée aux côtés d'une bonne triangle
radian : Degrés, minutes, secondes aux radians
péché : Sinus circulaire
sindg : Sinus circulaire de cornière en degrés
tan : Tangente circulaire
tandg : Tangente circulaire d'argument en degrés
cosm1 : Les approximations d'erreur relative pour des arguments de fonctionnement s'approchent de l'unité
maths d'utilisation : : Qw de Cephes (: hypers) ;
importations

acosh : Cosinus hyperbolique inverse
asinh : Sinus inverse
atanh : Tangente hyperbolique inverse
gourdin : Cosinus hyperbolique
sinh : Sinus
tanh : Tangente hyperbolique
maths d'utilisation : : Qw de Cephes (: explog) ;
importations

exp : Fonctionnement exponentiel
expxx : exp (x*x)
exp10 : Fonctionnement exponentiel de la base 10 (antilogarithme courant)
exp2 : Fonctionnement exponentiel de la base 2
logarithme naturel : Logarithme naturel
log10 : Logarithme ordinaire
log2 : Logarithme de la base 2
log1p, expm1 : Les approximations d'erreur relative pour des arguments de fonctionnement s'approchent de l'unité.
maths d'utilisation : : Qw de Cephes (: cmplx) ;
importations

new_cmplx : produire un objectif neuf de nombre complexe
taxis : Valeur absolue complexe
cacos : Cosinus circulaire complexe d'arc
cacosh : Cosinus hyperbolique inverse complexe
casin : Sinus circulaire complexe d'arc
casinh : Sinus inverse complexe
catan : Arc tangente circulaire complexe
catanh : Tangente hyperbolique inverse complexe
ccos : Cosinus circulaire complexe
ccosh : Cosinus hyperbolique complexe
ccot : Cotangent circulaire complexe
cexp : Fonctionnement exponentiel complexe
entrave : Logarithme naturel complexe
cadd : ajouter deux numéros complexes
csub : soustraire deux numéros complexes
cmul : multiplier deux numéros complexes
cdiv : nombres complexes de la ligne de partage deux
cmov : copier un numéro complexe à l'autre
cneg : réaliser une inversion un numéro complexe
cpow : Fonction puissance complexe
csin : Sinus circulaire complexe
csinh : Sinus complexe
csqrt : Racine carrée complexe
ctan : Tangente circulaire complexe
ctanh : Tangente hyperbolique complexe
maths d'utilisation : : Qw de Cephes (: utils) ;
importations

cbrt : Racine cubique
ceil : ceil
drand : Générateur de nombre pseudo-aléatoire
fabs : Valeur absolue
fac : Fonctionnement factoriel
sol : sol
frexp : frexp
ldexp : multiplie x par 2 ** N.
lrand : Générateur de nombre pseudo-aléatoire
lsqrt : Racine carrée de nombre entier
prisonnier de guerre : Fonction puissance
powi : Réel augmenté au pouvoir de nombre entier
rond : Double rond à le plus près ou même double évalué par nombre entier
racine carrée : Racine carrée
maths d'utilisation : : Qw de Cephes (: bessels) ;
importations

i0 : Fonction Bessel Modifiée de la commande zéro
i0e : Fonction Bessel Modifiée de la commande zéro, exponentiellement évaluée
i1 : Fonction Bessel Modifiée de la commande une
i1e : Fonction Bessel Modifiée de la commande une, exponentiellement évaluée
iv : Fonction Bessel Modifiée de commande de noninteger
j0 : Fonction Bessel De la commande zéro
j1 : Fonction Bessel De la commande une
jn : Fonction Bessel De commande de nombre entier
EC : Fonction Bessel De commande de noninteger
k0 : Fonction Bessel Modifiée, troisièmement genre, commande zéro
k0e : La fonction Bessel Modifiée, troisièmement genre, la commande zéro, a exponentiellement évalué
k1 : Fonction Bessel Modifiée, troisièmement genre, commande une
k1e : La fonction Bessel Modifiée, troisièmement genre, la commande une, a exponentiellement évalué
kn : Fonction Bessel Modifiée, troisièmement genre, commande de nombre entier
y0 : Fonction Bessel Du deuxième genre, commande zéro
y1 : Fonction Bessel De deuxième genre de commande une
yn : Fonction Bessel De deuxième genre de commande de nombre entier
yv : Fonction Bessel Yv avec le noninteger v
maths d'utilisation : : Qw de Cephes (: dists) ;
importations

bdtr : Distribution binomiale
bdtrc : Distribution binomiale complétée
bdtri : Distribution binomiale inverse
btdtr : Bêta distribution
chdtr : distribution de Chi-grand dos
chdtrc : Distribution complétée de Chi-grand dos
chdtri : Inverse de distribution complétée de Chi-grand dos
fdtr : Distribution de F
fdtrc : Distribution complétée de F
fdtri : Inverse de distribution complétée de F
gdtr : Fonction de répartition gamma
gdtrc : Fonction de répartition gamma complétée
nbdtr : Distribution binomiale négative
nbdtrc : Distribution binomiale négative complétée
nbdtri : Inverse fonctionnel de distribution binomiale négative
ndtr : Fonctionnement de distribution normale
ndtri : Inverse de fonctionnement de distribution normale
pdtr : Loi de Poisson
pdtrc : Loi de Poisson complétée
pdtri : Loi de Poisson Inverse
stdtr : Distribution des stagiaires t
stdtri : Inverse fonctionnel de distribution des stagiaires t
maths d'utilisation : : Qw de Cephes (: gamma) ;
importations

fac : Fonctionnement factoriel
gamma : Fonctionnement gamma
igam : Intégrale gamma inachevée
igamc : Intégrale gamma inachevée complétée
igami : Inverse d'intégrale gamma complétée d'imcomplete
LPC : Fonctionnement Psi (digamma)
rgamma : Fonctionnement gamma réciproque
maths d'utilisation : : Qw de Cephes (: betas) ;
importations

bêta : Bêta fonctionnement
incbet : Bêta intégrale inachevée
incbi : Inverse de bêta intégrale d'imcomplete
lbeta : Logarithme naturel de |bêta|
maths d'utilisation : : Qw de Cephes (: elliptics) ;
importations

ellie : Intégrale elliptique inachevée du deuxième genre
ellik : Intégrale elliptique inachevée du premier genre
ellpe : Compléter l'intégrale elliptique du deuxième genre
ellpj : Fonctionnements elliptiques de Jacobian
ellpk : Compléter l'intégrale elliptique du premier genre
maths d'utilisation : : Qw de Cephes (: hypergeometrics) ;
importations

hyp2f0 : Fonctionnement hypergéométrique F de gauss
hyp2f1 : Fonctionnement hypergéométrique F de gauss
hyperg : Fonctionnement hypergéométrique confluent
onef2 : Fonctionnement hypergéométrique 1F2
threef0 : Fonctionnement hypergéométrique 3F0
maths d'utilisation : : Qw de Cephes (: divers) ;
importations

bien aéré : Fonction d'Airy
bernum : Numéros de Bernoulli
dawsn : Intégrale de Dawsons
E-I : Intégrale exponentielle
erf : Fonction erreur
erfc : Fonction erreur complémentaire
expn : En exponentielle d'intégrale
fresnl : Intégrale de Fresnel
plancki : Intégrale de formule de rayonnement de fuselage noir de Plancks
polylog : Fonctionnement de Polylogarithm
shichi : Intégrales de sinus et de cosinus
sici : Intégrales de sinus et de cosinus
simpson : Règle de Simpsons pour trouver une intégrale
spence : Dilogarithm
struve : Fonctionnement de Struve
vecang : cornière entre deux vecteurs
zéta : Fonctionnement de zéta de Riemann de deux arguments
zetac : Fonctionnement de zéta de Riemann
maths d'utilisation : : Qw de Cephes (: fract) ;
importations

new_fract : produire un objectif neuf de fraction
radd : ajouter deux fractions
rmul : multiplier deux fractions
rsub : fractions de subtracttwo
rdiv : fractions de la ligne de partage deux
euclid : trouve le diviseur courant le plus grand

Maths : : Romain contient des nombres et la conversion romains classés arbitraires et en de l'arabe.

SYNTHÈSE

maths d'utilisation : : Qw romain (romain) ;

$a = maths neuves : : MCMLXXIII romain ; # 1973
$b = romain (MCMLXI) ; # 1961
impression $a - $b, « n » ; # impressions XII

$d = maths : : Roman->bzero () ; #
$d++ ; # I
$d += 1998 ; # MCMXCIX
$d - = MCM ; # XCIX

impression « $dn » ; # chaîne de caractères « MCMIC »
impression $d->as_number (), « n » ; # maths : : BigInt « +1999 »

Maths : : TotalBuilder : : Le terrain communal est un module de Perl avec les liasses d'imprimés courantes pour des totaux de construction.

SYNTHÈSE

maths d'utilisation : : TotalBuilder ;
maths d'utilisation : : TotalBuilder : : Courant ;

# ensembles pour 952 penny
mon %tender = construction ($Math : : TotalBuilder : : Terrain communal : : uk_money_old, 952) ;

Cet ensemble de mesures est juste un ensemble d'ensembles courants d'ensembles pour l'usage avec le code dans les maths : : TotalBuilder.

Maths : : Macopt est un emballage de Perl pour macopt++, qui est une bibliothèque de gradient conjugué.

INSTALLATION

L'ensemble de mesures peut être monté par la procédure d'installation normale de module de Perl :

Perl Makefile.PL
effectuer
effectuer le test
effectuer pour monter

Veuillez noter que codes sources originels de C++ de « macopt++ » sont compris en cet ensemble de mesures de Perl. Joindre de charge statique évite le conflit possible à n'importe quelle version prémontée de « macopt++ ».

SYNTHÈSE

employer strict ;
maths d'utilisation : : Macopt ;

&main () ;

force secondaire
{
# quelques réglages
mon ccn = 10 ;
mon $epsilon = 0.001 ;

# initialiser le Macopt
mon $macopt = maths neuves : : Macopt : : Base (ccn, 0) ;

# installer le fonctionnement et son gradient
mon $func = sous-marin {
mon $x = commande des vitesses ;

mon $size = $macopt->size () ;
mon $sum = 0 ;
foreach mon $i (0. $size-1) {
$sum += ($x-> [$i] - $i) ** 2 ;
}

$sum de renvoi ;
} ;
mon $dfunc = sous-marin {
mon $x = commande des vitesses ;

mon $size = $macopt->size () ;
mon $g = () ;
foreach mon $i (0. $size-1) {
$g-> [$i] = 2* ($x-> [$i] - $i) ;
}

$g de renvoi ;
} ;
$macopt->setFunc (&$func) ;
$macopt->setDfunc (&$dfunc) ;

# optimiseur using le macopt
mon $x = [(1) x (ccn)];
$macopt->maccheckgrad ($x, ccn, $epsilon, 0) ;
$macopt->macoptII ($x, ccn) ;

# étalage le résultat
printf « [%s] n », se joignent (, @$x) ;
}

Maths : : Cephes : : Le composé est une surface adjacente de Perl aux sous-programmes de nombre complexe de cephes.

SYNTHÈSE

maths d'utilisation : : Cephes : : Qw complexe (cmplx) ;
mon $z1 = cmplx (2.3) ; # $z1 = 2 + 3 I
mon $z2 = cmplx (3.4) ; # $z2 = 3 + 4 I
mon $z3 = $z1->radd ($z2) ; # $z3 = $z1 + $z2