case 5:
			delete pns;
			pns = new Pentagonal( 1, 8 );
			break;
		default:
			delete pns;
			return;
		}

          elem_val = pns->elem( pos );
          display( cout, *pns, pos, elem_val );
		  cout << pns->what_am_i() << " : ( " 
			   << pns->beg_pos()   << ", "
			   << pns->length()    << " ) : "
			   << *pns;
		  cout << endl;

		  pns->set_length( 12 );
		  cout << *pns << endl;

		  cout << "num_sequence::is_elem() ";
		  if ( ! pns->is_elem( elem_val ) ||
			     pns->is_elem( 2*elem_val ))
				 cout << "failed\n";
		  else cout << "ok!\n";

		  cout << "copy constructor and equality ";
		  num_sequence *pns2 = pns->clone();
		  if ( *pns != *pns2 )
			   cout << "failed!\n";
		  else cout << "ok!\n";

		  pns2->set_position( 5 );
 
		  int posit = pns->pos_elem( elem_val );
		  if ( pns->pos_elem( elem_val ) != pos )
	           cout << "pos_elem() failed : " << posit << "\n";
		  else cout << "pos_elem() -- ok: " << posit << "\n";

		  posit = pns->pos_elem( elem_values[ix] );
          if ( posit != find_pos ) 
			   cout << "pos_elem(): not found but grown: failed: " 
			        << posit << " correct: " << find_pos << "\n";
		  else cout << "pos_elem(): not found but grown: ok\n";

		  cout << "about to print final ns vector: \n";
		  pns->print();
		  cout << endl;
		  
		  cout << "ns2: should begin at position 5:\n" << *pns2 << endl;
	}
}

// derived class implementations
// normally would go in a program text file: .cpp

vector<unsigned int> Fibonacci::_elems;
vector<unsigned int> Pell::_elems;
vector<unsigned int> Lucas::_elems;
vector<unsigned int> Triangular::_elems;
vector<unsigned int> Square::_elems;
vector<unsigned int> Pentagonal::_elems;

bool num_sequence::
check_integrity( int pos, int size ) const
{
	if ( pos <= 0 || pos > _max_elems )
	{
		 cerr << "!! invalid position: " << pos
			  << " Cannot honor request\n";
		 return false;
	}

	if ( pos > size )
		 gen_elems( pos );

	return true;
}
			 
unsigned int Fibonacci::
elem( int pos ) const 
{
	    if ( ! check_integrity( pos, _elems.size() ))
			 return 0;

		return _elems[ pos-1 ];
}

unsigned int Pell::
elem( int pos ) const 
{
	    if ( ! check_integrity( pos, _elems.size() ))
			 return 0;

		return _elems[ pos-1 ];
}

unsigned int Lucas::
elem( int pos ) const 
{
	    if ( ! check_integrity( pos, _elems.size() ))
			 return 0;

		return _elems[ pos-1 ];
}

unsigned int Triangular::
elem( int pos ) const 
{
	    if ( ! check_integrity( pos, _elems.size() ))
			 return 0;

		return _elems[ pos-1 ];
}

unsigned int Square::
elem( int pos ) const 
{
	    if ( ! check_integrity( pos, _elems.size() ))
			 return 0;

		return _elems[ pos-1 ];
}

unsigned int Pentagonal::
elem( int pos ) const 
{
	    if ( ! check_integrity( pos, _elems.size() ))
			 return 0;

		return _elems[ pos-1 ];
}

ostream& Fibonacci:: 
print( ostream &os ) const
{
	int elem_pos = _beg_pos-1;
	int end_pos = elem_pos + _length;

    if ( end_pos > _elems.size() )
		 Fibonacci::gen_elems( end_pos );

	 os << "( "
	    << _beg_pos << " , "
	    << _length << " ) ";

	while ( elem_pos < end_pos )
		     os << _elems[ elem_pos++ ] << ' ';

	return os;
}

ostream& Pell::print( ostream &os ) const
{
	int elem_pos = _beg_pos-1;
	int end_pos = elem_pos + _length;

    if ( end_pos > _elems.size() )
		  Pell::gen_elems( end_pos );

	 os << "( "
	    << _beg_pos << " , "
	    << _length << " ) ";

	while ( elem_pos < end_pos )
		     os << _elems[ elem_pos++ ] << ' ';

	return os;
}

ostream& Lucas::print( ostream &os ) const 
{
	int elem_pos = _beg_pos-1;
	int end_pos = elem_pos + _length;

    if ( end_pos > _elems.size() )
		 Lucas::gen_elems( end_pos );

	 os << "( "
	    << _beg_pos << " , "
	    << _length << " ) ";

	while ( elem_pos < end_pos )
		     os << _elems[ elem_pos++ ] << ' ';

	return os;
}

ostream& Triangular::print( ostream &os ) const 
{
	int elem_pos = _beg_pos-1;
	int end_pos = elem_pos + _length;

    if ( end_pos > _elems.size() )
		 Triangular::gen_elems( end_pos );

	 os << "( "
	    << _beg_pos << " , "
	    << _length << " ) ";

	while ( elem_pos < end_pos )
		     os << _elems[ elem_pos++ ] << ' ';

	return os;
}

ostream& Square::print( ostream &os ) const 
{
	int elem_pos = _beg_pos-1;
	int end_pos = elem_pos + _length;

    if ( end_pos > _elems.size() )
		 Square::gen_elems( end_pos );

	 os << "( "
	    << _beg_pos << " , "
	    << _length << " ) ";

	while ( elem_pos < end_pos )
		     os << _elems[ elem_pos++ ] << ' ';

	return os;
}

