Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages


home | help
Math::Series(3)	      User Contributed Perl Documentation      Math::Series(3)

       Math::Series - Perl extension dealing with mathematic series

	 use Math::Series;
	 my $x_n = Math::Series->new( formula	    => 'n*x',
				      start_value   => 1,
				      iteration_var => 'n',
				      previous_var  => 'x',
				      start_index   => 0,
				      cached	    => 1      );

	 print $x_n->next(), "\n" foreach 0..5;
	 # prints 1, 2,	6, 24...

	 print $x_n->at_index(3);
	 # prints 24

       Math::Series defines a class for	simple mathematic series with a
       recursive definition such as "x_(n+1) = 1 / (x_n	+ 1)". Such a
       recursive definition is treated as a sequence whose elements will be
       added to	form a series. You can refer to	the previous sequence element
       as well as to the current index in the series. Creation of a
       Math::Series object is described	below in the paragraph about the

       Math::Series uses Math::Symbolic	to parse and modify the	recursive
       sequence	definitions. That means	you specify the	sequence as a string
       which is	parsed by Math::Symbolic. Alternatively, you can pass the
       constructor a Math::Symbolic tree directly.

       Because Math::Series uses Math::Symbolic	for its	implementation,	all
       results will be Math::Symbolic objects which may	contain	other
       variables than the sequence variable and	the iterator variable.

       Each Math::Series object	is an iterator to iterate over the elements of
       the series starting at the first	element	(which was specified by	the
       starting	element, the second argument to	the new() constructor).	It
       offers facilities to cache all calculated elements and access any
       element directly, though	unless the element has been cached in a
       previous	calculation, this is just a shortcut for repeated use of the

       Every element in	the series may only access its predecessor, not	the
       elements	before that.

       Math::Series defines the	following package variables:

	 This scalar contains a	Parse::RecDescent parser to parse formulas.
	 It is derived from the	Math::Symbolic::Parser grammar.

	 This scalar indicates whether Math::Series should warn	about the
	 performance implications of using the back() method on	uncached
	 series. It defaults to	true.

	 The constructor for Math::Series objects. It takes named parameters.
	 The following parameters are required:

	   The formula is the recursive	definition of a	sequence whose
	   elements up to the current element will be summed to	form the
	   current element of the series.  The formula may contain various
	   Math::Symbolic variables that are assigned a	value elsewhere	in
	   your	code, but it may also contain two special variables: The
	   number of the current iteration step, starting with 0, and the
	   previous element of the series.

	   The formula may be specified	as a string that can be	parsed by a
	   Math::Symbolic parser or as a Math::Symbolic	tree directly. Please
	   refer to the	Math::Symbolic and Math::Symbolic::Parser man pages
	   for details.

	   This	parameter defines the starting value for the series. It	used
	   as the element in the series	that is	defined	as the lowest series
	   element by the start_index parameter.  The starting value may be a
	   string that can be parsed as	a valid	Math::Symbolic tree or a
	   preconstructed Math::Symbolic tree.

	 The following parameters are optional:

	   The iteration variable is the name of the variable in the
	   Math::Symbolic tree that refers to the current iteration step. It
	   defaults to the variable 'n'.

	   It must be a	valid Math::Symbolic variable identifier. (That	means
	   it is "/[A-Za-z][A-Za-z0-9_]*/".)

	   The previous_var parameter sets the name of the variable that
	   represents the previous iteration step. It defaults to the name 'x'
	   and must be a valid Math::Symbolic variable identifier just like
	   the iteration variable.

	   This	parameter indicates whether or not to cache the	calculated
	   series' elements for	faster direct access. It defaults to true. At
	   run-time, the caching behaviour may be altered using	the cached()

	   The lower boundary for the series' summation. It defaults to	0, but
	   may be set to any positive integer or zero.

	 The next() method returns the next element of the series and advances
	 the iterator by one. This is the prefered method of walking down a
	 series' recursion.

	 Returns a true	value if the series is currently being cached, false
	 if it isn't. By default, new objects have caching enabled. It is
	 suggested that	you only disable caching if space is an	issue and you
	 will only walk	the series uni-directionally and only once.

	 cached() can be used to change	the caching behaviour. If the first
	 argument is true, caching will	be enabled. If it is false, caching
	 will be disabled.

	 Returns the index of the current element. That	is, the	index of the
	 element that will be returned by the next call	to the next() method.

	 This method also allows (re-)setting the element that will be next
	 returned by the next()	method.	In that	case, the first	argument
	 shoudl	be the appropriate index.

	 Returns undef and doesn't set the current index if the	argument is
	 below 0.

	 This method returns the series	element	with the index denoted by the
	 first argument	to the method. It does not change the state of the
	 iterator.  This method	is extremely slow for uncached series.

	 Returns undef for indices below the starting index.

	 This methods returns the series element previously returned by	the
	 next()	method.	Since it is extremely slow on uncached series, it
	 warns about this performance hit by default. To turn this warning
	 off, set the $Math::Series::warnings scalar to	a false	value.

	 This method decrements	the current iterator series element.

	 Returns undef if the current index goes below the starting index.

       Steffen Mueller,	<series-module at steffen-mueller dot net<gt>

       You may find the	current	versions of this module	at or on CPAN.

       This module is based on Math::Sequence.	Math::Symbolic and
       Math::Symbolic::Parser for the kinds of formulas	accepted by

perl v5.24.1			  2004-02-24		       Math::Series(3)


Want to link to this manual page? Use this URL:

home | help