Math::NumSeq -- number sequences
# only a base class, use one of the actual classes, such as use Math::NumSeq::Squares; my $seq = Math::NumSeq::Squares->new; my ($i, $value) = $seq->next;
This is a base class for some number sequences. Sequence objects can iterate through values and some sequences have random access and/or predicate test.
The idea is to generate things like squares or primes in a generic way. Some sequences, like squares, are so easy there's no need for this except for the genericness. Other sequences are trickier and an iterator is a good way to go through the values.
Sequence values have an integer index "i" starting either from i=0 or i=1 or similar as best suits the sequence. The values themselves can be anything, positive, negative, fractional, etc.
The intention is that all modules Math::NumSeq::Foo are sequence classes, and that supporting things are deeper, such as under Math::NumSeq::Something::Helper or Math::NumSeq::Base::SharedStuff.
Math::NumSeq::Foo
Math::NumSeq::Something::Helper
Math::NumSeq::Base::SharedStuff
The various methods try to support Math::BigInt and similar overloaded number types. So for instance pred() might be applied to test a big value, or ith() on a bigint to preserve precision from some rapidly growing sequence. Infinities and NaNs give nan or infinite returns of some kind (some unspecified kind as yet).
Math::BigInt
pred()
ith()
In the following "Foo" is one of the subclass names.
$seq = Math::NumSeq::Foo->new (key=>value,...)
Create and return a new sequence object.
($i, $value) = $seq->next()
Return the next index and value in the sequence.
$seq->rewind()
Rewind the sequence to its starting point.
$i = $seq->tell_i($i)
Return the current i position. This is the i which the next call to next() will return.
next()
$i = $seq->i_start()
Return the first $i in the sequence. This is the position rewind() returns to.
$i
rewind()
$str = $seq->description()
A human-readable description of the sequence. This might be translated into the locale language (but there's no message translations yet).
$value = $seq->values_min()
$value = $seq->values_max()
Return the minimum or maximum value taken by values in the sequence, or undef if unknown or infinity.
undef
$ret = $seq->characteristic($key)
Return something if the sequence has a $key (a string) characteristic, or undef if not. This is intended as a loose set of features or properties a sequence can have to describe itself.
$key
digits integer or undef, the radix if seq is digits count boolean, true if values are counts of something smaller boolean, true if v[i] < i generally integer boolean, true if all values are integers increasing boolean, true if v[i+1] > v[i] always non_decreasing boolean, true if v[i+1] >= v[i] always increasing_from_i integer, i for which v[i+1] > v[i] non_decreasing_from_i integer, i for which v[i+1] >= v[i] value_is_radix boolean, value is radix for i
value_is_radix means each value is a radix applying to the i index. For example RepdigitRadix gives a value which is a radix where i is a repdigit. Such values might also be 0 or 1 or -1 or some such non-radix to indicate no radix.
value_is_radix
$str = $seq->oeis_anum()
Return the A-number (a string) for $seq in Sloane's Online Encyclopedia of Integer Sequences, or return undef if not in the OEIS or not known. For example
$seq
my $seq = Math::NumSeq::Squares->new; my $anum = $seq->oeis_anum; # gives "A000290"
The web page for that is then
http://oeis.org/A000290
Sometimes the OEIS has duplicates, ie. two A-numbers which are the same sequence. When that's accidental or historical $seq->oeis_anum() is whichever is reckoned the primary one.
$seq->oeis_anum()
$aref = Math::NumSeq::Foo->parameter_info_array()
@list = Math::NumSeq::Foo->parameter_info_list()
Return an arrayref or list describing the parameters taken by a given class. This meant to help making widgets etc for user interaction in a GUI. Each element is a hashref
{ name => parameter key arg for new() share_key => string, or undef description => human readable string type => string "integer","boolean","enum" etc default => value minimum => number, or undef maximum => number, or undef width => integer, suggested display size choices => for enum, an arrayref choices_display => for enum, an arrayref }
type is a string, one of
type
"integer" "enum" "boolean" "string" "filename"
"filename" is separate from "string" since it might require subtly different handling to ensure it reaches Perl as a byte string, whereas a "string" type might in principle take Perl wide chars.
For "enum" the choices field is the possible values, such as
choices
{ name => "flavour", type => "enum", choices => ["strawberry","chocolate"], }
choices_display, if provided, is human-readable strings for those choices, possibly translated into another language (though there's no translations yet).
choices_display
minimum and maximum are omitted (or undef) if there's no hard limit on the parameter.
minimum
maximum
share_key is designed to indicate when parameters from different NumSeq classes can be a single control widget in a GUI etc. Normally the name is enough, but when the same name has slightly different meanings in different classes a share_key allows the same meanings to be matched up.
share_key
name
The following methods are only implemented for some sequences since it's sometimes difficult to generate an arbitrary numbered element etc. Check with $seq->can('ith') etc before using.
$seq->can('ith')
$i = $seq->seek_to_i($i)
$i = $seq->seek_to_value($value)
Move the current i so next() returns $i or $value on the next call. If $value is not in the sequence then move so as to return the next higher value which is.
$value
$value = $seq->ith($i)
Return the $i'th value in the sequence. Only some sequence classes implement this method.
$bool = $seq->pred($value)
Return true if $value occurs in the sequence. For example for the squares this returns true if $value is a square or false if not.
$i = $seq->value_to_i_ceil($value)
$i = $seq->value_to_i_floor($value)
Return the index i of $value, or if $value is not in the sequence then the i of the next higher or lower value which is. These methods usually only make sense for non-decreasing sequences.
$i = $seq->value_to_i_estimate($value)
Return an estimate of the i corresponding to $value.
The accuracy of this estimate is unspecified, but can at least hint at the growth rate of the sequence. For example if making an "intersection" checking for a given values in the sequence then if the estimated i is small it may be fastest to go through the sequence by next() and compare, rather than apply pred() to each target.
Math::NumSeq::Squares, Math::NumSeq::Cubes, Math::NumSeq::Pronic, Math::NumSeq::Triangular, Math::NumSeq::Polygonal, Math::NumSeq::Tetrahedral, Math::NumSeq::StarNumbers, Math::NumSeq::Powerful, Math::NumSeq::PowerPart, Math::NumSeq::PowerFlip
Math::NumSeq::Even, Math::NumSeq::Odd, Math::NumSeq::All, Math::NumSeq::AllDigits, Math::NumSeq::ConcatNumbers, Math::NumSeq::Runs
Math::NumSeq::Primes, Math::NumSeq::TwinPrimes, Math::NumSeq::SophieGermainPrimes, Math::NumSeq::AlmostPrimes, Math::NumSeq::DeletablePrimes, Math::NumSeq::Emirps, Math::NumSeq::MobiusFunction, Math::NumSeq::LiouvilleFunction, Math::NumSeq::DivisorCount, Math::NumSeq::GoldbachCount, Math::NumSeq::LemoineCount, Math::NumSeq::PythagoreanHypots
Math::NumSeq::PrimeFactorCount, Math::NumSeq::AllPrimeFactors
Math::NumSeq::ErdosSelfridgeClass, Math::NumSeq::PrimeIndexOrder, Math::NumSeq::PrimeIndexPrimes
Math::NumSeq::Totient, Math::NumSeq::TotientCumulative, Math::NumSeq::TotientSteps, Math::NumSeq::TotientStepsSum, Math::NumSeq::TotientPerfect, Math::NumSeq::DedekindPsiCumulative, Math::NumSeq::DedekindPsiSteps, Math::NumSeq::Abundant, Math::NumSeq::PolignacObstinate
Math::NumSeq::Factorials, Math::NumSeq::Primorials, Math::NumSeq::Fibonacci, Math::NumSeq::FibonacciWord, Math::NumSeq::LucasNumbers, Math::NumSeq::Fibbinary, Math::NumSeq::FibbinaryBitCount, Math::NumSeq::Pell, Math::NumSeq::Tribonacci, Math::NumSeq::Perrin, Math::NumSeq::SpiroFibonacci
Math::NumSeq::FractionDigits, Math::NumSeq::SqrtDigits, Math::NumSeq::SqrtEngel, Math::NumSeq::SqrtContinued, Math::NumSeq::SqrtContinuedPeriod
Math::NumSeq::DigitCount, Math::NumSeq::DigitCountLow, Math::NumSeq::DigitCountHigh
Math::NumSeq::DigitLength, Math::NumSeq::DigitLengthCumulative, Math::NumSeq::SelfLengthCumulative, Math::NumSeq::DigitProduct, Math::NumSeq::DigitProductSteps, Math::NumSeq::DigitSum, Math::NumSeq::DigitSumModulo, Math::NumSeq::RadixWithoutDigit Math::NumSeq::MaxDigitCount
Math::NumSeq::Palindromes, Math::NumSeq::Beastly, Math::NumSeq::Repdigits, Math::NumSeq::RepdigitAny, Math::NumSeq::RepdigitRadix, Math::NumSeq::UndulatingNumbers, Math::NumSeq::HarshadNumbers, Math::NumSeq::MoranNumbers, Math::NumSeq::HappyNumbers, Math::NumSeq::HappySteps,
Math::NumSeq::CullenNumbers, Math::NumSeq::ProthNumbers, Math::NumSeq::WoodallNumbers, Math::NumSeq::BaumSweet, Math::NumSeq::GolayRudinShapiro, Math::NumSeq::GolayRudinShapiroCumulative, Math::NumSeq::KlarnerRado, Math::NumSeq::UlamSequence, Math::NumSeq::ReRound, Math::NumSeq::ReReplace, Math::NumSeq::LuckyNumbers, Math::NumSeq::MephistoWaltz
Math::NumSeq::CollatzSteps, Math::NumSeq::ReverseAdd, Math::NumSeq::ReverseAddSteps, Math::NumSeq::JugglerSteps, Math::NumSeq::SternDiatomic, Math::NumSeq::NumAronson, Math::NumSeq::HofstadterFigure
Math::NumSeq::Kolakoski, Math::NumSeq::GolombSequence, Math::NumSeq::AsciiSelf, Math::NumSeq::Multiples, Math::NumSeq::Modulo
Math::NumSeq::Expression, Math::NumSeq::File, Math::NumSeq::OEIS
Math::NumSeq::Aronson (in the Math-Aronson dist)
Math::NumSeq::PlanePathCoord, Math::NumSeq::PlanePathDelta, Math::NumSeq::PlanePathTurn (in the Math-PlanePath dist)
Math::Sequence and Math::Series, for symbolic recursive sequence definitions
math-image, for displaying images with the NumSeq sequences
http://user42.tuxfamily.org/math-numseq/index.html
Copyright 2010, 2011, 2012 Kevin Ryde
Math-NumSeq is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version.
Math-NumSeq is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with Math-NumSeq. If not, see <http://www.gnu.org/licenses/>.
To install Math::NumSeq, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Math::NumSeq
CPAN shell
perl -MCPAN -e shell install Math::NumSeq
For more information on module installation, please visit the detailed CPAN module installation guide.