Mathe:: NumberCruncher Perl-Baugruppe enthält eine Ansammlung nützliche Mathe-in Verbindung stehende Funktionen.

SYNOPSE

Es sollte notiert, dass ab v4.0, es jetzt eine OO Schnittstelle zu Mathe: gibt: NumberCruncher. Für Rückwärtskompatibilität jedoch wird die vorhergehende, Funktionsart immer unterstützt.

# OO Art

Gebrauch Mathe:: NumberCruncher;

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

# ab hier, sind alle Subroutinen, die unten gezeigt werden, # durch $ref erhältlich (d.h., ($high, $low) = $ref->Range (@array)). Für den Grund # von Kürze, die Funktionsunterlagen (unten) für den Gebrauch # von speziellen Funktionen konsultieren.

# Funktionsart

Gebrauch Mathe:: NumberCruncher;

($high, $low) = Mathe:: NumberCruncher:: Reichweite (@array);
$mean = Mathe:: NumberCruncher:: Mittelwert (@array);
$median = Mathe:: NumberCruncher:: Mittelwert (@array [, $decimal_places]);
$odd_median = Mathe:: NumberCruncher:: OddMedian (@array);
$mode = Mathe:: NumberCruncher:: Betriebsart (@array);
$covariance = Mathe:: NumberCruncher:: Kovarianz (@array1, @array2);
$correlation = Mathe:: NumberCruncher:: Wechselbeziehung (@array1, @array2);
($slope, $y_intercept) = Mathe:: NumberCruncher:: BestFit (@array1, @array2 [, $decimal_places]);
$distance = Mathe:: NumberCruncher:: Abstand ($x1, $y1, $z1, $x2, $y2, $z2 [, $decimal_places]);
$distance = Mathe:: NumberCruncher:: Abstand ($x1, $y1, $x1, $x2 [, $decimal_places]);
$distance = Mathe:: NumberCruncher:: ManhattanDistance ($x1, $y1, $x2, $y2);
$probAll = Mathe:: NumberCruncher:: AllOf (0.3, 0.25, 0.91, 0.002);
$probNone = Mathe:: NumberCruncher:: NoneOf (0.4, 0.5772, 0.212);
$probSome = Mathe:: NumberCruncher:: SomeOf (0.11, 0.56, 0.3275);
$factorial = Mathe:: NumberCruncher:: Faktoren- ($some_number);
$permutations = Mathe:: NumberCruncher:: Permutation ($n);
$permutations = Mathe:: NumberCruncher:: Permutation ($n, $k);
$roll = Mathe:: NumberCruncher:: Düsen (3.12.4);
$randInt = Mathe:: NumberCruncher:: RandInt (10.50);
$randomElement = Mathe:: NumberCruncher:: RandomElement (@array);
Mathe:: NumberCruncher:: ShuffleArray (@array);
@unique = Mathe:: NumberCruncher:: Einzigartig (@array);
@a_only = Mathe:: NumberCruncher:: Vergleichen (@a, @b);
@union = Mathe:: NumberCruncher:: Verbindungsstück (@a, @b);
@intersection = Mathe:: NumberCruncher:: Durchschnitt (@a, @b);
@difference = Mathe:: NumberCruncher:: Unterschied (@a, @b);
$gaussianRand = Mathe:: NumberCruncher:: GaussianRand ();
$ways = Mathe:: NumberCruncher:: Wählen ($n, $k);
$binomial = Mathe:: NumberCruncher:: Binomial ($attempts, $successes, $probability);
$gaussianDist = Mathe:: NumberCruncher:: GaussianDist ($x, $mean, $variance);
$StdDev = Mathe:: NumberCruncher:: StandardDeviation (@array [, $decimal_places]);
$variance = Mathe:: NumberCruncher:: Abweichung (@array [, $decimal_places]);
@scores = Mathe:: NumberCruncher:: StandardScores (@array [, $decimal_places]);
$confidence = Mathe:: NumberCruncher:: SignSignificance ($trials, $hits, $probability);
$e = Mathe:: Numbercruncher:: EMC2 („m512“, „Meilen“ [, $decimal_places]);
$m = Mathe:: NumberCruncher:: EMC2 („e987432“ „Kilometer“ [, $decimal_places]);
$force = Mathe:: NumberCruncher:: FMA („m12“, „a73.5“ [, $decimal_places]);
$mass = Mathe:: NumberCruncher:: FMA („a43“, „f1324“ [, $decimal_places]);
$acceleration = Mathe:: NumberCruncher:: FMA („f53512“, „m356“ [, $decimal_places]);
$predicted_value = Mathe:: NubmerCruncher:: Voraussagen ($slope, $y_intercept, $proposed_x [, $decimal_places]);
$area = Mathe:: NumberCruncher:: TriangleHeron ($a, $b, $c [, $decimal_places]);
$area = Mathe:: NumberCruncher:: TriangleHeron (1.3, 5.7, 8.2 [, $decimal_places]);
$perimeter = Mathe:: NumberCruncher:: PolygonPerimeter ($x0, $y0, $x1, $y1, $x2, $y2,… [, p$decimal_places]);
$direction = Mathe:: NumberCruncher:: Rechts herum ($x0, $y0, $x1, $y1, $x2, $y2);
$collision = Mathe:: NumberCruncher:: InPolygon ($x, $y, @xy);
@points = Mathe:: NumberCruncher:: BoundingBox_Points ($d, @p);
$in_triangle = Mathe:: NumberCruncher:: InTriangle ($x, $y, $x0, $y0, $x1, $y1, $x2, $y2);
$area = Mathe:: NumberCruncher:: PolygonArea (0, 1, 1, 0, 2, 0, 3, 2, 2, 3 [, p$decimal_places]);
$area = Mathe:: NumberCruncher:: CircleArea ($diameter [, $decimal_places]);
$circumference = Mathe:: NumberCruncher:: Umfang ($diameter [, $decimal_places]);
$volume = Mathe:: NumberCruncher:: SphereVolume ($radius [, $decimal_places]);
$surface_area = Mathe:: NumberCruncher:: SphereSurface ($radius [, $decimal_places]);
$years = Mathe:: NumberCruncher:: RuleOf72 ($interest_rate [, $decimal_places]);
$volume = Mathe:: NumberCruncher:: CylinderVolume ($radius, $height [, $decimal_places]);
$volume = Mathe:: NumberCruncher:: ConeVolume ($lowerBaseArea, $height [, $decimal_places]);
$radians = Mathe:: NumberCruncher:: deg2rad ($degrees [, $decimal_places]);
$degrees = Mathe:: NumberCruncher:: rad2deg ($radians [, $decimal_places]);
$Fahrenheit = Mathe:: NumberCruncher:: C2F (Celsius [, $decimal_places]);
Celsius = Mathe:: NumberCruncher:: F2C ($Fahrenheit [, $decimal_places]);
$cm = Mathe:: NumberCruncher:: in2cm ($inches [, $decimal_places]);
$inches = Mathe:: NumberCruncher:: cm2in ($cm [, $decimal_places]);
$ft = Mathe:: NumberCruncher:: m2ft ($m [, $decimal_places]);
$m = Mathe:: NumberCruncher:: ft2m ($ft [, $decimal_places]);
$miles = Mathe:: NumberCruncher:: km2miles ($km [, $decimal_places]);
$km = Mathe:: NumberCruncher:: miles2km ($miles [, $decimal_places]);
$lb = Mathe:: NumberCruncher:: kg2lb ($kg [, $decimal_places]);
$kg = Mathe:: NumberCruncher:: lb2kg ($lb [, $decimal_places]);
$RelativeStride = Mathe:: NumberCruncher:: RelativeStride ($stride_length, $leg_length [, $decimal_places]);
$RelativeStride = Mathe:: NumberCruncher:: RelativeStride_2 ($DimensionlessSpeed [, $decimal_places]);
$DimensionlessSpeed = Mathe:: NumberCruncher:: DimensionlessSpeed ($RelativeStride [, $decimal_places]);
$DimensionlessSpeed = Mathe:: NumberCruncher:: DimensionlessSpeed_2 ($ActualSpeed, $leg_length [, $decimal_places]);
$ActualSpeed = Mathe:: NumberCruncher:: ActualSpeed ($leg_length, $DimensionlessSpeed [, $decimal_places]);
$eccentricity = Mathe:: NumberCruncher:: Exzentrizität ($half_major_axis, $half_minor_axis [, $decimal_places]);
$LatusRectum = Mathe:: NumberCruncher:: LatusRectum ($half_major_axis, $half_minor_axis [, $decimal_places]);
$EllipseArea = Mathe:: NumberCruncher:: EllipseArea ($half_major_axis, $half_minor_axis [, $decimal_places]);
$OrbitalVelocity = Mathe:: NumberCruncher:: OrbitalVelocity ($r, $a, $M [, $decimal_places]);
$sine = Mathe:: NumberCruncher:: Sünde ($x [, $decimal_places]);
$cosine = Mathe:: NumberCruncher:: Lattich ($x [, $decimal_places]);
$tangent = Mathe:: NumberCruncher:: Tan ($x [, $decimal_places]);
$arcsin = Mathe:: NumberCruncher:: asin ($x [, $decimal_places]);
$arccos = Mathe:: NumberCruncher:: acos ($x [, $decimal_places]);
$arctan = Mathe:: NumberCruncher:: atan ($x [, $decimal_places]);
$cotangent = Mathe:: NumberCruncher:: Feldbett ($x [, $decimal_places]);
$arccot = Mathe:: NumberCruncher:: acot ($x [, $decimal_places]);
$secant = Mathe:: NumberCruncher:: sek ($x [, $decimal_places]);
$arcsec = Mathe:: NumberCruncher:: asec ($x [, $decimal_places]);
$cosecant = Mathe:: NumberCruncher:: csc ($x [, $decimal_places]);
$arccosecant = Mathe:: NumberCruncher:: acsc ($x [, $decimal_places]);
$exsecant = Mathe:: NumberCruncher:: exsec ($x [, $decimal_places]);
$versine = Mathe:: NumberCruncher:: vers ($x [, $decimal_places]);
$coversine = Mathe:: NumberCruncher:: Deckel ($x [, $decimal_places]);
$haversine = Mathe:: NumberCruncher:: hav ($x [, $decimal_places]);
$grouped = Mathe:: NumberCruncher:: Kommas ($number);
$SqrRoot = Mathe:: NumberCruncher:: SqrRoot ($number [, $decimal_places]);
$square_root = Mathe:: NumberCruncher:: sqrt ($x [, $decimal_places]);
$root = Mathe:: NumberCruncher:: Wurzel (55, 3 [, $decimal_places]);
$root = Mathe:: NumberCruncher:: Root2 (55, 3 [, $decimal_places]);
$log = Mathe:: NumberCruncher:: Ln (100 [, $decimal_places]);
$log = Mathe:: NumberCruncher:: Bordbuch ($num [, $decimal_places]);
$num = Mathe:: NumberCruncher:: Exp (0.111 [, $decimal_places]);
$num = Mathe:: NumberCruncher:: exp ($log [, $decimal_places]);
$Pi = Mathe:: NumberCruncher:: PICONST ($decimal_places);
$E = Mathe:: NumberCruncher:: ECONST ($decimal_places);
($A, $B, C) = Mathe:: NumberCruncher:: PythagTriples ($x, $y [, $decimal_places]);
$z = Mathe:: NumberCruncher:: PythagTriplesSeq ($x, $y [, $decimal_places]);
@nums = Mathe:: NumberCruncher:: SIS ([$start, $numbers, $increment]);
$inverse = Mathe:: NumberCruncher:: Gegenteil ($number [, $decimal_places]);
@constants = Mathe:: NumberCruncher:: KONSTANTEN (alle [, $decimal_places]);
$bernoulli = Mathe:: NumberCruncher:: Bernoulli ($num [, $decimal_places]);
@bernoulli = Mathe:: NumberCruncher:: Bernoulli ($num);

