This is the mail archive of the
gcc-bugs@gcc.gnu.org
mailing list for the GCC project.
Internal Compiler Error
- To: gcc-bugs at gcc dot gnu dot org
- Subject: Internal Compiler Error
- From: Doug Warner <warner at vexcel dot com>
- Date: Sun, 9 Jul 2000 11:06:15 -0600
- Organization: Vexcel Corporation
Hi,
I just got an internal compiler error for some of my code that used to
compile fine with egcs. The verbose output is below and the preprocessed
source is attached.
Best regards,
Doug Warner
====================================================
Doug Warner, PhD Research Scientist
Vexcel Corporation - Image Information Engineering
4909 Nautilus Court voice: (303) 583-0218
Boulder CO 80301, USA fax: (303) 444-0470
http://www.vexcel.com
====================================================
c++ -v --save-temps -I. -I../ -I../VxNumerics -I../spline -I../reg -I../optim -c -o Affine_Map2.o Affine_Map2.cc
Reading specs from /pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/specs
gcc version 2.95.2 19991024 (release)
/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/cpp -lang-c++ -v -I. -I../ -I../VxNumerics -I../spline -I../reg -I../optim -D__GNUC__=2 -D__GNUG__=2 -D__GNUC_MINOR__=95 -D__cplusplus -Dsparc -Dsun -Dunix -D__svr4__ -D__SVR4 -D__sparc__ -D__sun__ -D__unix__ -D__svr4__ -D__SVR4 -D__sparc -D__sun -D__unix -Asystem(unix) -Asystem(svr4) -D__EXCEPTIONS -D__GCC_NEW_VARARGS__ -Acpu(sparc) -Amachine(sparc) Affine_Map2.cc Affine_Map2.ii
GNU CPP version 2.95.2 19991024 (release) (sparc)
#include "..." search starts here:
#include <...> search starts here:
.
..
../VxNumerics
../spline
../reg
../optim
/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++
/usr/local/include
/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/../../../../sparc-sun-solaris2.7/include
/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include
/usr/include
End of search list.
The following default directories have been omitted from the search path:
End of omitted list.
/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/cc1plus Affine_Map2.ii -quiet -dumpbase Affine_Map2.cc -version -o Affine_Map2.s
GNU C++ version 2.95.2 19991024 (release) (sparc-sun-solaris2.7) compiled by GNU C version 2.95.2 19991024 (release).
In file included from ../data-types.h:10,
from Affine_Map2.h:15,
from Affine_Map2.cc:9:
../VxNumerics/VxMatrix.h:150: Internal compiler error.
../VxNumerics/VxMatrix.h:150: Please submit a full bug report.
../VxNumerics/VxMatrix.h:150: See <URL:http://www.gnu.org/software/gcc/faq.html#bugreport> for instructions.
make: *** [Affine_Map2.o] Error 1
# 1 "Affine_Map2.cc"
# 1 "Affine_Map2.h" 1
# 1 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/iostream.h" 1 3
#pragma interface
# 1 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/streambuf.h" 1 3
#pragma interface
extern "C" {
# 1 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/libio.h" 1 3
# 1 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/_G_config.h" 1 3
typedef int _G_int8_t __attribute__((__mode__(__QI__)));
typedef unsigned int _G_uint8_t __attribute__((__mode__(__QI__)));
typedef int _G_int16_t __attribute__((__mode__(__HI__)));
typedef unsigned int _G_uint16_t __attribute__((__mode__(__HI__)));
typedef int _G_int32_t __attribute__((__mode__(__SI__)));
typedef unsigned int _G_uint32_t __attribute__((__mode__(__SI__)));
typedef int _G_int64_t __attribute__((__mode__(__DI__)));
typedef unsigned int _G_uint64_t __attribute__((__mode__(__DI__)));
__extension__ typedef long long _G_llong;
__extension__ typedef unsigned long long _G_ullong;
typedef long _G_clock_t;
typedef unsigned long _G_dev_t;
typedef long _G_fpos_t;
typedef long _G_gid_t;
typedef unsigned long _G_ino_t;
typedef unsigned long _G_mode_t;
typedef unsigned long _G_nlink_t;
typedef long _G_off_t;
typedef long _G_pid_t;
typedef int _G_ptrdiff_t;
typedef int _G_sigset_t;
typedef unsigned int _G_size_t;
typedef long _G_time_t;
typedef long _G_uid_t;
typedef long int _G_wchar_t;
typedef int _G_ssize_t;
typedef unsigned int _G_wint_t;
typedef void * _G_va_list;
# 1 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stddef.h" 1 3 4
# 19 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stddef.h" 3 4
# 61 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stddef.h" 3 4
# 131 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stddef.h" 3 4
# 190 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stddef.h" 3 4
# 271 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stddef.h" 3 4
# 283 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stddef.h" 3 4
# 317 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stddef.h" 3 4
# 86 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/_G_config.h" 2 3
# 30 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/libio.h" 2 3
# 55 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/libio.h" 3
# 104 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/libio.h" 3
struct _IO_jump_t; struct _IO_FILE;
# 174 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/libio.h" 3
typedef void _IO_lock_t;
struct _IO_marker {
struct _IO_marker *_next;
struct _IO_FILE *_sbuf;
int _pos;
# 207 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/libio.h" 3
};
struct _IO_FILE {
int _flags;
char* _IO_read_ptr;
char* _IO_read_end;
char* _IO_read_base;
char* _IO_write_base;
char* _IO_write_ptr;
char* _IO_write_end;
char* _IO_buf_base;
char* _IO_buf_end;
char *_IO_save_base;
char *_IO_backup_base;
char *_IO_save_end;
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
int _blksize;
_G_off_t _offset;
unsigned short _cur_column;
char _unused;
char _shortbuf[1];
};
struct _IO_FILE_plus;
extern struct _IO_FILE_plus _IO_stdin_, _IO_stdout_, _IO_stderr_;
typedef struct
{
_G_ssize_t (*read) (struct _IO_FILE *, void *, _G_ssize_t ) ;
_G_ssize_t (*write) (struct _IO_FILE *, const void *, _G_ssize_t ) ;
_G_fpos_t (*seek) (struct _IO_FILE *, _G_off_t , int) ;
int (*close) (struct _IO_FILE *) ;
} _IO_cookie_io_functions_t;
struct _IO_cookie_file
{
struct _IO_FILE file;
const void *vtable;
void *cookie;
_IO_cookie_io_functions_t io_functions;
};
extern "C" {
extern int __underflow (_IO_FILE *) ;
extern int __uflow (_IO_FILE *) ;
extern int __overflow (_IO_FILE *, int) ;
extern int _IO_getc (_IO_FILE *__fp) ;
extern int _IO_putc (int __c, _IO_FILE *__fp) ;
extern int _IO_feof (_IO_FILE *__fp) ;
extern int _IO_ferror (_IO_FILE *__fp) ;
extern int _IO_peekc_locked (_IO_FILE *__fp) ;
extern void _IO_flockfile (_IO_FILE *) ;
extern void _IO_funlockfile (_IO_FILE *) ;
extern int _IO_ftrylockfile (_IO_FILE *) ;
extern int _IO_vfscanf (_IO_FILE *, const char *, _G_va_list , int *) ;
extern int _IO_vfprintf (_IO_FILE *, const char *, _G_va_list ) ;
extern _G_ssize_t _IO_padn (_IO_FILE *, int, _G_ssize_t ) ;
extern _G_size_t _IO_sgetn (_IO_FILE *, void *, _G_size_t ) ;
extern _G_fpos_t _IO_seekoff (_IO_FILE *, _G_off_t , int, int) ;
extern _G_fpos_t _IO_seekpos (_IO_FILE *, _G_fpos_t , int) ;
extern void _IO_free_backup_area (_IO_FILE *) ;
}
# 36 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/streambuf.h" 2 3
}
extern "C++" {
class istream;
class ostream; class streambuf;
typedef _G_off_t streamoff;
typedef _G_fpos_t streampos;
typedef _G_ssize_t streamsize;
typedef unsigned long __fmtflags;
typedef unsigned char __iostate;
struct _ios_fields
{
streambuf *_strbuf;
ostream* _tie;
int _width;
__fmtflags _flags;
short _fill;
__iostate _state;
__iostate _exceptions;
int _precision;
void *_arrays;
};
# 124 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/streambuf.h" 3
class ios : public _ios_fields {
ios& operator=(ios&);
ios (const ios&);
public:
typedef __fmtflags fmtflags;
typedef int iostate;
typedef int openmode;
typedef _G_ssize_t streamsize;
enum io_state {
goodbit = 0 ,
eofbit = 1 ,
failbit = 2 ,
badbit = 4 };
enum open_mode {
in = 1 ,
out = 2 ,
ate = 4 ,
app = 8 ,
trunc = 16 ,
nocreate = 32 ,
noreplace = 64 ,
bin = 128 ,
binary = 128 };
enum seek_dir { beg, cur, end};
typedef enum seek_dir seekdir;
enum { skipws= 01 ,
left= 02 , right= 04 , internal= 010 ,
dec= 020 , oct= 040 , hex= 0100 ,
showbase= 0200 , showpoint= 0400 ,
uppercase= 01000 , showpos= 02000 ,
scientific= 04000 , fixed= 010000 ,
unitbuf= 020000 , stdio= 040000
};
enum {
basefield=dec+oct+hex,
floatfield = scientific+fixed,
adjustfield = left+right+internal
};
# 177 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/streambuf.h" 3
ostream* tie() const { return _tie; }
ostream* tie(ostream* val) { ostream* save=_tie; _tie=val; return save; }
short fill() const { return _fill; }
short fill(short newf)
{short oldf = _fill; _fill = newf; return oldf;}
fmtflags flags() const { return _flags; }
fmtflags flags(fmtflags new_val) {
fmtflags old_val = _flags; _flags = new_val; return old_val; }
int precision() const { return _precision; }
int precision(int newp) {
unsigned short oldp = _precision; _precision = (unsigned short)newp;
return oldp; }
fmtflags setf(fmtflags val) {
fmtflags oldbits = _flags;
_flags |= val; return oldbits; }
fmtflags setf(fmtflags val, fmtflags mask) {
fmtflags oldbits = _flags;
_flags = (_flags & ~mask) | (val & mask); return oldbits; }
fmtflags unsetf(fmtflags mask) {
fmtflags oldbits = _flags;
_flags &= ~mask; return oldbits; }
int width() const { return _width; }
int width(int val) { int save = _width; _width = val; return save; }
void _throw_failure() const { }
void clear(iostate state = 0) {
_state = _strbuf ? state : state|badbit;
if (_state & _exceptions) _throw_failure(); }
void set(iostate flag) { _state |= flag;
if (_state & _exceptions) _throw_failure(); }
void setstate(iostate flag) { _state |= flag;
if (_state & _exceptions) _throw_failure(); }
int good() const { return _state == 0; }
int eof() const { return _state & ios::eofbit; }
int fail() const { return _state & (ios::badbit|ios::failbit); }
int bad() const { return _state & ios::badbit; }
iostate rdstate() const { return _state; }
operator void*() const { return fail() ? (void*)0 : (void*)(-1); }
int operator!() const { return fail(); }
iostate exceptions() const { return _exceptions; }
void exceptions(iostate enable) {
_exceptions = enable;
if (_state & _exceptions) _throw_failure(); }
streambuf* rdbuf() const { return _strbuf; }
streambuf* rdbuf(streambuf *_s) {
streambuf *_old = _strbuf; _strbuf = _s; clear (); return _old; }
static int sync_with_stdio(int on);
static void sync_with_stdio() { sync_with_stdio(1); }
static fmtflags bitalloc();
static int xalloc();
void*& pword(int);
void* pword(int) const;
long& iword(int);
long iword(int) const;
class Init {
public:
Init () { }
};
protected:
inline ios(streambuf* sb = 0, ostream* tie_to = 0);
inline virtual ~ios();
inline void init(streambuf* sb, ostream* tie = 0);
};
typedef ios::seek_dir _seek_dir;
class streammarker : private _IO_marker {
friend class streambuf;
void set_offset(int offset) { _pos = offset; }
public:
streammarker(streambuf *sb);
~streammarker();
int saving() { return 1; }
int delta(streammarker&);
int delta();
};
struct streambuf : public _IO_FILE {
friend class ios;
friend class istream;
friend class ostream;
friend class streammarker;
const void *&_vtable() { return *(const void**)((_IO_FILE*)this + 1); }
protected:
static streambuf* _list_all;
_IO_FILE*& xchain() { return _chain; }
void _un_link();
void _link_in();
char* gptr() const
{ return _flags & 0x100 ? _IO_save_base : _IO_read_ptr; }
char* pptr() const { return _IO_write_ptr; }
char* egptr() const
{ return _flags & 0x100 ? _IO_save_end : _IO_read_end; }
char* epptr() const { return _IO_write_end; }
char* pbase() const { return _IO_write_base; }
char* eback() const
{ return _flags & 0x100 ? _IO_save_base : _IO_read_base;}
char* base() const { return _IO_buf_base; }
char* ebuf() const { return _IO_buf_end; }
int blen() const { return _IO_buf_end - _IO_buf_base; }
void xput_char(char c) { *_IO_write_ptr++ = c; }
int xflags() { return _flags ; }
int xflags(int f) {int fl = _flags ; _flags = f; return fl;}
void xsetflags(int f) { _flags |= f; }
void xsetflags(int f, int mask)
{ _flags = (_flags & ~mask) | (f & mask); }
void gbump(int n)
{ _flags & 0x100 ? (_IO_save_base+=n):(_IO_read_ptr+=n);}
void pbump(int n) { _IO_write_ptr += n; }
void setb(char* b, char* eb, int a=0);
void setp(char* p, char* ep)
{ _IO_write_base=_IO_write_ptr=p; _IO_write_end=ep; }
void setg(char* eb, char* g, char *eg) {
if (_flags & 0x100 ) _IO_free_backup_area(this);
_IO_read_base = eb; _IO_read_ptr = g; _IO_read_end = eg; }
char *shortbuf() { return _shortbuf; }
int in_backup() { return _flags & 0x100 ; }
char *Gbase() { return in_backup() ? _IO_save_base : _IO_read_base; }
char *eGptr() { return in_backup() ? _IO_save_end : _IO_read_end; }
char *Bbase() { return in_backup() ? _IO_read_base : _IO_save_base; }
char *Bptr() { return _IO_backup_base; }
char *eBptr() { return in_backup() ? _IO_read_end : _IO_save_end; }
char *Nbase() { return _IO_save_base; }
char *eNptr() { return _IO_save_end; }
int have_backup() { return _IO_save_base != __null ; }
int have_markers() { return _markers != __null ; }
void free_backup_area();
void unsave_markers();
int put_mode() { return _flags & 0x800 ; }
int switch_to_get_mode();
streambuf(int flags=0);
public:
static int flush_all();
static void flush_all_linebuffered();
virtual ~streambuf();
virtual int overflow(int c = (-1) );
virtual int underflow();
virtual int uflow();
virtual int pbackfail(int c);
virtual streamsize xsputn(const char* s, streamsize n);
virtual streamsize xsgetn(char* s, streamsize n);
virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
virtual streampos seekpos(streampos pos, int mode = ios::in|ios::out);
streampos pubseekoff(streamoff o, _seek_dir d, int mode=ios::in|ios::out)
{ return _IO_seekoff (this, o, d, mode); }
streampos pubseekpos(streampos pos, int mode = ios::in|ios::out)
{ return _IO_seekpos (this, pos, mode); }
streampos sseekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
streampos sseekpos(streampos pos, int mode = ios::in|ios::out);
virtual streambuf* setbuf(char* p, int len);
virtual int sync();
virtual int doallocate();
int seekmark(streammarker& mark, int delta = 0);
int sputbackc(char c);
int sungetc();
int unbuffered() { return _flags & 2 ? 1 : 0; }
int linebuffered() { return _flags & 0x200 ? 1 : 0; }
void unbuffered(int i)
{ if (i) _flags |= 2 ; else _flags &= ~2 ; }
void linebuffered(int i)
{ if (i) _flags |= 0x200 ; else _flags &= ~0x200 ; }
int allocate() {
if (base() || unbuffered()) return 0;
else return doallocate(); }
void allocbuf() { if (base() == __null ) doallocbuf(); }
void doallocbuf();
int in_avail() { return _IO_read_end - _IO_read_ptr; }
int out_waiting() { return _IO_write_ptr - _IO_write_base; }
streamsize sputn(const char* s, streamsize n) { return xsputn(s, n); }
streamsize padn(char pad, streamsize n) { return _IO_padn(this, pad, n); }
streamsize sgetn(char* s, streamsize n) { return _IO_sgetn(this, s, n); }
int ignore(int);
int get_column();
int set_column(int);
long sgetline(char* buf, _G_size_t n, char delim, int putback_delim);
int sputc(int c) { return _IO_putc(c, this); }
int sbumpc() { return _IO_getc(this); }
int sgetc() { return (( this )->_IO_read_ptr >= ( this )->_IO_read_end && __underflow ( this ) == (-1) ? (-1) : *(unsigned char *) ( this )->_IO_read_ptr) ; }
int snextc() {
if (_IO_read_ptr >= _IO_read_end && __underflow(this) == (-1) )
return (-1) ;
else return _IO_read_ptr++, sgetc(); }
void stossc() { if (_IO_read_ptr < _IO_read_end) _IO_read_ptr++; }
int vscan(char const *fmt0, _G_va_list ap, ios* stream = __null );
int scan(char const *fmt0 ...);
int vform(char const *fmt0, _G_va_list ap);
int form(char const *fmt0 ...);
virtual streamsize sys_read(char* buf, streamsize size);
virtual streamsize sys_write(const char*, streamsize);
virtual streampos sys_seek(streamoff, _seek_dir);
virtual int sys_close();
virtual int sys_stat(void*);
};
class filebuf : public streambuf {
protected:
void init();
public:
static const int openprot;
filebuf();
filebuf(int fd);
filebuf(int fd, char* p, int len);
~filebuf();
filebuf* attach(int fd);
filebuf* open(const char *filename, const char *mode);
filebuf* open(const char *filename, ios::openmode mode, int prot = 0664);
virtual int underflow();
virtual int overflow(int c = (-1) );
int is_open() const { return _fileno >= 0; }
int fd() const { return is_open() ? _fileno : (-1) ; }
filebuf* close();
virtual int doallocate();
virtual streampos seekoff(streamoff, _seek_dir, int mode=ios::in|ios::out);
virtual streambuf* setbuf(char* p, int len);
streamsize xsputn(const char* s, streamsize n);
streamsize xsgetn(char* s, streamsize n);
virtual int sync();
protected:
int is_reading() { return eback() != egptr(); }
char* cur_ptr() { return is_reading() ? gptr() : pptr(); }
char* file_ptr() { return eGptr(); }
virtual streamsize sys_read(char* buf, streamsize size);
virtual streampos sys_seek(streamoff, _seek_dir);
virtual streamsize sys_write(const char*, streamsize);
virtual int sys_stat(void*);
virtual int sys_close();
};
inline void ios::init(streambuf* sb, ostream* tie_to) {
_state = sb ? ios::goodbit : ios::badbit; _exceptions=0;
_strbuf=sb; _tie = tie_to; _width=0; _fill=' ';
_flags=ios::skipws|ios::dec;
_precision=6; _arrays = 0; }
inline ios::ios(streambuf* sb, ostream* tie_to) { init(sb, tie_to); }
inline ios::~ios() {
operator delete[] (_arrays);
}
}
# 31 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/iostream.h" 2 3
extern "C++" {
class istream; class ostream;
typedef ios& (*__manip)(ios&);
typedef istream& (*__imanip)(istream&);
typedef ostream& (*__omanip)(ostream&);
extern istream& ws(istream& ins);
extern ostream& flush(ostream& outs);
extern ostream& endl(ostream& outs);
extern ostream& ends(ostream& outs);
class ostream : virtual public ios
{
void do_osfx();
public:
ostream() { }
ostream(streambuf* sb, ostream* tied= __null );
int opfx() {
if (!good()) return 0;
else { if (_tie) _tie->flush(); ; return 1;} }
void osfx() { ;
if (flags() & (ios::unitbuf|ios::stdio))
do_osfx(); }
ostream& flush();
ostream& put(char c) { _strbuf->sputc(c); return *this; }
ostream& write(const char *s, streamsize n);
ostream& write(const unsigned char *s, streamsize n)
{ return write((const char*)s, n);}
ostream& write(const signed char *s, streamsize n)
{ return write((const char*)s, n);}
ostream& write(const void *s, streamsize n)
{ return write((const char*)s, n);}
ostream& seekp(streampos);
ostream& seekp(streamoff, _seek_dir);
streampos tellp();
ostream& form(const char *format ...);
ostream& vform(const char *format, _G_va_list args);
ostream& operator<<(char c);
ostream& operator<<(unsigned char c) { return (*this) << (char)c; }
ostream& operator<<(signed char c) { return (*this) << (char)c; }
ostream& operator<<(const char *s);
ostream& operator<<(const unsigned char *s)
{ return (*this) << (const char*)s; }
ostream& operator<<(const signed char *s)
{ return (*this) << (const char*)s; }
ostream& operator<<(const void *p);
ostream& operator<<(int n);
ostream& operator<<(unsigned int n);
ostream& operator<<(long n);
ostream& operator<<(unsigned long n);
__extension__ ostream& operator<<(long long n);
__extension__ ostream& operator<<(unsigned long long n);
ostream& operator<<(short n) {return operator<<((int)n);}
ostream& operator<<(unsigned short n) {return operator<<((unsigned int)n);}
ostream& operator<<(bool b) { return operator<<((int)b); }
ostream& operator<<(double n);
ostream& operator<<(float n) { return operator<<((double)n); }
ostream& operator<<(long double n) { return operator<<((double)n); }
ostream& operator<<(__omanip func) { return (*func)(*this); }
ostream& operator<<(__manip func) {(*func)(*this); return *this;}
ostream& operator<<(streambuf*);
};
class istream : virtual public ios
{
protected:
_G_size_t _gcount;
int _skip_ws();
public:
istream(): _gcount (0) { }
istream(streambuf* sb, ostream*tied= __null );
istream& get(char* ptr, int len, char delim = '\n');
istream& get(unsigned char* ptr, int len, char delim = '\n')
{ return get((char*)ptr, len, delim); }
istream& get(char& c);
istream& get(unsigned char& c) { return get((char&)c); }
istream& getline(char* ptr, int len, char delim = '\n');
istream& getline(unsigned char* ptr, int len, char delim = '\n')
{ return getline((char*)ptr, len, delim); }
istream& get(signed char& c) { return get((char&)c); }
istream& get(signed char* ptr, int len, char delim = '\n')
{ return get((char*)ptr, len, delim); }
istream& getline(signed char* ptr, int len, char delim = '\n')
{ return getline((char*)ptr, len, delim); }
istream& read(char *ptr, streamsize n);
istream& read(unsigned char *ptr, streamsize n)
{ return read((char*)ptr, n); }
istream& read(signed char *ptr, streamsize n)
{ return read((char*)ptr, n); }
istream& read(void *ptr, streamsize n)
{ return read((char*)ptr, n); }
istream& get(streambuf& sb, char delim = '\n');
istream& gets(char **s, char delim = '\n');
int ipfx(int need = 0) {
if (!good()) { set(ios::failbit); return 0; }
else {
;
if (_tie && (need == 0 || rdbuf()->in_avail() < need)) _tie->flush();
if (!need && (flags() & ios::skipws)) return _skip_ws();
else return 1;
}
}
int ipfx0() {
if (!good()) { set(ios::failbit); return 0; }
else {
;
if (_tie) _tie->flush();
if (flags() & ios::skipws) return _skip_ws();
else return 1;
}
}
int ipfx1() {
if (!good()) { set(ios::failbit); return 0; }
else {
;
if (_tie && rdbuf()->in_avail() == 0) _tie->flush();
return 1;
}
}
void isfx() { ; }
int get() { if (!ipfx1()) return (-1) ;
else { int ch = _strbuf->sbumpc();
if (ch == (-1) ) set(ios::eofbit);
isfx();
return ch;
} }
int peek();
_G_size_t gcount() { return _gcount; }
istream& ignore(int n=1, int delim = (-1) );
int sync ();
istream& seekg(streampos);
istream& seekg(streamoff, _seek_dir);
streampos tellg();
istream& putback(char ch) {
if (good() && _strbuf->sputbackc(ch) == (-1) ) clear(ios::badbit);
return *this;}
istream& unget() {
if (good() && _strbuf->sungetc() == (-1) ) clear(ios::badbit);
return *this;}
istream& scan(const char *format ...);
istream& vscan(const char *format, _G_va_list args);
istream& operator>>(char*);
istream& operator>>(unsigned char* p) { return operator>>((char*)p); }
istream& operator>>(signed char*p) { return operator>>((char*)p); }
istream& operator>>(char& c);
istream& operator>>(unsigned char& c) {return operator>>((char&)c);}
istream& operator>>(signed char& c) {return operator>>((char&)c);}
istream& operator>>(int&);
istream& operator>>(long&);
__extension__ istream& operator>>(long long&);
__extension__ istream& operator>>(unsigned long long&);
istream& operator>>(short&);
istream& operator>>(unsigned int&);
istream& operator>>(unsigned long&);
istream& operator>>(unsigned short&);
istream& operator>>(bool&);
istream& operator>>(float&);
istream& operator>>(double&);
istream& operator>>(long double&);
istream& operator>>( __manip func) {(*func)(*this); return *this;}
istream& operator>>(__imanip func) { return (*func)(*this); }
istream& operator>>(streambuf*);
};
class iostream : public istream, public ostream
{
public:
iostream() { }
iostream(streambuf* sb, ostream*tied= __null );
};
class _IO_istream_withassign : public istream {
public:
_IO_istream_withassign& operator=(istream&);
_IO_istream_withassign& operator=(_IO_istream_withassign& rhs)
{ return operator= (static_cast<istream&> (rhs)); }
};
class _IO_ostream_withassign : public ostream {
public:
_IO_ostream_withassign& operator=(ostream&);
_IO_ostream_withassign& operator=(_IO_ostream_withassign& rhs)
{ return operator= (static_cast<ostream&> (rhs)); }
};
extern _IO_istream_withassign cin;
extern _IO_ostream_withassign cout, cerr;
extern _IO_ostream_withassign clog
;
extern istream& lock(istream& ins);
extern istream& unlock(istream& ins);
extern ostream& lock(ostream& outs);
extern ostream& unlock(ostream& outs);
struct Iostream_init { } ;
inline ios& dec(ios& i)
{ i.setf(ios::dec, ios::dec|ios::hex|ios::oct); return i; }
inline ios& hex(ios& i)
{ i.setf(ios::hex, ios::dec|ios::hex|ios::oct); return i; }
inline ios& oct(ios& i)
{ i.setf(ios::oct, ios::dec|ios::hex|ios::oct); return i; }
}
# 14 "Affine_Map2.h" 2
# 1 "../data-types.h" 1
# 1 "../VxNumerics/VxVector.h" 1
# 1 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stddef.h" 1 3 4
# 61 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stddef.h" 3 4
typedef int ptrdiff_t;
typedef unsigned int size_t;
typedef unsigned int wint_t;
# 317 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stddef.h" 3 4
# 14 "../VxNumerics/VxVector.h" 2
# 1 "../VxNumerics/seq-alg.h" 1
# 1 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/iterator" 1 3
# 1 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/stl_config.h" 1 3
# 148 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/stl_config.h" 3
# 178 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/stl_config.h" 3
# 234 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/stl_config.h" 3
# 248 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/stl_config.h" 3
# 316 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/stl_config.h" 3
# 30 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/iterator" 2 3
# 1 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/stl_relops.h" 1 3
template <class _Tp>
inline bool operator!=(const _Tp& __x, const _Tp& __y) {
return !(__x == __y);
}
template <class _Tp>
inline bool operator>(const _Tp& __x, const _Tp& __y) {
return __y < __x;
}
template <class _Tp>
inline bool operator<=(const _Tp& __x, const _Tp& __y) {
return !(__y < __x);
}
template <class _Tp>
inline bool operator>=(const _Tp& __x, const _Tp& __y) {
return !(__x < __y);
}
# 31 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/iterator" 2 3
# 1 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stddef.h" 1 3 4
# 342 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stddef.h" 3 4
# 32 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/iterator" 2 3
# 1 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/stl_iterator.h" 1 3
struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag : public input_iterator_tag {};
struct bidirectional_iterator_tag : public forward_iterator_tag {};
struct random_access_iterator_tag : public bidirectional_iterator_tag {};
template <class _Tp, class _Distance> struct input_iterator {
typedef input_iterator_tag iterator_category;
typedef _Tp value_type;
typedef _Distance difference_type;
typedef _Tp* pointer;
typedef _Tp& reference;
};
struct output_iterator {
typedef output_iterator_tag iterator_category;
typedef void value_type;
typedef void difference_type;
typedef void pointer;
typedef void reference;
};
template <class _Tp, class _Distance> struct forward_iterator {
typedef forward_iterator_tag iterator_category;
typedef _Tp value_type;
typedef _Distance difference_type;
typedef _Tp* pointer;
typedef _Tp& reference;
};
template <class _Tp, class _Distance> struct bidirectional_iterator {
typedef bidirectional_iterator_tag iterator_category;
typedef _Tp value_type;
typedef _Distance difference_type;
typedef _Tp* pointer;
typedef _Tp& reference;
};
template <class _Tp, class _Distance> struct random_access_iterator {
typedef random_access_iterator_tag iterator_category;
typedef _Tp value_type;
typedef _Distance difference_type;
typedef _Tp* pointer;
typedef _Tp& reference;
};
# 98 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/stl_iterator.h" 3
template <class _Iterator>
struct iterator_traits {
typedef typename _Iterator::iterator_category iterator_category;
typedef typename _Iterator::value_type value_type;
typedef typename _Iterator::difference_type difference_type;
typedef typename _Iterator::pointer pointer;
typedef typename _Iterator::reference reference;
};
template <class _Tp>
struct iterator_traits<_Tp*> {
typedef random_access_iterator_tag iterator_category;
typedef _Tp value_type;
typedef ptrdiff_t difference_type;
typedef _Tp* pointer;
typedef _Tp& reference;
};
template <class _Tp>
struct iterator_traits<const _Tp*> {
typedef random_access_iterator_tag iterator_category;
typedef _Tp value_type;
typedef ptrdiff_t difference_type;
typedef const _Tp* pointer;
typedef const _Tp& reference;
};
template <class _Iter>
inline typename iterator_traits<_Iter>::iterator_category
__iterator_category(const _Iter&)
{
typedef typename iterator_traits<_Iter>::iterator_category _Category;
return _Category();
}
template <class _Iter>
inline typename iterator_traits<_Iter>::difference_type*
__distance_type(const _Iter&)
{
return static_cast<typename iterator_traits<_Iter>::difference_type*>(0);
}
template <class _Iter>
inline typename iterator_traits<_Iter>::value_type*
__value_type(const _Iter&)
{
return static_cast<typename iterator_traits<_Iter>::value_type*>(0);
}
template <class _Iter>
inline typename iterator_traits<_Iter>::iterator_category
iterator_category(const _Iter& __i) { return __iterator_category(__i); }
template <class _Iter>
inline typename iterator_traits<_Iter>::difference_type*
distance_type(const _Iter& __i) { return __distance_type(__i); }
template <class _Iter>
inline typename iterator_traits<_Iter>::value_type*
value_type(const _Iter& __i) { return __value_type(__i); }
# 259 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/stl_iterator.h" 3
template <class _InputIterator, class _Distance>
inline void __distance(_InputIterator __first, _InputIterator __last,
_Distance& __n, input_iterator_tag)
{
while (__first != __last) { ++__first; ++__n; }
}
template <class _RandomAccessIterator, class _Distance>
inline void __distance(_RandomAccessIterator __first,
_RandomAccessIterator __last,
_Distance& __n, random_access_iterator_tag)
{
__n += __last - __first;
}
template <class _InputIterator, class _Distance>
inline void distance(_InputIterator __first,
_InputIterator __last, _Distance& __n)
{
__distance(__first, __last, __n, iterator_category(__first));
}
template <class _InputIterator>
inline typename iterator_traits<_InputIterator>::difference_type
__distance(_InputIterator __first, _InputIterator __last, input_iterator_tag)
{
typename iterator_traits<_InputIterator>::difference_type __n = 0;
while (__first != __last) {
++__first; ++__n;
}
return __n;
}
template <class _RandomAccessIterator>
inline typename iterator_traits<_RandomAccessIterator>::difference_type
__distance(_RandomAccessIterator __first, _RandomAccessIterator __last,
random_access_iterator_tag) {
return __last - __first;
}
template <class _InputIterator>
inline typename iterator_traits<_InputIterator>::difference_type
distance(_InputIterator __first, _InputIterator __last) {
typedef typename iterator_traits<_InputIterator>::iterator_category
_Category;
return __distance(__first, __last, _Category());
}
template <class _InputIter, class _Distance>
inline void __advance(_InputIter& __i, _Distance __n, input_iterator_tag) {
while (__n--) ++__i;
}
template <class _BidirectionalIterator, class _Distance>
inline void __advance(_BidirectionalIterator& __i, _Distance __n,
bidirectional_iterator_tag) {
if (__n >= 0)
while (__n--) ++__i;
else
while (__n++) --__i;
}
template <class _RandomAccessIterator, class _Distance>
inline void __advance(_RandomAccessIterator& __i, _Distance __n,
random_access_iterator_tag) {
__i += __n;
}
template <class _InputIterator, class _Distance>
inline void advance(_InputIterator& __i, _Distance __n) {
__advance(__i, __n, iterator_category(__i));
}
template <class _Container>
class back_insert_iterator {
protected:
_Container* container;
public:
typedef _Container container_type;
typedef output_iterator_tag iterator_category;
typedef void value_type;
typedef void difference_type;
typedef void pointer;
typedef void reference;
explicit back_insert_iterator(_Container& __x) : container(&__x) {}
back_insert_iterator<_Container>&
operator=(const typename _Container::value_type& __value) {
container->push_back(__value);
return *this;
}
back_insert_iterator<_Container>& operator*() { return *this; }
back_insert_iterator<_Container>& operator++() { return *this; }
back_insert_iterator<_Container>& operator++(int) { return *this; }
};
# 378 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/stl_iterator.h" 3
template <class _Container>
inline back_insert_iterator<_Container> back_inserter(_Container& __x) {
return back_insert_iterator<_Container>(__x);
}
template <class _Container>
class front_insert_iterator {
protected:
_Container* container;
public:
typedef _Container container_type;
typedef output_iterator_tag iterator_category;
typedef void value_type;
typedef void difference_type;
typedef void pointer;
typedef void reference;
explicit front_insert_iterator(_Container& __x) : container(&__x) {}
front_insert_iterator<_Container>&
operator=(const typename _Container::value_type& __value) {
container->push_front(__value);
return *this;
}
front_insert_iterator<_Container>& operator*() { return *this; }
front_insert_iterator<_Container>& operator++() { return *this; }
front_insert_iterator<_Container>& operator++(int) { return *this; }
};
# 417 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/stl_iterator.h" 3
template <class _Container>
inline front_insert_iterator<_Container> front_inserter(_Container& __x) {
return front_insert_iterator<_Container>(__x);
}
template <class _Container>
class insert_iterator {
protected:
_Container* container;
typename _Container::iterator iter;
public:
typedef _Container container_type;
typedef output_iterator_tag iterator_category;
typedef void value_type;
typedef void difference_type;
typedef void pointer;
typedef void reference;
insert_iterator(_Container& __x, typename _Container::iterator __i)
: container(&__x), iter(__i) {}
insert_iterator<_Container>&
operator=(const typename _Container::value_type& __value) {
iter = container->insert(iter, __value);
++iter;
return *this;
}
insert_iterator<_Container>& operator*() { return *this; }
insert_iterator<_Container>& operator++() { return *this; }
insert_iterator<_Container>& operator++(int) { return *this; }
};
# 459 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/stl_iterator.h" 3
template <class _Container, class _Iterator>
inline
insert_iterator<_Container> inserter(_Container& __x, _Iterator __i)
{
typedef typename _Container::iterator __iter;
return insert_iterator<_Container>(__x, __iter(__i));
}
template <class _BidirectionalIterator, class _Tp, class _Reference = _Tp&,
class _Distance = ptrdiff_t>
class reverse_bidirectional_iterator {
typedef reverse_bidirectional_iterator<_BidirectionalIterator, _Tp,
_Reference, _Distance> _Self;
protected:
_BidirectionalIterator current;
public:
typedef bidirectional_iterator_tag iterator_category;
typedef _Tp value_type;
typedef _Distance difference_type;
typedef _Tp* pointer;
typedef _Reference reference;
reverse_bidirectional_iterator() {}
explicit reverse_bidirectional_iterator(_BidirectionalIterator __x)
: current(__x) {}
_BidirectionalIterator base() const { return current; }
_Reference operator*() const {
_BidirectionalIterator __tmp = current;
return *--__tmp;
}
pointer operator->() const { return &(operator*()); }
_Self& operator++() {
--current;
return *this;
}
_Self operator++(int) {
_Self __tmp = *this;
--current;
return __tmp;
}
_Self& operator--() {
++current;
return *this;
}
_Self operator--(int) {
_Self __tmp = *this;
++current;
return __tmp;
}
};
# 550 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/stl_iterator.h" 3
template <class _BiIter, class _Tp, class _Ref,
class _Distance>
inline bool operator==(
const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __x,
const reverse_bidirectional_iterator<_BiIter, _Tp, _Ref, _Distance>& __y)
{
return __x.base() == __y.base();
}
template <class _Iterator>
class reverse_iterator
{
protected:
_Iterator current;
public:
typedef typename iterator_traits<_Iterator>::iterator_category
iterator_category;
typedef typename iterator_traits<_Iterator>::value_type
value_type;
typedef typename iterator_traits<_Iterator>::difference_type
difference_type;
typedef typename iterator_traits<_Iterator>::pointer
pointer;
typedef typename iterator_traits<_Iterator>::reference
reference;
typedef _Iterator iterator_type;
typedef reverse_iterator<_Iterator> _Self;
public:
reverse_iterator() {}
explicit reverse_iterator(iterator_type __x) : current(__x) {}
reverse_iterator(const _Self& __x) : current(__x.current) {}
template <class _Iter>
reverse_iterator(const reverse_iterator<_Iter>& __x)
: current(__x.base()) {}
iterator_type base() const { return current; }
reference operator*() const {
_Iterator __tmp = current;
return *--__tmp;
}
pointer operator->() const { return &(operator*()); }
_Self& operator++() {
--current;
return *this;
}
_Self operator++(int) {
_Self __tmp = *this;
--current;
return __tmp;
}
_Self& operator--() {
++current;
return *this;
}
_Self operator--(int) {
_Self __tmp = *this;
++current;
return __tmp;
}
_Self operator+(difference_type __n) const {
return _Self(current - __n);
}
_Self& operator+=(difference_type __n) {
current -= __n;
return *this;
}
_Self operator-(difference_type __n) const {
return _Self(current + __n);
}
_Self& operator-=(difference_type __n) {
current += __n;
return *this;
}
reference operator[](difference_type __n) const { return *(*this + __n); }
};
template <class _Iterator>
inline bool operator==(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y) {
return __x.base() == __y.base();
}
template <class _Iterator>
inline bool operator<(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y) {
return __y.base() < __x.base();
}
template <class _Iterator>
inline typename reverse_iterator<_Iterator>::difference_type
operator-(const reverse_iterator<_Iterator>& __x,
const reverse_iterator<_Iterator>& __y) {
return __y.base() - __x.base();
}
template <class _Iterator>
inline reverse_iterator<_Iterator>
operator+(typename reverse_iterator<_Iterator>::difference_type __n,
const reverse_iterator<_Iterator>& __x) {
return reverse_iterator<_Iterator>(__x.base() - __n);
}
# 805 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/stl_iterator.h" 3
template <class _Tp, class _Dist = ptrdiff_t>
class istream_iterator {
friend bool operator== <> (const istream_iterator&,
const istream_iterator&);
protected:
istream* _M_stream;
_Tp _M_value;
bool _M_end_marker;
void _M_read() {
_M_end_marker = (*_M_stream) ? true : false;
if (_M_end_marker) *_M_stream >> _M_value;
_M_end_marker = (*_M_stream) ? true : false;
}
public:
typedef input_iterator_tag iterator_category;
typedef _Tp value_type;
typedef _Dist difference_type;
typedef const _Tp* pointer;
typedef const _Tp& reference;
istream_iterator() : _M_stream(&cin), _M_end_marker(false) {}
istream_iterator(istream& __s) : _M_stream(&__s) { _M_read(); }
reference operator*() const { return _M_value; }
pointer operator->() const { return &(operator*()); }
istream_iterator<_Tp, _Dist>& operator++() {
_M_read();
return *this;
}
istream_iterator<_Tp, _Dist> operator++(int) {
istream_iterator<_Tp, _Dist> __tmp = *this;
_M_read();
return __tmp;
}
};
# 864 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/stl_iterator.h" 3
template <class _Tp, class _Distance>
inline bool operator==(const istream_iterator<_Tp, _Distance>& __x,
const istream_iterator<_Tp, _Distance>& __y) {
return (__x._M_stream == __y._M_stream &&
__x._M_end_marker == __y._M_end_marker) ||
__x._M_end_marker == false && __y._M_end_marker == false;
}
template <class _Tp>
class ostream_iterator {
protected:
ostream* _M_stream;
const char* _M_string;
public:
typedef output_iterator_tag iterator_category;
typedef void value_type;
typedef void difference_type;
typedef void pointer;
typedef void reference;
ostream_iterator(ostream& __s) : _M_stream(&__s), _M_string(0) {}
ostream_iterator(ostream& __s, const char* __c)
: _M_stream(&__s), _M_string(__c) {}
ostream_iterator<_Tp>& operator=(const _Tp& __value) {
*_M_stream << __value;
if (_M_string) *_M_stream << _M_string;
return *this;
}
ostream_iterator<_Tp>& operator*() { return *this; }
ostream_iterator<_Tp>& operator++() { return *this; }
ostream_iterator<_Tp>& operator++(int) { return *this; }
};
# 907 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/stl_iterator.h" 3
# 38 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/iterator" 2 3
# 20 "../VxNumerics/seq-alg.h" 2
template< class InputIterator, class OutputIterator >
void
seq_add (InputIterator first1, InputIterator last1,
OutputIterator first2)
{
while (first1 != last1)
*first2++ += *first1++;
}
template< class InputIterator1, class InputIterator2,
class OutputIterator >
void
seq_add (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, OutputIterator first3)
{
while (first1 != last1)
*first3++ = *first1++ + *first2++;
}
template< class ValueType, class InputIterator, class OutputIterator >
void
seq_add (ValueType a, InputIterator first1, InputIterator last1,
OutputIterator first2)
{
while (first1 != last1)
*first2++ = *first1++ + a;
}
template< class InputIterator, class OutputIterator >
void
seq_sub (InputIterator first1, InputIterator last1,
OutputIterator first2)
{
while (first1 != last1)
*first2++ -= *first1++;
}
template< class InputIterator1, class InputIterator2,
class OutputIterator >
void
seq_sub (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, OutputIterator first3)
{
while (first1 != last1)
*first3++ = *first1++ - *first2++;
}
template< class InputIterator, class OutputIterator >
void
seq_mul (InputIterator first1, InputIterator last1,
OutputIterator first2)
{
while (first1 != last1)
*first2++ *= *first1++;
}
template< class ValueType, class ForwardIterator >
void
seq_mul (ValueType a, ForwardIterator first, ForwardIterator last)
{
while (first != last)
*first++ *= a;
}
template< class InputIterator1, class InputIterator2,
class OutputIterator >
void
seq_mul (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, OutputIterator first3)
{
while (first1 != last1)
*first3++ = *first1++ * *first2++;
}
template< class ValueType, class InputIterator, class OutputIterator >
void
seq_mul (ValueType a, InputIterator first1, InputIterator last1,
OutputIterator first2)
{
while (first1 != last1)
*first2++ = *first1++ * a;
}
template< class InputIterator, class OutputIterator >
void
seq_div (InputIterator first1, InputIterator last1,
OutputIterator first2)
{
while (first1 != last1)
*first2++ /= *first1++;
}
template< class ValueType, class ForwardIterator >
void
seq_div (ValueType a, ForwardIterator first, ForwardIterator last)
{
while (first != last)
*first++ /= a;
}
template< class InputIterator1, class InputIterator2,
class OutputIterator >
void
seq_div (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, OutputIterator first3)
{
while (first1 != last1)
*first3++ = *first1++ / *first2++;
}
template< class ValueType, class InputIterator, class OutputIterator >
void
seq_div (ValueType a, InputIterator first1, InputIterator last1,
OutputIterator first2)
{
while (first1 != last1)
*first2++ = *first1++ / a;
}
template< class InputIterator, class OutputIterator >
void
seq_copy (InputIterator first1, InputIterator last1, OutputIterator first2)
{
while (first1 != last1)
*first2++ = *first1++;
}
template< class InputIterator1, class InputIterator2 >
bool
seq_eq (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
{
while (first1 != last1)
if (*first1++ != *first2++)
return false;
return true;
}
template< class InputIterator1, class InputIterator2 >
bool
seq_neq (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2)
{
while (first1 != last1)
if (*first1++ == *first2++)
return false;
return true;
}
template< class ValueType, class InputIterator >
bool
seq_neq (InputIterator first, InputIterator last, ValueType a)
{
while (first != last)
if (*first++ == a)
return false;
return true;
}
template< class InputIterator1, class InputIterator2, class ValueType >
void
seq_scalar (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, ValueType& r)
{
r = *first1++ * *first2++;
while (first1 != last1)
r += *first1++ * *first2++;
}
template< class Vector >
typename Vector::value_type
inner (Vector const& u, Vector const& v)
{
typedef typename Vector::const_iterator const_iterator;
if (u.size () != v.size ())
{
cerr << "::inner -> incompatible Vector sizes\n";
exit (1);
}
typename Vector::value_type sum = 0;
const_iterator p = u.begin (), q = u.end ();
const_iterator r = v.begin ();
while (p < q)
sum += *p++ * *r++;
return sum;
}
# 15 "../VxNumerics/VxVector.h" 2
template< class T >
class VxVector
{
public:
typedef T* iterator;
typedef T const* const_iterator;
typedef ptrdiff_t difference_type;
typedef ptrdiff_t size_type;
typedef T value_type;
typedef T* pointer;
typedef T const* const_pointer;
typedef T& reference;
typedef T const& const_reference;
VxVector ();
explicit VxVector (size_type size);
VxVector (size_type size, T value);
VxVector (const_iterator b, const_iterator e);
reference operator [] (size_type index);
const_reference operator [] (size_type index) const;
reference operator () (size_type index);
const_reference operator () (size_type index) const;
reference elem (size_type index);
const_reference elem (size_type index) const;
iterator begin ();
const_iterator begin () const;
iterator end ();
const_iterator end () const;
size_type size () const;
void resize (size_type new_size);
void swap (VxVector& v);
value_type sum () const;
VxVector (VxVector const& new_value);
VxVector& operator = (VxVector const& rhs);
VxVector& operator = (T val);
~VxVector ();
private:
void clone ();
struct rep_type;
rep_type* m_rep;
};
template< class Type >
struct VxVector< Type >::rep_type
{
rep_type ()
: count (1), data (0), size (0) {}
rep_type (size_type size)
: count (1), data (new Type [size]), size (size) {}
rep_type (rep_type const* old_rep)
: count (1), data (new Type [old_rep->size]), size (old_rep->size)
{
::seq_copy (old_rep->data, old_rep->data + size, data);
}
~rep_type () { delete [] data; }
void ref () { ++count; }
void deref () { if (--count == 0) delete this; }
size_t count;
Type* data;
size_type size;
};
# 1 "../VxNumerics/VxVector.cc" 1
# 1 "../VxNumerics/g-util.h" 1
template< class T >
inline
void
swap (T& a, T& b)
{
T c = a;
a = b;
b = c;
}
# 10 "../VxNumerics/VxVector.cc" 2
template< class T >
inline VxVector< T >::VxVector ()
: m_rep (new rep_type ())
{}
template< class T >
inline VxVector< T >::VxVector (size_type size)
: m_rep (new rep_type (size))
{}
template< class T >
inline void
VxVector< T >::clone ()
{
if (m_rep->count > 1)
{
rep_type* old_rep = m_rep;
m_rep = new rep_type (old_rep);
old_rep->deref ();
}
}
template< class T >
inline VxVector< T >::reference
VxVector< T >::operator [] (size_type index)
{
clone ();
return m_rep->data [index];
}
template< class T >
inline VxVector< T >::const_reference
VxVector< T >::operator [] (size_type index) const
{
return m_rep->data [index];
}
template< class T >
inline VxVector< T >::reference
VxVector< T >::operator () (size_type index)
{
clone ();
return m_rep->data [index];
}
template< class T >
inline VxVector< T >::const_reference
VxVector< T >::operator () (size_type index) const
{
return m_rep->data [index];
}
template< class T >
inline VxVector< T >::iterator
VxVector< T >::begin ()
{
clone ();
return m_rep->data;
}
template< class T >
inline VxVector< T >::const_iterator
VxVector< T >::begin () const
{
return m_rep->data;
}
template< class T >
inline VxVector< T >::iterator
VxVector< T >::end ()
{
clone ();
return m_rep->data + m_rep->size;
}
template< class T >
inline VxVector< T >::const_iterator
VxVector< T >::end () const
{
return m_rep->data + m_rep->size;
}
template< class T >
inline VxVector< T >::size_type
VxVector< T >::size () const
{
return m_rep->size;
}
template< class T >
void
VxVector< T >::resize (size_type new_size)
{
if (new_size != size ())
{
m_rep->deref ();
m_rep = new rep_type (new_size);
}
}
template< class T >
T
VxVector< T >::sum () const
{
value_type result = 0;
const_iterator p = begin (), q = end ();
if (p < q)
result = *p++;
while (p < q)
result += *p++;
return result;
}
template< class T >
inline void
VxVector< T >::swap (VxVector< T >& v)
{
::swap (m_rep, v.m_rep);
}
template< class T >
inline
VxVector< T >::~VxVector ()
{
m_rep->deref ();
}
template< class T >
VxVector< T >::VxVector (size_type size, T value)
: m_rep (new rep_type (size))
{
iterator p = begin (), q = end ();
while (p < q)
*p++ = value;
}
template< class T >
VxVector< T >::VxVector (const_iterator b, const_iterator e)
: m_rep (new rep_type (e - b))
{
iterator p = begin (), q = end ();
while (p < q)
*p++ = *b++;
}
template< class T >
VxVector< T >::VxVector (VxVector< T > const& v)
: m_rep (v.m_rep)
{
m_rep->ref ();
}
template< class T >
VxVector< T >&
VxVector< T >::operator = (VxVector< T > const& rhs)
{
if (m_rep != rhs.m_rep)
{
m_rep->deref ();
m_rep = rhs.m_rep;
m_rep->ref ();
}
return *this;
}
template< class T >
VxVector< T >&
VxVector< T >::operator = (T val)
{
clone ();
iterator p = begin (), q = end ();
while (p < q)
*p++ = val;
return *this;
}
# 112 "../VxNumerics/VxVector.h" 2
# 8 "../data-types.h" 2
# 1 "../VxNumerics/VxFixVector.h" 1
template< class T, int N >
class VxFixVector
{
public:
typedef T* iterator;
typedef T const* const_iterator;
typedef int difference_type;
typedef int size_type;
typedef T value_type;
typedef T& reference;
typedef T const& const_reference;
VxFixVector () {}
explicit VxFixVector (value_type value);
explicit VxFixVector (const_iterator first);
reference operator [] (size_type index);
const_reference operator [] (size_type index) const;
reference operator () (size_type index);
const_reference operator () (size_type index) const;
reference elem (size_type index);
const_reference elem (size_type index) const;
iterator begin ();
const_iterator begin () const;
iterator end ();
const_iterator end () const;
size_type size () const;
static VxFixVector< T, N > unsafe_make (value_type value, ...);
VxFixVector (VxFixVector const& new_value);
VxFixVector& operator = (VxFixVector const& rhs);
~VxFixVector ();
private:
T m_data [N];
};
template< class T >
inline VxFixVector< T, 2 >
make_fixvec (T const& x, T const& y)
{
return VxFixVector< T, 2 >::unsafe_make (x, y);
}
template< class T >
inline VxFixVector< T, 3 >
make_fixvec (T const& x, T const& y, T const& z)
{
return VxFixVector< T, 3 >::unsafe_make (x, y, z);
}
template< class T >
inline VxFixVector< T, 4 >
make_fixvec (T const& w, T const& x, T const& y, T const& z)
{
return VxFixVector< T, 4 >::unsafe_make (w, x, y, z);
}
template< class T >
inline VxFixVector< T, 6 >
make_fixvec (T const& u, T const& v, T const& w,
T const& x, T const& y, T const& z)
{
return VxFixVector< T, 6 >::unsafe_make (u, v, w, x, y, z);
}
# 1 "../VxNumerics/VxFixVector.cc" 1
# 1 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stdarg.h" 1 3 4
# 1 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/va-sparc.h" 1 3 4
typedef void * __gnuc_va_list;
# 47 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/va-sparc.h" 3 4
void va_end (__gnuc_va_list);
enum __va_type_classes {
__no_type_class = -1,
__void_type_class,
__integer_type_class,
__char_type_class,
__enumeral_type_class,
__boolean_type_class,
__pointer_type_class,
__reference_type_class,
__offset_type_class,
__real_type_class,
__complex_type_class,
__function_type_class,
__method_type_class,
__record_type_class,
__union_type_class,
__array_type_class,
__string_type_class,
__set_type_class,
__file_type_class,
__lang_type_class
};
# 134 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/va-sparc.h" 3 4
# 159 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/va-sparc.h" 3 4
# 30 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stdarg.h" 2 3 4
# 135 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stdarg.h" 3 4
typedef __gnuc_va_list va_list;
# 207 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stdarg.h" 3 4
# 9 "../VxNumerics/VxFixVector.cc" 2
template< class T, int N >
inline
VxFixVector< T, N >::reference
VxFixVector< T, N >::operator [] (size_type index)
{
return m_data [index];
}
template< class T, int N >
inline
VxFixVector< T, N >::const_reference
VxFixVector< T, N >::operator [] (size_type index) const
{
return m_data [index];
}
template< class T, int N >
inline
VxFixVector< T, N >::reference
VxFixVector< T, N >::operator () (size_type index)
{
return m_data [index];
}
template< class T, int N >
inline
VxFixVector< T, N >::const_reference
VxFixVector< T, N >::operator () (size_type index) const
{
return m_data [index];
}
template< class T, int N >
inline
VxFixVector< T, N >::reference
VxFixVector< T, N >::elem (size_type index)
{
if (0 <= index && index < N)
return m_data [index];
cerr << "attempt to index element " << index
<< " in size " << N << " VxFixVector object\n";
exit (1);
}
template< class T, int N >
inline
VxFixVector< T, N >::const_reference
VxFixVector< T, N >::elem (size_type index) const
{
if (0 <= index && index < N)
return m_data [index];
cerr << "attempt to index element " << index
<< " in size " << N << " VxFixVector object\n";
exit (1);
}
template< class T, int N >
inline
VxFixVector< T, N >::iterator
VxFixVector< T, N >::begin ()
{
return m_data;
}
template< class T, int N >
inline
VxFixVector< T, N >::const_iterator
VxFixVector< T, N >::begin () const
{
return m_data;
}
template< class T, int N >
inline
VxFixVector< T, N >::iterator
VxFixVector< T, N >::end ()
{
return m_data + N;
}
template< class T, int N >
inline
VxFixVector< T, N >::const_iterator
VxFixVector< T, N >::end () const
{
return m_data + N;
}
template< class T, int N >
inline
VxFixVector< T, N >::size_type
VxFixVector< T, N >::size () const
{
return N;
}
template< class T, int N >
inline
VxFixVector< T, N >::~VxFixVector ()
{
}
template< class T, int N >
VxFixVector< T, N >::VxFixVector (value_type value)
{
iterator p = begin ();
iterator q = end ();
while (p < q)
*p++ = value;
}
template< class T, int N >
VxFixVector< T, N >::VxFixVector (const_iterator first)
{
iterator p = begin ();
iterator q = end ();
while (p < q)
*p++ = *first++;
}
template< class T, int N >
VxFixVector< T, N >::VxFixVector (VxFixVector< T, N > const& v)
{
iterator p = begin ();
const_iterator q = v.begin ();
iterator r = end ();
while (p < r)
*p++ = *q++;
}
template< class T, int N >
VxFixVector< T, N >&
VxFixVector< T, N >::operator = (VxFixVector< T, N > const& rhs)
{
iterator p = begin ();
const_iterator q = rhs.begin ();
iterator r = end ();
while (p < r)
*p++ = *q++;
return *this;
}
template< class T, int N >
VxFixVector< T, N >
VxFixVector< T, N >::unsafe_make (value_type value, ...)
{
VxFixVector< T, N > result;
va_list ap;
(__builtin_next_arg ( value ), ap = (char *) __builtin_saveregs ()) ;
iterator p = result.begin (), q = result.end ();
*p++ = value;
while (p < q)
*p++ = __extension__ (*({((__builtin_classify_type (*( T *) 0) >= __record_type_class || (__builtin_classify_type (*( T *) 0) == __real_type_class && sizeof ( T ) == 16)) ? (( ap ) = (char *)( ap ) + (((sizeof ( T * ) + sizeof (int) - 1) / sizeof (int)) * sizeof (int)) , *( T **) (void *) ((char *)( ap ) - (((sizeof ( T * ) + sizeof (int) - 1) / sizeof (int)) * sizeof (int)) )) : (((sizeof ( T ) + sizeof (int) - 1) / sizeof (int)) * sizeof (int)) == 8 ? ({ union {char __d[sizeof ( T )]; int __i[2];} __u; __u.__i[0] = ((int *) (void *) ( ap ))[0]; __u.__i[1] = ((int *) (void *) ( ap ))[1]; ( ap ) = (char *)( ap ) + 8; ( T *) (void *) __u.__d; }) : (( ap ) = (char *)( ap ) + (((sizeof ( T ) + sizeof (int) - 1) / sizeof (int)) * sizeof (int)) , (( T *) (void *) ((char *)( ap ) - (((sizeof ( T ) + sizeof (int) - 1) / sizeof (int)) * sizeof (int)) ))));})) ;
((void)0) ;
return result;
}
# 109 "../VxNumerics/VxFixVector.h" 2
# 9 "../data-types.h" 2
# 1 "../VxNumerics/VxMatrix.h" 1
# 1 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stddef.h" 1 3 4
# 342 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stddef.h" 3 4
# 14 "../VxNumerics/VxMatrix.h" 2
template< class T >
class VxMatrix
{
public:
typedef T* iterator;
typedef T const* const_iterator;
typedef ptrdiff_t difference_type;
typedef ptrdiff_t size_type;
typedef T value_type;
typedef T* pointer;
typedef T const* const_pointer;
typedef T& reference;
typedef T const& const_reference;
enum {inplace};
class index_type;
class block_type;
VxMatrix ();
VxMatrix (size_type rows, size_type cols);
VxMatrix (size_type rows, size_type cols, T value);
VxMatrix (size_type rows, size_type cols, const_iterator b, const_iterator e);
reference operator () (size_type row, size_type col);
const_reference operator () (size_type row, size_type col) const;
iterator begin ();
const_iterator begin () const;
iterator end ();
const_iterator end () const;
size_type rows () const;
size_type cols () const;
size_type size () const;
void get_row (size_type row, iterator first, iterator last) const;
void get_col (size_type col, iterator first, iterator last) const;
void put_row (size_type row, const_iterator first, const_iterator last);
void put_col (size_type col, const_iterator first, const_iterator last);
void swap_row (size_type row1, size_type row2);
void swap_col (size_type col1, size_type col2);
VxMatrix< T > submatrix (size_type row, size_type col,
size_type bx, size_type by) const;
void submatrix (block_type const& block, iterator pout) const;
void submatrix (VxFixVector< int, 4 > const& block, iterator pout) const;
void resize (size_type rows, size_type cols);
VxMatrix< T > transpose () const;
VxMatrix< T > inverse () const;
void inverse (int);
void solve (pointer v) const;
void solve (pointer v, int);
void svdcmp (VxVector<T> &w, VxMatrix<T> &v);
void svbksb (VxVector<T> const &w, VxMatrix<T> const &v,
VxVector<T> const &b, VxVector<T> &x) const;
value_type sum () const;
static VxMatrix< T > Identity (size_type n);
VxMatrix (VxMatrix const& new_value);
VxMatrix& operator = (VxMatrix const& rhs);
VxMatrix& operator = (T val);
virtual ~VxMatrix ();
private:
void clone ();
struct rep_type;
rep_type* m_rep;
};
template< class Type >
struct VxMatrix< Type >::rep_type
{
rep_type ()
: count (1), data (0), rows (0), cols (0) {}
rep_type (size_type trows, size_type tcols)
: count (1), data (new Type [trows * tcols]), rows (trows), cols (tcols) {}
rep_type (rep_type const* old_rep)
: count (1), data (new Type [old_rep->rows * old_rep->cols]),
rows (old_rep->rows), cols (old_rep->cols)
{
::seq_copy (old_rep->data, old_rep->data + rows * cols, data);
}
~rep_type () { delete [] data; }
void ref () { ++count; }
void deref () { if (--count == 0) delete this; }
size_t count;
Type* data;
size_type rows;
size_type cols;
};
template< class T >
class VxMatrix< T >::index_type
: public VxFixVector< typename VxMatrix< T >::size_type, 2 >
{
public:
index_type (size_type val = 0)
: VxFixVector< size_type, 2 > (val) {}
index_type (size_type i, size_type j)
: VxFixVector< size_type, 2 > (make_fixvec (i, j)) {}
};
template< class T >
class VxMatrix< T >::block_type
{
public:
block_type ()
: start (0), extent (0) {}
block_type (index_type the_start, index_type the_extent)
: start (the_start), extent (the_extent) {}
block_type (VxMatrix< T > const& Matrix)
: start (0), extent (Matrix.rows (), Matrix.cols ()) {}
size_type elements () { return extent [0] * extent [1]; }
index_type start;
index_type extent;
};
# 1 "../VxNumerics/VxMatrix.cc" 1
# 1 "../VxNumerics/m-util.h" 1
template< class T >
inline
T
max (T const& a, T const& b)
{
return a > b ? a : b;
}
template< class T >
inline
T
min (T const& a, T const& b)
{
return a < b ? a : b;
}
template< class T >
inline
T
sqr (T const& a)
{
return a * a;
}
# 9 "../VxNumerics/VxMatrix.cc" 2
# 1 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/math.h" 1 3 4
# 1 "/usr/include/math.h" 1 3 4
extern "C" {
#pragma ident "@(#)math.h 2.7 98/01/27"
typedef union _h_val {
unsigned long _i[sizeof(double) / sizeof(unsigned long)];
double _d;
} _h_val;
extern const _h_val __huge_val;
extern int signgam;
enum version {libm_ieee = -1, c_issue_4, ansi_1, strict_ansi};
extern const enum version _lib_version;
struct __math_exception {
int type;
char *name;
double arg1;
double arg2;
double retval;
};
extern double acos (double) ;
extern double asin (double) ;
extern double atan (double) ;
extern double atan2 (double, double) ;
extern double cos (double) ;
extern double sin (double) ;
extern double tan (double) ;
extern double cosh (double) ;
extern double sinh (double) ;
extern double tanh (double) ;
extern double exp (double) ;
extern double frexp (double, int *) ;
extern double ldexp (double, int) ;
extern double log (double) ;
extern double log10 (double) ;
extern double modf (double, double *) ;
extern double pow (double, double) ;
extern double sqrt (double) ;
extern double ceil (double) ;
extern double fabs (double) ;
extern double floor (double) ;
extern double fmod (double, double) ;
extern double erf (double) ;
extern double erfc (double) ;
extern double gamma (double) ;
extern double hypot (double, double) ;
extern int isnan (double) ;
extern double j0 (double) ;
extern double j1 (double) ;
extern double jn (int, double) ;
extern double lgamma (double) ;
extern double y0 (double) ;
extern double y1 (double) ;
extern double yn (int, double) ;
extern double acosh (double) ;
extern double asinh (double) ;
extern double atanh (double) ;
extern double cbrt (double) ;
extern double logb (double) ;
extern double nextafter (double, double) ;
extern double remainder (double, double) ;
extern double scalb (double, double) ;
extern double expm1 (double) ;
extern int ilogb (double) ;
extern double log1p (double) ;
extern double rint (double) ;
extern int matherr (struct __math_exception *) ;
extern double significand (double) ;
extern double copysign (double, double) ;
extern double scalbn (double, int) ;
extern float modff (float, float *) ;
# 1 "/usr/include/floatingpoint.h" 1 3 4
extern "C" {
#pragma ident "@(#)floatingpoint.h 2.4 94/06/09"
# 1 "/usr/include/stdio.h" 1 3 4
#pragma ident "@(#)stdio.h 1.69 98/07/13 SMI"
# 1 "/usr/include/sys/feature_tests.h" 1 3 4
#pragma ident "@(#)feature_tests.h 1.17 97/12/04 SMI"
# 1 "/usr/include/sys/isa_defs.h" 1 3 4
#pragma ident "@(#)isa_defs.h 1.16 99/05/25 SMI"
extern "C" {
# 218 "/usr/include/sys/isa_defs.h" 3 4
# 316 "/usr/include/sys/isa_defs.h" 3 4
}
# 15 "/usr/include/sys/feature_tests.h" 2 3 4
extern "C" {
}
# 22 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/sys/va_list.h" 1 3 4
#pragma ident "@(#)va_list.h 1.11 97/11/22 SMI"
extern "C" {
typedef void *__va_list;
}
# 23 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/stdio_tag.h" 1 3 4
#pragma ident "@(#)stdio_tag.h 1.3 98/04/20 SMI"
extern "C" {
typedef struct FILE __FILE;
}
# 24 "/usr/include/stdio.h" 2 3 4
# 1 "/usr/include/stdio_impl.h" 1 3 4
#pragma ident "@(#)stdio_impl.h 1.7 98/04/17 SMI"
extern "C" {
typedef int ssize_t;
# 36 "/usr/include/stdio_impl.h" 3 4
struct FILE
{
ssize_t _cnt;
unsigned char *_ptr;
unsigned char *_base;
unsigned char _flag;
unsigned char _file;
unsigned __orientation:2;
unsigned __filler:6;
};
}
# 25 "/usr/include/stdio.h" 2 3 4
extern "C" {
typedef __FILE FILE;
typedef long long __longlong_t;
typedef long off_t;
typedef __longlong_t off64_t;
typedef long fpos_t;
typedef __longlong_t fpos64_t;
extern FILE __iob[20 ];
extern unsigned char _sibuf[], _sobuf[];
# 227 "/usr/include/stdio.h" 3 4
extern unsigned char *_bufendtab[];
extern FILE *_lastbuf;
# 257 "/usr/include/stdio.h" 3 4
extern int remove(const char *);
extern int rename(const char *, const char *);
extern FILE *tmpfile(void);
extern char *tmpnam(char *);
extern int fclose(FILE *);
extern int fflush(FILE *);
extern FILE *fopen(const char *, const char *);
extern FILE *freopen(const char *, const char *, FILE *);
extern void setbuf(FILE *, char *);
extern void setbuffer(FILE *, char *, size_t);
extern int setlinebuf(FILE *);
extern int setvbuf(FILE *, char *, int, size_t);
extern int fprintf(FILE *, const char *, ...);
extern int fscanf(FILE *, const char *, ...);
extern int printf(const char *, ...);
extern int scanf(const char *, ...);
extern int snprintf(char *, size_t, const char *, ...);
extern int sprintf(char *, const char *, ...);
extern int sscanf(const char *, const char *, ...);
extern int vfprintf(FILE *, const char *, __va_list);
extern int vprintf(const char *, __va_list);
extern int vsnprintf(char *, size_t, const char *, __va_list);
extern int vsprintf(char *, const char *, __va_list);
extern int fgetc(FILE *);
extern char *fgets(char *, int, FILE *);
extern int fputc(int, FILE *);
extern int fputs(const char *, FILE *);
extern int getc(FILE *);
extern int getchar(void);
extern char *gets(char *);
extern int putc(int, FILE *);
extern int putchar(int);
extern int puts(const char *);
extern int ungetc(int, FILE *);
extern size_t fread(void *, size_t, size_t, FILE *);
extern size_t fwrite(const void *, size_t, size_t, FILE *);
extern int fgetpos(FILE *, fpos_t *);
extern int fseek(FILE *, long, int);
extern int fsetpos(FILE *, const fpos_t *);
extern long ftell(FILE *);
extern void rewind(FILE *);
extern void clearerr(FILE *);
extern int feof(FILE *);
extern int ferror(FILE *);
extern void perror(const char *);
extern int __filbuf(FILE *);
extern int __flsbuf(int, FILE *);
extern FILE *fdopen(int, const char *);
extern char *ctermid(char *);
extern int fileno(FILE *);
# 358 "/usr/include/stdio.h" 3 4
extern FILE *popen(const char *, const char *);
extern char *cuserid(char *);
extern char *tempnam(const char *, const char *);
extern int getopt(int, char *const *, const char *);
extern int getsubopt(char **, char *const *, char **);
extern char *optarg;
extern int optind, opterr, optopt;
extern int getw(FILE *);
extern int putw(int, FILE *);
extern int pclose(FILE *);
extern int fseeko(FILE *, off_t, int);
extern off_t ftello(FILE *);
extern FILE *fopen64(const char *, const char *);
extern FILE *freopen64(const char *, const char *, FILE *);
extern FILE *tmpfile64(void);
extern int fgetpos64(FILE *, fpos64_t *);
extern int fsetpos64(FILE *, const fpos64_t *);
extern int fseeko64(FILE *, off64_t, int);
extern off64_t ftello64(FILE *);
# 515 "/usr/include/stdio.h" 3 4
# 567 "/usr/include/stdio.h" 3 4
}
# 33 "/usr/include/floatingpoint.h" 2 3 4
# 1 "/usr/include/sys/ieeefp.h" 1 3 4
#pragma ident "@(#)ieeefp.h 2.7 94/11/09"
extern "C" {
enum fp_direction_type {
fp_nearest = 0,
fp_tozero = 1,
fp_positive = 2,
fp_negative = 3
};
enum fp_precision_type {
fp_extended = 0,
fp_single = 1,
fp_double = 2,
fp_precision_3 = 3
};
enum fp_exception_type {
fp_inexact = 0,
fp_division = 1,
fp_underflow = 2,
fp_overflow = 3,
fp_invalid = 4
};
enum fp_trap_enable_type {
fp_trap_inexact = 0,
fp_trap_division = 1,
fp_trap_underflow = 2,
fp_trap_overflow = 3,
fp_trap_invalid = 4
};
# 81 "/usr/include/sys/ieeefp.h" 3 4
# 122 "/usr/include/sys/ieeefp.h" 3 4
enum fp_class_type {
fp_zero = 0,
fp_subnormal = 1,
fp_normal = 2,
fp_infinity = 3,
fp_quiet = 4,
fp_signaling = 5
};
}
# 35 "/usr/include/floatingpoint.h" 2 3 4
typedef int sigfpe_code_type;
typedef void (*sigfpe_handler_type)();
extern sigfpe_handler_type sigfpe (sigfpe_code_type, sigfpe_handler_type) ;
typedef float single;
typedef unsigned extended[3];
typedef long double quadruple;
typedef unsigned fp_exception_field_type;
typedef char decimal_string[512 ];
typedef struct {
enum fp_class_type fpclass;
int sign;
int exponent;
decimal_string ds;
int more;
int ndigits;
} decimal_record;
enum decimal_form {
fixed_form,
floating_form
};
typedef struct {
enum fp_direction_type rd;
enum decimal_form df;
int ndigits;
} decimal_mode;
enum decimal_string_form {
invalid_form,
whitespace_form,
fixed_int_form,
fixed_intdot_form,
fixed_dotfrac_form,
fixed_intdotfrac_form,
floating_int_form,
floating_intdot_form,
floating_dotfrac_form,
floating_intdotfrac_form,
inf_form,
infinity_form,
nan_form,
nanstring_form
};
extern void single_to_decimal (single *, decimal_mode *, decimal_record *,
fp_exception_field_type *) ;
extern void double_to_decimal (double *, decimal_mode *, decimal_record *,
fp_exception_field_type *) ;
extern void extended_to_decimal (extended *, decimal_mode *,
decimal_record *, fp_exception_field_type *) ;
extern void quadruple_to_decimal (quadruple *, decimal_mode *,
decimal_record *, fp_exception_field_type *) ;
extern void decimal_to_single (single *, decimal_mode *, decimal_record *,
fp_exception_field_type *) ;
extern void decimal_to_double (double *, decimal_mode *, decimal_record *,
fp_exception_field_type *) ;
extern void decimal_to_extended (extended *, decimal_mode *,
decimal_record *, fp_exception_field_type *) ;
extern void decimal_to_quadruple (quadruple *, decimal_mode *,
decimal_record *, fp_exception_field_type *) ;
extern void string_to_decimal (char **, int, int, decimal_record *,
enum decimal_string_form *, char **) ;
extern void func_to_decimal (char **, int, int, decimal_record *,
enum decimal_string_form *, char **,
int (*)(void), int *, int (*)(int)) ;
extern void file_to_decimal (char **, int, int, decimal_record *,
enum decimal_string_form *, char **,
FILE *, int *) ;
extern char *seconvert (single *, int, int *, int *, char *) ;
extern char *sfconvert (single *, int, int *, int *, char *) ;
extern char *sgconvert (single *, int, int, char *) ;
extern char *econvert (double, int, int *, int *, char *) ;
extern char *fconvert (double, int, int *, int *, char *) ;
extern char *gconvert (double, int, int, char *) ;
extern char *qeconvert (quadruple *, int, int *, int *, char *) ;
extern char *qfconvert (quadruple *, int, int *, int *, char *) ;
extern char *qgconvert (quadruple *, int, int, char *) ;
extern char *ecvt (double, int, int *, int *) ;
extern char *fcvt (double, int, int *, int *) ;
extern char *gcvt (double, int, char *) ;
extern double atof (const char *) ;
extern double strtod (const char *, char **) ;
}
# 213 "/usr/include/math.h" 2 3 4
}
# 5 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/math.h" 2 3 4
# 10 "../VxNumerics/VxMatrix.cc" 2
# 1 "/usr/include/stdlib.h" 1 3 4
#pragma ident "@(#)stdlib.h 1.44 98/01/22 SMI"
extern "C" {
typedef struct {
int quot;
int rem;
} div_t;
typedef struct {
long quot;
long rem;
} ldiv_t;
typedef struct {
long long quot;
long long rem;
} lldiv_t;
typedef long uid_t;
# 101 "/usr/include/stdlib.h" 3 4
# 117 "/usr/include/stdlib.h" 3 4
extern unsigned char __ctype[];
extern double atof(const char *);
extern int atoi(const char *);
extern long int atol(const char *);
extern double strtod(const char *, char **);
extern long int strtol(const char *, char **, int);
extern unsigned long int strtoul(const char *, char **, int);
extern int rand(void);
extern void srand(unsigned int);
extern void *calloc(size_t, size_t);
extern void free(void *);
extern void *malloc(size_t);
extern void *realloc(void *, size_t);
extern void abort(void);
extern int atexit(void (*)(void));
extern void exit(int);
extern void _exithandle(void);
extern char *getenv(const char *);
extern int system(const char *);
extern void *bsearch(const void *, const void *, size_t, size_t,
int (*)(const void *, const void *));
extern void qsort(void *, size_t, size_t,
int (*)(const void *, const void *));
extern int abs(int);
extern div_t div(int, int);
extern long int labs(long);
extern ldiv_t ldiv(long, long);
extern int mbtowc(wchar_t *, const char *, size_t);
extern int mblen(const char *, size_t);
extern int wctomb(char *, wchar_t);
extern size_t mbstowcs(wchar_t *, const char *, size_t);
extern size_t wcstombs(char *, const wchar_t *, size_t);
extern double drand48(void);
extern double erand48(unsigned short *);
extern long jrand48(unsigned short *);
extern void lcong48(unsigned short *);
extern long lrand48(void);
extern long mrand48(void);
extern long nrand48(unsigned short *);
extern unsigned short *seed48(unsigned short *);
extern void srand48(long);
extern int putenv(char *);
extern void setkey(const char *);
extern void swab(const char *, char *, int);
extern int mkstemp(char *);
extern int mkstemp64(char *);
extern long a64l(const char *);
extern char *ecvt(double, int, int *, int *);
extern char *fcvt(double, int, int *, int *);
extern char *gcvt(double, int, char *);
extern int getsubopt(char **, char *const *, char **);
extern int grantpt(int);
extern char *initstate(unsigned, char *, size_t);
extern char *l64a(long);
extern char *mktemp(char *);
extern char *ptsname(int);
extern long random(void);
extern char *realpath(const char *, char *);
extern char *setstate(const char *);
extern void srandom(unsigned);
extern int ttyslot(void);
extern int unlockpt(int);
extern void *valloc(size_t);
extern int dup2(int, int);
extern char *qecvt(long double, int, int *, int *);
extern char *qfcvt(long double, int, int *, int *);
extern char *qgcvt(long double, int, char *);
extern char *getcwd(char *, size_t);
extern const char *getexecname(void);
extern char *getlogin(void);
extern int getopt(int, char *const *, const char *);
extern char *optarg;
extern int optind, opterr, optopt;
extern char *getpass(const char *);
extern char *getpassphrase(const char *);
extern int getpw(uid_t, char *);
extern int isatty(int);
extern void *memalign(size_t, size_t);
extern char *ttyname(int);
extern long long atoll(const char *);
extern long long llabs(long long);
extern lldiv_t lldiv(long long, long long);
extern char *lltostr(long long, char *);
extern long long strtoll(const char *, char **, int);
extern unsigned long long strtoull(const char *, char **, int);
extern char *ulltostr(unsigned long long, char *);
# 380 "/usr/include/stdlib.h" 3 4
}
# 11 "../VxNumerics/VxMatrix.cc" 2
template< class T >
inline
VxMatrix< T >::VxMatrix ()
: m_rep (new rep_type ())
{}
template< class T >
inline
VxMatrix< T >::VxMatrix (size_type rows, size_type cols)
: m_rep (new rep_type (rows, cols))
{}
template< class T >
inline void
VxMatrix< T >::clone ()
{
if (m_rep->count > 1)
{
rep_type* old_rep = m_rep;
m_rep = new rep_type (old_rep);
old_rep->deref ();
}
}
template< class T >
inline
VxMatrix< T >::reference
VxMatrix< T >::operator () (size_type row, size_type col)
{
clone ();
return m_rep->data [row * m_rep->cols + col];
}
template< class T >
inline
VxMatrix< T >::const_reference
VxMatrix< T >::operator () (size_type row, size_type col) const
{
return m_rep->data [row * m_rep->cols + col];
}
template< class T >
inline
VxMatrix< T >::iterator
VxMatrix< T >::begin ()
{
clone ();
return m_rep->data;
}
template< class T >
inline
VxMatrix< T >::const_iterator
VxMatrix< T >::begin () const
{
return m_rep->data;
}
template< class T >
inline
VxMatrix< T >::iterator
VxMatrix< T >::end ()
{
clone ();
return m_rep->data + m_rep->rows * m_rep->cols;
}
template< class T >
inline
VxMatrix< T >::const_iterator
VxMatrix< T >::end () const
{
return m_rep->data + m_rep->rows * m_rep->cols;
}
template< class T >
inline
VxMatrix< T >::size_type
VxMatrix< T >::rows () const
{
return m_rep->rows;
}
template< class T >
inline
VxMatrix< T >::size_type
VxMatrix< T >::cols () const
{
return m_rep->cols;
}
template< class T >
inline
VxMatrix< T >::size_type
VxMatrix< T >::size () const
{
return rows () * cols ();
}
template< class T >
inline
VxMatrix< T >::~VxMatrix ()
{
m_rep->deref ();
}
template< class T >
VxMatrix< T >::VxMatrix (size_type rows, size_type cols, T value)
: m_rep (new rep_type (rows, cols))
{
iterator p = begin (), q = end ();
while (p < q)
*p++ = value;
}
template< class T >
VxMatrix< T >::VxMatrix (size_type rows, size_type cols,
const_iterator b, const_iterator e)
: m_rep (new rep_type (rows, cols))
{
iterator p = begin (), q = end ();
while (p < q)
*p++ = *b++;
}
template< class T >
VxMatrix< T >::VxMatrix (VxMatrix< T > const& v)
: m_rep (v.m_rep)
{
m_rep->ref ();
}
template< class T >
VxMatrix< T >&
VxMatrix< T >::operator = (VxMatrix< T > const& rhs)
{
if (m_rep != rhs.m_rep)
{
m_rep->deref ();
m_rep = rhs.m_rep;
m_rep->ref ();
}
return *this;
}
template< class T >
VxMatrix< T >&
VxMatrix< T >::operator = (T val)
{
clone ();
iterator p = begin (), q = end ();
while (p < q)
*p++ = val;
return *this;
}
template< class T >
void
VxMatrix< T >::get_row (size_type row, iterator first, iterator last) const
{
iterator p = m_rep->data + row * m_rep->cols;
while (first < last)
*first++ = *p++;
}
template< class T >
void
VxMatrix< T >::get_col (size_type col, iterator first, iterator last) const
{
size_type cols = m_rep->cols;
iterator p = m_rep->data + col;
while (first < last)
{
*first++ = *p;
p += cols;
}
}
template< class T >
void
VxMatrix< T >::put_row (size_type row,
const_iterator first, const_iterator last)
{
clone ();
iterator p = m_rep->data + row * m_rep->cols;
while (first < last)
*p++ = *first++;
}
template< class T >
void
VxMatrix< T >::put_col (size_type col,
const_iterator first, const_iterator last)
{
clone ();
size_type cols = m_rep->cols;
iterator p = m_rep->data + col;
while (first < last)
{
*p = *first++;
p += cols;
}
}
template< class T >
void
VxMatrix< T >::swap_row (size_type row1, size_type row2)
{
clone ();
if (row1 != row2)
{
size_type cols = m_rep->cols;
iterator p = m_rep->data + row1 + cols, q = m_rep->data + row2 + cols;
for (size_type j = cols; j > 0; --j)
swap (*p++, *q++);
}
}
template< class T >
void
VxMatrix< T >::swap_col (size_type col1, size_type col2)
{
clone ();
if (col1 != col2)
{
size_type cols = m_rep->cols;
iterator p = m_rep->data + col1, q = m_rep->data + col2;
for (size_type i = m_rep->rows; i > 0; --i, p += cols, q += cols)
swap (*p, *q);
}
}
template< class T >
VxMatrix< T >
VxMatrix< T >::submatrix (size_type row, size_type col,
size_type rows, size_type cols) const
{
VxMatrix< T > result (rows, cols);
size_type stride = m_rep->cols;
const_iterator p = begin () + row * stride + col;
iterator r = result.begin ();
while (rows-- > 0)
{
const_iterator q = p;
for (size_type j = cols; j > 0; --j)
*r++ = *q++;
p += stride;
}
return result;
}
template< class T >
void
VxMatrix< T >::submatrix (block_type const& block, iterator pout) const
{
size_type rows = block.extent [0], cols = block.extent [1];
size_type stride = m_rep->cols;
const_iterator p = begin () + block.start [0] * stride + block.start [1];
while (rows-- > 0)
{
const_iterator q = p;
for (size_type j = cols; j > 0; --j)
*pout++ = *q++;
p += stride;
}
}
template< class T >
void
VxMatrix< T >::submatrix (VxFixVector< int, 4 > const& block,
iterator pout) const
{
submatrix (block_type (index_type (block [0], block [1]),
index_type (block [2], block [3])),
pout);
}
template< class T >
void
VxMatrix< T >::resize (size_type rows, size_type cols)
{
if (m_rep->rows != rows || m_rep->cols != cols)
{
m_rep->deref ();
m_rep = new rep_type (rows, cols);
}
}
template< class T >
T
VxMatrix< T >::sum () const
{
value_type result = 0;
const_iterator p = begin (), q = end ();
if (p < q)
result = *p++;
while (p < q)
result += *p++;
return result;
}
template< class T >
VxMatrix< T >
VxMatrix< T >::transpose () const
{
VxMatrix< T > result (m_rep->cols, m_rep->rows);
const_iterator p = begin (), q = end ();
iterator r = result.begin (), s = result.end ();
while (p < q)
for (iterator t = r++; t < s; t += stride)
*t = *p++;
return result;
}
template< class T >
VxMatrix< T >
VxMatrix< T >::inverse () const
{
VxMatrix< T > result = *this;
result.inverse (inplace);
return result;
}
template< class T >
void
VxMatrix< T >::inverse (int)
{
clone ();
solve (0, inplace);
}
template< class T >
void
VxMatrix< T >::solve (pointer v) const
{
if (v)
{
VxMatrix< T > temp = *this;
temp.solve (v, inplace);
}
}
template< class T >
void
VxMatrix< T >::solve (pointer v, int)
{
clone ();
size_type rank = cols ();
VxVector< size_type > pivot_rows (rank, 0);
VxVector< size_type > pivot_cols (rank, 0);
VxVector< size_type > pivot_flag (rank, 0);
for (size_type n = 0; n < rank; ++n)
{
bool pivot_found = false;
T pivot_value = 0;
size_type pivot_row = 0, pivot_col = 0;
const_iterator data = begin ();
for (size_type i = 0; i < m_rep->rows; ++i)
{
if (pivot_flag (i) == 0)
for (size_type j = 0; j < m_rep->cols; ++j)
{
if (pivot_flag (j) == 0)
{
T absv = fabs (*data);
if (absv > pivot_value)
{
pivot_found = true;
pivot_value = absv;
pivot_row = i;
pivot_col = j;
}
}
++data;
}
else
data += m_rep->cols;
}
if (!pivot_found)
{
cerr << "No pivot element found in VxMatrix<T>::solve" << endl;
exit (1);
}
pivot_rows (n) = pivot_row;
pivot_cols (n) = pivot_col;
pivot_flag (pivot_col) += 1;
swap_row (pivot_row, pivot_col);
if (v)
swap (v [pivot_row], v [pivot_col]);
reference pivot = (*this) (pivot_col, pivot_col);
T pivot_inv = 1 / pivot;
pivot = 1;
for (size_type j = 0; j < m_rep->cols; ++j)
m_rep->data [pivot_col * m_rep->cols + j] *= pivot_inv;
if (v)
v [pivot_col] *= pivot_inv;
for (size_type i = 0; i < m_rep->rows; ++i)
if (i != pivot_col)
{
T scale = m_rep->data [i * m_rep->cols + pivot_col];
m_rep->data [i * m_rep->cols + pivot_col] = 0;
for (size_type j = 0; j < m_rep->cols; ++j)
m_rep->data [i * m_rep->cols + j] -= scale * m_rep->data [pivot_col * m_rep->cols + j];
if (v)
v [i] -= scale * v [pivot_col];
}
}
for (size_type n = rank; --n >= 0;)
if (pivot_rows (n) != pivot_cols (n))
swap_col (pivot_rows (n), pivot_cols (n));
}
template< class T >
void
VxMatrix< T >::svdcmp (VxVector<T> &wvec, VxMatrix<T> &vmat)
{
size_type m = rows (), n = cols ();
wvec.resize (n);
vmat.resize (n, n);
VxVector<T> rv1_vec (n);
iterator w = wvec.begin ();
iterator v = vmat.begin ();
iterator a = begin ();
double pythag (double a, double b);
size_type flag, i, its, j, jj, k, l, nm;
T anorm, c, f, g, h, s, scale, x, y, z, *rv1;
rv1 = rv1_vec.begin ();
g = scale = anorm = 0;
for (i = 0; i < n; ++i)
{
l = i + 1;
rv1 [i] = scale * g;
g = s = scale = 0;
if (i < m)
{
for (k = i; k < m; ++k)
scale += fabs (a [k * n + i]);
if (scale)
{
for (k = i; k < m; ++k)
{
a [k * n + i] /= scale;
s += a [k * n + i] * a [k * n + i];
}
f = a [i * n + i];
g = (f >= 0 ? -1 : +1) * fabs (sqrt (s));
h = f * g - s;
a [i * n + i] = f - g;
for (j = l; j < n; ++j)
{
for (s = 0, k = i; k < m; ++k)
s += a [k * n + i] * a [k * n + j];
f = s / h;
for (k = i; k < m; ++k)
a [k * n + j] += f * a [k * n + i];
}
for (k = i; k < m; ++k)
a [k * n + i] *= scale;
}
}
w [i] = scale * g;
g = s = scale = 0;
if (i < m && i != n - 1)
{
for (k = l; k < n; ++k)
scale += fabs (a [i * n + k]);
if (scale)
{
for (k = l; k < n; ++k)
{
a [i * n + k] /= scale;
s += a [i * n + k] * a [i * n + k];
}
f = a [i * n + l];
g = (f >= 0.0 ? -1 : +1) * fabs (sqrt (s));
h = f * g - s;
a [i * n + l] = f - g;
for (k = l; k < n; ++k)
rv1 [k] = a [i * n + k] / h;
for (j = l; j < m; ++j)
{
for (s = 0, k = l; k < n; ++k)
s += a [j * n + k] * a [i * n + k];
for (k = l; k < n; ++k)
a [j * n + k] += s * rv1 [k];
}
for (k = l; k < n; ++k)
a [i * n + k] *= scale;
}
}
anorm = max (anorm, fabs (w [i]) + fabs (rv1 [i]));
}
for (i = n - 1; i >= 0; --i)
{
if (i < n - 1)
{
if (g)
{
for (j = l; j < n; ++j)
v [j * n + i] = (a [i * n + j] / a [i * n + l]) / g;
for (j = l; j < n; ++j)
{
for (s = 0, k = l; k < n; ++k)
s += a [i * n + k] * v [k * n + j];
for (k = l; k < n; ++k)
v [k * n + j] += s * v [k * n + i];
}
}
for (j = l; j < n; ++j)
v [i * n + j] = v [j * n + i] = 0;
}
v [i * n + i] = 1;
g = rv1 [i];
l = i;
}
for (i = min (m, n) - 1; i >= 0; --i)
{
l = i + 1;
g = w [i];
for (j = l; j < n; ++j)
a [i * n + j] = 0;
if (g)
{
g = 1 / g;
for (j = l; j < n; ++j)
{
for (s = 0, k = l; k < m; ++k)
s += a [k * n + i] * a [k * n + j];
f = (s / a [i * n + i]) * g;
for (k = i; k < m; ++k)
a [k * n + j] += f * a [k * n + i];
}
for (j = i; j < m; ++j)
a [j * n + i] *= g;
}
else
for (j = i; j < m; ++j)
a [j * n + i] = 0;
++a [i * n + i];
}
for (k = n - 1; k >= 0; --k)
{
for (its = 1; its <= 30; ++its)
{
flag = 1;
for (l = k; l >= 0; --l)
{
nm = l - 1;
if (fabs (rv1 [l]) + anorm == anorm)
{
flag = 0;
break;
}
if (fabs (w [nm]) + anorm == anorm)
break;
}
if (flag)
{
c = 0;
s = 1;
for (i = l; i <= k; ++i)
{
f = s * rv1 [i];
rv1 [i] = c * rv1 [i];
if (fabs (f) + anorm == anorm)
break;
g = w [i];
h = pythag (f, g);
w [i] = h;
h = 1 / h;
c = g * h;
s = -f * h;
for (j = 0; j < m; ++j)
{
y = a [j * n + nm];
z = a [j *n + i];
a [j * n + nm] = y * c + z * s;
a [j * n + i] = z * c - y * s;
}
}
}
z = w [k];
if (l == k)
{
if (z < 0)
{
w [k] = -z;
for (j = 0; j < n; ++j)
v [j * n + k] = -v [j * n + k];
}
break;
}
if (its == 30)
{
cerr << "no convergence in 30 svdcmp iterations" << endl;
exit (1);
}
x = w [l];
nm = k - 1;
y = w [nm];
g = rv1 [nm];
h = rv1 [k];
f = ((y - z) * (y + z) + (g - h) * (g + h)) / (2 * h * y);
g = pythag (f, 1);
f = ((x - z) * (x + z)
+ h * ((y / (f + (f >= 0 ? +1 : -1) * g)) - h))/x;
c = s = 1;
for (j = l; j <= nm; ++j)
{
i = j + 1;
g = rv1 [i];
y = w [i];
h = s * g;
g = c * g;
z = pythag (f, h);
rv1 [j] = z;
c = f / z;
s = h / z;
f = x * c + g * s;
g = g * c - x * s;
h = y * s;
y *= c;
for (jj = 0; jj < n; ++jj)
{
x = v [jj * n + j];
z = v [jj * n + i];
v [jj * n + j] = x * c + z * s;
v [jj * n + i] = z * c - x * s;
}
z = pythag (f, h);
w [j] = z;
if (z)
{
z = 1 / z;
c = f * z;
s = h * z;
}
f = c * g + s * y;
x = c * y - s * g;
for (jj = 0; jj < m; ++jj)
{
y = a [jj * n + j];
z = a [jj * n + i];
a [jj * n + j] = y * c + z * s;
a [jj * n + i] = z * c - y * s;
}
}
rv1 [l] = 0;
rv1 [k] = f;
w [k] = x;
}
}
}
static double
pythag (double a, double b)
{
double absa = fabs (a);
double absb = fabs (b);
if (absa > absb)
return absa * sqrt (1.0 + sqr (absb / absa));
else
return absb == 0.0 ? 0.0 : absb * sqrt (1.0 + sqr (absa / absb));
}
template< class T >
void
VxMatrix< T >::svbksb (VxVector<T> const &wvec, VxMatrix<T> const &vmat,
VxVector<T> const &bvec, VxVector<T> &xvec) const
{
size_type m = rows (), n = cols ();
xvec.resize (n);
VxVector<T> tmp_vec (n);
const_iterator u = begin ();
const_iterator w = wvec.begin ();
const_iterator v = vmat.begin ();
const_iterator b = bvec.begin ();
iterator x = xvec.begin ();
size_type jj, j, i;
T s, *tmp;
tmp = tmp_vec.begin ();
for (j = 0; j < n; ++j)
{
s = 0;
if (w [j])
{
for (i = 0; i < m; ++i)
s += u [i * n + j] * b [i];
s /= w [j];
}
tmp [j] = s;
}
for (j = 0; j < n; ++j)
{
s = 0;
for (jj = 0; jj < n; ++jj)
s += v [j * n + jj] * tmp [jj];
x [j] = s;
}
}
template< class T >
VxMatrix< T >
VxMatrix< T >::Identity (size_type n)
{
VxMatrix< T > eye (n, n, 0);
iterator p = eye.begin ();
for (size_type stride = n + 1; n > 0; --n, p += stride)
*p = 1;
return eye;
}
# 186 "../VxNumerics/VxMatrix.h" 2
# 10 "../data-types.h" 2
# 1 "../VxNumerics/VxVolume.h" 1
# 1 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stddef.h" 1 3 4
# 342 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stddef.h" 3 4
# 14 "../VxNumerics/VxVolume.h" 2
# 1 "../VxNumerics/VxBlock.h" 1
template< class T, int N >
struct VxBlock
{
typedef VxFixVector< T, N > vector_type;
VxBlock ();
VxBlock (vector_type const& the_start, vector_type const& the_extent);
vector_type::size_type elements () const;
vector_type start;
vector_type extent;
};
# 1 "../VxNumerics/VxBlock.cc" 1
template< class T, int N >
VxBlock< T, N >::VxBlock< T, N > ()
: start (0), extent (0)
{
}
template< class T, int N >
VxBlock< T, N >::VxBlock< T, N > (vector_type const& the_start,
vector_type const& the_extent)
: start (the_start), extent (the_extent)
{
}
template< class T, int N >
inline VxBlock< T, N >::vector_type::size_type
VxBlock< T, N >::elements () const
{
vector_type::const_iterator p = extent.begin (), q = extent.end ();
T prod = *p++;
while (p < q)
prod *= *p++;
return prod;
}
# 45 "../VxNumerics/VxBlock.h" 2
# 15 "../VxNumerics/VxVolume.h" 2
class VxVolumeBase
{
public:
typedef ptrdiff_t difference_type;
typedef ptrdiff_t size_type;
class index_type;
class block_type;
size_type levels () const;
size_type rows () const;
size_type cols () const;
size_type size () const;
index_type dims () const;
protected:
struct rep_type;
VxVolumeBase ();
VxVolumeBase (rep_type *rep);
VxVolumeBase (VxVolumeBase const &other);
rep_type *m_rep;
private:
VxVolumeBase& operator = (VxVolumeBase const& rhs);
};
template< class T >
class VxVolume
: public VxVolumeBase
{
public:
typedef T *iterator;
typedef T const *const_iterator;
typedef T value_type;
typedef T *pointer;
typedef T *const_pointer;
typedef T &reference;
typedef T const &const_reference;
VxVolume ();
VxVolume (size_type levels, size_type rows, size_type cols);
VxVolume (size_type levels, size_type rows, size_type cols, T value);
VxVolume (size_type levels, size_type rows, size_type cols,
const_iterator first, const_iterator last);
explicit VxVolume (index_type const& extent);
VxVolume (index_type const& extent, T value);
VxVolume (index_type const& extent,
const_iterator first, const_iterator last);
reference operator ()
(size_type level, size_type row, size_type col);
const_reference operator ()
(size_type level, size_type row, size_type col) const;
reference elem (size_type level, size_type row, size_type col);
const_reference elem (size_type level, size_type row, size_type col) const;
iterator begin ();
const_iterator begin () const;
iterator end ();
const_iterator end () const;
void get_xvec (size_type level, size_type row,
iterator first, iterator last) const;
void get_yvec (size_type level, size_type col,
iterator first, iterator last) const;
void get_zvec (size_type row, size_type col,
iterator first, iterator last) const;
void put_xvec (size_type level, size_type row,
const_iterator first, const_iterator last);
void put_yvec (size_type level, size_type col,
const_iterator first, const_iterator last);
void put_zvec (size_type row, size_type col,
const_iterator first, const_iterator last);
VxVolume< T > subvolume (size_type level, size_type row, size_type col,
size_type bz, size_type by, size_type bx) const;
VxVolume< T > subvolume (block_type const& block) const;
void subvolume (block_type const& block, iterator pout) const;
void resize (size_type levels, size_type rows, size_type cols);
void resize (index_type const& dims);
VxVolume& operator = (value_type val);
VxVolume (VxVolume const& new_value);
VxVolume& operator = (VxVolume const& rhs);
~VxVolume ();
private:
void clone ();
};
class VxVolumeBase::index_type
: public VxFixVector< VxVolumeBase::size_type, 3 >
{
public:
index_type (size_type val = 0)
: VxFixVector< size_type, 3 > (val) {}
index_type (size_type i, size_type j, size_type k)
: VxFixVector< size_type, 3 > (make_fixvec (i, j, k)) {}
};
class VxVolumeBase::block_type
{
public:
block_type ()
: start (0), extent (0) {}
block_type (index_type the_start, index_type the_extent)
: start (the_start), extent (the_extent) {}
block_type (VxVolumeBase const& volume)
: start (0), extent (volume.dims ()) {}
size_type elements () { return extent [0] * extent [1] * extent [2]; }
index_type start;
index_type extent;
};
struct VxVolumeBase::rep_type
{
rep_type ()
: count (1), data (0), rows (0), cols (0) {}
rep_type (void *data, size_type levels, size_type rows, size_type cols)
: count (1), data (data), levels (levels), rows (rows), cols (cols) {}
void ref () { ++count; }
template< class T >
void deref (VxVolume< T > const *client)
{
if (--count == 0)
{
delete [] static_cast< T* > (data);
delete this;
}
}
size_t count;
void *data;
size_type levels;
size_type rows;
size_type cols;
};
# 1 "../VxNumerics/VxVolume.cc" 1
# 1 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/../../../../sparc-sun-solaris2.7/include/assert.h" 1 3 4
# 19 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/../../../../sparc-sun-solaris2.7/include/assert.h" 3 4
extern "C" {
extern void __eprintf (const char *, const char *, unsigned, const char *)
__attribute__ ((noreturn));
}
# 52 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/../../../../sparc-sun-solaris2.7/include/assert.h" 3 4
# 9 "../VxNumerics/VxVolume.cc" 2
inline
VxVolumeBase::VxVolumeBase ()
: m_rep (new rep_type ())
{
}
inline
VxVolumeBase::VxVolumeBase (rep_type *rep)
: m_rep (rep)
{
m_rep->ref ();
}
inline
VxVolumeBase::VxVolumeBase (VxVolumeBase const& other)
: m_rep (other.m_rep)
{
m_rep->ref ();
}
inline
VxVolumeBase::size_type
VxVolumeBase::levels () const
{
return m_rep->levels;
}
inline
VxVolumeBase::size_type
VxVolumeBase::rows () const
{
return m_rep->rows;
}
inline
VxVolumeBase::size_type
VxVolumeBase::cols () const
{
return m_rep->cols;
}
inline
VxVolumeBase::size_type
VxVolumeBase::size () const
{
return m_rep->levels * m_rep->rows * m_rep->cols;
}
inline
VxVolumeBase::index_type
VxVolumeBase::dims () const
{
return index_type (m_rep->levels, m_rep->rows, m_rep->cols);
}
template< class T >
inline
VxVolume< T >::VxVolume ()
: VxVolumeBase ()
{
}
template< class T >
inline
VxVolume< T >::VxVolume (size_type levels, size_type rows, size_type cols)
: VxVolumeBase (new rep_type (new T [levels * rows * cols],
levels, rows, cols))
{}
template< class T >
VxVolume< T >::VxVolume (size_type levels, size_type rows, size_type cols,
T value)
: VxVolumeBase (new rep_type (new T [levels * rows * cols],
levels, rows, cols))
{
iterator p = begin ();
iterator q = end ();
while (p < q)
*p++ = value;
}
template< class T >
VxVolume< T >::VxVolume (size_type levels, size_type rows, size_type cols,
const_iterator b, const_iterator e)
: VxVolumeBase (new rep_type (new T [levels * rows * cols],
levels, rows, cols))
{
iterator p = begin ();
iterator q = end ();
while (p < q && b < e)
*p++ = *b++;
}
template< class T >
inline
VxVolume< T >::VxVolume (index_type const& extent)
: VxVolumeBase (new rep_type (0, extent [0], extent [1], extent [2]))
{
m_rep->data = new T [size ()];
}
template< class T >
VxVolume< T >::VxVolume (index_type const& extent, T value)
: VxVolumeBase (new rep_type (0, extent [0], extent [1], extent [2]))
{
m_rep->data = new T [size ()];
iterator p = begin ();
iterator q = end ();
while (p < q)
*p++ = value;
}
template< class T >
VxVolume< T >::VxVolume (index_type const& extent,
const_iterator first, const_iterator last)
: VxVolumeBase (new rep_type (0, extent [0], extent [1], extent [2]))
{
m_rep->data = new T [size ()];
iterator p = begin ();
iterator q = end ();
while (p < q && first < last)
*p++ = *first++;
}
template< class T >
VxVolume< T >::VxVolume (VxVolume< T > const& v)
: VxVolumeBase (v)
{
}
template< class T >
inline void
VxVolume< T >::clone ()
{
if (m_rep->count > 1)
{
const_pointer po = static_cast< const_pointer > (m_rep->data);
const_pointer qo = po + size ();
rep_type *old_rep = m_rep;
m_rep = new rep_type (new value_type [size ()],
m_rep->levels, m_rep->rows, m_rep->cols);
pointer pn = static_cast< pointer > (m_rep->data);
while (po < qo)
*pn++ = *po++;
old_rep->deref (this);
}
}
template< class T >
inline
VxVolume< T >::reference
VxVolume< T >::operator () (size_type level, size_type row, size_type col)
{
return begin () [(level * m_rep->rows + row) * m_rep->cols + col];
}
template< class T >
inline
VxVolume< T >::const_reference
VxVolume< T >::operator ()
(size_type level, size_type row, size_type col) const
{
return begin () [(level * m_rows + row) * m_rep->cols + col];
}
template< class T >
inline
VxVolume< T >::reference
VxVolume< T >::elem (size_type level, size_type row, size_type col)
{
if (0 <= level && level < m_rep->levels
&& 0 <= row && row < m_rep->rows
&& 0 <= col && col < m_rep->cols)
return begin () [(level * m_rep->rows + row) * m_rep->cols + col];
cerr << "attempt to index element (" << level << ", " << row << ", " << col
<< ") in " << m_rep->levels << 'x' << m_rep->rows << 'x' << m_rep->cols
<< " VxVolume object\n";
exit (1);
}
template< class T >
inline
VxVolume< T >::const_reference
VxVolume< T >::elem (size_type level, size_type row, size_type col) const
{
if (0 <= level && level < m_rep->levels
&& 0 <= row && row < m_rep->rows
&& 0 <= col && col < m_rep->cols)
return begin () [(level * m_rep->rows + row) * m_rep->cols + col];
cerr << "attempt to index element (" << level << ", " << row << ", " << col
<< ") in " << m_rep->levels << 'x' << m_rep->rows << 'x' << m_rep->cols
<< " VxVolume object\n";
exit (1);
}
template< class T >
inline
VxVolume< T >::iterator
VxVolume< T >::begin ()
{
clone ();
return (T*) m_rep->data;
}
template< class T >
inline
VxVolume< T >::const_iterator
VxVolume< T >::begin () const
{
return (T const*) m_rep->data;
}
template< class T >
inline
VxVolume< T >::iterator
VxVolume< T >::end ()
{
clone ();
return (T*) m_rep->data + m_rep->levels * m_rep->rows * m_rep->cols;
}
template< class T >
inline
VxVolume< T >::const_iterator
VxVolume< T >::end () const
{
return (T const*) m_rep->data + m_rep->levels * m_rep->rows * m_rep->cols;
}
template< class T >
void
VxVolume< T >::get_xvec (size_type level, size_type row,
iterator first, iterator last) const
{
const_iterator p = begin () + (level * m_rep->rows + row) * m_rep->cols;
const_iterator q = p + m_rep->cols;
while (p < q && first < last)
*first++ = *p++;
}
template< class T >
void
VxVolume< T >::get_yvec (size_type level, size_type col,
iterator first, iterator last) const
{
size_type step = m_rep->cols;
size_type rows = m_rep->rows;
const_iterator p = begin () + level * rows * step + col;
for (size_type i = 0; i < rows && first < last; ++i, p += step)
*first++ = *p;
}
template< class T >
void
VxVolume< T >::get_zvec (size_type row, size_type col,
iterator first, iterator last) const
{
size_type levels = m_rep->levels;
size_type step = m_rep->rows * m_rep->cols;
const_iterator p = begin () + row * m_rep->cols + col;
for (size_type i = 0; i < levels && first < last; ++i, p += step)
*first++ = *p;
}
template< class T >
void
VxVolume< T >::put_xvec (size_type level, size_type row,
const_iterator first, const_iterator last)
{
iterator p = begin () + (level * m_rep->rows + row) * m_rep->cols;
iterator q = p + m_rep->cols;
while (p < q && first < last)
*p++ = *first++;
}
template< class T >
void
VxVolume< T >::put_yvec (size_type level, size_type col,
const_iterator first, const_iterator last)
{
size_type step = m_rep->cols;
size_type rows = m_rep->rows;
iterator p = begin () + level * rows * step + col;
for (size_type i = 0; i < rows && first < last; ++i, p += step)
*p = *first++;
}
template< class T >
void
VxVolume< T >::put_zvec (size_type row, size_type col,
const_iterator first, const_iterator last)
{
size_type levels = m_rep->levels;
size_type step = m_rep->rows * m_rep->cols;
iterator p = begin () + row * m_rep->cols + col;
for (size_type i = 0; i < levels && first < last; ++i, p += step)
*p = *first++;
}
template< class T >
VxVolume< T >
VxVolume< T >::subvolume (size_type level, size_type row, size_type col,
size_type nl, size_type nr, size_type nc) const
{
VxVolume< T > result (nl, nr, nc);
const_iterator p = begin ();
iterator r = result.begin ();
size_type rows = m_rep->rows;
size_type cols = m_rep->cols;
for (size_type i = level, imax = i + nl; i < imax; ++i)
for (size_type j = row, jmax = j + nr; j < jmax; ++j)
for (size_type k = col, kmax = k + nc; k < kmax; ++k)
*r++ = p [(i * rows + j) * cols + k];
return result;
}
template< class T >
VxVolume< T >
VxVolume< T >::subvolume (block_type const& block) const
{
VxVolume< T > result (block.extent);
subvolume (block, result.begin ());
return result;
}
template< class T >
void
VxVolume< T >::subvolume (block_type const& block, iterator pout) const
{
size_type is = block.start [0], js = block.start [1], ks = block.start [2];
size_type ie = block.extent [0], je = block.extent [1], ke = block.extent [2];
const_iterator p = begin () + (is * m_rep->rows + js) * m_rep->cols, q;
size_type i, j, k, cols = m_rep->cols, row_col = m_rep->rows * cols;
for (i = ie; i > 0; --i, p += row_col)
for (j = je; j > 0; --j, p += cols)
for (k = ke, q = p + ks; k > 0; --k)
*pout++ = *q++;
}
template< class T >
void
VxVolume< T >::resize (size_type levels, size_type rows, size_type cols)
{
if (m_rep->levels != levels || m_rep->rows != rows || m_rep->cols != cols)
{
m_rep->deref (this);
m_rep = new rep_type (new T [levels * rows * cols], levels, rows, cols);
}
}
template< class T >
inline void
VxVolume< T >::resize (index_type const& dims)
{
resize (dims [0], dims [1], dims [2]);
}
template< class T >
inline
VxVolume< T >::~VxVolume ()
{
m_rep->deref (this);
}
template< class T >
VxVolume< T >&
VxVolume< T >::operator = (VxVolume< T > const& rhs)
{
if (m_rep != rhs.m_rep)
{
m_rep->deref (this);
m_rep = rhs.m_rep;
m_rep->ref ();
}
return *this;
}
template< class T >
VxVolume< T >&
VxVolume< T >::operator = (value_type val)
{
iterator p = begin (), q = end ();
while (p < q)
*p++ = val;
return *this;
}
# 213 "../VxNumerics/VxVolume.h" 2
# 11 "../data-types.h" 2
typedef double real_type;
typedef double ext_real_type;
typedef VxVector< real_type > Vector;
typedef VxMatrix< real_type > Matrix;
typedef VxVolume< real_type > Volume;
typedef VxFixVector< int, 2 > iVector2;
typedef VxFixVector< int, 3 > iVector3;
typedef VxFixVector< int, 4 > iVector4;
typedef VxFixVector< int, 6 > iVector6;
typedef VxFixVector< real_type, 2 > Vector2;
typedef VxFixVector< real_type, 3 > Vector3;
typedef VxFixVector< real_type, 4 > Vector4;
typedef VxFixVector< real_type, 6 > Vector6;
# 15 "Affine_Map2.h" 2
# 1 "../VxNumerics/VxFixMatrix.h" 1
# 1 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stddef.h" 1 3 4
# 342 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/stddef.h" 3 4
# 14 "../VxNumerics/VxFixMatrix.h" 2
template< class T, int NX, int NY >
class VxFixMatrix
{
public:
typedef T* iterator;
typedef T const* const_iterator;
typedef int difference_type;
typedef int size_type;
typedef T value_type;
typedef T& reference;
typedef T const& const_reference;
VxFixMatrix () {}
explicit VxFixMatrix (T value);
explicit VxFixMatrix (const_iterator first);
reference operator () (size_type ix, size_type iy);
const_reference operator () (size_type ix, size_type iy) const;
reference elem (size_type ix, size_type iy);
const_reference elem (size_type ix, size_type iy) const;
iterator begin ();
const_iterator begin () const;
iterator end ();
const_iterator end () const;
size_type nx () const;
size_type ny () const;
size_type size () const;
VxFixMatrix< T, NY, NX > transpose () const;
static VxFixMatrix< T, NX, NY > Identity ();
VxFixMatrix (VxFixMatrix const& new_value);
VxFixMatrix& operator = (VxFixMatrix const& rhs);
~VxFixMatrix () {}
private:
T m_data [NX * NY];
};
# 1 "../VxNumerics/VxFixMatrix.cc" 1
template< class T, int NX, int NY >
inline
VxFixMatrix< T, NX, NY >::reference
VxFixMatrix< T, NX, NY >::operator () (size_type ix, size_type iy)
{
return m_data [ix * NY + iy];
}
template< class T, int NX, int NY >
inline
VxFixMatrix< T, NX, NY >::const_reference
VxFixMatrix< T, NX, NY >::operator () (size_type ix, size_type iy) const
{
return m_data [ix * NY + iy];
}
template< class T, int NX, int NY >
inline
VxFixMatrix< T, NX, NY >::reference
VxFixMatrix< T, NX, NY >::elem (size_type ix, size_type iy)
{
if (0 <= ix && ix < NX && 0 <= iy && iy < NY)
return m_data [ix * NY + iy];
cerr << "attempt to index element (" << ix << ", " << iy
<< ") in " << NX << "-by-" << NY << " VxFixMatrix object\n";
exit (1);
}
template< class T, int NX, int NY >
inline
VxFixMatrix< T, NX, NY >::const_reference
VxFixMatrix< T, NX, NY >::elem (size_type ix, size_type iy) const
{
if (0 <= ix && ix < NX && 0 <= iy && iy < NY)
return m_data [ix * NY + iy];
cerr << "attempt to index element (" << ix << ", " << iy
<< ") in " << NX << "-by-" << NY << " VxFixMatrix object\n";
exit (1);
}
template< class T, int NX, int NY >
inline
VxFixMatrix< T, NX, NY >::iterator
VxFixMatrix< T, NX, NY >::begin ()
{
return m_data;
}
template< class T, int NX, int NY >
inline
VxFixMatrix< T, NX, NY >::const_iterator
VxFixMatrix< T, NX, NY >::begin () const
{
return m_data;
}
template< class T, int NX, int NY >
inline
VxFixMatrix< T, NX, NY >::iterator
VxFixMatrix< T, NX, NY >::end ()
{
return m_data + NX * NY;
}
template< class T, int NX, int NY >
inline
VxFixMatrix< T, NX, NY >::const_iterator
VxFixMatrix< T, NX, NY >::end () const
{
return m_data + NX * NY;
}
template< class T, int NX, int NY >
inline
VxFixMatrix< T, NX, NY >::size_type
VxFixMatrix< T, NX, NY >::nx () const
{
return NX;
}
template< class T, int NX, int NY >
inline
VxFixMatrix< T, NX, NY >::size_type
VxFixMatrix< T, NX, NY >::ny () const
{
return NY;
}
template< class T, int NX, int NY >
inline
VxFixMatrix< T, NX, NY >::size_type
VxFixMatrix< T, NX, NY >::size () const
{
return NX * NY;
}
template< class T, int NX, int NY >
VxFixMatrix< T, NX, NY >::VxFixMatrix (T value)
{
iterator p = begin ();
iterator q = end ();
while (p < q)
*p++ = value;
}
template< class T, int NX, int NY >
VxFixMatrix< T, NX, NY >::VxFixMatrix (const_iterator first)
{
iterator p = begin ();
iterator q = end ();
while (p < q)
*p++ = *first++;
}
template< class T, int NX, int NY >
VxFixMatrix< T, NX, NY >::VxFixMatrix (VxFixMatrix< T, NX, NY > const& rhs)
{
iterator p = begin ();
const_iterator q = rhs.begin ();
iterator r = end ();
while (p < r)
*p++ = *q++;
}
template< class T, int NX, int NY >
VxFixMatrix< T, NX, NY >&
VxFixMatrix< T, NX, NY >::operator = (VxFixMatrix< T, NX, NY > const& rhs)
{
iterator p = begin ();
const_iterator q = rhs.begin ();
iterator r = end ();
while (p < r)
*p++ = *q++;
return *this;
}
template< class T, int NX, int NY >
VxFixMatrix< T, NX, NY >
VxFixMatrix< T, NX, NY >::Identity ()
{
VxFixMatrix< T, NX, NY > result (T (0));
size_type n = min (NX, NY);
iterator p = result.begin ();
for (size_type i = 0; i < n; ++i)
p [i * NY + i] = 1;
return result;
}
template< class T, int NX, int NY >
VxFixMatrix< T, NY, NX >
VxFixMatrix< T, NX, NY >::transpose () const
{
VxFixMatrix< T, NY, NX > result;
for (size_type i = 0; i < NY; ++i)
for (size_type j = 0; j < NX; ++j)
result (i, j) = (*this) (j, i);
return result;
}
# 75 "../VxNumerics/VxFixMatrix.h" 2
# 17 "Affine_Map2.h" 2
class Affine_Map2
{
public:
typedef real_type value_type;
typedef VxFixMatrix< value_type, 2, 2 > matrix_type;
typedef VxFixVector< value_type, 2 > vector_type;
typedef VxMatrix< value_type > Matrix;
virtual matrix_type linear () const = 0;
virtual vector_type offset () const = 0;
Matrix homogeneous (int dim) const;
virtual ostream& print (ostream& os) const;
virtual ~Affine_Map2 () = 0;
protected:
Affine_Map2 () {}
};
class Skew_Map2
: public Affine_Map2
{
public:
Skew_Map2 ()
: Affine_Map2 (), m_A (0.0), m_x (0.0) {}
Skew_Map2 (matrix_type const& A, vector_type const& x = vector_type (0.0))
: Affine_Map2 (), m_A (A), m_x (x) {}
virtual matrix_type linear () const { return m_A; }
virtual vector_type offset () const { return m_x; }
matrix_type& linear () { return m_A; }
vector_type& offset () { return m_x; }
virtual ~Skew_Map2 () {}
private:
matrix_type m_A;
vector_type m_x;
};
class Rotation_Map2
: public Affine_Map2
{
public:
Rotation_Map2 ()
: Affine_Map2 (), m_theta (0.0), m_x (0.0) {}
Rotation_Map2 (value_type theta, vector_type const& x = vector_type (0.0))
: Affine_Map2 (), m_theta (theta), m_x (x) {}
value_type angle () const { return m_theta; }
virtual matrix_type linear () const;
virtual vector_type offset () const { return m_x; }
value_type& angle () { return m_theta; }
vector_type& offset () { return m_x; }
virtual ostream& print (ostream& os) const;
virtual ~Rotation_Map2 () {}
private:
value_type m_theta;
vector_type m_x;
};
ostream&
operator << (ostream& os, Affine_Map2 const& map);
# 9 "Affine_Map2.cc" 2
# 1 "/pkg/gnu/SunOS/lib/gcc-lib/sparc-sun-solaris2.7/2.95.2/include/g++/iomanip.h" 1 3
#pragma interface
extern "C++" {
template<class TP> class smanip;
template<class TP> class sapp {
ios& (*_f)(ios&, TP);
public:
sapp(ios& (*f)(ios&, TP)) : _f(f) {}
smanip<TP> operator()(TP a)
{ return smanip<TP>(_f, a); }
};
template<class TP>
inline istream& operator>>(istream& i, const smanip<TP>& m);
template<class TP>
inline ostream& operator<<(ostream& o, const smanip<TP>& m);
template <class TP> class smanip {
ios& (*_f)(ios&, TP);
TP _a;
public:
smanip(ios& (*f)(ios&, TP), TP a) : _f(f), _a(a) {}
friend
istream& operator>> <>(istream& i, const smanip<TP>& m);
friend
ostream& operator<< <>(ostream& o, const smanip<TP>& m);
};
__extension__ extern template class smanip<int>;
__extension__ extern template class smanip<ios::fmtflags>;
template<class TP>
inline istream& operator>>(istream& i, const smanip<TP>& m)
{ (*m._f)(i, m._a); return i; }
template<class TP>
inline ostream& operator<<(ostream& o, const smanip<TP>& m)
{ (*m._f)(o, m._a); return o;}
__extension__ extern
template istream& operator>>(istream&, const smanip<int>&);
__extension__ extern
template istream& operator>>(istream&, const smanip<ios::fmtflags>&);
__extension__ extern
template ostream& operator<<(ostream&, const smanip<int>&);
__extension__ extern
template ostream& operator<<(ostream&, const smanip<ios::fmtflags>&);
template<class TP> class imanip;
template<class TP> class iapp {
istream& (*_f)(istream&, TP);
public:
iapp(istream& (*f)(istream&,TP)) : _f(f) {}
imanip<TP> operator()(TP a)
{ return imanip<TP>(_f, a); }
};
template <class TP>
inline istream& operator>>(istream&, const imanip<TP>&);
template <class TP> class imanip {
istream& (*_f)(istream&, TP);
TP _a;
public:
imanip(istream& (*f)(istream&, TP), TP a) : _f(f), _a(a) {}
friend
istream& operator>> <>(istream& i, const imanip<TP>& m);
};
template <class TP>
inline istream& operator>>(istream& i, const imanip<TP>& m)
{ return (*m._f)( i, m._a); }
template<class TP> class omanip;
template<class TP> class oapp {
ostream& (*_f)(ostream&, TP);
public:
oapp(ostream& (*f)(ostream&,TP)) : _f(f) {}
omanip<TP> operator()(TP a)
{ return omanip<TP>(_f, a); }
};
template <class TP>
inline ostream& operator<<(ostream&, const omanip<TP>&);
template <class TP> class omanip {
ostream& (*_f)(ostream&, TP);
TP _a;
public:
omanip(ostream& (*f)(ostream&, TP), TP a) : _f(f), _a(a) {}
friend
ostream& operator<< <>(ostream& o, const omanip<TP>& m);
};
template <class TP>
inline ostream& operator<<(ostream& o, const omanip<TP>& m)
{ return (*m._f)(o, m._a); }
extern ios& __iomanip_setbase (ios&, int ); inline smanip < int > setbase ( int n) { return smanip < int > (__iomanip_setbase , n); }
extern ios& __iomanip_setfill (ios&, int ); inline smanip < int > setfill ( int n) { return smanip < int > (__iomanip_setfill , n); }
extern ios& __iomanip_setprecision (ios&, int ); inline smanip < int > setprecision ( int n) { return smanip < int > (__iomanip_setprecision , n); }
extern ios& __iomanip_setw (ios&, int ); inline smanip < int > setw ( int n) { return smanip < int > (__iomanip_setw , n); }
extern ios& __iomanip_resetiosflags (ios&, ios::fmtflags ); inline smanip < ios::fmtflags > resetiosflags ( ios::fmtflags n) { return smanip < ios::fmtflags > (__iomanip_resetiosflags , n); }
extern ios& __iomanip_setiosflags (ios&, ios::fmtflags ); inline smanip < ios::fmtflags > setiosflags ( ios::fmtflags n) { return smanip < ios::fmtflags > (__iomanip_setiosflags , n); }
}
# 12 "Affine_Map2.cc" 2
Affine_Map2::~Affine_Map2 ()
{
}
Affine_Map2::Matrix
Affine_Map2::homogeneous (int dim) const
{
if (dim < 2 || dim > 3)
{
cerr << "Affine_Map2::homogeneous: dimension must be 2 or 3\n";
exit (1);
}
Matrix result = Matrix::Identity (dim + 1);
matrix_type A = linear ();
vector_type x = offset ();
for (Matrix::size_type j = 0; j < 2; ++j)
for (Matrix::size_type i = 0; i < 2; ++i)
result (i, j) = A (i, j);
result (0, dim) = x (0);
result (1, dim) = x (1);
return result;
}
ostream&
Affine_Map2::print (ostream& os) const
{
matrix_type A = linear ();
os << " [" << A (0, 0)
<< ", " << A (0, 1) << "]\n";
os << " A = [ ]\n";
os << " [" << A (1, 0)
<< ", " << A (1, 1) << "]\n\n";
vector_type b = offset ();
os << " b = [" << b (0)
<< ", " << b (1) << "]\n";
return os;
}
Affine_Map2::matrix_type
Rotation_Map2::linear () const
{
matrix_type result;
value_type c = cos (m_theta);
value_type s = sin (m_theta);
result (0, 0) = c;
result (1, 1) = c;
result (0, 1) = s;
result (1, 0) = -s;
return result;
}
ostream&
Rotation_Map2::print (ostream& os) const
{
os << " theta = [" << m_theta << "] ";
os << " b = [" << m_x (0) << ", " << m_x (1) << "]\n";
return os;
}
ostream&
operator << (ostream& os, Affine_Map2 const& map)
{
return map.print (os);
}