| Sponsored Links | ||||||||||||||
|
| ||||||||||||||
|
Collapse All
|
||||||||||||||
| Software Name | Software Type | Category | Price | |||||||||||
| 1 | Math::NumberCruncher 5.00 |
linux | Programming->Libraries | Free |
View Detail
|
|||||||||
Math::NumberCruncher Perl module contains a collection of useful math-related functions. SYNOPSIS It should be noted that as of v4.0, there is now an OO interface to Math::NumberCruncher. For backwards compatibility, however, the previous, functional style will always be supported. # OO Style use Math::NumberCruncher; $ref = Math::NumberCruncher->new(); # From this point on, all of the subroutines shown below will be available # through $ref (i.e., ( $high,$low ) = $ref->Range( @array )). For the sake # of brevity, consult the functional documentation (below) for the use # of specific functions. # Functional Style use Math::NumberCruncher; ($high, $low) = Math::NumberCruncher::Range(@array); $mean = Math::NumberCruncher::Mean(@array); $median = Math::NumberCruncher::Median(@array [, $decimal_places]); $odd_median = Math::NumberCruncher::OddMedian(@array); $mode = Math::NumberCruncher::Mode(@array); $covariance = Math::NumberCruncher::Covariance(@array1, @array2); $correlation = Math::NumberCruncher::Correlation(@array1, @array2); ($slope, $y_intercept) = Math::NumberCruncher::BestFit(@array1, @array2 [, $decimal_places]); $distance = Math::NumberCruncher::Distance($x1,$y1,$z1,$x2,$y2,$z2 [, $decimal_places]); $distance = Math::NumberCruncher::Distance($x1,$y1,$x1,$x2 [, $decimal_places]); $distance = Math::NumberCruncher::ManhattanDistance($x1,$y1,$x2,$y2); $probAll = Math::NumberCruncher::AllOf(0.3,0.25,0.91,0.002); $probNone = Math::NumberCruncher::NoneOf(0.4,0.5772,0.212); $probSome = Math::NumberCruncher::SomeOf(0.11,0.56,0.3275); $factorial = Math::NumberCruncher::Factorial($some_number); $permutations = Math::NumberCruncher::Permutation($n); $permutations = Math::NumberCruncher::Permutation($n,$k); $roll = Math::NumberCruncher::Dice(3,12,4); $randInt = Math::NumberCruncher::RandInt(10,50); $randomElement = Math::NumberCruncher::RandomElement(@array); Math::NumberCruncher::ShuffleArray(@array); @unique = Math::NumberCruncher::Unique(@array); @a_only = Math::NumberCruncher::Compare(@a,@b); @union = Math::NumberCruncher::Union(@a,@b); @intersection = Math::NumberCruncher::Intersection(@a,@b); @difference = Math::NumberCruncher::Difference(@a,@b); $gaussianRand = Math::NumberCruncher::GaussianRand(); $ways = Math::NumberCruncher::Choose($n,$k); $binomial = Math::NumberCruncher::Binomial($attempts,$successes,$probability); $gaussianDist = Math::NumberCruncher::GaussianDist($x,$mean,$variance); $StdDev = Math::NumberCruncher::StandardDeviation(@array [, $decimal_places]); $variance = Math::NumberCruncher::Variance(@array [, $decimal_places]); @scores = Math::NumberCruncher::StandardScores(@array [, $decimal_places]); $confidence = Math::NumberCruncher::SignSignificance($trials,$hits,$probability); $e = Math::Numbercruncher::EMC2( "m512", "miles" [, $decimal_places] ); $m = Math::NumberCruncher::EMC2( "e987432" "km" [, $decimal_places] ); $force = Math::NumberCruncher::FMA( "m12", "a73.5" [, $decimal_places] ); $mass = Math::NumberCruncher::FMA( "a43", "f1324" [, $decimal_places] ); $acceleration = Math::NumberCruncher::FMA( "f53512", "m356" [, $decimal_places] ); $predicted_value = Math::NubmerCruncher::Predict( $slope, $y_intercept, $proposed_x [, $decimal_places] ); $area = Math::NumberCruncher::TriangleHeron( $a, $b, $c [, $decimal_places] ); $area = Math::NumberCruncher::TriangleHeron( 1,3, 5,7, 8,2 [, $decimal_places] ); $perimeter = Math::NumberCruncher::PolygonPerimeter( $x0,$y0, $x1,$y1, $x2,$y2, ... [, p$decimal_places]); $direction = Math::NumberCruncher::Clockwise( $x0,$y0, $x1,$y1, $x2,$y2 ); $collision = Math::NumberCruncher::InPolygon( $x, $y, @xy ); @points = Math::NumberCruncher::BoundingBox_Points( $d, @p ); $in_triangle = Math::NumberCruncher::InTriangle( $x,$y, $x0,$y0, $x1,$y1, $x2,$y2 ); $area = Math::NumberCruncher::PolygonArea( 0, 1, 1, 0, 2, 0, 3, 2, 2, 3 [, p$decimal_places] ); $area = Math::NumberCruncher::CircleArea( $diameter [, $decimal_places] ); $circumference = Math::NumberCruncher::Circumference( $diameter [, $decimal_places] ); $volume = Math::NumberCruncher::SphereVolume( $radius [, $decimal_places] ); $surface_area = Math::NumberCruncher::SphereSurface( $radius [, $decimal_places] ); $years = Math::NumberCruncher::RuleOf72( $interest_rate [, $decimal_places] ); $volume = Math::NumberCruncher::CylinderVolume( $radius, $height [, $decimal_places] ); $volume = Math::NumberCruncher::ConeVolume( $lowerBaseArea, $height [, $decimal_places] ); $radians = Math::NumberCruncher::deg2rad( $degrees [, $decimal_places] ); $degrees = Math::NumberCruncher::rad2deg( $radians [, $decimal_places] ); $Fahrenheit = Math::NumberCruncher::C2F( $Celsius [, $decimal_places] ); $Celsius = Math::NumberCruncher::F2C( $Fahrenheit [, $decimal_places] ); $cm = Math::NumberCruncher::in2cm( $inches [, $decimal_places] ); $inches = Math::NumberCruncher::cm2in( $cm [, $decimal_places] ); $ft = Math::NumberCruncher::m2ft( $m [, $decimal_places] ); $m = Math::NumberCruncher::ft2m( $ft [, $decimal_places] ); $miles = Math::NumberCruncher::km2miles( $km [, $decimal_places] ); $km = Math::NumberCruncher::miles2km( $miles [, $decimal_places] ); $lb = Math::NumberCruncher::kg2lb( $kg [, $decimal_places] ); $kg = Math::NumberCruncher::lb2kg( $lb [, $decimal_places] ); $RelativeStride = Math::NumberCruncher::RelativeStride( $stride_length, $leg_length [, $decimal_places] ); $RelativeStride = Math::NumberCruncher::RelativeStride_2( $DimensionlessSpeed [, $decimal_places] ); $DimensionlessSpeed = Math::NumberCruncher::DimensionlessSpeed( $RelativeStride [, $decimal_places] ); $DimensionlessSpeed = Math::NumberCruncher::DimensionlessSpeed_2( $ActualSpeed, $leg_length [, $decimal_places]); $ActualSpeed = Math::NumberCruncher::ActualSpeed( $leg_length, $DimensionlessSpeed [, $decimal_places] ); $eccentricity = Math::NumberCruncher::Eccentricity( $half_major_axis, $half_minor_axis [, $decimal_places] ); $LatusRectum = Math::NumberCruncher::LatusRectum( $half_major_axis, $half_minor_axis [, $decimal_places] ); $EllipseArea = Math::NumberCruncher::EllipseArea( $half_major_axis, $half_minor_axis [, $decimal_places] ); $OrbitalVelocity = Math::NumberCruncher::OrbitalVelocity( $r, $a, $M [, $decimal_places] ); $sine = Math::NumberCruncher::sin( $x [, $decimal_places] ); $cosine = Math::NumberCruncher::cos( $x [, $decimal_places] ); $tangent = Math::NumberCruncher::tan( $x [, $decimal_places] ); $arcsin = Math::NumberCruncher::asin( $x [, $decimal_places] ); $arccos = Math::NumberCruncher::acos( $x [, $decimal_places] ); $arctan = Math::NumberCruncher::atan( $x [, $decimal_places] ); $cotangent = Math::NumberCruncher::cot( $x [, $decimal_places] ); $arccot = Math::NumberCruncher::acot( $x [, $decimal_places] ); $secant = Math::NumberCruncher::sec( $x [, $decimal_places] ); $arcsec = Math::NumberCruncher::asec( $x [, $decimal_places] ); $cosecant = Math::NumberCruncher::csc( $x [, $decimal_places] ); $arccosecant = Math::NumberCruncher::acsc( $x [, $decimal_places] ); $exsecant = Math::NumberCruncher::exsec( $x [, $decimal_places] ); $versine = Math::NumberCruncher::vers( $x [, $decimal_places] ); $coversine = Math::NumberCruncher::covers( $x [, $decimal_places] ); $haversine = Math::NumberCruncher::hav( $x [, $decimal_places] ); $grouped = Math::NumberCruncher::Commas( $number ); $SqrRoot = Math::NumberCruncher::SqrRoot( $number [, $decimal_places] ); $square_root = Math::NumberCruncher::sqrt( $x [, $decimal_places] ); $root = Math::NumberCruncher::Root( 55, 3 [, $decimal_places] ); $root = Math::NumberCruncher::Root2( 55, 3 [, $decimal_places] ); $log = Math::NumberCruncher::Ln( 100 [, $decimal_places] ); $log = Math::NumberCruncher::log( $num [, $decimal_places] ); $num = Math::NumberCruncher::Exp( 0.111 [, $decimal_places] ); $num = Math::NumberCruncher::exp( $log [, $decimal_places] ); $Pi = Math::NumberCruncher::PICONST( $decimal_places ); $E = Math::NumberCruncher::ECONST( $decimal_places ); ( $A, $B, $C ) = Math::NumberCruncher::PythagTriples( $x, $y [, $decimal_places] ); $z = Math::NumberCruncher::PythagTriplesSeq( $x, $y [, $decimal_places] ); @nums = Math::NumberCruncher::SIS( [$start, $numbers, $increment] ); $inverse = Math::NumberCruncher::Inverse( $number [, $decimal_places] ); @constants = Math::NumberCruncher::CONSTANTS( all [, $decimal_places] ); $bernoulli = Math::NumberCruncher::Bernoulli( $num [, $decimal_places] ); @bernoulli = Math::NumberCruncher::Bernoulli( $num ); |
||||||||||||||
| 2 | Math functions |
script | ASP | Free |
View Detail
|
|||||||||
|
||||||||||||||
| 3 | Dr. Math |
script | PHP | Free |
View Detail
|
|||||||||
|
||||||||||||||
| 4 | Math::BigRat 0.20 |
linux | Programming->Libraries | Free |
View Detail
|
|||||||||
Math::BigRat package arbitrary big rational numbers. SYNOPSIS use Math::BigRat; my $x = Math::BigRat->new(3/7); $x += 5/9; print $x->bstr(),"n"; print $x ** 2,"n"; my $y = Math::BigRat->new(inf); print "$y ", ($y->is_inf ? is : is not) , " infinityn"; my $z = Math::BigRat->new(144); $z->bsqrt(); Math::BigRat complements Math::BigInt and Math::BigFloat by providing support for arbitrary big rational numbers. MATH LIBRARY You can change the underlying module that does the low-level math operations by using: use Math::BigRat try => GMP; Note: This needs Math::BigInt::GMP installed. The following would first try to find Math::BigInt::Foo, then Math::BigInt::Bar, and when this also fails, revert to Math::BigInt::Calc: use Math::BigRat try => Foo,Math::BigInt::Bar; If you want to get warned when the fallback occurs, replace "try" with "lib": use Math::BigRat lib => Foo,Math::BigInt::Bar; If you want the code to die instead, replace "try" with "only": use Math::BigRat only => Foo,Math::BigInt::Bar; |
||||||||||||||
| 5 | Math Kards 1.4 |
windows | Windows Widgets->Widget Miscellaneous | Free |
View Detail
|
|||||||||
Math Kards is a study aid for K6 students. The widget will present you simple math functions (addition, subtraction, multiplication, and division) from 0 to 12 as cards in a deck. Math Kards uses the Macintosh Speech System to read the math fact on each card to the user. Cards can be presented in random, ascending, or descending order. Math Kards is a nice Widget to leaving lying around your daughters or sons desktop. |
||||||||||||||
| 6 | Math::Vec 1.01 |
linux | Programming->Libraries | Free |
View Detail
|
|||||||||
Math::Vec is a Object-Oriented Vector Math Methods in Perl. SYNOPSIS use Math::Vec; $v = Math::Vec->new(0,1,2); or use Math::Vec qw(NewVec); $v = NewVec(0,1,2); @res = $v->Cross([1,2.5,0]); $p = NewVec(@res); $q = $p->Dot([0,1,0]); or use Math::Vec qw(:terse); $v = V(0,1,2); $q = ($v x [1,2.5,0]) * [0,1,0]; NOTICE This module is still somewhat incomplete. If a function does nothing, there is likely a really good reason. Please have a look at the code if you are trying to use this in a production environment. |
||||||||||||||
| 7 | Math::GMPz 0.21 |
linux | Programming->Libraries | Free |
View Detail
|
|||||||||
Math::GMPz is a Perl interface to the GMP librarys integer (mpz) functions. A bignum module utilising the Gnu MP (GMP) library. Basically this module simply wraps nearly all of the integer functions provided by that library. The documentation below extensively plagiarises the documentation at http://swox.com/gmp/manual. See the Math::GMPz test suite for examples of usage. SYNOPSIS use Math::GMPz qw(:mpz :primes :supp); my $string = fa9eeeeeeeeeeeeea1234dcbaef1; my $base = 16; # Create the Math::GMPz object my $bn1 = Rmpz_init_set_str($string, $base); # Create another Math::GMPz object that holds # an initial value of zero, but has enough # memory allocated to store a 131-bit number. # If 131 bits turns out to be insufficient, it # doesnt matter - additional memory is allocated # automatically to Math::GMPz objects as needed # by the GMP library. my $bn2 = Rmpz_init2(131); # Create another Math::GMPz object initialised to 0. my $bn3 = Rmpz_init(); # or use the new() function: my $bn4 = Math::GMPz->new(12345); # Perform some operations ... see FUNCTIONS below. . . # print out the value held by $bn1 (in octal): print Rmpz_get_str($bn1, 8), "n"; # print out the value held by $bn1 (in decimal): print Rmpz_get_str($bn1, 10); # print out the value held by $bn1 (in base 29) # using the (alternative) Rmpz_out_str() # function. (This function doesnt print a newline.) Rmpz_out_str($bn1, 29); |
||||||||||||||
| 8 | Math TRb-8r 1.0 |
windows | Home Shell Desktop->People Screen Savers | Free |
View Detail
|
|||||||||
Math TRb-8r is a screensaver that will let you watch in awe as the amazing Math TRb-8r generates and solves complex math problems right before your eyes. |
||||||||||||||
| 9 | Alans Math 2.0 |
windows | Home Education->Mathematics | Free |
View Detail
|
|||||||||
|
||||||||||||||
| 10 | Math Logic 4.0 |
windows | Home Education->Mathematics | $19.95 |
View Detail
|
|||||||||
|
||||||||||||||
| 11 | Math Crony 1 |
windows | Home Education->Mathematics | $14.95 |
View Detail
|
|||||||||
Math Crony is interactive and user friendly software designed for improving the basic math skills of your children. This tool allows children to practice math at their own pace. The parent is able to guide and monitor the progress of their children without spending any time on managing and grading tests. It is the time the parent spends mentoring combined with practice that helps the child improve. Some of the highlights of this software are: Targeted towards Pre-K thru 3rd grade students. Huge collection of question sets covering Addition, Subtraction, Multiplication and Division. Gradual but varying degree of difficulty. Automatic timing and grading for instant feedback on speed, accuracy and performance. Extensive graphical reports. |
||||||||||||||
| 12 | Math::String 1.27 |
linux | Programming->Libraries | Free |
View Detail
|
|||||||||
Math::String module contains arbitrary sized integers having arbitrary charsets to calculate with key rooms. SYNOPSIS use Math::String; use Math::String::Charset; $a = new Math::String cafebabe; # default a-z $b = new Math::String deadbeef; # a-z print $a + $b; # Math::String "" $a = new Math::String aa; # default a-z $b = $a; $b++; print "$b > $a" if ($b > $a); # prove that ++ makes it greater $b--; print "$b == $a" if ($b == $a); # and that ++ and -- are reverse $d = Math::String->bzero( [0...9] ); # like Math::Bigint $d += Math::String->new ( 9999, [ 0..9 ] ); # Math::String "9999" print "$dn"; # string "00000n" print $d->as_number(),"n"; # Math::BigInt "+11111" print $d->last(5),"n"; # string "99999" print $d->first(3),"n"; # string "111" print $d->length(),"n"; # faster than length("$d"); $d = Math::String->new ( , Math::String::Charset->new ( { minlen => 2, start => [ a..z ], } ); print $d->minlen(),"n"; # print 2 print ++$d,"n"; # print aa |
||||||||||||||
| 13 | Math::NoCarry 1.10 |
linux | Programming->Libraries | Free |
View Detail
|
|||||||||
Math::NoCarry is a Perl extension for no carry arithmetic. SYNOPSIS use Math::NoCarry; my $sum = Math::NoCarry::add( 123, 456 ); my $difference = Math::NoCarry::subtract( 123, 456 ); my $product = Math::NoCarry::multiply( 123, 456 ); No carry arithmetic doesnt allow you to carry digits to the next column. For example, if you add 8 and 4, you normally expect the answer to be 12, but that 1 digit is a carry. In no carry arithmetic you cant do that, so the sum of 8 and 4 is just 2. In effect, this is addition modulo 10 in each column. I discard all of the carry digits in this example: 1234 + 5678 ------ 6802 For multiplication, the result of pair-wise multiplication of digits is the modulo 10 value of their normal, everyday multiplication. 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 Since multiplication and subtraction are actually types of additions, you can multiply and subtract like this as well. No carry arithmetic is both associative and commutative. |
||||||||||||||
| 14 | Math::BaseCalc 1.011 |
linux | Programming->Libraries | Free |
View Detail
|
|||||||||
Math::BaseCalc is a Perl module that can convert numbers between various bases. SYNOPSIS use Math::BaseCalc; my $calc = new Math::BaseCalc(digits => [0,1]); #Binary my $bin_string = $calc->to_base(465); # Convert 465 to binary $calc->digits(oct); # Octal my $number = $calc->from_base(1574); # Convert octal 1574 to decimal This module facilitates the conversion of numbers between various number bases. You may define your own digit sets, or use any of several predefined digit sets. The to_base() and from_base() methods convert between Perl numbers and strings which represent these numbers in other bases. For instance, if youre using the binary digit set [0,1], $calc->to_base(5) will return the string "101". $calc->from_base("101") will return the number 5. To convert between, say, base 7 and base 36, use the 2-step process of first converting to a Perl number, then to the desired base for the result: $calc7 = new Math::BaseCalc(digits=>[0..6]); $calc36 = new Math::BaseCalc(digits=>[0..9,a..z]; $in_base_36 = $calc36->to_base( $calc7->from_base(3506) ); If you just need to handle regular octal & hexdecimal strings, you probably dont need this module. See the sprintf(), oct(), and hex() Perl functions. |
||||||||||||||
| 15 | Math::BigInt 1.87 |
linux | Programming->Libraries | Free |
View Detail
|
|||||||||
Math::BigInt is an arbitrary size integer/float math package. SYNOPSIS use Math::BigInt; # or make it faster: install (optional) Math::BigInt::GMP # and always use (it will fall back to pure Perl if the # GMP library is not installed): # will warn if Math::BigInt::GMP cannot be found use Math::BigInt lib => GMP; # to supress the warning use this: # use Math::BigInt try => GMP; my $str = 1234567890; my @values = (64,74,18); my $n = 1; my $sign = -; # Number creation my $x = Math::BigInt->new($str); # defaults to 0 my $y = $x->copy(); # make a true copy my $nan = Math::BigInt->bnan(); # create a NotANumber my $zero = Math::BigInt->bzero(); # create a +0 my $inf = Math::BigInt->binf(); # create a +inf my $inf = Math::BigInt->binf(-); # create a -inf my $one = Math::BigInt->bone(); # create a +1 my $mone = Math::BigInt->bone(-); # create a -1 my $pi = Math::BigInt->bpi(); # returns 3 # see Math::BigFloat::bpi() $h = Math::BigInt->new(0x123); # from hexadecimal $b = Math::BigInt->new(0b101); # from binary $o = Math::BigInt->from_oct(0101); # from octal # Testing (dont modify their arguments) # (return true if the condition is met, otherwise false) $x->is_zero(); # if $x is +0 $x->is_nan(); # if $x is NaN $x->is_one(); # if $x is +1 $x->is_one(-); # if $x is -1 $x->is_odd(); # if $x is odd $x->is_even(); # if $x is even $x->is_pos(); # if $x >= 0 $x->is_neg(); # if $x < 0 $x->is_inf($sign); # if $x is +inf, or -inf (sign is default +) $x->is_int(); # if $x is an integer (not a float) # comparing and digit/sign extraction $x->bcmp($y); # compare numbers (undef,<0,=0,>0) $x->bacmp($y); # compare absolutely (undef,<0,=0,>0) $x->sign(); # return the sign, either +,- or NaN $x->digit($n); # return the nth digit, counting from right $x->digit(-$n); # return the nth digit, counting from left # The following all modify their first argument. If you want to preserve # $x, use $z = $x->copy()->bXXX($y); See under L # necessary when mixing $a = $b assignments with non-overloaded math. $x->bzero(); # set $x to 0 $x->bnan(); # set $x to NaN $x->bone(); # set $x to +1 $x->bone(-); # set $x to -1 $x->binf(); # set $x to inf $x->binf(-); # set $x to -inf $x->bneg(); # negation $x->babs(); # absolute value $x->bnorm(); # normalize (no-op in BigInt) $x->bnot(); # twos complement (bit wise not) $x->binc(); # increment $x by 1 $x->bdec(); # decrement $x by 1 $x->badd($y); # addition (add $y to $x) $x->bsub($y); # subtraction (subtract $y from $x) $x->bmul($y); # multiplication (multiply $x by $y) $x->bdiv($y); # divide, set $x to quotient # return (quo,rem) or quo if scalar $x->bmuladd($y,$z); # $x = $x * $y + $z $x->bmod($y); # modulus (x % y) $x->bmodpow($exp,$mod); # modular exponentation (($num**$exp) % $mod)) $x->bmodinv($mod); # the inverse of $x in the given modulus $mod $x->bpow($y); # power of arguments (x ** y) $x->blsft($y); # left shift in base 2 $x->brsft($y); # right shift in base 2 # returns (quo,rem) or quo if in scalar context $x->blsft($y,$n); # left shift by $y places in base $n $x->brsft($y,$n); # right shift by $y places in base $n # returns (quo,rem) or quo if in scalar context $x->band($y); # bitwise and $x->bior($y); # bitwise inclusive or $x->bxor($y); # bitwise exclusive or $x->bnot(); # bitwise not (twos complement) $x->bsqrt(); # calculate square-root $x->broot($y); # $yth root of $x (e.g. $y == 3 => cubic root) $x->bfac(); # factorial of $x (1*2*3*4*..$x) $x->bnok($y); # x over y (binomial coefficient n over k) $x->blog(); # logarithm of $x to base e (Eulers number) $x->blog($base); # logarithm of $x to base $base (f.i. 2) $x->bexp(); # calculate e ** $x where e is Eulers number $x->round($A,$P,$mode); # round to accuracy or precision using mode $mode $x->bround($n); # accuracy: preserve $n digits $x->bfround($n); # round to $nth digit, no-op for BigInts # The following do not modify their arguments in BigInt (are no-ops), # but do so in BigFloat: $x->bfloor(); # return integer less or equal than $x $x->bceil(); # return integer greater or equal than $x # The following do not modify their arguments: # greatest common divisor (no OO style) my $gcd = Math::BigInt::bgcd(@values); # lowest common multiplicator (no OO style) my $lcm = Math::BigInt::blcm(@values); $x->length(); # return number of digits in number ($xl,$f) = $x->length(); # length of number and length of fraction part, # latter is always 0 digits long for BigInts $x->exponent(); # return exponent as BigInt $x->mantissa(); # return (signed) mantissa as BigInt $x->parts(); # return (mantissa,exponent) as BigInt $x->copy(); # make a true copy of $x (unlike $y = $x;) $x->as_int(); # return as BigInt (in BigInt: same as copy()) $x->numify(); # return as scalar (might overflow!) # conversation to string (do not modify their argument) $x->bstr(); # normalized string (e.g. 3) $x->bsstr(); # norm. string in scientific notation (e.g. 3E0) $x->as_hex(); # as signed hexadecimal string with prefixed 0x $x->as_bin(); # as signed binary string with prefixed 0b $x->as_oct(); # as signed octal string with prefixed 0 # precision and accuracy (see section about rounding for more) $x->precision(); # return P of $x (or global, if P of $x undef) $x->precision($n); # set P of $x to $n $x->accuracy(); # return A of $x (or global, if A of $x undef) $x->accuracy($n); # set A $x to $n # Global methods Math::BigInt->precision(); # get/set global P for all BigInt objects Math::BigInt->accuracy(); # get/set global A for all BigInt objects Math::BigInt->round_mode(); # get/set global round mode, one of # even, odd, +inf, -inf, zero, trunc or common Math::BigInt->config(); # return hash containing configuration |
||||||||||||||
| 16 | Math::CDF 0.1 |
linux | Programming->Libraries | Free |
View Detail
|
|||||||||
Math::CDF is a Perl module to generate probabilities and quantiles from several statistical probability functions. SYNOPSIS use Math::CDF; $prob = &Math::CDF::pnorm(1.96); if( not defined($z = &Math::CDF::qnorm(0.975)) ) { die "qnorm() failed"; } or use Math::CDF qw(:all); $prob = pnorm(1.96); This module provides a perl interface to the DCDFLIB. See the section on DCDFLIB for more information. Functions are available for 7 continuous distributions (Beta, Chi-square, F, Gamma, Normal, Poisson and T-distribution) and for two discrete distributions (Binomial and Negative Binomial). Optional non-centrality parameters are available for the Chi-square, F and T-distributions. Cumulative probabilities are available for all 9 distributions and quantile functions are available for the 7 continuous distributions. All cumulative probability function names begin with the character "p". They give the probability of being less than or equal to the given value [ P(X <= x) ] All quantile function names begin with the character q. They give a value of x such that P(X <= x) = p where the value of p is provided to the function. Non-centrality parameters are always the last function argument when available. You do not need to supply the non-centrality parameter in which case it will be assumed to be 0. All functions will return an undefined value if the function fails (probably due to parameters being out of allowed range) but will not otherwise generate an error message. The user should check for valid output from the Math::CDF functions with the defined() function as demonstrated in the SYNOPSIS section. |
||||||||||||||
| 17 | Snakey Math 2.2 |
mac | Games->Others | $9 |
View Detail
|
|||||||||
Snakey Math is an educational game combining arithmetic practice with classic arcade action for one to four players. Compete against other players and/or computer-controlled snakes to eat answers to problems. Options include various number ranges, negatives, and mixed reviews. Here are some key features of "Snakey Math": · Arcade experience with lots of color, sound, motion, and music · Four snakes, each of which can be controlled by a player or by the computer · One to four players can enjoy the game on one computer · Negative numbers, mixed reviews, and various ranges for operands are included · Three power-ups for added fun, plus electric switches. Limitations: · Math settings are limited to Multiplication with numbers from 1 to 6. Whats New in This Release: · Adds confirmation when ending a game · other minor improvements. |
||||||||||||||
| 18 | Math square 2 |
windows | Home Education->Kids Parenting | N |
View Detail
|
|||||||||
|
||||||||||||||
| 19 | Math::MagicSquare 2.04 |
linux | Programming->Libraries | Free |
View Detail
|
|||||||||
Math::MagicSquare is a Magic Square Checker and Designer. SYNOPSIS use Math::MagicSquare; $a= Math::MagicSquare -> new ([num,...,num], ..., [num,...,num]); $a->print("string"); $a->printhtml(); $a->printimage(); $a->check(); $a->rotation(); $a->reflection(); The following methods are available: new Constructor arguments are a list of references to arrays of the same length. $a = Math::MagicSquare -> new ([num,...,num], ..., [num,...,num]); check This function can return 4 value 0: the Square is not Magic 1: the Square is a Semimagic Square (the sum of the rows and the columns is equal) 2: the Square is a Magic Square (the sum of the rows, the columns and the diagonals is equal) 3: the Square ia Panmagic Square (the sum of the rows, the columns, the diagonals and the broken diagonals is equal) Prints the Square on STDOUT. If the method has additional parameters, these are printed before the Magic Square is printed. printhtml Prints the Square on STDOUT in an HTML format (exactly a inside a TABLE) printimage Prints the Square on STDOUT in png format. rotation Rotates the Magic Square of 90 degree clockwise reflection Reflect the Magic Square |
||||||||||||||
| 20 | Math::Combinatorics 0.09 |
linux | Programming->Libraries | Free |
View Detail
|
|||||||||
Math::Combinatorics is a Perl module that can perform combinations and permutations on lists. SYNOPSIS Available as an object oriented API. use Math::Combinatorics; my @n = qw(a b c); my $combinat = Math::Combinatorics->new(count => 2, data => [@n], ); print "combinations of 2 from: ".join(" ",@n)."n"; print "------------------------".("--" x scalar(@n))."n"; while(my @combo = $combinat->next_combination){ print join( , @combo)."n"; } print "n"; print "permutations of 3 from: ".join(" ",@n)."n"; print "------------------------".("--" x scalar(@n))."n"; while(my @permu = $combinat->next_permutation){ print join( , @permu)."n"; } output: Or available via exported functions permute, combine, and factorial. use Math::Combinatorics; my @n = qw(a b c); print "combinations of 2 from: ".join(" ",@n)."n"; print "------------------------".("--" x scalar(@n))."n"; print join("n", map { join " ", @$_ } combine(2,@n)),"n"; print "n"; print "permutations of 3 from: ".join(" ",@n)."n"; print "------------------------".("--" x scalar(@n))."n"; print join("n", map { join " ", @$_ } permute(@n)),"n"; Output: combinations of 2 from: a b c ------------------------------ a b a c b c permutations of 3 from: a b c ------------------------------ a b c a c b b a c b c a c a b c b a Output from both types of calls is the same, but the object-oriented approach consumes much less memory for large sets. |
||||||||||||||
My Software
You have not saved any software. Click "Save" next to each software to save it to your software basket