Mathe:: Willkürliche grosse rationale Zahlen des BigRat Pakets.

SYNOPSE

Gebrauch Mathe:: BigRat;

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

Druck $x->bstr (), „N“;
Druck $x ** 2, „N“;

mein $y = Mathe:: BigRat->new (inf);
Druck „$y“, ($y->is_inf? ist: ist nicht), „infinityn“;

mein $z = Mathe:: BigRat->new (144); $z->bsqrt ();

Mathe:: BigRat ergänzt Mathe: zt: BigInt und Mathe:: BigFloat durch das Gewähren des Trägers für willkürliche grosse rationale Zahlen.

MATHEMATISCHE BIBLIOTHEK

Sie können die zugrundeliegende Baugruppe ändern, die die niedrigen Mathearbeitsweisen tut, indem es verwendet:

Gebrauch Mathe:: BigRat Versuch => GMP;

Mitteilung: Dieses benötigt Mathe:: BigInt:: GMP eingebaut.
Das folgende versuchen zuerst, Mathe zu finden:: BigInt:: Foo, dann Mathe:: BigInt:: Rechtsanwaltschaft und wenn diese auch ausfällt, zurückkehrt zu Mathe: ehrt: BigInt:: Calc:

Gebrauch Mathe:: BigRat Versuch => Foo, Mathe:: BigInt:: Rechtsanwaltschaft;

Wenn Sie erhalten möchten gewarnt, wann der Rückfall auftritt, „Versuch“ durch „Bibliothek“ ersetzen:

Gebrauch Mathe:: BigRat Bibliothek => Foo, Mathe:: BigInt:: Rechtsanwaltschaft;

Wenn Sie den Code anstatt sterben wünschen, „Versuch“ durch „nur“ ersetzen:

Gebrauch Mathe:: BigRat nur => Foo, Mathe:: BigInt:: Rechtsanwaltschaft;

Mathe:: Vec ist objektorientierte vektormathe-Methoden in Perl.

SYNOPSE

Gebrauch Mathe:: Vec;
$v = Mathe:: Vec->new (0.1.2);

oder

