// { dg-do run }
|
// { dg-do run }
|
// GROUPS passed code-generation
|
// GROUPS passed code-generation
|
// code-gen file
|
// code-gen file
|
// From: "David"
|
// From: "David"
|
// Date: Mon, 15 Nov 1993 20:59:14 -0600 (CST)
|
// Date: Mon, 15 Nov 1993 20:59:14 -0600 (CST)
|
// Subject: An error!
|
// Subject: An error!
|
// Message-ID: <9311160259.AA03353@pi14.arc.umn.edu>
|
// Message-ID: <9311160259.AA03353@pi14.arc.umn.edu>
|
|
|
#include
|
#include
|
#include
|
#include
|
#include
|
#include
|
#include
|
#include
|
#include
|
#include
|
#include
|
#include
|
|
|
#define ANSI_C
|
#define ANSI_C
|
|
|
typedef double VEC ;
|
typedef double VEC ;
|
|
|
class Vector;
|
class Vector;
|
|
|
class VectorInt
|
class VectorInt
|
{
|
{
|
public:
|
public:
|
|
|
/* Nothing public!! Only Vector can use this class */
|
/* Nothing public!! Only Vector can use this class */
|
|
|
private:
|
private:
|
|
|
VectorInt( int );
|
VectorInt( int );
|
VectorInt( int, double *, int = 0 );
|
VectorInt( int, double *, int = 0 );
|
VectorInt( const VectorInt & );
|
VectorInt( const VectorInt & );
|
~VectorInt();
|
~VectorInt();
|
|
|
VectorInt *refer();
|
VectorInt *refer();
|
void unrefer();
|
void unrefer();
|
int count; /* Number of Vector's referring to me */
|
int count; /* Number of Vector's referring to me */
|
|
|
VEC *vec;
|
VEC *vec;
|
|
|
friend class Vector;
|
friend class Vector;
|
friend class VecElem;
|
friend class VecElem;
|
};
|
};
|
|
|
class VecElem
|
class VecElem
|
{
|
{
|
public:
|
public:
|
|
|
operator double();
|
operator double();
|
double operator=( double );
|
double operator=( double );
|
|
|
private:
|
private:
|
|
|
VecElem( Vector &, int );
|
VecElem( Vector &, int );
|
VecElem( const VecElem & );
|
VecElem( const VecElem & );
|
|
|
Vector &v;
|
Vector &v;
|
int row; /* Row element refers to */
|
int row; /* Row element refers to */
|
|
|
friend class Vector;
|
friend class Vector;
|
};
|
};
|
|
|
class Vector
|
class Vector
|
{
|
{
|
public:
|
public:
|
|
|
Vector(); // Must be assigned to before used
|
Vector(); // Must be assigned to before used
|
Vector( VectorInt * );
|
Vector( VectorInt * );
|
Vector( int );
|
Vector( int );
|
Vector( int, double *, int beg = 0 );
|
Vector( int, double *, int beg = 0 );
|
Vector( const Vector & );
|
Vector( const Vector & );
|
Vector &operator=( const Vector & );
|
Vector &operator=( const Vector & );
|
~Vector() { if(r) r->unrefer(); }
|
~Vector() { if(r) r->unrefer(); }
|
|
|
int row() const { return 19; }
|
int row() const { return 19; }
|
int dim() const { return 10; }
|
int dim() const { return 10; }
|
|
|
double operator()( int ) const;
|
double operator()( int ) const;
|
VecElem operator()( int );
|
VecElem operator()( int );
|
|
|
double assign( int, double );
|
double assign( int, double );
|
|
|
friend std::ostream& operator<<(std::ostream&, const Vector& m );
|
friend std::ostream& operator<<(std::ostream&, const Vector& m );
|
|
|
private:
|
private:
|
|
|
VectorInt *r; /* Reference to real data */
|
VectorInt *r; /* Reference to real data */
|
|
|
friend class VecElem;
|
friend class VecElem;
|
friend class LUDecom;
|
friend class LUDecom;
|
friend class SVD;
|
friend class SVD;
|
};
|
};
|
|
|
|
|
Vector::
|
Vector::
|
Vector()
|
Vector()
|
: r(0)
|
: r(0)
|
{}
|
{}
|
|
|
Vector::
|
Vector::
|
Vector( VectorInt *vi )
|
Vector( VectorInt *vi )
|
: r(vi)
|
: r(vi)
|
{
|
{
|
r->refer();
|
r->refer();
|
}
|
}
|
|
|
Vector::
|
Vector::
|
Vector( int row )
|
Vector( int row )
|
{
|
{
|
assert( row > 0 );
|
assert( row > 0 );
|
|
|
r = new VectorInt( row );
|
r = new VectorInt( row );
|
|
|
r->refer();
|
r->refer();
|
}
|
}
|
|
|
Vector::
|
Vector::
|
Vector( int row, double *d, int beg )
|
Vector( int row, double *d, int beg )
|
{
|
{
|
assert( row > 0 );
|
assert( row > 0 );
|
|
|
r = new VectorInt( row, d, beg );
|
r = new VectorInt( row, d, beg );
|
|
|
r->refer();
|
r->refer();
|
}
|
}
|
|
|
Vector::
|
Vector::
|
Vector( const Vector &A )
|
Vector( const Vector &A )
|
: r( A.r->refer() )
|
: r( A.r->refer() )
|
{}
|
{}
|
|
|
Vector& Vector::
|
Vector& Vector::
|
operator=( const Vector &A )
|
operator=( const Vector &A )
|
{
|
{
|
if( r )
|
if( r )
|
r->unrefer();
|
r->unrefer();
|
|
|
r = A.r->refer();
|
r = A.r->refer();
|
|
|
return *this;
|
return *this;
|
}
|
}
|
|
|
double Vector::
|
double Vector::
|
operator()( int row ) const
|
operator()( int row ) const
|
{
|
{
|
assert(r != 0);
|
assert(r != 0);
|
|
|
return *r->vec;
|
return *r->vec;
|
}
|
}
|
|
|
VecElem Vector::
|
VecElem Vector::
|
operator()( int r )
|
operator()( int r )
|
{
|
{
|
assert(r != 0);
|
assert(r != 0);
|
|
|
return VecElem( *this, r );
|
return VecElem( *this, r );
|
}
|
}
|
|
|
/* assign changes the matrix, it does not create a new one! */
|
/* assign changes the matrix, it does not create a new one! */
|
double Vector::
|
double Vector::
|
assign( int rownum, double d )
|
assign( int rownum, double d )
|
{
|
{
|
assert(r != 0);
|
assert(r != 0);
|
|
|
if( rownum > row() || rownum <= 0 ) {
|
if( rownum > row() || rownum <= 0 ) {
|
std::cerr << "Warning: trying to assign out of bounds" << std::endl;
|
std::cerr << "Warning: trying to assign out of bounds" << std::endl;
|
std::cerr << "row " << rownum << std::endl;
|
std::cerr << "row " << rownum << std::endl;
|
std::cerr << "Vector size " << row() << std::endl;
|
std::cerr << "Vector size " << row() << std::endl;
|
std::abort();
|
std::abort();
|
}
|
}
|
|
|
if( r->count == 1 ) {
|
if( r->count == 1 ) {
|
/* Don't need to create a new matrix, since we are the only */
|
/* Don't need to create a new matrix, since we are the only */
|
/* one pointing to ours */
|
/* one pointing to ours */
|
}
|
}
|
else {
|
else {
|
VectorInt *vi = new VectorInt( *r );
|
VectorInt *vi = new VectorInt( *r );
|
r->unrefer();
|
r->unrefer();
|
r = vi->refer();
|
r = vi->refer();
|
}
|
}
|
|
|
return d;
|
return d;
|
}
|
}
|
|
|
|
|
VectorInt::
|
VectorInt::
|
VectorInt( int sx )
|
VectorInt( int sx )
|
: vec( new double[sx] ), count(0)
|
: vec( new double[sx] ), count(0)
|
{ }
|
{ }
|
|
|
VectorInt::
|
VectorInt::
|
VectorInt( int sx, double *, int )
|
VectorInt( int sx, double *, int )
|
: vec( new double[sx] ), count(0)
|
: vec( new double[sx] ), count(0)
|
{
|
{
|
}
|
}
|
|
|
VectorInt::
|
VectorInt::
|
VectorInt( const VectorInt & )
|
VectorInt( const VectorInt & )
|
: vec( new double[10] ), count(0)
|
: vec( new double[10] ), count(0)
|
{
|
{
|
}
|
}
|
|
|
VectorInt * VectorInt::
|
VectorInt * VectorInt::
|
refer()
|
refer()
|
{
|
{
|
count ++;
|
count ++;
|
return this;
|
return this;
|
|
|
// cout << "Refering vec" << endl;
|
// cout << "Refering vec" << endl;
|
}
|
}
|
|
|
void VectorInt::
|
void VectorInt::
|
unrefer()
|
unrefer()
|
{
|
{
|
count--;
|
count--;
|
|
|
if( count == 0 ) {
|
if( count == 0 ) {
|
delete this;
|
delete this;
|
}
|
}
|
|
|
// cout << "Unrefering vec" << endl;
|
// cout << "Unrefering vec" << endl;
|
}
|
}
|
|
|
VectorInt::
|
VectorInt::
|
~VectorInt()
|
~VectorInt()
|
{
|
{
|
delete vec;
|
delete vec;
|
vec = 0;
|
vec = 0;
|
}
|
}
|
|
|
VecElem::
|
VecElem::
|
VecElem( Vector &vec, int r )
|
VecElem( Vector &vec, int r )
|
: v(vec), row(r)
|
: v(vec), row(r)
|
{
|
{
|
if( r < 1 || r > vec.row() ) {
|
if( r < 1 || r > vec.row() ) {
|
std::cerr << "Trying to access vector element out of bounds";
|
std::cerr << "Trying to access vector element out of bounds";
|
std::cerr << std::endl;
|
std::cerr << std::endl;
|
std::abort();
|
std::abort();
|
}
|
}
|
}
|
}
|
|
|
VecElem::
|
VecElem::
|
VecElem( const VecElem &elem )
|
VecElem( const VecElem &elem )
|
: v(elem.v), row(elem.row)
|
: v(elem.v), row(elem.row)
|
{}
|
{}
|
|
|
VecElem::
|
VecElem::
|
operator double()
|
operator double()
|
{
|
{
|
assert( v.r->vec != 0 );
|
assert( v.r->vec != 0 );
|
return *v.r->vec;
|
return *v.r->vec;
|
}
|
}
|
|
|
double VecElem::
|
double VecElem::
|
operator=( double d )
|
operator=( double d )
|
{
|
{
|
return v.assign( row, d );
|
return v.assign( row, d );
|
}
|
}
|
|
|
|
|
|
|
|
|
|
|
int makeforms( Vector cen, Vector **a, Vector **b );
|
int makeforms( Vector cen, Vector **a, Vector **b );
|
|
|
int main()
|
int main()
|
{
|
{
|
Vector *a[8], *b[8], disp(3);
|
Vector *a[8], *b[8], disp(3);
|
Vector cen(3), cen2(3);
|
Vector cen(3), cen2(3);
|
int i, j;
|
int i, j;
|
|
|
if (makeforms (cen,a,b) != 10)
|
if (makeforms (cen,a,b) != 10)
|
{ std::printf ("FAIL\n"); return 1; }
|
{ std::printf ("FAIL\n"); return 1; }
|
else
|
else
|
std::printf ("PASS\n");
|
std::printf ("PASS\n");
|
|
|
|
|
}
|
}
|
|
|
int
|
int
|
makeforms( Vector cen, Vector **a, Vector **b)
|
makeforms( Vector cen, Vector **a, Vector **b)
|
{
|
{
|
return 10;
|
return 10;
|
}
|
}
|
|
|
|
|
|
|
|
|