ostream& Pentagonal::print( ostream &os ) const 
{
	int elem_pos = _beg_pos-1;
	int end_pos = elem_pos + _length;

    if ( end_pos > _elems.size() )
		 Pentagonal::gen_elems( end_pos );

	 os << "( "
	    << _beg_pos << " , "
	    << _length << " ) ";

	while ( elem_pos < end_pos )
		     os << _elems[ elem_pos++ ] << ' ';

	return os;
}

void Fibonacci::
gen_elems( int pos ) const
{   
	if ( pos <= 0 || pos > max_elems() )
		 return;

    if ( _elems.empty() )
       { _elems.push_back( 1 ); _elems.push_back( 1 ); }

    if ( _elems.size() <= pos )
	{
		    int ix = _elems.size();
			int n_2 = _elems[ ix-2 ], 
				n_1 = _elems[ ix-1 ];

			int elem;
			for ( ; ix <= pos; ++ix ){
				    elem = n_2 + n_1; 
					// cout << "gen_elems: " << elem << endl;
					_elems.push_back( elem );
					n_2 = n_1; n_1 = elem;
			}
	 }
}
   
void Pell::
gen_elems( int pos ) const    
{    
	if ( pos <= 0 || pos > max_elems() )
		 return;

    if ( _elems.empty() )
       {  _elems.push_back( 1 ); _elems.push_back( 2 ); }

    if ( _elems.size() <= pos )
	{
		    int ix = _elems.size();
			int n_2 = _elems[ ix-2 ], 
				n_1 = _elems[ ix-1 ];

			int elem;
			for ( ; ix <= pos; ++ix ){
				    elem = n_2 + 2 * n_1; 
					_elems.push_back( elem );
					n_2 = n_1; n_1 = elem;
			}
	 }
}
   
void Lucas::
gen_elems( int pos ) const
{     
	if ( pos <= 0 || pos > max_elems() )
		 return;

    if ( _elems.empty() )
       {  _elems.push_back( 1 ); _elems.push_back( 3 ); }

    if ( _elems.size() <= pos )
	{
		    int ix = _elems.size();
			int n_2 = _elems[ ix-2 ], 
				n_1 = _elems[ ix-1 ];

			int elem;
			for ( ; ix <= pos; ++ix ){
				    elem = n_2 +  n_1; 
					_elems.push_back( elem );
					n_2 = n_1; n_1 = elem;
			}
	 }
}    

void Triangular::
gen_elems( int pos ) const
{
	if ( pos <= 0 || pos > max_elems() )
		 return;

    if ( _elems.size() <= pos )
	{
		int end_pos = pos+1;
		int ix = _elems.size()+1;
		cout << "tri: ix: " << ix << " pos: " << pos << endl;
		for ( ; ix <= end_pos; ++ix )
			  _elems.push_back( ix*(ix+1)/2 );
	}
}

void Square::
gen_elems( int pos ) const
{
 	if ( pos <= 0 || pos > max_elems() )
		 return;

    if ( _elems.size() <= pos )
	{
		int end_pos = pos + 1;
		int ix = _elems.size()+1;
		for ( ; ix <= end_pos; ++ix )
			  _elems.push_back( ix*ix );
	}
}   
    
void Pentagonal::
gen_elems( int pos ) const
{
 	if ( pos <= 0 || pos > max_elems() )
		 return;

    if ( _elems.size() <= pos )
	{
		int end_pos = pos + 1;
		int ix = _elems.size()+1;
		for ( ; ix <= end_pos; ++ix )
			  _elems.push_back( ix*(3*ix-1)/2 );
	}
}

bool Fibonacci::
operator==( const num_sequence &rhs ) const 
{
	return ( _beg_pos == rhs.beg_pos() ) &&
		   ( _length  == rhs.length() );
}

bool Fibonacci::
operator !=( const num_sequence &rhs ) const 
{ return ! ( *this == rhs ); }

void Fibonacci::
set_position( int pos )
{
	if ( pos <= 0 || pos > _max_elems ){
		 cerr << "!! invalid position: " << pos 
			  << " setting pos to default value of 1\n"
			  << "If inadequate, invoke set_position(pos)\n";
		 pos = 1;
	}
	_beg_pos = pos;
}

void Fibonacci::
set_length( int len )
{
	if ( len <= 0 || len + _beg_pos - 1 > _max_elems ){
		 cerr << "!! invalid length for this object: " << len 
			  << " setting length to default value of 1\n"
			  << "If inadequate, invoke set_length(len)\n";
	     len = 1;
	}
	_length = len;
}

bool Lucas::
operator==( const num_sequence &rhs ) const 
{
	return ( _beg_pos == rhs.beg_pos() ) &&
		   ( _length  == rhs.length() );
}

bool Lucas::
operator !=( const num_sequence &rhs ) const 
{ return ! ( *this == rhs ); }

void Lucas::
set_position( int pos )
{
	if ( pos <= 0 || pos > _max_elems ){
		 cerr << "!! invalid position: " << pos 
			  << " setting pos to default value of 1\n"
			  << "If inadequate, invoke set_position(pos)\n";
		 pos = 1;
	}
	_beg_pos = pos;
}

void Lucas::
set_length( int len )
{
	if ( len <= 0 || len + _beg_pos - 1 > _max_elems ){
		 cerr << "!! invalid length for this object: " << len 
			  << " setting length to default value of 1\n"
			  << "If inadequate, invoke set_length(len)\n";
	     len = 1;
	}
	_length = len;
}

bool Pell::
operator==( const num_sequence &rhs ) const 
{
	return ( _beg_pos == rhs.beg_pos() ) &&
		   ( _length  == rhs.length() );
}

bool Pell::
operator !=( const num_sequence &rhs ) const