Gebrauch Mathe:: Vec qw (NewVec);
$v = NewVec (0.1.2);
@res = $v->Cross ([1.2.5, 0]);
$p = NewVec (@res);
$q = $p->Dot ([0.1.0]);

oder

Gebrauch Mathe:: Vec qw (: kurz);
$v = V (0.1.2);
$q = ($v x [1.2.5, 0]) * [0.1.0];

BEGRIFF

Diese Baugruppe ist noch ein wenig unvollständig. Wenn eine Funktion nichts tut, gibt es ein wirklich triftiger Grund wahrscheinlich. Einen Blick am Code bitte haben, wenn Sie versuchen, dieses in einer Produktionsumgebung zu verwenden.

Mathe:: GMPz ist eine Perl-Schnittstelle zu den Funktionen der GMP librarys ganzen Zahl (mpz).

Eine bignum Baugruppe, welche die verwendet Bibliothek Gnu Wartungstafel-(GMP). Im Allgemeinen wickelt diese Baugruppe einfach fast alle Zahlfunktionen ein, die von dieser Bibliothek bereitgestellt werden. Die Unterlagen unten plagiarises weitgehend die Unterlagen bei http://swox.com/gmp/manual.

Mathe sehen:: GMPz Prüfungssuite für Beispiele des Verbrauches.

SYNOPSE

Gebrauch Mathe:: GMPz qw (: mpz: grundiert: zusätzl.);

mein $string = fa9eeeeeeeeeeeeea1234dcbaef1;
mein $base = 16;

# Mathe erstellen:: GMPz Nachricht
mein $bn1 = Rmpz_init_set_str ($string, $base);

# ein anderes Mathe erstellen:: GMPz Nachricht, die anhält
# hat ein Anfangswert von null, aber genug
# Speicher zugeordnet, um eine Zahl des Bits zu lagern 131.
#, wenn 131 Bits ausfällt, unzureichend zu sein, es
# macht nicht aus - zusätzlicher Speicher wird zugeordnet
# automatisch zu Mathe:: GMPz Nachrichten, wie gebraucht
# durch die GMP-Bibliothek.
mein $bn2 = Rmpz_init2 (131);

# ein anderes Mathe erstellen:: GMPz Nachricht initialisiert bis 0.
mein $bn3 = Rmpz_init ();

# oder die neue () Funktion verwenden:
mein $bn4 = Mathe:: GMPz->new (12345);

# einige Arbeitsweisen durchführen… sehen FUNKTIONEN unten.

.
.

# ausdrucken, das der Wert durch $bn1 anhielt (in oktalem):
Druck Rmpz_get_str ($bn1, 8), „N“;

# ausdrucken, das der Wert durch $bn1 anhielt (im Dezimalstrich):
Druck Rmpz_get_str ($bn1, 10);

# ausdrucken, das der Wert durch $bn1 anhielt (in Unterseite 29)
# using das (alternative) Rmpz_out_str ()
# Funktion. (Diese Funktion druckt nicht eine neue Zeile.)
Rmpz_out_str ($bn1, 29);

Mathe:: Zeichenkettebaugruppe enthält die willkürlichen sortierten ganzen Zahlen, die willkürliche charsets, um mit Schlüsselräumen zu berechnen haben.

SYNOPSE

Gebrauch Mathe:: Zeichenkette;
Gebrauch Mathe:: Zeichenkette:: Charset;

$a = neues Mathe:: Zeichenkette cafebabe; # Zahlungseinstellung A-z
$b = neues Mathe:: Zeichenkette deadbeef; # A-z
Druck $a + $b; # Mathe:: Zeichenkette ""

$a = neues Mathe:: Zeichenkette AA; # Zahlungseinstellung A-z
$b = $a;
$b++;
Druck „$b > $a“ wenn ($b > $a); # prüfen, dass ++ es grösser bildet
$b--;
„$b == $a“ drucken wenn ($b == $a); # und dieses ++ und -- Rück sein

$d = Mathe:: String->bzero ([0… 9]); # wie Mathe:: Bigint
$d += Mathe:: String->new (9999, [0..9]);
# Mathe:: Zeichenkette „9999“

Druck „$dn“; # Zeichenkette „00000n“
Druck $d->as_number (), „N“; # Mathe:: BigInt „+11111“
Druck $d->last (5), „N“; # Zeichenkette „99999“
Druck $d->first (3), „N“; # Zeichenkette „111“
Druck $d->length (), „N“; # schneller als Länge („$d“);

$d = Mathe:: String->new (, Mathe:: Zeichenkette:: Charset->new ({
=> 2, Anfangs=> [a.z] minlen,});

$d->minlen drucken (), „N“; # Druck 2
Druck ++$d, „N“; # Druck AA

Mathe:: NoCarry ist eine Perl-Extension für kein tragen Arithmetik.

SYNOPSE

Gebrauch Mathe:: NoCarry;

mein $sum = Mathe:: NoCarry:: addieren (123, 456);

mein $difference = Mathe:: NoCarry:: subtrahieren (123, 456);

mein $product = Mathe:: NoCarry:: multiplizieren (123, 456);

Kein Arithmetik tragen erlaubt Sie nicht zu 5Bertragsbits zur folgenden Säule. Z.B. wenn Sie 8 und 4 hinzufügen, erwarten Sie normalerweise die Antwort, um 12 zu sein, aber dieses 1 Digit ist tragen. In keinem Arithmetik, die Sie schräg, dass, also die Summe von 8 und von 4 gerade 2. in Wirklichkeit, ist diese tragen sind Zusatzmodulo 10 in jeder Säule tun. Ich verwerfe alles 5Bertragsbits in diesem Beispiel:

1234
+ 5678
------
6802

Für Vermehrung ist das Resultat paarweise der Vermehrung der Digits der Wert des Modulos 10 ihrer normalen, täglichen Vermehrung.

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
Seit Vermehrung und Abzug wirklich sind Typen der Zusätze, können Sie so außerdem multiplizieren und subtrahieren.

Kein Arithmetik tragen ist vereinigend und auswechselbar.

Mathe:: BaseCalc ist eine Perl-Baugruppe, die Zahlen zwischen verschiedenen Unterseiten konvertieren kann.

SYNOPSE

Gebrauch Mathe:: BaseCalc;

mein $calc = neues Mathe:: BaseCalc (Digits => [0.1]); #Binary
mein $bin_string = $calc->to_base (465); # Bekehrter 465 zur Zweiheit

$calc->digits (Okt); # oktal
mein $number = $calc->from_base (1574); # Bekehrter oktales 1574 zum Dezimalstrich

Diese Baugruppe ermöglicht die Konvertierung von Zahlen zwischen verschiedenen Basen. Sie können Ihre eigenen Digiteinstellungen definieren, oder irgendwelche von mehreren verwenden vorbestimmte Digiteinstellungen.

Das to_base () und from_base () die Methoden konvertieren zwischen Perl-Zahlen und Zeichenketten, die diese Zahlen in anderen Unterseiten darstellen. Zum Beispiel wenn youre using die Binärziffereinstellung [0.1], $calc->to_base (5) zurückbringt die Zeichenkette „101“. $calc->from_base („101“) zurückbringt die Nr. 5. gt.
Um zwischen Unterseite 7 und Unterseite 6 sagen wir zu konvertieren, den Prozeß mit 2 Stufen von in eine Perl-Zahl, dann in die gewünschte Unterseite zuerst konvertieren für das Resultat verwenden:

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

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

Wenn Sie gerade regelmäßige oktale u. hexdecimal Zeichenketten handhaben müssen, benötigen Sie vermutlich nicht diese Baugruppe. Das sprintf (), Okt () und hex () Perl-Funktionen sehen.

Mathe:: Komplex ist eine Perl-Baugruppe mit komplizierten Zahlen und dazugehörigen mathematischen Funktionen.

SYNOPSE

Gebrauch Mathe:: Kompliziert;

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

Mathe:: BigInt ist ein willkürliches Mathepaket der Größenganzen zahl/Gleitbetrieb.

SYNOPSE

Gebrauch Mathe:: BigInt;

# oder es schneller bilden: (wahlweise) Mathe einbauen:: BigInt:: GMP
# und immer Gebrauch (er fällt zurück zu reinem Perl wenn
# ist GMP-Bibliothek nicht) eingebaut:

# warnt, wenn Mathe:: BigInt:: GMP kann nicht gefunden werden
Gebrauch Mathe:: BigInt Bibliothek => GMP;

# den warnenden Gebrauch unterdrücken dieses:
# Gebrauch Mathe:: BigInt Versuch => GMP;

mein $str = 1234567890;
meine @values = (64.74.18);
mein $n = 1; mein $sign = -;

# Zahlkreation
mein $x = Mathe:: BigInt->new ($str); # Zahlungseinstellungen bis 0
mein $y = $x->copy (); # ein zutreffendes Exemplar erstellen
mein $nan = Mathe:: BigInt->bnan (); # ein NotANumber erstellen
mein $zero = Mathe:: BigInt->bzero (); # +0 erstellen
mein $inf = Mathe:: BigInt->binf (); # ein +inf erstellen
mein $inf = Mathe:: BigInt->binf (-); # a erstellen - inf
mein $one = Mathe:: BigInt->bone (); # +1 erstellen
mein $mone = Mathe:: BigInt->bone (-); # -1 erstellen

mein $pi = Mathe:: BigInt->bpi (); # Umsätze 3
# Mathe sehen:: BigFloat:: BPI ()

$h = Mathe:: BigInt->new (0x123); # von den hexadezimalen Zahlen
$b = Mathe:: BigInt->new (0b101); # von der Zweiheit
$o = Mathe:: BigInt->from_oct (0101); # von oktalem

# Prüfung (ihre Argumente nicht ändern)
# (zutreffendes, wenn die Bedingung getroffen wird, falsches andernfalls zurückbringen)

$x->is_zero (); #, wenn $x +0 ist
$x->is_nan (); #, wenn $x NaN ist
$x->is_one (); #, wenn $x +1 ist
$x->is_one (-); #, wenn $x -1 ist
$x->is_odd (); #, wenn $x ungerade ist
$x->is_even (); #, wenn $x gleichmäßig ist
$x->is_pos (); # wenn $x >= 0
$x->is_neg (); # wenn $x < 0
$x->is_inf ($sign); #, wenn $x +inf ist oder - inf (Zeichen ist Zahlungseinstellung +)
$x->is_int (); #, wenn $x eine ganze Zahl ist (nicht ein Gleitbetrieb)

# Vergleichen und Digit-/Zeichenextraktion
$x->bcmp ($y); # Zahlen (undef, <0, =0, >0) vergleichen
$x->bacmp ($y); # absolut vergleichen (undef, <0, =0, >0)
$x->sign (); # Umsatz das Zeichen, entweder +, - oder NaN
$x->digit ($n); # Umsatz das nth Digit, zählend vom Recht
$x->digit (- $n); # Umsatz das nth Digit, zählend vom links

# alle ändert folgenden ihr erstes Argument. Wenn Sie konservieren möchten
# $x, Gebrauch $z = $x->copy () - >bXXX ($y); Sehen unter L für, warum dieses ist
# notwendig beim Mischen $a = $b Anweisungen mit nicht-überbelastetem Mathe.

$x->bzero (); # $x bis 0 einstellen
$x->bnan (); # $x nach NaN einstellen
$x->bone (); # $x bis +1 einstellen
$x->bone (-); # $x bis -1 einstellen
$x->binf (); # $x auf inf einstellen
$x->binf (-); # $x auf - inf einstellen

$x->bneg (); # Widerlegung
$x->babs (); # Absolutwert
$x->bnorm (); # normalisieren (No-Op in BigInt)
$x->bnot (); # Ergänzung twos (gebissenes kluges nicht)
$x->binc (); # Stufensprung $x durch 1
$x->bdec (); # Dekrement $x durch 1

$x->badd ($y); # Zusatz ($y $x) addieren
$x->bsub ($y); # Abzug ($y von $x) subtrahieren
$x->bmul ($y); # Vermehrung ($x mit $y) multiplizieren
$x->bdiv ($y); # stellte Verteilung, $x auf Quotienten ein
# zurückgehen (quo, Rem) oder quo wenn Scalar

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

$x->bmod ($y); # Modul (% x y)
$x->bmodpow ($exp, $mod); # modulares exponentation (($num ** $exp) % $mod))
$x->bmodinv ($mod); # das Gegenteil von $x im gegebenen Modul $mod

$x->bpow ($y); # Leistung der Argumente (x ** y)
$x->blsft ($y); # Linksverschiebung in Unterseite 2
$x->brsft ($y); # rechte Schiebung in Unterseite 2
# Umsätze (quo, Rem) oder quo wenn im Skalarzusammenhang
$x->blsft ($y, $n); # Linksverschiebung durch $y Plätze in der Unterseite $n
$x->brsft ($y, $n); # rechte Schiebung durch $y Plätze in der Unterseite $n
# Umsätze (quo, Rem) oder quo wenn im Skalarzusammenhang

$x->band ($y); # bitweise und
$x->bior ($y); # bitweise einschließlich oder
$x->bxor ($y); # bitweise Exklusives oder
$x->bnot (); # bitweise nicht (Ergänzung twos)

$x->bsqrt (); # berechnen Quadratwurzel
$x->broot ($y); # $yth Wurzel von $x (z.B. $y == 3 => Kubikwurzel)
$x->bfac (); # Faktoren- von $x (1*2*3*4*. $x)

$x->bnok ($y); # x über o (binomialer Koeffizient N über k)

$x->blog (); # Logarithmus von $x, zum von e (Eulers Zahl) zu gründen
$x->blog ($base); # Logarithmus von $x, zum von $base (f.i. 2) zu gründen
$x->bexp (); # e berechnen ** $x, in dem e Eulers Zahl ist

$x->round ($A, $P, $mode); # rund zur Genauigkeit oder zur Präzision using Betriebsart $mode
$x->bround ($n); # Genauigkeit: Konserve $n-Digits
$x->bfround ($n); # rund zum $nth Digit, No-Op für BigInts

# ändert die folgenden nicht ihre Argumente in BigInt (sind No-Ops),
# aber in BigFloat so tun:

$x->bfloor (); # Rückholganze zahl weniger oder Gleichgestelltes als $x
$x->bceil (); # Rückholganze zahl grösser oder gleich als $x

# ändert die folgenden nicht ihre Argumente:

# größter gemeinsamer Teiler (keine OO Art)
mein $gcd = Mathe:: BigInt:: bgcd (@values);
# am niedrigsten geläufiger Multiplikator (keine OO Art)
mein $lcm = Mathe:: BigInt:: blcm (@values);

$x->length (); # Rückholzahl der Digits zahlreich
($xl, $f) = $x->length (); # Länge der Zahl und Länge des Bruchteils,
# ist letzteres immer Digits 0 lang für BigInts

$x->exponent (); # Rückholexponent als BigInt
$x->mantissa (); # Mantisse des Umsatzes (gekennzeichnet) als BigInt
$x->parts (); # Umsatz (Mantisse, Exponent) als BigInt
$x->copy (); # ein zutreffendes Exemplar von $x erstellen (anders als $y = $x;)
$x->as_int (); # Umsatz als BigInt (in BigInt: selben wie Exemplar ())
$x->numify (); # Umsatz als Scalar (konnte überlaufen!)

# Gespräch zur Zeichenkette (ihr Argument nicht ändern)
$x->bstr (); # normalisierten Zeichenkette (z.B. 3)
$x->bsstr (); # Norm. Zeichenkette in der wissenschaftlichen Darstellung (z.B. 3E0)
$x->as_hex (); # als gekennzeichnete hexadezimale Zeichenkette mit vorgesetztem 0x
$x->as_bin (); # als Zeichenkette der gekennzeichneten Zweiheit mit vorgesetztem 0b
$x->as_oct (); # als gekennzeichnete oktale Zeichenkette mit vorgesetztem 0


# Präzision und Genauigkeit (Abschnitt über das Aufrunden für mehr sehen)
$x->precision (); # Rückholp von $x (oder global, wenn P von $x undef)
$x->precision ($n); # P von $x auf $n einstellen
$x->accuracy (); # Umsatz A von $x (oder globales, wenn A von $x undef)
$x->accuracy ($n); # A $x auf $n einstellen

# globale Methoden
Mathe:: BigInt->precision (); # globales P für alle BigInt Nachrichten erhalten/einstellen
Mathe:: BigInt->accuracy (); # globales A für alle BigInt Nachrichten erhalten/einstellen
Mathe:: BigInt->round_mode (); # globale runde Betriebsart, ein erhalten/einstellen von
# sogar, ungerade, +inf, - inf, null, trunc oder Common
Mathe:: BigInt->config (); # Rückholdurcheinander, das Konfiguration enthält

Mathe:: CDF ist eine Perl-Baugruppe, zum von Wahrscheinlichkeiten und von Quantiln von einigen Wahrscheinlichkeitfunktionen festzulegen.

SYNOPSE

Gebrauch Mathe:: CDF;

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

wenn (nicht definiert ($z = &Math:: CDF:: qnorm (0.975)) ) {„qnorm sterben () ausfiel“; }

oder

Gebrauch Mathe:: CDF qw (: alle);

$prob = pnorm (1.96);

Diese Baugruppe stellt eine Perl-Schnittstelle zum DCDFLIB zur Verfügung. Den Abschnitt auf DCDFLIB zu mehr Information sehen.

Funktionen sind für 7 kontinuierliche Verteilungen (Beta-, Chi-Quadrat, F, Gamma, Normal, Poisson und T-Verteilung) und für zwei getrennte Verteilungen erhältlich (binomiales und negatives Binom). Wahlweisec$nichtzentrale lage Parameter sind für das Chi-Quadrat, das F und die T-Verteilungen erhältlich. Kumulative Wahrscheinlichkeiten sind für alle 9 Verteilungen erhältlich und Quantilfunktionen sind für die 7 kontinuierlichen Verteilungen erhältlich.

Alle Funktionsnamen der kumulativen Wahrscheinlichkeit fangen mit dem Zeichen „P“ an. Sie geben die Wahrscheinlichkeit des Seins kleiner als oder Gleichgestelltes zum gegebenen Wert [P (X <= x)]

Alle Quantilfunktionsnamen fangen mit dem Zeichen Q. an. Sie geben einem Wert von x so dass P (X <= x) = P, in dem der Wert von P zur Funktion zur Verfügung gestellt wird.

Nicht-zentrale Lage Parameter sind immer das letzte Funktionsargument, wenn erhältlich. Sie brauchen nicht, den Nichtzentrale Lage Parameter zu liefern, in diesem Fall es angenommen wird, um 0 zu sein.

Alle Funktionen bringen einen unbestimmten Wert zurück, wenn Funktionsausfallen (vermutlich wegen der Parameter, die aus erlaubter Reichweite heraus sind) aber nicht anders eine Fehlermeldung festlegt. Der Benutzer sollte auf gültigem Ausgang von Mathe überprüfen:: CDF arbeitet mit der definierten () Funktion, wie im SYNOPSE-Abschnitt demonstriert.

Mathe:: MagicSquare ist ein magisches Quadrat-Kontrolleur und ein Entwerfer.

SYNOPSE

Gebrauch Mathe:: MagicSquare;

$a= Mathe:: MagicSquare - > neu ([numerisch,…, numerisch],
…,
[numerisch,…, numerisch]);
$a->print („Zeichenkette“);
$a->printhtml ();
$a->printimage ();
$a->check ();
$a->rotation ();
$a->reflection ();

Die folgenden Methoden sind erhältlich:

neu

Erbauerargumente sind eine Liste von Hinweisen auf Reihen der gleichen Länge.

$a = Mathe:: MagicSquare - > neu ([numerisch,…, numerisch],
…,
[numerisch,…, numerisch]);

Check

Diese Funktion kann Wert 4 zurückbringen

0: das Quadrat ist nicht magisch
1: das Quadrat ist ein Semimagic Quadrat (die Summe der Reihen und der Säulen ist gleich)
2: das Quadrat ist ein magisches Quadrat (die Summe der Reihen, der Säulen und der Diagonalen ist gleich)
3: das quadratische ia Panmagic Quadrat (die Summe der Reihen, der Säulen, der Diagonalen und der unterbrochenen Diagonalen ist gleich)

Druck

Druckt das Quadrat auf STDOUT. Wenn die Methode zusätzliche Parameter hat, werden diese gedruckt, bevor das magische Quadrat gedruckt wird.

printhtml

Druckt das Quadrat auf STDOUT in einem HTML-Format (genau a innerhalb eines TISCHES)

printimage

Druckt das Quadrat auf STDOUT im png-Format.

Umdrehung

Dreht das magische Quadrat von 90 Grad nach rechts

Reflexion

Das magische Quadrat reflektieren

Mathe:: Kombinatorik ist eine Perl-Baugruppe, die Kombinationen und Permutationen auf Listen durchführen kann.

SYNOPSE

Erhältlich als objektorientierte API.

Gebrauch Mathe:: Kombinatorik;

mein @n = qw (ein b c);
mein $combinat = Mathe:: Combinatorics->new (Zählimpuls => 2,
Daten => [@n],
);

Druck„Kombinationen von 2 von: “ .join („„, @n). „N“;
Druck „------------------------“. („--“ xscalar (@n)). „N“;
während (mein @combo = $combinat->next_combination) {
Druck verbinden (, @combo). „N“;
}

Druck „N“;

Druck„Permutationen von 3 von: “ .join („„, @n). „N“;
Druck „------------------------“. („--“ xscalar (@n)). „N“;
während (mein @permu = $combinat->next_permutation) {
Druck verbinden (, @permu). „N“;
}

Ausgang:

Oder erhältlich über Exportfunktionen permutieren, kombinieren, und Faktoren-.

Gebrauch Mathe:: Kombinatorik;

mein @n = qw (ein b c);
Druck„Kombinationen von 2 von: “ .join („„, @n). „N“;
Druck „------------------------“. („--“ xscalar (@n)). „N“;
Druck verbinden („N“, Mähdrescher der Karte {“ „, @$_ verbinden} (2, @n)), „N“;
„N“ drucken;
„Permutationen von 3 von drucken: “ .join („„, @n). „N“;
Druck „------------------------“. („--“ xscalar (@n)). „N“;
Druck verbinden („N“, Karte {“ „, @$_ verbinden}, permutieren (@n)), „N“;

Ausgang:

Kombinationen von 2 von: ein b c
------------------------------
ein b
Wechselstrom
b c

Permutationen von 3 von: ein b c
------------------------------
ein b c
Wechselstrom b
b-Wechselstrom
b c a
c ein b
c b a

Ausgang von beiden Typen Aufrufe ist der selbe, aber der objektorientierte Anflug verbraucht viel weniger Speicher für große Einstellungen.

Mathe:: HashSum kann eine Liste der Schlüsselwert Paare auf einer Proschlüssel Basis summieren.

SYNOPSE

Gebrauch Mathe:: HashSum qw (hashsum);

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

Druck „$sum {a} N“; # Drucke .3
Druck „$sum {b} N“; # Drucke .9

Diese Baugruppe erlaubt Ihnen, eine Liste der Schlüsselwert Paare auf einer Proschlüssel Basis zu summieren. Sie fügt oben alle Werte hinzu, die mit jedem Schlüssel in der gegebenen Liste verbunden sind und bringt ein Durcheinander zurück, welches die Summe enthält, die mit jedem Schlüssel verbunden ist.

Das Beispiel in der Synopse sollte Verbrauch der Baugruppes effektiv erklären.

Mathe:: Expr ist eine Perl-Baugruppe, die mathematische Ausdrücke analysiert.

SYNOPSE

Mathe erfordern:: Expr;

$p=new Mathe:: Expr;
$e=$p->Parse („a+4*b-d/log+f (d, e)“);

Analysiert mathematische Ausdrücke in eine Baumstruktur. Die Ausdrücke können ganze Zahlen, reale Zahlen, alphanumerische variable Namen, alphanumerische Funktionsnamen enthalten und die meisten anderen Zeichen konnten als Bediener verwendet werden. Die Bediener können als ein Zeichen länger sogar sein! Die einzige Beschränkung ist, dass ein Variablen- oder Funktionsname möglicherweise nicht auf einem Digit beginnen kann, und nicht alle Putzfrauen werden als Arbeitsweisen angenommen. Zu genau zu sein, ist hier grammatic (in der Perl regexp Darstellung):

< Expr > = -? < Elem > (< OpChr >< Elem >) *
< Elem > = < Zahl >|< Var >|< Funktion >|(< Expr >)
< Zahl > = < ganze Zahl >|< Gleitbetrieb >
< ganze Zahl > = d+
< Gleitbetrieb > = d*.d+
< Var > = [a-zA-Z] [a-zA-Z0-9] * (: [a-zA-Z] [a-zA-Z0-9] *)?
< Funktion > = [a-zA-Z] [a-zA-Z0-9] * (< Expr > (, < Expr >) *)
< OpChr > = [^a-zA-Z0-9 ().:]+

Wenn - Zeichen ist zu Beginn eines < Expr anwesend, >, das es im genauen die gleiche Zelle wie 0< Expr > analysiert wird. Das ist, Aufbauten wie „- a*b“ oder „b+3* (- 7) zu erlauben,“.

Eine Variable besteht aus zwei Teilen, die durch a getrennt werden: - Putzfrau. Das erste Teil ist der variable Name, und das zweite wahlweiseteil ist sein Typ. Zahlungseinstellungtyp ist real.

METHODEN

$p = neues Mathe:: Expr

Dieses ist der Erbauer, es erstellt eine Nachricht, die später verwendet werden kann, um die Zeichenketten zu analysieren.

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

Dieses analysiert die Zeichenkette $str und bringt einen Ausdruckbaum, in Form Mathe: zurück: Expr:: Opp Nachricht (oder in den einfachen Fällen nur Mathe:: Expr:: Var oder Mathe:: Expr:: Numerische Nachricht).

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

Dieses legt den Vorrang ALLER Operande fest (es gibt aktuell keine Methode, nur ein von ihnen zu ändern). Der Vorrang beschließt, was konstruiert werden sollte, wenn einige Operande ohne Begrenzungen aufgeführt ist. Z.B., wenn a+b*c wie behandelt wird (a+b)*c oder a+ (b*c). (Zahlungseinstellung wird im Vorsatz verzeichnet).

$p->SetOppDB ($db)

Stellt das an ein $db gewöhnt zu sein OpperationDB. Mathe sehen:: Expr:: OpperationDB für mehr Info. Dieses wird unten zu allen Nachrichten geführt, die durch das Syntaxanalyse aswell zurückgebracht werden.

Mathe:: TotalBuilder ist eine Perl-Baugruppe, zum einer vollständigen Gesamtmenge aus bewerteten Stücken heraus aufzubauen.

SYNOPSE

Gebrauch Mathe:: TotalBuilder;

mein %lsd = (Pound => 240, Schilling => 20, Penny => 1);

# Geräte für 952 Pennies
mein %tender = Bau (%lsd, 952);

# Gesamtwert von 3, 21, 98
mein $wealth = Gesamtmenge (%lsd, {Pound => 3, Schilling => 21, Penny => 98});

# Darstellung von 18, 6, 40 gut verbessern
mein %moolah = Bau (%lsd,
Gesamtmenge (%lsd, {Pound => 18, Schilling => 6, Penny => 40}));

Diese Baugruppe liefert zwei Subroutinen, Bau und Gesamtmenge, die verwendet werden können, um Mengen der bewerteten Punkte zu handhaben. Diese können verwendet werden, um den korrekten Tender aufzubauen, um eine Menge Geld darzustellen, eine Masse von den Standardgewichten zu bestehen, einen Unterschied von Sekunden in eine Einstellung Zeitgeräte oder andere ähnliche Berechnungen zu konvertieren.

Mathe:: Cephes ist eine Perl-Schnittstelle zur cephes mathematischen Bibliothek.

SYNOPSE

Gebrauch Mathe:: Cephes qw (: alle);

Diese Baugruppe stellt eine Schnittstelle zu über 150 Funktionen von zur Verfügung
cephes mathematische Bibliothek von Stephen Moshier. Keine Funktionen werden exportiert
durch Zahlungseinstellung aber muß, als innen eher ausdrücklich importiert werden

Gebrauch Mathe:: Cephes qw (Sünde Lattich);

Es gibt einige definierte Exportmarken, die gewähren
Import der Gruppen Funktionen:
Gebrauch Mathe:: Cephes qw (: Konstanten);
importiert die Variablen

$PI: 3.14159265358979323846 # PU
$PIO2: 1.57079632679489661923 # pi/2
$PIO4: 0.785398163397448309616 # pi/4
$SQRT2: 1.41421356237309504880 # sqrt (2)
$SQRTH: 0.707106781186547524401 # sqrt (2)/2
$LOG2E: 1.4426950408889634073599 # 1/log (2)
$SQ2OPI: 0.79788456080286535587989 # sqrt (2/pi)
$LOGE2: 0.693147180559945309417 # Bordbuch (2)
$LOGSQ2: 0.346573590279972654709 # Bordbuch (2)/2
$THPIO4: 2.35619449019234492885 # 3*pi/4
$TWOOPI: 0.636619772367581343075535 # 2/pi

Außerdem gibt es 4 machine-specific erhältliche Zahlen:

$MACHEP: Maschine Roundofffehler
$MAXLOG: maximaler LOGON die Maschine
$MINLOG: minimaler LOGON die Maschine
$MAXNUM: größte Zahl stellte dar
Gebrauch Mathe:: Cephes qw (: trigs);
Importe

acos: Umgekehrter Kreiskosinus
asin: Umgekehrter Kreissinus
atan: Umgekehrte Kreistangente (Arkustangens)
atan2: Quadrantkorrekte umgekehrte Kreistangente
Lattich: Kreiskosinus
cosdg: Kreiskosinus des Winkels in den Grad
Feldbett: Kreiscotangent
cotdg: Kreiscotangent des Arguments in den Grad
hypot: Hypothenuse gehörte mit den Seiten eines rechten Dreiecks dazu
Einheitswinkel: Grad, Protokoll, Sekunden zu den Einheitswinkeln
Sünde: Kreissinus
sindg: Kreissinus des Winkels in den Grad
Tan: Kreistangente
tandg: Kreistangente des Arguments in den Grad
cosm1: Näherungswerte des relativen Fehlers für Funktionsargumente nähern sich Einheit
Gebrauch Mathe:: Cephes qw (: hypers);
Importe

acosh: Umgekehrter hyperbolischer Kosinus
asinh: Umgekehrter hyperbolischer Sinus
atanh: Umgekehrte hyperbolische Tangente
Totschläger: Hyperbolischer Kosinus
sinh: Hyperbolischer Sinus
tanh: Hyperbolische Tangente
Gebrauch Mathe:: Cephes qw (: explog);
Importe

exp: Exponentialfunktion
expxx: exp (x*x)
exp10: Exponentialfunktion der Unterseite 10 (geläufiger Antilogarithm)
exp2: Exponentialfunktion der Unterseite 2
Bordbuch: Natürlicher Logarithmus
log10: Geläufiger Logarithmus
log2: Logarithmus der Unterseite 2
log1p, expm1: Näherungswerte des relativen Fehlers für Funktionsargumente nähern sich Einheit.
Gebrauch Mathe:: Cephes qw (: cmplx);
Importe

new_cmplx: eine neue Nachricht der komplizierten Zahl erstellen
Fahrerhäuser: Komplizierter Absolutwert
cacos: Komplizierter Kreislichtbogenkosinus
cacosh: Komplizierter umgekehrter hyperbolischer Kosinus
casin: Komplizierter Kreislichtbogensinus
casinh: Komplizierter umgekehrter hyperbolischer Sinus
catan: Komplizierte Kreislichtbogentangente
catanh: Komplizierte umgekehrte hyperbolische Tangente
ccos: Komplizierter Kreiskosinus
ccosh: Komplizierter hyperbolischer Kosinus
ccot: Komplizierter Kreiscotangent
cexp: Kompliziertes Exponentialfunktion
Klotz: Komplizierter natürlicher Logarithmus
cadd: zwei komplizierte Zahlen hinzufügen
csub: zwei komplizierte Zahlen subtrahieren
cmul: zwei komplizierte Zahlen multiplizieren
cdiv: komplizierte Zahlen der Verteilung zwei
cmov: eine komplizierte Zahl zu anderen kopieren
cneg: eine komplizierte Zahl verneinen
cpow: Komplizierte Potenz-Funktion
csin: Komplizierter Kreissinus
csinh: Komplizierter hyperbolischer Sinus
csqrt: Komplizierte Quadratwurzel
ctan: Komplizierte Kreistangente
ctanh: Komplizierte hyperbolische Tangente
Gebrauch Mathe:: Cephes qw (: utils);
Importe

cbrt: Kubikwurzel
ceil: ceil
drand: Pseudozufallszahlgenerator
fabs: Absolutwert
fac: Faktoren- Funktion
Sohle: Sohle
frexp: frexp
ldexp: multipliziert x mit 2 ** N.
lrand: Pseudozufallszahlgenerator
lsqrt: Quadratwurzel der ganzen Zahl
Kriegsgefangen: Potenz-Funktion
powi: Reales angehoben zur Zahlleistung
rund: Rundes Doppeltes zu nahe oder sogar ganze Zahl bewertetes Doppeltes
sqrt: Quadratwurzel
Gebrauch Mathe:: Cephes qw (: bessels);
Importe

i0: Geänderte Bessel-Funktion von Ordnung null
i0e: Geänderte Bessel-Funktion von Ordnung null, exponential eingestuft
i1: Geänderte Bessel-Funktion von Ordnung eine
i1e: Geänderte Bessel-Funktion von Ordnung eine, exponential eingestuft
iv: Geänderte Bessel-Funktion der noninteger Ordnung
j0: Bessel-Funktion von Ordnung null
j1: Bessel-Funktion von Ordnung eine
jn: Bessel-Funktion der Zahlordnung
jv: Bessel-Funktion der noninteger Ordnung
k0: Geänderte Bessel-Funktion, an dritter Stelle Art, Ordnung null
k0e: Geänderte Bessel-Funktion, an dritter Stelle Art, Ordnung null, stufte exponential ein
k1: Geänderte Bessel-Funktion, an dritter Stelle Art, Ordnung eine
k1e: Geänderte Bessel-Funktion, an dritter Stelle Art, Ordnung eine, stufte exponential ein
kn: Geänderte Bessel-Funktion, an dritter Stelle Art, Zahlordnung
YO: Bessel-Funktion der zweiten Art, Ordnung null
y1: Bessel-Funktion der zweiten Art von Ordnung eine
yn: Bessel-Funktion der zweiten Art der Zahlordnung
yv: Bessel-Funktion Yv mit noninteger V
Gebrauch Mathe:: Cephes qw (: dists);
Importe

bdtr: Binomiale Verteilung
bdtrc: Ergägenzte binomiale Verteilung
bdtri: Umgekehrte binomiale Verteilung
btdtr: Betaverteilung
chdtr: Chi-Quadrat Verteilung
chdtrc: Ergägenzte Chi-Quadrat Verteilung
chdtri: Gegenteil der ergägenzten Chi-Quadrat Verteilung
fdtr: F-Verteilung
fdtrc: Ergägenzte F-Verteilung
fdtri: Gegenteil der ergägenzten F-Verteilung
gdtr: Gamma Verteilungsfunktion
gdtrc: Ergägenzte gamma Verteilungsfunktion
nbdtr: Negative binomiale Verteilung
nbdtrc: Ergägenzte negative binomiale Verteilung
nbdtri: Funktionsgegenteil der negativen binomialen Verteilung
ndtr: Normalverteilungsfunktion
ndtri: Gegenteil der Normalverteilungsfunktion
pdtr: Poisson-Verteilung
pdtrc: Ergägenzte Poisson-Verteilung
pdtri: Umgekehrte Poisson-Verteilung
stdtr: Kursteilnehmert-verteilung
stdtri: Funktionsgegenteil der Kursteilnehmert-verteilung
Gebrauch Mathe:: Cephes qw (: Gamma);
Importe

fac: Faktoren- Funktion
Gamma: Gamma-Funktion
igam: Unvollständiges gamma Integral
igamc: Ergägenztes unvollständiges gamma Integral
igami: Gegenteil des ergägenzten imcomplete gamma Integrals
P/in: Funktion P-/in(Digamma)
rgamma: Wechselseitige Gamma-Funktion
Gebrauch Mathe:: Cephes qw (: betas);
Importe

Beta: Betafunktion
incbet: Unvollständiges Betaintegral
incbi: Gegenteil imcomplete des Betaintegrals
lbeta: Natürlicher Logarithmus von |Beta|
Gebrauch Mathe:: Cephes qw (: elliptics);
Importe

ellie: Unvollständiges elliptisches Integral der zweiten Art
ellik: Unvollständiges elliptisches Integral der ersten Art
ellpe: Elliptisches Integral der zweiten Art beenden
ellpj: Jacobian elliptische Funktionen
ellpk: Elliptisches Integral der ersten Art beenden
Gebrauch Mathe:: Cephes qw (: hypergeometrics);
Importe

hyp2f0: Hypergeometrische Funktion F des Gauß
hyp2f1: Hypergeometrische Funktion F des Gauß
hyperg: Zusammenfließende hypergeometrische Funktion
onef2: Hypergeometrische Funktion 1F2
threef0: Hypergeometrische Funktion 3F0
Gebrauch Mathe:: Cephes qw (: verschieden);
Importe

luftig: Luftige Funktion
bernum: Bernoull'ische Zahlen
dawsn: Dawsons Integral
E-I: Exponentiales Integral
erf: Fehlerfunktion
erfc: Komplementäre Fehlerfunktion
expn: Exponentiales Integral en
fresnl: Fresnel-Integral
plancki: Integral Plancks der Strahlungsformel der schwarzen Karosserie
polylog: Polylogarithm Funktion
shichi: Integrale des hyperbolischen Sinus und des Kosinus
sici: Sinus- und Kosinusintegrale
simpson: Simpsons Richtlinie, zum eines Integrals zu finden
spence: Dilogarithm
struve: Struve Funktion
vecang: Winkel zwischen zwei Vektoren
Zeta: Riemann Zetafunktion von zwei Argumenten
zetac: Riemann Zetafunktion
Gebrauch Mathe:: Cephes qw (: fract);
Importe

new_fract: eine neue Bruchnachricht erstellen
radd: zwei Brüche hinzufügen
rmul: zwei Brüche multiplizieren
rsub: subtracttwo Brüche
rdiv: Brüche der Verteilung zwei
euclid: findet den größten gemeinsamen Teiler

Mathe:: Römisch enthält willkürliche sortierte römische Zahlen und Konvertierung und zu vom Arabisch.

SYNOPSE

Gebrauch Mathe:: Römisches qw (römisch);

$a = neues Mathe:: Römisches MCMLXXIII; # 1973
$b = römisch (MCMLXI); # 1961
Druck $a - $b, „N“; # Drucke XII

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

Druck „$dn“; # Zeichenkette „MCMIC“
Druck $d->as_number (), „N“; # Mathe:: BigInt „+1999“

Mathe:: TotalBuilder:: Common ist eine Perl-Baugruppe mit geläufigen Geräteneinstellungen für Gebäudegesamtmengen.

SYNOPSE

Gebrauch Mathe:: TotalBuilder;
Gebrauch Mathe:: TotalBuilder:: Geläufig;

# Geräte für 952 Pennies
mein %tender = Bau ($Math:: TotalBuilder:: Common:: uk_money_old, 952);

Dieses Paket ist gerade eine Einstellung geläufige Einstellungen Geräte für Gebrauch mit dem Code in Mathe:: TotalBuilder.

Mathe:: Macopt ist eine Perl-Verpackung für macopt++, das eine Bibliothek der verbundenen Steigung ist.

EINBAU

Das Paket kann durch das Standard-Perl-BaugruppenEinbauverfahren eingebaut werden:

Perl Makefile.PL
bilden
Prüfung bilden
bilden einzubauen

Notiert bitte, dass der ursprüngliche „macopt++“ C++ Quellencode in diesem Perl-Paket eingeschlossen ist. Die Staticbindung vermeidet die mögliche $überschneidung zu jeder möglicher pre-installed Version von „macopt++“.

SYNOPSE

strenges verwenden;
Gebrauch Mathe:: Macopt;

&main ();

Vorhauptleitung
{
# einige Einstellungen
mein $N = 10;
mein $epsilon = 0.001;

# das Macopt initialisieren
mein $macopt = neues Mathe:: Macopt:: Unterseite ($N, 0);

# die Funktion und seine Steigung vorbringen
mein $func = Unterseeboot {
mein $x = Schiebung;

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

Rückhol$sum;
};
mein $dfunc = Unterseeboot {
mein $x = Schiebung;

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

Rückhol$g;
};
$macopt->setFunc (&$func);
$macopt->setDfunc (&$dfunc);

# Optimierer using macopt
mein $x = [(1) x ($N)];
$macopt->maccheckgrad ($x, $N, $epsilon, 0);
$macopt->macoptII ($x, $N);

# Anzeige das Resultat
printf „[%s] N“, verbinden (, @$x);
}

Mathe:: Cephes:: Komplex ist eine Perl-Schnittstelle zu den cephes Programmen der komplizierten Zahl.

SYNOPSE

Gebrauch Mathe:: Cephes:: Kompliziertes qw (cmplx);
mein $z1 = cmplx (2.3); # $z1 = 2 + 3 i
mein $z2 = cmplx (3.4); # $z2 = 3 + 4 i
mein $z3 = $z1->radd ($z2); # $z3 = $z1 + $z2