- added implementation of stdc++ for haiku
- this differs slightly from the one that lives in buildtools/gcc as it has been "ported" to the newer libio that haiku uses as part of its own libroot git-svn-id: file:///srv/svn/repos/haiku/trunk/current@9906 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Oliver Tappe
@@ -0,0 +1,524 @@
|
||||
// Member templates for the -*- C++ -*- string classes.
|
||||
// Copyright (C) 1994, 1999 Free Software Foundation
|
||||
|
||||
// This file is part of the GNU ANSI C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
// As a special exception, if you link this library with files
|
||||
// compiled with a GNU compiler to produce an executable, this does not cause
|
||||
// the resulting executable to be covered by the GNU General Public License.
|
||||
// This exception does not however invalidate any other reasons why
|
||||
// the executable file might be covered by the GNU General Public License.
|
||||
|
||||
// Written by Jason Merrill based upon the specification by Takanori Adachi
|
||||
// in ANSI X3J16/94-0013R2.
|
||||
|
||||
extern "C++" {
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline void * basic_string <charT, traits, Allocator>::Rep::
|
||||
operator new (size_t s, size_t extra)
|
||||
{
|
||||
return Allocator::allocate(s + extra * sizeof (charT));
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline void basic_string <charT, traits, Allocator>::Rep::
|
||||
operator delete (void * ptr)
|
||||
{
|
||||
Allocator::deallocate(ptr, sizeof(Rep) +
|
||||
reinterpret_cast<Rep *>(ptr)->res *
|
||||
sizeof (charT));
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline size_t basic_string <charT, traits, Allocator>::Rep::
|
||||
frob_size (size_t s)
|
||||
{
|
||||
size_t i = 16;
|
||||
while (i < s) i *= 2;
|
||||
return i;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline basic_string <charT, traits, Allocator>::Rep *
|
||||
basic_string <charT, traits, Allocator>::Rep::
|
||||
create (size_t extra)
|
||||
{
|
||||
extra = frob_size (extra + 1);
|
||||
Rep *p = new (extra) Rep;
|
||||
p->res = extra;
|
||||
p->ref = 1;
|
||||
p->selfish = false;
|
||||
return p;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
charT * basic_string <charT, traits, Allocator>::Rep::
|
||||
clone ()
|
||||
{
|
||||
Rep *p = Rep::create (len);
|
||||
p->copy (0, data (), len);
|
||||
p->len = len;
|
||||
return p->data ();
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline bool basic_string <charT, traits, Allocator>::Rep::
|
||||
excess_slop (size_t s, size_t r)
|
||||
{
|
||||
return 2 * (s <= 16 ? 16 : s) < r;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline bool basic_string <charT, traits, Allocator>::
|
||||
check_realloc (basic_string::size_type s) const
|
||||
{
|
||||
s += sizeof (charT);
|
||||
rep ()->selfish = false;
|
||||
return (rep ()->ref > 1
|
||||
|| s > capacity ()
|
||||
|| Rep::excess_slop (s, capacity ()));
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
void basic_string <charT, traits, Allocator>::
|
||||
alloc (basic_string::size_type __size, bool __save)
|
||||
{
|
||||
if (! check_realloc (__size))
|
||||
return;
|
||||
|
||||
Rep *p = Rep::create (__size);
|
||||
|
||||
if (__save)
|
||||
{
|
||||
p->copy (0, data (), length ());
|
||||
p->len = length ();
|
||||
}
|
||||
else
|
||||
p->len = 0;
|
||||
|
||||
repup (p);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
basic_string <charT, traits, Allocator>&
|
||||
basic_string <charT, traits, Allocator>::
|
||||
replace (size_type pos1, size_type n1,
|
||||
const basic_string& _str, size_type pos2, size_type n2)
|
||||
{
|
||||
const size_t len2 = _str.length ();
|
||||
|
||||
if (pos1 == 0 && n1 >= length () && pos2 == 0 && n2 >= len2)
|
||||
return operator= (_str);
|
||||
|
||||
OUTOFRANGE (pos2 > len2);
|
||||
|
||||
if (n2 > len2 - pos2)
|
||||
n2 = len2 - pos2;
|
||||
|
||||
return replace (pos1, n1, _str.data () + pos2, n2);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline void basic_string <charT, traits, Allocator>::Rep::
|
||||
copy (size_t pos, const charT *s, size_t n)
|
||||
{
|
||||
if (n)
|
||||
traits::copy (data () + pos, s, n);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline void basic_string <charT, traits, Allocator>::Rep::
|
||||
move (size_t pos, const charT *s, size_t n)
|
||||
{
|
||||
if (n)
|
||||
traits::move (data () + pos, s, n);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
basic_string <charT, traits, Allocator>&
|
||||
basic_string <charT, traits, Allocator>::
|
||||
replace (size_type pos, size_type n1, const charT* s, size_type n2)
|
||||
{
|
||||
const size_type len = length ();
|
||||
OUTOFRANGE (pos > len);
|
||||
if (n1 > len - pos)
|
||||
n1 = len - pos;
|
||||
LENGTHERROR (len - n1 > max_size () - n2);
|
||||
size_t newlen = len - n1 + n2;
|
||||
|
||||
if (check_realloc (newlen))
|
||||
{
|
||||
Rep *p = Rep::create (newlen);
|
||||
p->copy (0, data (), pos);
|
||||
p->copy (pos + n2, data () + pos + n1, len - (pos + n1));
|
||||
p->copy (pos, s, n2);
|
||||
repup (p);
|
||||
}
|
||||
else
|
||||
{
|
||||
rep ()->move (pos + n2, data () + pos + n1, len - (pos + n1));
|
||||
rep ()->copy (pos, s, n2);
|
||||
}
|
||||
rep ()->len = newlen;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline void basic_string <charT, traits, Allocator>::Rep::
|
||||
set (size_t pos, const charT c, size_t n)
|
||||
{
|
||||
traits::set (data () + pos, c, n);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
basic_string <charT, traits, Allocator>& basic_string <charT, traits, Allocator>::
|
||||
replace (size_type pos, size_type n1, size_type n2, charT c)
|
||||
{
|
||||
const size_t len = length ();
|
||||
OUTOFRANGE (pos > len);
|
||||
if (n1 > len - pos)
|
||||
n1 = len - pos;
|
||||
LENGTHERROR (len - n1 > max_size () - n2);
|
||||
size_t newlen = len - n1 + n2;
|
||||
|
||||
if (check_realloc (newlen))
|
||||
{
|
||||
Rep *p = Rep::create (newlen);
|
||||
p->copy (0, data (), pos);
|
||||
p->copy (pos + n2, data () + pos + n1, len - (pos + n1));
|
||||
p->set (pos, c, n2);
|
||||
repup (p);
|
||||
}
|
||||
else
|
||||
{
|
||||
rep ()->move (pos + n2, data () + pos + n1, len - (pos + n1));
|
||||
rep ()->set (pos, c, n2);
|
||||
}
|
||||
rep ()->len = newlen;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
void basic_string <charT, traits, Allocator>::
|
||||
resize (size_type n, charT c)
|
||||
{
|
||||
LENGTHERROR (n > max_size ());
|
||||
|
||||
if (n > length ())
|
||||
append (n - length (), c);
|
||||
else
|
||||
erase (n);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
basic_string <charT, traits, Allocator>::size_type
|
||||
basic_string <charT, traits, Allocator>::
|
||||
copy (charT* s, size_type n, size_type pos) const
|
||||
{
|
||||
OUTOFRANGE (pos > length ());
|
||||
|
||||
if (n > length () - pos)
|
||||
n = length () - pos;
|
||||
|
||||
traits::copy (s, data () + pos, n);
|
||||
return n;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
basic_string <charT, traits, Allocator>::size_type
|
||||
basic_string <charT, traits, Allocator>::
|
||||
find (const charT* s, size_type pos, size_type n) const
|
||||
{
|
||||
size_t xpos = pos;
|
||||
for (; xpos + n <= length (); ++xpos)
|
||||
if (traits::eq (data () [xpos], *s)
|
||||
&& traits::compare (data () + xpos, s, n) == 0)
|
||||
return xpos;
|
||||
return npos;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline basic_string <charT, traits, Allocator>::size_type
|
||||
basic_string <charT, traits, Allocator>::
|
||||
_find (const charT* ptr, charT c, size_type xpos, size_type len)
|
||||
{
|
||||
for (; xpos < len; ++xpos)
|
||||
if (traits::eq (ptr [xpos], c))
|
||||
return xpos;
|
||||
return npos;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
basic_string <charT, traits, Allocator>::size_type
|
||||
basic_string <charT, traits, Allocator>::
|
||||
find (charT c, size_type pos) const
|
||||
{
|
||||
return _find (data (), c, pos, length ());
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
basic_string <charT, traits, Allocator>::size_type
|
||||
basic_string <charT, traits, Allocator>::
|
||||
rfind (const charT* s, size_type pos, size_type n) const
|
||||
{
|
||||
if (n > length ())
|
||||
return npos;
|
||||
|
||||
size_t xpos = length () - n;
|
||||
if (xpos > pos)
|
||||
xpos = pos;
|
||||
|
||||
for (++xpos; xpos-- > 0; )
|
||||
if (traits::eq (data () [xpos], *s)
|
||||
&& traits::compare (data () + xpos, s, n) == 0)
|
||||
return xpos;
|
||||
return npos;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
basic_string <charT, traits, Allocator>::size_type
|
||||
basic_string <charT, traits, Allocator>::
|
||||
rfind (charT c, size_type pos) const
|
||||
{
|
||||
if (1 > length ())
|
||||
return npos;
|
||||
|
||||
size_t xpos = length () - 1;
|
||||
if (xpos > pos)
|
||||
xpos = pos;
|
||||
|
||||
for (++xpos; xpos-- > 0; )
|
||||
if (traits::eq (data () [xpos], c))
|
||||
return xpos;
|
||||
return npos;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
basic_string <charT, traits, Allocator>::size_type
|
||||
basic_string <charT, traits, Allocator>::
|
||||
find_first_of (const charT* s, size_type pos, size_type n) const
|
||||
{
|
||||
size_t xpos = pos;
|
||||
for (; xpos < length (); ++xpos)
|
||||
if (_find (s, data () [xpos], 0, n) != npos)
|
||||
return xpos;
|
||||
return npos;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
basic_string <charT, traits, Allocator>::size_type
|
||||
basic_string <charT, traits, Allocator>::
|
||||
find_last_of (const charT* s, size_type pos, size_type n) const
|
||||
{
|
||||
if (length() == 0)
|
||||
return npos;
|
||||
size_t xpos = length () - 1;
|
||||
if (xpos > pos)
|
||||
xpos = pos;
|
||||
for (++xpos; xpos-- > 0;)
|
||||
if (_find (s, data () [xpos], 0, n) != npos)
|
||||
return xpos;
|
||||
return npos;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
basic_string <charT, traits, Allocator>::size_type
|
||||
basic_string <charT, traits, Allocator>::
|
||||
find_first_not_of (const charT* s, size_type pos, size_type n) const
|
||||
{
|
||||
size_t xpos = pos;
|
||||
for (; xpos < length (); ++xpos)
|
||||
if (_find (s, data () [xpos], 0, n) == npos)
|
||||
return xpos;
|
||||
return npos;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
basic_string <charT, traits, Allocator>::size_type
|
||||
basic_string <charT, traits, Allocator>::
|
||||
find_first_not_of (charT c, size_type pos) const
|
||||
{
|
||||
size_t xpos = pos;
|
||||
for (; xpos < length (); ++xpos)
|
||||
if (traits::ne (data () [xpos], c))
|
||||
return xpos;
|
||||
return npos;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
basic_string <charT, traits, Allocator>::size_type
|
||||
basic_string <charT, traits, Allocator>::
|
||||
find_last_not_of (const charT* s, size_type pos, size_type n) const
|
||||
{
|
||||
if (length() == 0)
|
||||
return npos;
|
||||
size_t xpos = length () - 1;
|
||||
if (xpos > pos)
|
||||
xpos = pos;
|
||||
for (++xpos; xpos-- > 0;)
|
||||
if (_find (s, data () [xpos], 0, n) == npos)
|
||||
return xpos;
|
||||
return npos;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
basic_string <charT, traits, Allocator>::size_type
|
||||
basic_string <charT, traits, Allocator>::
|
||||
find_last_not_of (charT c, size_type pos) const
|
||||
{
|
||||
if (length() == 0)
|
||||
return npos;
|
||||
size_t xpos = length () - 1;
|
||||
if (xpos > pos)
|
||||
xpos = pos;
|
||||
for (++xpos; xpos-- > 0;)
|
||||
if (traits::ne (data () [xpos], c))
|
||||
return xpos;
|
||||
return npos;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
int basic_string <charT, traits, Allocator>::
|
||||
compare (const basic_string& _str, size_type pos, size_type n) const
|
||||
{
|
||||
OUTOFRANGE (pos > length ());
|
||||
|
||||
size_t rlen = length () - pos;
|
||||
if (rlen > n)
|
||||
rlen = n;
|
||||
if (rlen > _str.length ())
|
||||
rlen = _str.length ();
|
||||
int r = traits::compare (data () + pos, _str.data (), rlen);
|
||||
if (r != 0)
|
||||
return r;
|
||||
if (rlen == n)
|
||||
return 0;
|
||||
return (length () - pos) - _str.length ();
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
int basic_string <charT, traits, Allocator>::
|
||||
compare (const charT* s, size_type pos, size_type n) const
|
||||
{
|
||||
OUTOFRANGE (pos > length ());
|
||||
|
||||
size_t rlen = length () - pos;
|
||||
if (rlen > n)
|
||||
rlen = n;
|
||||
int r = traits::compare (data () + pos, s, rlen);
|
||||
if (r != 0)
|
||||
return r;
|
||||
return (length () - pos) - n;
|
||||
}
|
||||
|
||||
#include <iostream.h>
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
istream &
|
||||
operator>> (istream &is, basic_string <charT, traits, Allocator> &s)
|
||||
{
|
||||
int w = is.width (0);
|
||||
if (is.ipfx0 ())
|
||||
{
|
||||
register streambuf *sb = is.rdbuf ();
|
||||
s.resize (0);
|
||||
while (1)
|
||||
{
|
||||
int ch = sb->sbumpc ();
|
||||
if (ch == EOF)
|
||||
{
|
||||
is.setstate (ios::eofbit);
|
||||
break;
|
||||
}
|
||||
else if (traits::is_del (ch))
|
||||
{
|
||||
sb->sungetc ();
|
||||
break;
|
||||
}
|
||||
s += static_cast<charT> (ch);
|
||||
if (--w == 1)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
is.isfx ();
|
||||
if (s.length () == 0)
|
||||
is.setstate (ios::failbit);
|
||||
|
||||
return is;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
ostream &
|
||||
operator<< (ostream &o, const basic_string <charT, traits, Allocator>& s)
|
||||
{
|
||||
return o.write (s.data (), s.length ());
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
istream&
|
||||
getline (istream &is, basic_string <charT, traits, Allocator>& s, charT delim)
|
||||
{
|
||||
if (is.ipfx1 ())
|
||||
{
|
||||
_IO_size_t _count = 0;
|
||||
streambuf *sb = is.rdbuf ();
|
||||
s.resize (0);
|
||||
|
||||
while (1)
|
||||
{
|
||||
int ch = sb->sbumpc ();
|
||||
if (ch == EOF)
|
||||
{
|
||||
is.setstate (_count == 0
|
||||
? (ios::failbit|ios::eofbit)
|
||||
: ios::eofbit);
|
||||
break;
|
||||
}
|
||||
|
||||
++_count;
|
||||
|
||||
if (ch == delim)
|
||||
break;
|
||||
|
||||
s += static_cast<charT> (ch);
|
||||
|
||||
if (s.length () == s.npos - 1)
|
||||
{
|
||||
is.setstate (ios::failbit);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// We need to be friends with istream to do this.
|
||||
// is._gcount = _count;
|
||||
is.isfx ();
|
||||
|
||||
return is;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
basic_string <charT, traits, Allocator>::Rep
|
||||
basic_string<charT, traits, Allocator>::nilRep = { 0, 0, 1, false };
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
const basic_string <charT, traits, Allocator>::size_type
|
||||
basic_string <charT, traits, Allocator>::npos;
|
||||
|
||||
} // extern "C++"
|
||||
@@ -0,0 +1,668 @@
|
||||
// Main templates for the -*- C++ -*- string classes.
|
||||
// Copyright (C) 1994, 1995, 1999 Free Software Foundation
|
||||
|
||||
// This file is part of the GNU ANSI C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
// As a special exception, if you link this library with files
|
||||
// compiled with a GNU compiler to produce an executable, this does not cause
|
||||
// the resulting executable to be covered by the GNU General Public License.
|
||||
// This exception does not however invalidate any other reasons why
|
||||
// the executable file might be covered by the GNU General Public License.
|
||||
|
||||
// Written by Jason Merrill based upon the specification by Takanori Adachi
|
||||
// in ANSI X3J16/94-0013R2.
|
||||
|
||||
#ifndef __BASTRING__
|
||||
#define __BASTRING__
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
#include <cstddef>
|
||||
#include <std/straits.h>
|
||||
|
||||
// NOTE : This does NOT conform to the draft standard and is likely to change
|
||||
#include <alloc.h>
|
||||
|
||||
extern "C++" {
|
||||
class istream; class ostream;
|
||||
|
||||
#include <iterator>
|
||||
|
||||
#ifdef __STL_USE_EXCEPTIONS
|
||||
|
||||
extern void __out_of_range (const char *);
|
||||
extern void __length_error (const char *);
|
||||
|
||||
#define OUTOFRANGE(cond) \
|
||||
do { if (cond) __out_of_range (#cond); } while (0)
|
||||
#define LENGTHERROR(cond) \
|
||||
do { if (cond) __length_error (#cond); } while (0)
|
||||
|
||||
#else
|
||||
|
||||
#include <cassert>
|
||||
#define OUTOFRANGE(cond) assert (!(cond))
|
||||
#define LENGTHERROR(cond) assert (!(cond))
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __BEOS__
|
||||
// Needed for atomic_add():
|
||||
typedef long int32;
|
||||
typedef volatile long vint32;
|
||||
extern "C" int32 atomic_add(vint32* value, int32 addvalue);
|
||||
#endif /* __BEOS__ */
|
||||
|
||||
template <class charT, class traits = string_char_traits<charT>,
|
||||
class Allocator = alloc >
|
||||
class basic_string
|
||||
{
|
||||
private:
|
||||
struct Rep {
|
||||
size_t len, res, ref;
|
||||
bool selfish;
|
||||
|
||||
charT* data () { return reinterpret_cast<charT *>(this + 1); }
|
||||
charT& operator[] (size_t s) { return data () [s]; }
|
||||
#ifdef __BEOS__
|
||||
charT* grab () { if (selfish) return clone (); atomic_add((vint32*) &ref, 1); return data (); }
|
||||
void release() { if (atomic_add((int32*) &ref, -1) == 1) delete this; }
|
||||
#else
|
||||
charT* grab () { if (selfish) return clone (); ++ref; return data (); }
|
||||
#if defined __i486__ || defined __i586__ || defined __i686__
|
||||
void release ()
|
||||
{
|
||||
size_t __val;
|
||||
// This opcode exists as a .byte instead of as a mnemonic for the
|
||||
// benefit of SCO OpenServer 5. The system assembler (which is
|
||||
// essentially required on this target) can't assemble xaddl in
|
||||
//COFF mode.
|
||||
asm (".byte 0xf0, 0x0f, 0xc1, 0x02" // lock; xaddl %eax, (%edx)
|
||||
: "=a" (__val)
|
||||
: "0" (-1), "m" (ref), "d" (&ref)
|
||||
: "memory");
|
||||
|
||||
if (__val == 1)
|
||||
delete this;
|
||||
}
|
||||
#elif defined __sparcv9__
|
||||
void release ()
|
||||
{
|
||||
size_t __newval, __oldval = ref;
|
||||
do
|
||||
{
|
||||
__newval = __oldval - 1;
|
||||
__asm__ ("cas [%4], %2, %0"
|
||||
: "=r" (__oldval), "=m" (ref)
|
||||
: "r" (__oldval), "m" (ref), "r"(&(ref)), "0" (__newval));
|
||||
}
|
||||
while (__newval != __oldval);
|
||||
|
||||
if (__oldval == 0)
|
||||
delete this;
|
||||
}
|
||||
#else
|
||||
void release () { if (--ref == 0) delete this; }
|
||||
#endif
|
||||
#endif /* __BEOS__ */
|
||||
inline static void * operator new (size_t, size_t);
|
||||
inline static void operator delete (void *);
|
||||
inline static Rep* create (size_t);
|
||||
charT* clone ();
|
||||
|
||||
inline void copy (size_t, const charT *, size_t);
|
||||
inline void move (size_t, const charT *, size_t);
|
||||
inline void set (size_t, const charT, size_t);
|
||||
|
||||
inline static bool excess_slop (size_t, size_t);
|
||||
inline static size_t frob_size (size_t);
|
||||
|
||||
private:
|
||||
Rep &operator= (const Rep &);
|
||||
};
|
||||
|
||||
public:
|
||||
// types:
|
||||
typedef traits traits_type;
|
||||
typedef typename traits::char_type value_type;
|
||||
typedef Allocator allocator_type;
|
||||
|
||||
typedef size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
typedef charT& reference;
|
||||
typedef const charT& const_reference;
|
||||
typedef charT* pointer;
|
||||
typedef const charT* const_pointer;
|
||||
typedef pointer iterator;
|
||||
typedef const_pointer const_iterator;
|
||||
typedef ::reverse_iterator<iterator> reverse_iterator;
|
||||
typedef ::reverse_iterator<const_iterator> const_reverse_iterator;
|
||||
static const size_type npos = static_cast<size_type>(-1);
|
||||
|
||||
private:
|
||||
Rep *rep () const { return reinterpret_cast<Rep *>(dat) - 1; }
|
||||
void repup (Rep *p) { rep ()->release (); dat = p->data (); }
|
||||
|
||||
public:
|
||||
const charT* data () const
|
||||
{ return rep ()->data(); }
|
||||
size_type length () const
|
||||
{ return rep ()->len; }
|
||||
size_type size () const
|
||||
{ return rep ()->len; }
|
||||
size_type capacity () const
|
||||
{ return rep ()->res; }
|
||||
size_type max_size () const
|
||||
{ return (npos - 1)/sizeof (charT); } // XXX
|
||||
bool empty () const
|
||||
{ return size () == 0; }
|
||||
|
||||
// _lib.string.cons_ construct/copy/destroy:
|
||||
basic_string& operator= (const basic_string& str)
|
||||
{
|
||||
if (&str != this) { rep ()->release (); dat = str.rep ()->grab (); }
|
||||
return *this;
|
||||
}
|
||||
|
||||
explicit basic_string (): dat (nilRep.grab ()) { }
|
||||
basic_string (const basic_string& _str): dat (_str.rep ()->grab ()) { }
|
||||
basic_string (const basic_string& _str, size_type pos, size_type n = npos)
|
||||
: dat (nilRep.grab ()) { assign (_str, pos, n); }
|
||||
basic_string (const charT* s, size_type n)
|
||||
: dat (nilRep.grab ()) { assign (s, n); }
|
||||
basic_string (const charT* s)
|
||||
: dat (nilRep.grab ()) { assign (s); }
|
||||
basic_string (size_type n, charT c)
|
||||
: dat (nilRep.grab ()) { assign (n, c); }
|
||||
#ifdef __STL_MEMBER_TEMPLATES
|
||||
template<class InputIterator>
|
||||
basic_string(InputIterator __begin, InputIterator __end)
|
||||
#else
|
||||
basic_string(const_iterator __begin, const_iterator __end)
|
||||
#endif
|
||||
: dat (nilRep.grab ()) { assign (__begin, __end); }
|
||||
|
||||
~basic_string ()
|
||||
{ rep ()->release (); }
|
||||
|
||||
void swap (basic_string &s) { charT *d = dat; dat = s.dat; s.dat = d; }
|
||||
|
||||
basic_string& append (const basic_string& _str, size_type pos = 0,
|
||||
size_type n = npos)
|
||||
{ return replace (length (), 0, _str, pos, n); }
|
||||
basic_string& append (const charT* s, size_type n)
|
||||
{ return replace (length (), 0, s, n); }
|
||||
basic_string& append (const charT* s)
|
||||
{ return append (s, traits::length (s)); }
|
||||
basic_string& append (size_type n, charT c)
|
||||
{ return replace (length (), 0, n, c); }
|
||||
#ifdef __STL_MEMBER_TEMPLATES
|
||||
template<class InputIterator>
|
||||
basic_string& append(InputIterator first, InputIterator last)
|
||||
#else
|
||||
basic_string& append(const_iterator first, const_iterator last)
|
||||
#endif
|
||||
{ return replace (iend (), iend (), first, last); }
|
||||
|
||||
void push_back(charT __c)
|
||||
{ append(1, __c); }
|
||||
|
||||
basic_string& assign (const basic_string& str, size_type pos = 0,
|
||||
size_type n = npos)
|
||||
{ return replace (0, npos, str, pos, n); }
|
||||
basic_string& assign (const charT* s, size_type n)
|
||||
{ return replace (0, npos, s, n); }
|
||||
basic_string& assign (const charT* s)
|
||||
{ return assign (s, traits::length (s)); }
|
||||
basic_string& assign (size_type n, charT c)
|
||||
{ return replace (0, npos, n, c); }
|
||||
#ifdef __STL_MEMBER_TEMPLATES
|
||||
template<class InputIterator>
|
||||
basic_string& assign(InputIterator first, InputIterator last)
|
||||
#else
|
||||
basic_string& assign(const_iterator first, const_iterator last)
|
||||
#endif
|
||||
{ return replace (ibegin (), iend (), first, last); }
|
||||
|
||||
basic_string& operator= (const charT* s)
|
||||
{ return assign (s); }
|
||||
basic_string& operator= (charT c)
|
||||
{ return assign (1, c); }
|
||||
|
||||
basic_string& operator+= (const basic_string& rhs)
|
||||
{ return append (rhs); }
|
||||
basic_string& operator+= (const charT* s)
|
||||
{ return append (s); }
|
||||
basic_string& operator+= (charT c)
|
||||
{ return append (1, c); }
|
||||
|
||||
basic_string& insert (size_type pos1, const basic_string& str,
|
||||
size_type pos2 = 0, size_type n = npos)
|
||||
{ return replace (pos1, 0, str, pos2, n); }
|
||||
basic_string& insert (size_type pos, const charT* s, size_type n)
|
||||
{ return replace (pos, 0, s, n); }
|
||||
basic_string& insert (size_type pos, const charT* s)
|
||||
{ return insert (pos, s, traits::length (s)); }
|
||||
basic_string& insert (size_type pos, size_type n, charT c)
|
||||
{ return replace (pos, 0, n, c); }
|
||||
iterator insert(iterator p, charT c)
|
||||
{ size_type __o = p - ibegin ();
|
||||
insert (p - ibegin (), 1, c); selfish ();
|
||||
return ibegin () + __o; }
|
||||
iterator insert(iterator p, size_type n, charT c)
|
||||
{ size_type __o = p - ibegin ();
|
||||
insert (p - ibegin (), n, c); selfish ();
|
||||
return ibegin () + __o; }
|
||||
#ifdef __STL_MEMBER_TEMPLATES
|
||||
template<class InputIterator>
|
||||
void insert(iterator p, InputIterator first, InputIterator last)
|
||||
#else
|
||||
void insert(iterator p, const_iterator first, const_iterator last)
|
||||
#endif
|
||||
{ replace (p, p, first, last); }
|
||||
|
||||
basic_string& erase (size_type pos = 0, size_type n = npos)
|
||||
{ return replace (pos, n, (size_type)0, (charT)0); }
|
||||
iterator erase(iterator p)
|
||||
{ size_type __o = p - begin();
|
||||
replace (__o, 1, (size_type)0, (charT)0); selfish ();
|
||||
return ibegin() + __o; }
|
||||
iterator erase(iterator f, iterator l)
|
||||
{ size_type __o = f - ibegin();
|
||||
replace (__o, l-f, (size_type)0, (charT)0);selfish ();
|
||||
return ibegin() + __o; }
|
||||
|
||||
basic_string& replace (size_type pos1, size_type n1, const basic_string& str,
|
||||
size_type pos2 = 0, size_type n2 = npos);
|
||||
basic_string& replace (size_type pos, size_type n1, const charT* s,
|
||||
size_type n2);
|
||||
basic_string& replace (size_type pos, size_type n1, const charT* s)
|
||||
{ return replace (pos, n1, s, traits::length (s)); }
|
||||
basic_string& replace (size_type pos, size_type n1, size_type n2, charT c);
|
||||
basic_string& replace (size_type pos, size_type n, charT c)
|
||||
{ return replace (pos, n, 1, c); }
|
||||
basic_string& replace (iterator i1, iterator i2, const basic_string& str)
|
||||
{ return replace (i1 - ibegin (), i2 - i1, str); }
|
||||
basic_string& replace (iterator i1, iterator i2, const charT* s, size_type n)
|
||||
{ return replace (i1 - ibegin (), i2 - i1, s, n); }
|
||||
basic_string& replace (iterator i1, iterator i2, const charT* s)
|
||||
{ return replace (i1 - ibegin (), i2 - i1, s); }
|
||||
basic_string& replace (iterator i1, iterator i2, size_type n, charT c)
|
||||
{ return replace (i1 - ibegin (), i2 - i1, n, c); }
|
||||
#ifdef __STL_MEMBER_TEMPLATES
|
||||
template<class InputIterator>
|
||||
basic_string& replace(iterator i1, iterator i2,
|
||||
InputIterator j1, InputIterator j2);
|
||||
#else
|
||||
basic_string& replace(iterator i1, iterator i2,
|
||||
const_iterator j1, const_iterator j2);
|
||||
#endif
|
||||
|
||||
private:
|
||||
static charT eos () { return traits::eos (); }
|
||||
void unique () { if (rep ()->ref > 1) alloc (length (), true); }
|
||||
void selfish () { unique (); rep ()->selfish = true; }
|
||||
|
||||
public:
|
||||
charT operator[] (size_type pos) const
|
||||
{
|
||||
if (pos == length ())
|
||||
return eos ();
|
||||
return data ()[pos];
|
||||
}
|
||||
|
||||
reference operator[] (size_type pos)
|
||||
{ selfish (); return (*rep ())[pos]; }
|
||||
|
||||
reference at (size_type pos)
|
||||
{
|
||||
OUTOFRANGE (pos >= length ());
|
||||
return (*this)[pos];
|
||||
}
|
||||
const_reference at (size_type pos) const
|
||||
{
|
||||
OUTOFRANGE (pos >= length ());
|
||||
return data ()[pos];
|
||||
}
|
||||
|
||||
private:
|
||||
void terminate () const
|
||||
{ traits::assign ((*rep ())[length ()], eos ()); }
|
||||
|
||||
public:
|
||||
const charT* c_str () const
|
||||
{ if (length () == 0) return ""; terminate (); return data (); }
|
||||
void resize (size_type n, charT c);
|
||||
void resize (size_type n)
|
||||
{ resize (n, eos ()); }
|
||||
void reserve (size_type) { }
|
||||
|
||||
size_type copy (charT* s, size_type n, size_type pos = 0) const;
|
||||
|
||||
size_type find (const basic_string& str, size_type pos = 0) const
|
||||
{ return find (str.data(), pos, str.length()); }
|
||||
size_type find (const charT* s, size_type pos, size_type n) const;
|
||||
size_type find (const charT* _s, size_type pos = 0) const
|
||||
{ return find (_s, pos, traits::length (_s)); }
|
||||
size_type find (charT c, size_type pos = 0) const;
|
||||
|
||||
size_type rfind (const basic_string& str, size_type pos = npos) const
|
||||
{ return rfind (str.data(), pos, str.length()); }
|
||||
size_type rfind (const charT* s, size_type pos, size_type n) const;
|
||||
size_type rfind (const charT* s, size_type pos = npos) const
|
||||
{ return rfind (s, pos, traits::length (s)); }
|
||||
size_type rfind (charT c, size_type pos = npos) const;
|
||||
|
||||
size_type find_first_of (const basic_string& str, size_type pos = 0) const
|
||||
{ return find_first_of (str.data(), pos, str.length()); }
|
||||
size_type find_first_of (const charT* s, size_type pos, size_type n) const;
|
||||
size_type find_first_of (const charT* s, size_type pos = 0) const
|
||||
{ return find_first_of (s, pos, traits::length (s)); }
|
||||
size_type find_first_of (charT c, size_type pos = 0) const
|
||||
{ return find (c, pos); }
|
||||
|
||||
size_type find_last_of (const basic_string& str, size_type pos = npos) const
|
||||
{ return find_last_of (str.data(), pos, str.length()); }
|
||||
size_type find_last_of (const charT* s, size_type pos, size_type n) const;
|
||||
size_type find_last_of (const charT* s, size_type pos = npos) const
|
||||
{ return find_last_of (s, pos, traits::length (s)); }
|
||||
size_type find_last_of (charT c, size_type pos = npos) const
|
||||
{ return rfind (c, pos); }
|
||||
|
||||
size_type find_first_not_of (const basic_string& str, size_type pos = 0) const
|
||||
{ return find_first_not_of (str.data(), pos, str.length()); }
|
||||
size_type find_first_not_of (const charT* s, size_type pos, size_type n) const;
|
||||
size_type find_first_not_of (const charT* s, size_type pos = 0) const
|
||||
{ return find_first_not_of (s, pos, traits::length (s)); }
|
||||
size_type find_first_not_of (charT c, size_type pos = 0) const;
|
||||
|
||||
size_type find_last_not_of (const basic_string& str, size_type pos = npos) const
|
||||
{ return find_last_not_of (str.data(), pos, str.length()); }
|
||||
size_type find_last_not_of (const charT* s, size_type pos, size_type n) const;
|
||||
size_type find_last_not_of (const charT* s, size_type pos = npos) const
|
||||
{ return find_last_not_of (s, pos, traits::length (s)); }
|
||||
size_type find_last_not_of (charT c, size_type pos = npos) const;
|
||||
|
||||
basic_string substr (size_type pos = 0, size_type n = npos) const
|
||||
{ return basic_string (*this, pos, n); }
|
||||
|
||||
int compare (const basic_string& str, size_type pos = 0, size_type n = npos) const;
|
||||
// There is no 'strncmp' equivalent for charT pointers.
|
||||
int compare (const charT* s, size_type pos, size_type n) const;
|
||||
int compare (const charT* s, size_type pos = 0) const
|
||||
{ return compare (s, pos, traits::length (s)); }
|
||||
|
||||
iterator begin () { selfish (); return &(*this)[0]; }
|
||||
iterator end () { selfish (); return &(*this)[length ()]; }
|
||||
|
||||
private:
|
||||
iterator ibegin () const { return &(*rep ())[0]; }
|
||||
iterator iend () const { return &(*rep ())[length ()]; }
|
||||
|
||||
public:
|
||||
const_iterator begin () const { return ibegin (); }
|
||||
const_iterator end () const { return iend (); }
|
||||
|
||||
reverse_iterator rbegin() { return reverse_iterator (end ()); }
|
||||
const_reverse_iterator rbegin() const
|
||||
{ return const_reverse_iterator (end ()); }
|
||||
reverse_iterator rend() { return reverse_iterator (begin ()); }
|
||||
const_reverse_iterator rend() const
|
||||
{ return const_reverse_iterator (begin ()); }
|
||||
|
||||
private:
|
||||
void alloc (size_type size, bool save);
|
||||
static size_type _find (const charT* ptr, charT c, size_type xpos, size_type len);
|
||||
inline bool check_realloc (size_type s) const;
|
||||
|
||||
static Rep nilRep;
|
||||
charT *dat;
|
||||
};
|
||||
|
||||
#ifdef __STL_MEMBER_TEMPLATES
|
||||
template <class charT, class traits, class Allocator> template <class InputIterator>
|
||||
basic_string <charT, traits, Allocator>& basic_string <charT, traits, Allocator>::
|
||||
replace (iterator i1, iterator i2, InputIterator j1, InputIterator j2)
|
||||
#else
|
||||
template <class charT, class traits, class Allocator>
|
||||
basic_string <charT, traits, Allocator>& basic_string <charT, traits, Allocator>::
|
||||
replace (iterator i1, iterator i2, const_iterator j1, const_iterator j2)
|
||||
#endif
|
||||
{
|
||||
const size_type len = length ();
|
||||
size_type pos = i1 - ibegin ();
|
||||
size_type n1 = i2 - i1;
|
||||
size_type n2 = j2 - j1;
|
||||
|
||||
OUTOFRANGE (pos > len);
|
||||
if (n1 > len - pos)
|
||||
n1 = len - pos;
|
||||
LENGTHERROR (len - n1 > max_size () - n2);
|
||||
size_t newlen = len - n1 + n2;
|
||||
|
||||
if (check_realloc (newlen))
|
||||
{
|
||||
Rep *p = Rep::create (newlen);
|
||||
p->copy (0, data (), pos);
|
||||
p->copy (pos + n2, data () + pos + n1, len - (pos + n1));
|
||||
for (; j1 != j2; ++j1, ++pos)
|
||||
traits::assign ((*p)[pos], *j1);
|
||||
repup (p);
|
||||
}
|
||||
else
|
||||
{
|
||||
rep ()->move (pos + n2, data () + pos + n1, len - (pos + n1));
|
||||
for (; j1 != j2; ++j1, ++pos)
|
||||
traits::assign ((*rep ())[pos], *j1);
|
||||
}
|
||||
rep ()->len = newlen;
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline basic_string <charT, traits, Allocator>
|
||||
operator+ (const basic_string <charT, traits, Allocator>& lhs,
|
||||
const basic_string <charT, traits, Allocator>& rhs)
|
||||
{
|
||||
basic_string <charT, traits, Allocator> _str (lhs);
|
||||
_str.append (rhs);
|
||||
return _str;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline basic_string <charT, traits, Allocator>
|
||||
operator+ (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
|
||||
{
|
||||
basic_string <charT, traits, Allocator> _str (lhs);
|
||||
_str.append (rhs);
|
||||
return _str;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline basic_string <charT, traits, Allocator>
|
||||
operator+ (charT lhs, const basic_string <charT, traits, Allocator>& rhs)
|
||||
{
|
||||
basic_string <charT, traits, Allocator> _str (1, lhs);
|
||||
_str.append (rhs);
|
||||
return _str;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline basic_string <charT, traits, Allocator>
|
||||
operator+ (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
|
||||
{
|
||||
basic_string <charT, traits, Allocator> _str (lhs);
|
||||
_str.append (rhs);
|
||||
return _str;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline basic_string <charT, traits, Allocator>
|
||||
operator+ (const basic_string <charT, traits, Allocator>& lhs, charT rhs)
|
||||
{
|
||||
basic_string <charT, traits, Allocator> str (lhs);
|
||||
str.append (1, rhs);
|
||||
return str;
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline bool
|
||||
operator== (const basic_string <charT, traits, Allocator>& lhs,
|
||||
const basic_string <charT, traits, Allocator>& rhs)
|
||||
{
|
||||
return (lhs.compare (rhs) == 0);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline bool
|
||||
operator== (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
|
||||
{
|
||||
return (rhs.compare (lhs) == 0);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline bool
|
||||
operator== (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
|
||||
{
|
||||
return (lhs.compare (rhs) == 0);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline bool
|
||||
operator!= (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
|
||||
{
|
||||
return (rhs.compare (lhs) != 0);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline bool
|
||||
operator!= (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
|
||||
{
|
||||
return (lhs.compare (rhs) != 0);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline bool
|
||||
operator< (const basic_string <charT, traits, Allocator>& lhs,
|
||||
const basic_string <charT, traits, Allocator>& rhs)
|
||||
{
|
||||
return (lhs.compare (rhs) < 0);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline bool
|
||||
operator< (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
|
||||
{
|
||||
return (rhs.compare (lhs) > 0);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline bool
|
||||
operator< (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
|
||||
{
|
||||
return (lhs.compare (rhs) < 0);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline bool
|
||||
operator> (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
|
||||
{
|
||||
return (rhs.compare (lhs) < 0);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline bool
|
||||
operator> (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
|
||||
{
|
||||
return (lhs.compare (rhs) > 0);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline bool
|
||||
operator<= (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
|
||||
{
|
||||
return (rhs.compare (lhs) >= 0);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline bool
|
||||
operator<= (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
|
||||
{
|
||||
return (lhs.compare (rhs) <= 0);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline bool
|
||||
operator>= (const charT* lhs, const basic_string <charT, traits, Allocator>& rhs)
|
||||
{
|
||||
return (rhs.compare (lhs) <= 0);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline bool
|
||||
operator>= (const basic_string <charT, traits, Allocator>& lhs, const charT* rhs)
|
||||
{
|
||||
return (lhs.compare (rhs) >= 0);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline bool
|
||||
operator!= (const basic_string <charT, traits, Allocator>& lhs,
|
||||
const basic_string <charT, traits, Allocator>& rhs)
|
||||
{
|
||||
return (lhs.compare (rhs) != 0);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline bool
|
||||
operator> (const basic_string <charT, traits, Allocator>& lhs,
|
||||
const basic_string <charT, traits, Allocator>& rhs)
|
||||
{
|
||||
return (lhs.compare (rhs) > 0);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline bool
|
||||
operator<= (const basic_string <charT, traits, Allocator>& lhs,
|
||||
const basic_string <charT, traits, Allocator>& rhs)
|
||||
{
|
||||
return (lhs.compare (rhs) <= 0);
|
||||
}
|
||||
|
||||
template <class charT, class traits, class Allocator>
|
||||
inline bool
|
||||
operator>= (const basic_string <charT, traits, Allocator>& lhs,
|
||||
const basic_string <charT, traits, Allocator>& rhs)
|
||||
{
|
||||
return (lhs.compare (rhs) >= 0);
|
||||
}
|
||||
|
||||
class istream; class ostream;
|
||||
template <class charT, class traits, class Allocator> istream&
|
||||
operator>> (istream&, basic_string <charT, traits, Allocator>&);
|
||||
template <class charT, class traits, class Allocator> ostream&
|
||||
operator<< (ostream&, const basic_string <charT, traits, Allocator>&);
|
||||
template <class charT, class traits, class Allocator> istream&
|
||||
getline (istream&, basic_string <charT, traits, Allocator>&, charT delim = '\n');
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#include <std/bastring.cc>
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,273 @@
|
||||
// Member templates for the -*- C++ -*- complex number classes.
|
||||
// Copyright (C) 1994 Free Software Foundation
|
||||
|
||||
// This file is part of the GNU ANSI C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
// As a special exception, if you link this library with files
|
||||
// compiled with a GNU compiler to produce an executable, this does not cause
|
||||
// the resulting executable to be covered by the GNU General Public License.
|
||||
// This exception does not however invalidate any other reasons why
|
||||
// the executable file might be covered by the GNU General Public License.
|
||||
|
||||
// Written by Jason Merrill based upon the specification in the 27 May 1994
|
||||
// C++ working paper, ANSI document X3J16/94-0098.
|
||||
|
||||
#include <complex>
|
||||
|
||||
extern "C++" {
|
||||
template <class FLOAT> complex<FLOAT>
|
||||
cos (const complex<FLOAT>& x)
|
||||
{
|
||||
return complex<FLOAT> (cos (real (x)) * cosh (imag (x)),
|
||||
- sin (real (x)) * sinh (imag (x)));
|
||||
}
|
||||
|
||||
template <class FLOAT> complex<FLOAT>
|
||||
cosh (const complex<FLOAT>& x)
|
||||
{
|
||||
return complex<FLOAT> (cosh (real (x)) * cos (imag (x)),
|
||||
sinh (real (x)) * sin (imag (x)));
|
||||
}
|
||||
|
||||
template <class FLOAT> complex<FLOAT>
|
||||
exp (const complex<FLOAT>& x)
|
||||
{
|
||||
return polar (FLOAT (exp (real (x))), imag (x));
|
||||
}
|
||||
|
||||
template <class FLOAT> complex<FLOAT>
|
||||
log (const complex<FLOAT>& x)
|
||||
{
|
||||
return complex<FLOAT> (log (abs (x)), arg (x));
|
||||
}
|
||||
|
||||
template <class FLOAT> complex<FLOAT>
|
||||
pow (const complex<FLOAT>& x, const complex<FLOAT>& y)
|
||||
{
|
||||
FLOAT logr = log (abs (x));
|
||||
FLOAT t = arg (x);
|
||||
|
||||
return polar (FLOAT (exp (logr * real (y) - imag (y) * t)),
|
||||
FLOAT (imag (y) * logr + real (y) * t));
|
||||
}
|
||||
|
||||
template <class FLOAT> complex<FLOAT>
|
||||
pow (const complex<FLOAT>& x, FLOAT y)
|
||||
{
|
||||
return exp (FLOAT (y) * log (x));
|
||||
}
|
||||
|
||||
template <class FLOAT> complex<FLOAT>
|
||||
pow (FLOAT x, const complex<FLOAT>& y)
|
||||
{
|
||||
return exp (y * FLOAT (log (x)));
|
||||
}
|
||||
|
||||
template <class FLOAT> complex<FLOAT>
|
||||
sin (const complex<FLOAT>& x)
|
||||
{
|
||||
return complex<FLOAT> (sin (real (x)) * cosh (imag (x)),
|
||||
cos (real (x)) * sinh (imag (x)));
|
||||
}
|
||||
|
||||
template <class FLOAT> complex<FLOAT>
|
||||
sinh (const complex<FLOAT>& x)
|
||||
{
|
||||
return complex<FLOAT> (sinh (real (x)) * cos (imag (x)),
|
||||
cosh (real (x)) * sin (imag (x)));
|
||||
}
|
||||
|
||||
#include <iostream.h>
|
||||
|
||||
template <class FLOAT> istream&
|
||||
operator >> (istream& is, complex<FLOAT>& x)
|
||||
{
|
||||
FLOAT re, im = 0;
|
||||
char ch = 0;
|
||||
|
||||
if (is.ipfx0 ())
|
||||
{
|
||||
if (is.peek () == '(')
|
||||
is >> ch;
|
||||
is >> re;
|
||||
if (ch == '(')
|
||||
{
|
||||
is >> ch;
|
||||
if (ch == ',')
|
||||
is >> im >> ch;
|
||||
}
|
||||
}
|
||||
is.isfx ();
|
||||
|
||||
if (ch != 0 && ch != ')')
|
||||
is.setstate (ios::failbit);
|
||||
else if (is.good ())
|
||||
x = complex<FLOAT> (re, im);
|
||||
|
||||
return is;
|
||||
}
|
||||
|
||||
template <class FLOAT> ostream&
|
||||
operator << (ostream& os, const complex<FLOAT>& x)
|
||||
{
|
||||
return os << '(' << real (x) << ',' << imag (x) << ')';
|
||||
}
|
||||
|
||||
// The code below is adapted from f2c's libF77, and is subject to this
|
||||
// copyright:
|
||||
|
||||
/****************************************************************
|
||||
Copyright 1990, 1991, 1992, 1993 by AT&T Bell Laboratories and Bellcore.
|
||||
|
||||
Permission to use, copy, modify, and distribute this software
|
||||
and its documentation for any purpose and without fee is hereby
|
||||
granted, provided that the above copyright notice appear in all
|
||||
copies and that both that the copyright notice and this
|
||||
permission notice and warranty disclaimer appear in supporting
|
||||
documentation, and that the names of AT&T Bell Laboratories or
|
||||
Bellcore or any of their entities not be used in advertising or
|
||||
publicity pertaining to distribution of the software without
|
||||
specific, written prior permission.
|
||||
|
||||
AT&T and Bellcore disclaim all warranties with regard to this
|
||||
software, including all implied warranties of merchantability
|
||||
and fitness. In no event shall AT&T or Bellcore be liable for
|
||||
any special, indirect or consequential damages or any damages
|
||||
whatsoever resulting from loss of use, data or profits, whether
|
||||
in an action of contract, negligence or other tortious action,
|
||||
arising out of or in connection with the use or performance of
|
||||
this software.
|
||||
****************************************************************/
|
||||
|
||||
template <class FLOAT> complex<FLOAT>&
|
||||
__doadv (complex<FLOAT>* ths, const complex<FLOAT>& y)
|
||||
{
|
||||
FLOAT ar = abs (y.re);
|
||||
FLOAT ai = abs (y.im);
|
||||
FLOAT nr, ni;
|
||||
FLOAT t, d;
|
||||
if (ar <= ai)
|
||||
{
|
||||
t = y.re / y.im;
|
||||
d = y.im * (1 + t*t);
|
||||
nr = (ths->re * t + ths->im) / d;
|
||||
ni = (ths->im * t - ths->re) / d;
|
||||
}
|
||||
else
|
||||
{
|
||||
t = y.im / y.re;
|
||||
d = y.re * (1 + t*t);
|
||||
nr = (ths->re + ths->im * t) / d;
|
||||
ni = (ths->im - ths->re * t) / d;
|
||||
}
|
||||
ths->re = nr;
|
||||
ths->im = ni;
|
||||
return *ths;
|
||||
}
|
||||
|
||||
template <class FLOAT> complex<FLOAT>
|
||||
operator / (const complex<FLOAT>& x, const complex<FLOAT>& y)
|
||||
{
|
||||
FLOAT ar = abs (real (y));
|
||||
FLOAT ai = abs (imag (y));
|
||||
FLOAT nr, ni;
|
||||
FLOAT t, d;
|
||||
if (ar <= ai)
|
||||
{
|
||||
t = real (y) / imag (y);
|
||||
d = imag (y) * (1 + t*t);
|
||||
nr = (real (x) * t + imag (x)) / d;
|
||||
ni = (imag (x) * t - real (x)) / d;
|
||||
}
|
||||
else
|
||||
{
|
||||
t = imag (y) / real (y);
|
||||
d = real (y) * (1 + t*t);
|
||||
nr = (real (x) + imag (x) * t) / d;
|
||||
ni = (imag (x) - real (x) * t) / d;
|
||||
}
|
||||
return complex<FLOAT> (nr, ni);
|
||||
}
|
||||
|
||||
template <class FLOAT> complex<FLOAT>
|
||||
operator / (FLOAT x, const complex<FLOAT>& y)
|
||||
{
|
||||
FLOAT ar = abs (real (y));
|
||||
FLOAT ai = abs (imag (y));
|
||||
FLOAT nr, ni;
|
||||
FLOAT t, d;
|
||||
if (ar <= ai)
|
||||
{
|
||||
t = real (y) / imag (y);
|
||||
d = imag (y) * (1 + t*t);
|
||||
nr = x * t / d;
|
||||
ni = -x / d;
|
||||
}
|
||||
else
|
||||
{
|
||||
t = imag (y) / real (y);
|
||||
d = real (y) * (1 + t*t);
|
||||
nr = x / d;
|
||||
ni = -x * t / d;
|
||||
}
|
||||
return complex<FLOAT> (nr, ni);
|
||||
}
|
||||
|
||||
template <class FLOAT> complex<FLOAT>
|
||||
pow (const complex<FLOAT>& xin, int y)
|
||||
{
|
||||
if (y == 0)
|
||||
return complex<FLOAT> (1.0);
|
||||
complex<FLOAT> r (1.0);
|
||||
complex<FLOAT> x (xin);
|
||||
if (y < 0)
|
||||
{
|
||||
y = -y;
|
||||
x = FLOAT(1)/x;
|
||||
}
|
||||
for (;;)
|
||||
{
|
||||
if (y & 1)
|
||||
r *= x;
|
||||
if (y >>= 1)
|
||||
x *= x;
|
||||
else
|
||||
return r;
|
||||
}
|
||||
}
|
||||
|
||||
template <class FLOAT> complex<FLOAT>
|
||||
sqrt (const complex<FLOAT>& x)
|
||||
{
|
||||
FLOAT r = abs (x);
|
||||
FLOAT nr, ni;
|
||||
if (r == 0.0)
|
||||
nr = ni = r;
|
||||
else if (real (x) > 0)
|
||||
{
|
||||
nr = sqrt (0.5 * (r + real (x)));
|
||||
ni = imag (x) / nr / 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
ni = sqrt (0.5 * (r - real (x)));
|
||||
if (imag (x) < 0)
|
||||
ni = - ni;
|
||||
nr = imag (x) / ni / 2;
|
||||
}
|
||||
return complex<FLOAT> (nr, ni);
|
||||
}
|
||||
} // extern "C++"
|
||||
@@ -0,0 +1,400 @@
|
||||
// The template and inlines for the -*- C++ -*- complex number classes.
|
||||
// Copyright (C) 1994 Free Software Foundation
|
||||
|
||||
// This file is part of the GNU ANSI C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the terms of
|
||||
// the GNU General Public License as published by the Free Software
|
||||
// Foundation; either version 2, or (at your option) any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
// As a special exception, if you link this library with files compiled
|
||||
// with a GNU compiler to produce an executable, this does not cause the
|
||||
// resulting executable to be covered by the GNU General Public License.
|
||||
// This exception does not however invalidate any other reasons why the
|
||||
// executable file might be covered by the GNU General Public License.
|
||||
|
||||
// Written by Jason Merrill based upon the specification in the 27 May 1994
|
||||
// C++ working paper, ANSI document X3J16/94-0098.
|
||||
|
||||
#ifndef __COMPLEXT__
|
||||
#define __COMPLEXT__
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface
|
||||
#endif
|
||||
|
||||
#include <cmath>
|
||||
|
||||
#if ! defined (__GNUG__) && ! defined (__attribute__)
|
||||
#define __attribute__(foo) /* Ignore. */
|
||||
#endif
|
||||
|
||||
class istream;
|
||||
class ostream;
|
||||
|
||||
extern "C++" {
|
||||
template <class _FLT> class complex;
|
||||
template <class _FLT> complex<_FLT>&
|
||||
__doapl (complex<_FLT>* ths, const complex<_FLT>& r);
|
||||
template <class _FLT> complex<_FLT>&
|
||||
__doami (complex<_FLT>* ths, const complex<_FLT>& r);
|
||||
template <class _FLT> complex<_FLT>&
|
||||
__doaml (complex<_FLT>* ths, const complex<_FLT>& r);
|
||||
template <class _FLT> complex<_FLT>&
|
||||
__doadv (complex<_FLT>* ths, const complex<_FLT>& r);
|
||||
|
||||
template <class _FLT>
|
||||
class complex
|
||||
{
|
||||
public:
|
||||
complex (_FLT r = 0, _FLT i = 0): re (r), im (i) { }
|
||||
complex& operator += (const complex&);
|
||||
complex& operator -= (const complex&);
|
||||
complex& operator *= (const complex&);
|
||||
complex& operator /= (const complex&);
|
||||
_FLT real () const { return re; }
|
||||
_FLT imag () const { return im; }
|
||||
private:
|
||||
_FLT re, im;
|
||||
|
||||
friend complex& __doapl<> (complex *, const complex&);
|
||||
friend complex& __doami<> (complex *, const complex&);
|
||||
friend complex& __doaml<> (complex *, const complex&);
|
||||
friend complex& __doadv<> (complex *, const complex&);
|
||||
};
|
||||
|
||||
// Declare specializations.
|
||||
class complex<float>;
|
||||
class complex<double>;
|
||||
class complex<long double>;
|
||||
|
||||
template <class _FLT>
|
||||
inline complex<_FLT>&
|
||||
__doapl (complex<_FLT>* ths, const complex<_FLT>& r)
|
||||
{
|
||||
ths->re += r.re;
|
||||
ths->im += r.im;
|
||||
return *ths;
|
||||
}
|
||||
template <class _FLT>
|
||||
inline complex<_FLT>&
|
||||
complex<_FLT>::operator += (const complex<_FLT>& r)
|
||||
{
|
||||
return __doapl (this, r);
|
||||
}
|
||||
|
||||
template <class _FLT>
|
||||
inline complex<_FLT>&
|
||||
__doami (complex<_FLT>* ths, const complex<_FLT>& r)
|
||||
{
|
||||
ths->re -= r.re;
|
||||
ths->im -= r.im;
|
||||
return *ths;
|
||||
}
|
||||
template <class _FLT>
|
||||
inline complex<_FLT>&
|
||||
complex<_FLT>::operator -= (const complex<_FLT>& r)
|
||||
{
|
||||
return __doami (this, r);
|
||||
}
|
||||
|
||||
template <class _FLT>
|
||||
inline complex<_FLT>&
|
||||
__doaml (complex<_FLT>* ths, const complex<_FLT>& r)
|
||||
{
|
||||
_FLT f = ths->re * r.re - ths->im * r.im;
|
||||
ths->im = ths->re * r.im + ths->im * r.re;
|
||||
ths->re = f;
|
||||
return *ths;
|
||||
}
|
||||
template <class _FLT>
|
||||
inline complex<_FLT>&
|
||||
complex<_FLT>::operator *= (const complex<_FLT>& r)
|
||||
{
|
||||
return __doaml (this, r);
|
||||
}
|
||||
|
||||
template <class _FLT>
|
||||
inline complex<_FLT>&
|
||||
complex<_FLT>::operator /= (const complex<_FLT>& r)
|
||||
{
|
||||
return __doadv (this, r);
|
||||
}
|
||||
|
||||
template <class _FLT> inline _FLT
|
||||
imag (const complex<_FLT>& x) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline _FLT
|
||||
imag (const complex<_FLT>& x)
|
||||
{
|
||||
return x.imag ();
|
||||
}
|
||||
|
||||
template <class _FLT> inline _FLT
|
||||
real (const complex<_FLT>& x) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline _FLT
|
||||
real (const complex<_FLT>& x)
|
||||
{
|
||||
return x.real ();
|
||||
}
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator + (const complex<_FLT>& x, const complex<_FLT>& y) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator + (const complex<_FLT>& x, const complex<_FLT>& y)
|
||||
{
|
||||
return complex<_FLT> (real (x) + real (y), imag (x) + imag (y));
|
||||
}
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator + (const complex<_FLT>& x, _FLT y) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator + (const complex<_FLT>& x, _FLT y)
|
||||
{
|
||||
return complex<_FLT> (real (x) + y, imag (x));
|
||||
}
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator + (_FLT x, const complex<_FLT>& y) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator + (_FLT x, const complex<_FLT>& y)
|
||||
{
|
||||
return complex<_FLT> (x + real (y), imag (y));
|
||||
}
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator - (const complex<_FLT>& x, const complex<_FLT>& y) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator - (const complex<_FLT>& x, const complex<_FLT>& y)
|
||||
{
|
||||
return complex<_FLT> (real (x) - real (y), imag (x) - imag (y));
|
||||
}
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator - (const complex<_FLT>& x, _FLT y) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator - (const complex<_FLT>& x, _FLT y)
|
||||
{
|
||||
return complex<_FLT> (real (x) - y, imag (x));
|
||||
}
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator - (_FLT x, const complex<_FLT>& y) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator - (_FLT x, const complex<_FLT>& y)
|
||||
{
|
||||
return complex<_FLT> (x - real (y), - imag (y));
|
||||
}
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator * (const complex<_FLT>& x, const complex<_FLT>& y) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator * (const complex<_FLT>& x, const complex<_FLT>& y)
|
||||
{
|
||||
return complex<_FLT> (real (x) * real (y) - imag (x) * imag (y),
|
||||
real (x) * imag (y) + imag (x) * real (y));
|
||||
}
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator * (const complex<_FLT>& x, _FLT y) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator * (const complex<_FLT>& x, _FLT y)
|
||||
{
|
||||
return complex<_FLT> (real (x) * y, imag (x) * y);
|
||||
}
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator * (_FLT x, const complex<_FLT>& y) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator * (_FLT x, const complex<_FLT>& y)
|
||||
{
|
||||
return complex<_FLT> (x * real (y), x * imag (y));
|
||||
}
|
||||
|
||||
template <class _FLT> complex<_FLT>
|
||||
operator / (const complex<_FLT>& x, _FLT y) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> complex<_FLT>
|
||||
operator / (const complex<_FLT>& x, _FLT y)
|
||||
{
|
||||
return complex<_FLT> (real (x) / y, imag (x) / y);
|
||||
}
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator + (const complex<_FLT>& x) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator + (const complex<_FLT>& x)
|
||||
{
|
||||
return x;
|
||||
}
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator - (const complex<_FLT>& x) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
operator - (const complex<_FLT>& x)
|
||||
{
|
||||
return complex<_FLT> (-real (x), -imag (x));
|
||||
}
|
||||
|
||||
template <class _FLT> inline bool
|
||||
operator == (const complex<_FLT>& x, const complex<_FLT>& y) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline bool
|
||||
operator == (const complex<_FLT>& x, const complex<_FLT>& y)
|
||||
{
|
||||
return real (x) == real (y) && imag (x) == imag (y);
|
||||
}
|
||||
|
||||
template <class _FLT> inline bool
|
||||
operator == (const complex<_FLT>& x, _FLT y) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline bool
|
||||
operator == (const complex<_FLT>& x, _FLT y)
|
||||
{
|
||||
return real (x) == y && imag (x) == 0;
|
||||
}
|
||||
|
||||
template <class _FLT> inline bool
|
||||
operator == (_FLT x, const complex<_FLT>& y) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline bool
|
||||
operator == (_FLT x, const complex<_FLT>& y)
|
||||
{
|
||||
return x == real (y) && imag (y) == 0;
|
||||
}
|
||||
|
||||
template <class _FLT> inline bool
|
||||
operator != (const complex<_FLT>& x, const complex<_FLT>& y) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline bool
|
||||
operator != (const complex<_FLT>& x, const complex<_FLT>& y)
|
||||
{
|
||||
return real (x) != real (y) || imag (x) != imag (y);
|
||||
}
|
||||
|
||||
template <class _FLT> inline bool
|
||||
operator != (const complex<_FLT>& x, _FLT y) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline bool
|
||||
operator != (const complex<_FLT>& x, _FLT y)
|
||||
{
|
||||
return real (x) != y || imag (x) != 0;
|
||||
}
|
||||
|
||||
template <class _FLT> inline bool
|
||||
operator != (_FLT x, const complex<_FLT>& y) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline bool
|
||||
operator != (_FLT x, const complex<_FLT>& y)
|
||||
{
|
||||
return x != real (y) || imag (y) != 0;
|
||||
}
|
||||
|
||||
// Some targets don't provide a prototype for hypot when -ansi.
|
||||
extern "C" double hypot (double, double) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline _FLT
|
||||
abs (const complex<_FLT>& x) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline _FLT
|
||||
abs (const complex<_FLT>& x)
|
||||
{
|
||||
return hypot (real (x), imag (x));
|
||||
}
|
||||
|
||||
template <class _FLT> inline _FLT
|
||||
arg (const complex<_FLT>& x) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline _FLT
|
||||
arg (const complex<_FLT>& x)
|
||||
{
|
||||
return atan2 (imag (x), real (x));
|
||||
}
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
polar (_FLT r, _FLT t) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
polar (_FLT r, _FLT t)
|
||||
{
|
||||
return complex<_FLT> (r * cos (t), r * sin (t));
|
||||
}
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
conj (const complex<_FLT>& x) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline complex<_FLT>
|
||||
conj (const complex<_FLT>& x)
|
||||
{
|
||||
return complex<_FLT> (real (x), -imag (x));
|
||||
}
|
||||
|
||||
template <class _FLT> inline _FLT
|
||||
norm (const complex<_FLT>& x) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> inline _FLT
|
||||
norm (const complex<_FLT>& x)
|
||||
{
|
||||
return real (x) * real (x) + imag (x) * imag (x);
|
||||
}
|
||||
|
||||
// Declarations of templates in complext.ccI
|
||||
|
||||
template <class _FLT> complex<_FLT>
|
||||
operator / (const complex<_FLT>&, const complex<_FLT>&) __attribute__ ((const));
|
||||
template <class _FLT> complex<_FLT>
|
||||
operator / (_FLT, const complex<_FLT>&) __attribute__ ((const));
|
||||
template <class _FLT> complex<_FLT>
|
||||
cos (const complex<_FLT>&) __attribute__ ((const));
|
||||
template <class _FLT> complex<_FLT>
|
||||
cosh (const complex<_FLT>&) __attribute__ ((const));
|
||||
template <class _FLT> complex<_FLT>
|
||||
exp (const complex<_FLT>&) __attribute__ ((const));
|
||||
template <class _FLT> complex<_FLT>
|
||||
log (const complex<_FLT>&) __attribute__ ((const));
|
||||
template <class _FLT> complex<_FLT>
|
||||
pow (const complex<_FLT>&, const complex<_FLT>&) __attribute__ ((const));
|
||||
template <class _FLT> complex<_FLT>
|
||||
pow (const complex<_FLT>&, _FLT) __attribute__ ((const));
|
||||
template <class _FLT> complex<_FLT>
|
||||
pow (const complex<_FLT>&, int) __attribute__ ((const));
|
||||
template <class _FLT> complex<_FLT>
|
||||
pow (_FLT, const complex<_FLT>&) __attribute__ ((const));
|
||||
template <class _FLT> complex<_FLT>
|
||||
sin (const complex<_FLT>&) __attribute__ ((const));
|
||||
template <class _FLT> complex<_FLT>
|
||||
sinh (const complex<_FLT>&) __attribute__ ((const));
|
||||
template <class _FLT> complex<_FLT>
|
||||
sqrt (const complex<_FLT>&) __attribute__ ((const));
|
||||
|
||||
template <class _FLT> istream& operator >> (istream&, complex<_FLT>&);
|
||||
template <class _FLT> ostream& operator << (ostream&, const complex<_FLT>&);
|
||||
} // extern "C++"
|
||||
|
||||
// Specializations and such
|
||||
|
||||
#include <std/fcomplex.h>
|
||||
#include <std/dcomplex.h>
|
||||
#include <std/ldcomplex.h>
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,91 @@
|
||||
// The -*- C++ -*- double_complex class.
|
||||
// Copyright (C) 1994 Free Software Foundation
|
||||
|
||||
// This file is part of the GNU ANSI C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
// As a special exception, if you link this library with files
|
||||
// compiled with a GNU compiler to produce an executable, this does not cause
|
||||
// the resulting executable to be covered by the GNU General Public License.
|
||||
// This exception does not however invalidate any other reasons why
|
||||
// the executable file might be covered by the GNU General Public License.
|
||||
|
||||
// Written by Jason Merrill based upon the specification in the 27 May 1994
|
||||
// C++ working paper, ANSI document X3J16/94-0098.
|
||||
|
||||
#ifndef __DCOMPLEX__
|
||||
#define __DCOMPLEX__
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "dcomplex"
|
||||
#endif
|
||||
|
||||
extern "C++" {
|
||||
class complex<double>
|
||||
{
|
||||
public:
|
||||
complex (double r = 0, double i = 0): re (r), im (i) { }
|
||||
complex (const complex<float>& r): re (r.real ()), im (r.imag ()) { }
|
||||
explicit complex (const complex<long double>& r);
|
||||
|
||||
complex& operator+= (const complex& r) { return __doapl (this, r); }
|
||||
complex& operator-= (const complex& r) { return __doami (this, r); }
|
||||
complex& operator*= (const complex& r) { return __doaml (this, r); }
|
||||
complex& operator/= (const complex& r) { return __doadv (this, r); }
|
||||
|
||||
double real () const { return re; }
|
||||
double imag () const { return im; }
|
||||
private:
|
||||
double re, im;
|
||||
|
||||
friend complex& __doapl<> (complex *, const complex&);
|
||||
friend complex& __doami<> (complex *, const complex&);
|
||||
friend complex& __doaml<> (complex *, const complex&);
|
||||
friend complex& __doadv<> (complex *, const complex&);
|
||||
|
||||
#ifndef __STRICT_ANSI__
|
||||
friend inline complex operator + (const complex& x, double y)
|
||||
{ return operator+<> (x, y); }
|
||||
friend inline complex operator + (double x, const complex& y)
|
||||
{ return operator+<> (x, y); }
|
||||
friend inline complex operator - (const complex& x, double y)
|
||||
{ return operator-<> (x, y); }
|
||||
friend inline complex operator - (double x, const complex& y)
|
||||
{ return operator-<> (x, y); }
|
||||
friend inline complex operator * (const complex& x, double y)
|
||||
{ return operator*<> (x, y); }
|
||||
friend inline complex operator * (double x, const complex& y)
|
||||
{ return operator*<> (x, y); }
|
||||
friend inline complex operator / (const complex& x, double y)
|
||||
{ return operator/<> (x, y); }
|
||||
friend inline complex operator / (double x, const complex& y)
|
||||
{ return operator/<> (x, y); }
|
||||
friend inline bool operator == (const complex& x, double y)
|
||||
{ return operator==<> (x, y); }
|
||||
friend inline bool operator == (double x, const complex& y)
|
||||
{ return operator==<> (x, y); }
|
||||
friend inline bool operator != (const complex& x, double y)
|
||||
{ return operator!=<> (x, y); }
|
||||
friend inline bool operator != (double x, const complex& y)
|
||||
{ return operator!=<> (x, y); }
|
||||
#endif /* __STRICT_ANSI__ */
|
||||
};
|
||||
|
||||
inline complex<float>::complex (const complex<double>& r)
|
||||
: re (r.real ()), im (r.imag ())
|
||||
{ }
|
||||
} // extern "C++"
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,87 @@
|
||||
// The -*- C++ -*- float_complex class.
|
||||
// Copyright (C) 1994 Free Software Foundation
|
||||
|
||||
// This file is part of the GNU ANSI C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
// As a special exception, if you link this library with files
|
||||
// compiled with a GNU compiler to produce an executable, this does not cause
|
||||
// the resulting executable to be covered by the GNU General Public License.
|
||||
// This exception does not however invalidate any other reasons why
|
||||
// the executable file might be covered by the GNU General Public License.
|
||||
|
||||
// Written by Jason Merrill based upon the specification in the 27 May 1994
|
||||
// C++ working paper, ANSI document X3J16/94-0098.
|
||||
|
||||
#ifndef __FCOMPLEX__
|
||||
#define __FCOMPLEX__
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "fcomplex"
|
||||
#endif
|
||||
|
||||
extern "C++" {
|
||||
class complex<float>
|
||||
{
|
||||
public:
|
||||
complex (float r = 0, float i = 0): re (r), im (i) { }
|
||||
explicit complex (const complex<double>& r);
|
||||
explicit complex (const complex<long double>& r);
|
||||
|
||||
complex& operator+= (const complex& r) { return __doapl (this, r); }
|
||||
complex& operator-= (const complex& r) { return __doami (this, r); }
|
||||
complex& operator*= (const complex& r) { return __doaml (this, r); }
|
||||
complex& operator/= (const complex& r) { return __doadv (this, r); }
|
||||
|
||||
float real () const { return re; }
|
||||
float imag () const { return im; }
|
||||
private:
|
||||
float re, im;
|
||||
|
||||
friend complex& __doapl<> (complex *, const complex&);
|
||||
friend complex& __doami<> (complex *, const complex&);
|
||||
friend complex& __doaml<> (complex *, const complex&);
|
||||
friend complex& __doadv<> (complex *, const complex&);
|
||||
|
||||
#ifndef __STRICT_ANSI__
|
||||
friend inline complex operator + (const complex& x, float y)
|
||||
{ return operator+<> (x, y); }
|
||||
friend inline complex operator + (float x, const complex& y)
|
||||
{ return operator+<> (x, y); }
|
||||
friend inline complex operator - (const complex& x, float y)
|
||||
{ return operator-<> (x, y); }
|
||||
friend inline complex operator - (float x, const complex& y)
|
||||
{ return operator-<> (x, y); }
|
||||
friend inline complex operator * (const complex& x, float y)
|
||||
{ return operator*<> (x, y); }
|
||||
friend inline complex operator * (float x, const complex& y)
|
||||
{ return operator*<> (x, y); }
|
||||
friend inline complex operator / (const complex& x, float y)
|
||||
{ return operator/<> (x, y); }
|
||||
friend inline complex operator / (float x, const complex& y)
|
||||
{ return operator/<> (x, y); }
|
||||
friend inline bool operator == (const complex& x, float y)
|
||||
{ return operator==<> (x, y); }
|
||||
friend inline bool operator == (float x, const complex& y)
|
||||
{ return operator==<> (x, y); }
|
||||
friend inline bool operator != (const complex& x, float y)
|
||||
{ return operator!=<> (x, y); }
|
||||
friend inline bool operator != (float x, const complex& y)
|
||||
{ return operator!=<> (x, y); }
|
||||
#endif /* __STRICT_ANSI__ */
|
||||
};
|
||||
} // extern "C++"
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,111 @@
|
||||
// The template and inlines for the -*- C++ -*- gslice class.
|
||||
|
||||
// Copyright (C) 1997-1999 Cygnus Solutions
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <[email protected]>
|
||||
|
||||
#ifndef __GSLICE__
|
||||
#define __GSLICE__
|
||||
|
||||
extern "C++" {
|
||||
|
||||
struct _Indexer {
|
||||
size_t _M_count;
|
||||
size_t _M_start;
|
||||
valarray<size_t> _M_size;
|
||||
valarray<size_t> _M_stride;
|
||||
valarray<size_t> _M_index;
|
||||
_Indexer(size_t, const valarray<size_t>&, const valarray<size_t>&);
|
||||
void _M_increment_use() { ++_M_count; }
|
||||
size_t _M_decrement_use() { return --_M_count; }
|
||||
};
|
||||
|
||||
|
||||
class gslice
|
||||
{
|
||||
public:
|
||||
gslice ();
|
||||
gslice (size_t, const valarray<size_t>&, const valarray<size_t>&);
|
||||
gslice(const gslice&);
|
||||
~gslice();
|
||||
|
||||
gslice& operator= (const gslice&);
|
||||
size_t start () const;
|
||||
valarray<size_t> size () const;
|
||||
valarray<size_t> stride () const;
|
||||
|
||||
private:
|
||||
_Indexer* _M_index;
|
||||
|
||||
template<typename _Tp> friend class valarray;
|
||||
};
|
||||
|
||||
inline size_t
|
||||
gslice::start () const
|
||||
{ return _M_index ? _M_index->_M_start : 0; }
|
||||
|
||||
inline valarray<size_t>
|
||||
gslice::size () const
|
||||
{ return _M_index ? _M_index->_M_size : valarray<size_t>(); }
|
||||
|
||||
inline valarray<size_t>
|
||||
gslice::stride () const
|
||||
{ return _M_index ? _M_index->_M_stride : valarray<size_t>(); }
|
||||
|
||||
inline gslice::gslice () : _M_index(0) {}
|
||||
|
||||
inline
|
||||
gslice::gslice(size_t __o, const valarray<size_t>& __l,
|
||||
const valarray<size_t>& __s)
|
||||
: _M_index(new _Indexer(__o, __l, __s)) {}
|
||||
|
||||
inline
|
||||
gslice::gslice(const gslice& __g) : _M_index(__g._M_index)
|
||||
{ if (_M_index) _M_index->_M_increment_use(); }
|
||||
|
||||
inline
|
||||
gslice::~gslice()
|
||||
{ if (_M_index && _M_index->_M_decrement_use() == 0) delete _M_index; }
|
||||
|
||||
inline gslice&
|
||||
gslice::operator= (const gslice& __g)
|
||||
{
|
||||
if (__g._M_index) __g._M_index->_M_increment_use();
|
||||
if (_M_index && _M_index->_M_decrement_use() == 0) delete _M_index;
|
||||
_M_index = __g._M_index;
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#endif // __GSLICE__
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
@@ -0,0 +1,170 @@
|
||||
// The template and inlines for the -*- C++ -*- gslice_array class.
|
||||
|
||||
// Copyright (C) 1997-1999 Cygnus Solutions
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <[email protected]>
|
||||
|
||||
#ifndef __GSLICE_ARRAY__
|
||||
#define __GSLICE_ARRAY__
|
||||
|
||||
extern "C++" {
|
||||
|
||||
template<typename _Tp> class gslice_array
|
||||
{
|
||||
public:
|
||||
typedef _Tp value_type;
|
||||
|
||||
void operator= (const valarray<_Tp>&) const;
|
||||
void operator*= (const valarray<_Tp>&) const;
|
||||
void operator/= (const valarray<_Tp>&) const;
|
||||
void operator%= (const valarray<_Tp>&) const;
|
||||
void operator+= (const valarray<_Tp>&) const;
|
||||
void operator-= (const valarray<_Tp>&) const;
|
||||
void operator^= (const valarray<_Tp>&) const;
|
||||
void operator&= (const valarray<_Tp>&) const;
|
||||
void operator|= (const valarray<_Tp>&) const;
|
||||
void operator<<=(const valarray<_Tp>&) const;
|
||||
void operator>>=(const valarray<_Tp>&) const;
|
||||
void operator=(const _Tp&);
|
||||
|
||||
template<class _Dom>
|
||||
void operator= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator*= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator/= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator%= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator+= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator-= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator^= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator&= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator|= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator<<= (const _Expr<_Dom,_Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator>>= (const _Expr<_Dom,_Tp>&) const;
|
||||
|
||||
private:
|
||||
_Array<_Tp> _M_array;
|
||||
const valarray<size_t>& _M_index;
|
||||
|
||||
friend class valarray<_Tp>;
|
||||
|
||||
gslice_array (_Array<_Tp>, const valarray<size_t>&);
|
||||
|
||||
// this constructor needs to be implemented.
|
||||
gslice_array (const gslice_array&);
|
||||
|
||||
// not implemented
|
||||
gslice_array();
|
||||
gslice_array& operator= (const gslice_array&);
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
gslice_array<_Tp>::gslice_array (_Array<_Tp> __a,
|
||||
const valarray<size_t>& __i)
|
||||
: _M_array (__a), _M_index (__i) {}
|
||||
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
gslice_array<_Tp>::gslice_array (const gslice_array<_Tp>& __a)
|
||||
: _M_array (__a._M_array), _M_index (__a._M_index) {}
|
||||
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
gslice_array<_Tp>::operator= (const _Tp& __t)
|
||||
{
|
||||
__valarray_fill (_M_array, _Array<size_t>(_M_index),
|
||||
_M_index.size(), __t);
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
gslice_array<_Tp>::operator= (const valarray<_Tp>& __v) const
|
||||
{
|
||||
__valarray_copy (_Array<_Tp> (__v), __v.size (),
|
||||
_M_array, _Array<size_t>(_M_index));
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
template<class E>
|
||||
inline void
|
||||
gslice_array<_Tp>::operator= (const _Expr<E, _Tp>& __e) const
|
||||
{
|
||||
__valarray_copy (__e, _M_index.size(), _M_array,
|
||||
_Array<size_t>(_M_index));
|
||||
}
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
#define _DEFINE_VALARRAY_OPERATOR(op, name) \
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
gslice_array<_Tp>::operator##op##= (const valarray<_Tp>& __v) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _Array<size_t>(_M_index), \
|
||||
_Array<_Tp> (__v), __v.size ()); \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> template<class E> \
|
||||
inline void \
|
||||
gslice_array<_Tp>::operator##op##= (const _Expr<E, _Tp>& __e) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _Array<size_t>(_M_index), __e, \
|
||||
_M_index.size()); \
|
||||
}
|
||||
|
||||
_DEFINE_VALARRAY_OPERATOR(*, multiplies)
|
||||
_DEFINE_VALARRAY_OPERATOR(/, divides)
|
||||
_DEFINE_VALARRAY_OPERATOR(%, modulus)
|
||||
_DEFINE_VALARRAY_OPERATOR(+, plus)
|
||||
_DEFINE_VALARRAY_OPERATOR(-, minus)
|
||||
_DEFINE_VALARRAY_OPERATOR(^, xor)
|
||||
_DEFINE_VALARRAY_OPERATOR(&, and)
|
||||
_DEFINE_VALARRAY_OPERATOR(|, or)
|
||||
_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
|
||||
_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
|
||||
#endif // __GSLICE_ARRAY__
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
@@ -0,0 +1,157 @@
|
||||
// The template and inlines for the -*- C++ -*- indirect_array class.
|
||||
|
||||
// Copyright (C) 1997-1999 Cygnus Solutions
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <[email protected]>
|
||||
|
||||
#ifndef __INDIRECT_ARRAY__
|
||||
#define __INDIRECT_ARRAY__
|
||||
|
||||
extern "C++" {
|
||||
|
||||
template <class _Tp> class indirect_array
|
||||
{
|
||||
public:
|
||||
typedef _Tp value_type;
|
||||
|
||||
void operator= (const valarray<_Tp>&) const;
|
||||
void operator*= (const valarray<_Tp>&) const;
|
||||
void operator/= (const valarray<_Tp>&) const;
|
||||
void operator%= (const valarray<_Tp>&) const;
|
||||
void operator+= (const valarray<_Tp>&) const;
|
||||
void operator-= (const valarray<_Tp>&) const;
|
||||
void operator^= (const valarray<_Tp>&) const;
|
||||
void operator&= (const valarray<_Tp>&) const;
|
||||
void operator|= (const valarray<_Tp>&) const;
|
||||
void operator<<= (const valarray<_Tp>&) const;
|
||||
void operator>>= (const valarray<_Tp>&) const;
|
||||
void operator= (const _Tp&);
|
||||
|
||||
template<class _Dom>
|
||||
void operator= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator*= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator/= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator%= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator+= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator-= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator^= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator&= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator|= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator<<= (const _Expr<_Dom, _Tp>&) const;
|
||||
template<class _Dom>
|
||||
void operator>>= (const _Expr<_Dom, _Tp>&) const;
|
||||
|
||||
private:
|
||||
indirect_array (const indirect_array&);
|
||||
indirect_array (_Array<_Tp>, size_t, _Array<size_t>);
|
||||
|
||||
friend class valarray<_Tp>;
|
||||
friend class gslice_array<_Tp>;
|
||||
|
||||
const size_t _M_sz;
|
||||
const _Array<size_t> _M_index;
|
||||
const _Array<_Tp> _M_array;
|
||||
|
||||
// not implemented
|
||||
indirect_array ();
|
||||
indirect_array& operator= (const indirect_array&);
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
inline indirect_array<_Tp>::indirect_array(const indirect_array<_Tp>& __a)
|
||||
: _M_sz (__a._M_sz), _M_index (__a._M_index),
|
||||
_M_array (__a._M_array) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
indirect_array<_Tp>::indirect_array (_Array<_Tp> __a, size_t __s,
|
||||
_Array<size_t> __i)
|
||||
: _M_sz (__s), _M_index (__i), _M_array (__a) {}
|
||||
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
indirect_array<_Tp>::operator= (const _Tp& __t)
|
||||
{ __valarray_fill(_M_array, _M_index, _M_sz, __t); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
indirect_array<_Tp>::operator= (const valarray<_Tp>& __v) const
|
||||
{ __valarray_copy (_Array<_Tp> (__v), _M_sz, _M_array, _M_index); }
|
||||
|
||||
template<typename _Tp>
|
||||
template<class _Dom>
|
||||
inline void
|
||||
indirect_array<_Tp>::operator= (const _Expr<_Dom,_Tp>& __e) const
|
||||
{ __valarray_copy (__e, _M_sz, _M_array, _M_index); }
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
#define _DEFINE_VALARRAY_OPERATOR(op, name) \
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
indirect_array<_Tp>::operator##op##= (const valarray<_Tp>& __v) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _M_index, _Array<_Tp> (__v), _M_sz); \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> template<class _Dom> \
|
||||
inline void \
|
||||
indirect_array<_Tp>::operator##op##= (const _Expr<_Dom,_Tp>& __e) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _M_index, __e, _M_sz); \
|
||||
}
|
||||
|
||||
_DEFINE_VALARRAY_OPERATOR(*, multiplies)
|
||||
_DEFINE_VALARRAY_OPERATOR(/, divides)
|
||||
_DEFINE_VALARRAY_OPERATOR(%, modulus)
|
||||
_DEFINE_VALARRAY_OPERATOR(+, plus)
|
||||
_DEFINE_VALARRAY_OPERATOR(-, minus)
|
||||
_DEFINE_VALARRAY_OPERATOR(^, xor)
|
||||
_DEFINE_VALARRAY_OPERATOR(&, and)
|
||||
_DEFINE_VALARRAY_OPERATOR(|, or)
|
||||
_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
|
||||
_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#endif // __INDIRECT_ARRAY__
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
@@ -0,0 +1,95 @@
|
||||
// The -*- C++ -*- long_double_complex class.
|
||||
// Copyright (C) 1994 Free Software Foundation
|
||||
|
||||
// This file is part of the GNU ANSI C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
// As a special exception, if you link this library with files
|
||||
// compiled with a GNU compiler to produce an executable, this does not cause
|
||||
// the resulting executable to be covered by the GNU General Public License.
|
||||
// This exception does not however invalidate any other reasons why
|
||||
// the executable file might be covered by the GNU General Public License.
|
||||
|
||||
// Written by Jason Merrill based upon the specification in the 27 May 1994
|
||||
// C++ working paper, ANSI document X3J16/94-0098.
|
||||
|
||||
#ifndef __LDCOMPLEX__
|
||||
#define __LDCOMPLEX__
|
||||
|
||||
#ifdef __GNUG__
|
||||
#pragma interface "ldcomplex"
|
||||
#endif
|
||||
|
||||
extern "C++" {
|
||||
class complex<long double>
|
||||
{
|
||||
public:
|
||||
complex (long double r = 0, long double i = 0): re (r), im (i) { }
|
||||
complex (const complex<float>& r): re (r.real ()), im (r.imag ()) { }
|
||||
complex (const complex<double>& r): re (r.real ()), im (r.imag ()) { }
|
||||
|
||||
complex& operator+= (const complex& r) { return __doapl (this, r); }
|
||||
complex& operator-= (const complex& r) { return __doami (this, r); }
|
||||
complex& operator*= (const complex& r) { return __doaml (this, r); }
|
||||
complex& operator/= (const complex& r) { return __doadv (this, r); }
|
||||
|
||||
long double real () const { return re; }
|
||||
long double imag () const { return im; }
|
||||
private:
|
||||
long double re, im;
|
||||
|
||||
friend complex& __doapl<> (complex *, const complex&);
|
||||
friend complex& __doami<> (complex *, const complex&);
|
||||
friend complex& __doaml<> (complex *, const complex&);
|
||||
friend complex& __doadv<> (complex *, const complex&);
|
||||
|
||||
#ifndef __STRICT_ANSI__
|
||||
friend inline complex operator + (const complex& x, long double y)
|
||||
{ return operator+<> (x, y); }
|
||||
friend inline complex operator + (long double x, const complex& y)
|
||||
{ return operator+<> (x, y); }
|
||||
friend inline complex operator - (const complex& x, long double y)
|
||||
{ return operator-<> (x, y); }
|
||||
friend inline complex operator - (long double x, const complex& y)
|
||||
{ return operator-<> (x, y); }
|
||||
friend inline complex operator * (const complex& x, long double y)
|
||||
{ return operator*<> (x, y); }
|
||||
friend inline complex operator * (long double x, const complex& y)
|
||||
{ return operator*<> (x, y); }
|
||||
friend inline complex operator / (const complex& x, long double y)
|
||||
{ return operator/<> (x, y); }
|
||||
friend inline complex operator / (long double x, const complex& y)
|
||||
{ return operator/<> (x, y); }
|
||||
friend inline bool operator == (const complex& x, long double y)
|
||||
{ return operator==<> (x, y); }
|
||||
friend inline bool operator == (long double x, const complex& y)
|
||||
{ return operator==<> (x, y); }
|
||||
friend inline bool operator != (const complex& x, long double y)
|
||||
{ return operator!=<> (x, y); }
|
||||
friend inline bool operator != (long double x, const complex& y)
|
||||
{ return operator!=<> (x, y); }
|
||||
#endif /* __STRICT_ANSI__ */
|
||||
};
|
||||
|
||||
inline complex<float>::complex (const complex<long double>& r)
|
||||
: re (r.real ()), im (r.imag ())
|
||||
{ }
|
||||
|
||||
inline complex<double>::complex (const complex<long double>& r)
|
||||
: re (r.real ()), im (r.imag ())
|
||||
{ }
|
||||
} // extern "C++"
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,154 @@
|
||||
// The template and inlines for the -*- C++ -*- mask_array class.
|
||||
|
||||
// Copyright (C) 1997-1999 Cygnus Solutions
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <[email protected]>
|
||||
|
||||
#ifndef __MASK_ARRAY__
|
||||
#define __MASK_ARRAY__
|
||||
|
||||
extern "C++" {
|
||||
|
||||
template <class _T> class mask_array
|
||||
{
|
||||
public:
|
||||
typedef _T value_type;
|
||||
|
||||
void operator= (const valarray<_T>&) const;
|
||||
void operator*= (const valarray<_T>&) const;
|
||||
void operator/= (const valarray<_T>&) const;
|
||||
void operator%= (const valarray<_T>&) const;
|
||||
void operator+= (const valarray<_T>&) const;
|
||||
void operator-= (const valarray<_T>&) const;
|
||||
void operator^= (const valarray<_T>&) const;
|
||||
void operator&= (const valarray<_T>&) const;
|
||||
void operator|= (const valarray<_T>&) const;
|
||||
void operator<<=(const valarray<_T>&) const;
|
||||
void operator>>=(const valarray<_T>&) const;
|
||||
void operator= (const _T&);
|
||||
|
||||
template<class _Dom>
|
||||
void operator= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator*= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator/= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator%= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator+= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator-= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator^= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator&= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator|= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator<<=(const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator>>=(const _Expr<_Dom,_T>&) const;
|
||||
|
||||
private:
|
||||
mask_array (_Array<_T>, size_t, _Array<bool>);
|
||||
friend class valarray<_T>;
|
||||
|
||||
const size_t _M_sz;
|
||||
const _Array<bool> _M_mask;
|
||||
const _Array<_T> _M_array;
|
||||
|
||||
mask_array (const mask_array&);
|
||||
|
||||
// not implemented
|
||||
mask_array ();
|
||||
mask_array& operator= (const mask_array&);
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
inline mask_array<_Tp>::mask_array (const mask_array<_Tp>& a)
|
||||
: _M_sz (a._M_sz), _M_mask (a._M_mask), _M_array (a._M_array) {}
|
||||
|
||||
template<typename _T>
|
||||
inline
|
||||
mask_array<_T>::mask_array (_Array<_T> __a, size_t __s, _Array<bool> __m)
|
||||
: _M_sz (__s), _M_mask (__m), _M_array (__a) {}
|
||||
|
||||
template<typename _T>
|
||||
inline void
|
||||
mask_array<_T>::operator= (const _T& __t)
|
||||
{ __valarray_fill (_M_array, _M_sz, _M_mask, __t); }
|
||||
|
||||
template<typename _T>
|
||||
inline void
|
||||
mask_array<_T>::operator= (const valarray<_T>& __v) const
|
||||
{ __valarray_copy (_Array<_T> (__v), __v.size (), _M_array, _M_mask); }
|
||||
|
||||
template<typename _T>
|
||||
template<class E>
|
||||
inline void
|
||||
mask_array<_T>::operator= (const _Expr<E, _T>& __e) const
|
||||
{ __valarray_copy (__e, __e.size (), _M_array, _M_mask); }
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
#define _DEFINE_VALARRAY_OPERATOR(op, name) \
|
||||
template<typename _T> \
|
||||
inline void \
|
||||
mask_array<_T>::operator##op##= (const valarray<_T>& __v) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _M_mask, \
|
||||
_Array<_T> (__v), __v.size ()); \
|
||||
} \
|
||||
\
|
||||
template<typename _T> template<class E> \
|
||||
inline void \
|
||||
mask_array<_T>::operator##op##= (const _Expr<E, _T>& __e) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _M_mask, __e, __e.size ()); \
|
||||
}
|
||||
|
||||
_DEFINE_VALARRAY_OPERATOR(*, multiplies)
|
||||
_DEFINE_VALARRAY_OPERATOR(/, divides)
|
||||
_DEFINE_VALARRAY_OPERATOR(%, modulus)
|
||||
_DEFINE_VALARRAY_OPERATOR(+, plus)
|
||||
_DEFINE_VALARRAY_OPERATOR(-, minus)
|
||||
_DEFINE_VALARRAY_OPERATOR(^, xor)
|
||||
_DEFINE_VALARRAY_OPERATOR(&, and)
|
||||
_DEFINE_VALARRAY_OPERATOR(|, or)
|
||||
_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
|
||||
_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#endif // __MASK_ARRAY__
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
@@ -0,0 +1,76 @@
|
||||
// The template and inlines for the -*- C++ -*- slice class.
|
||||
|
||||
// Copyright (C) 1997-1999 Cygnus Solutions
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <[email protected]>
|
||||
|
||||
#ifndef __SLICE__
|
||||
#define __SLICE__
|
||||
|
||||
extern "C++" {
|
||||
|
||||
class slice
|
||||
{
|
||||
public:
|
||||
slice ();
|
||||
slice (size_t, size_t, size_t);
|
||||
|
||||
size_t start () const;
|
||||
size_t size () const;
|
||||
size_t stride () const;
|
||||
|
||||
private:
|
||||
size_t _M_off; // offset
|
||||
size_t _M_sz; // size
|
||||
size_t _M_st; // stride unit
|
||||
};
|
||||
|
||||
inline slice::slice () {}
|
||||
|
||||
inline slice::slice (size_t __o, size_t __d, size_t __s)
|
||||
: _M_off (__o), _M_sz (__d), _M_st (__s) {}
|
||||
|
||||
inline size_t
|
||||
slice::start () const
|
||||
{ return _M_off; }
|
||||
|
||||
inline size_t
|
||||
slice::size () const
|
||||
{ return _M_sz; }
|
||||
|
||||
inline size_t
|
||||
slice::stride () const
|
||||
{ return _M_st; }
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#endif // __SLICE__
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
@@ -0,0 +1,156 @@
|
||||
// The template and inlines for the -*- C++ -*- slice_array class.
|
||||
|
||||
// Copyright (C) 1997-1999 Cygnus Solutions
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <[email protected]>
|
||||
|
||||
#ifndef __SLICE_ARRAY__
|
||||
#define __SLICE_ARRAY__
|
||||
|
||||
extern "C++" {
|
||||
|
||||
template<typename _T>
|
||||
class slice_array
|
||||
{
|
||||
public:
|
||||
typedef _T value_type;
|
||||
|
||||
void operator= (const valarray<_T>&) const;
|
||||
void operator*= (const valarray<_T>&) const;
|
||||
void operator/= (const valarray<_T>&) const;
|
||||
void operator%= (const valarray<_T>&) const;
|
||||
void operator+= (const valarray<_T>&) const;
|
||||
void operator-= (const valarray<_T>&) const;
|
||||
void operator^= (const valarray<_T>&) const;
|
||||
void operator&= (const valarray<_T>&) const;
|
||||
void operator|= (const valarray<_T>&) const;
|
||||
void operator<<= (const valarray<_T>&) const;
|
||||
void operator>>= (const valarray<_T>&) const;
|
||||
void operator= (const _T &);
|
||||
|
||||
template<class _Dom>
|
||||
void operator= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator*= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator/= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator%= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator+= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator-= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator^= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator&= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator|= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator<<= (const _Expr<_Dom,_T>&) const;
|
||||
template<class _Dom>
|
||||
void operator>>= (const _Expr<_Dom,_T>&) const;
|
||||
|
||||
private:
|
||||
friend class valarray<_T>;
|
||||
slice_array(_Array<_T>, const slice&);
|
||||
|
||||
const size_t _M_sz;
|
||||
const size_t _M_stride;
|
||||
const _Array<_T> _M_array;
|
||||
|
||||
// this constructor is implemented since we need to return a value.
|
||||
slice_array (const slice_array&);
|
||||
|
||||
// not implemented
|
||||
slice_array ();
|
||||
slice_array& operator= (const slice_array&);
|
||||
};
|
||||
|
||||
template<typename _T>
|
||||
inline slice_array<_T>::slice_array (_Array<_T> __a, const slice& __s)
|
||||
: _M_sz (__s.size ()), _M_stride (__s.stride ()),
|
||||
_M_array (__a.begin () + __s.start ()) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline slice_array<_Tp>::slice_array(const slice_array<_Tp>& a)
|
||||
: _M_sz(a._M_sz), _M_stride(a._M_stride), _M_array(a._M_array) {}
|
||||
|
||||
template<typename _T>
|
||||
inline void
|
||||
slice_array<_T>::operator= (const _T& __t)
|
||||
{ __valarray_fill (_M_array, _M_sz, _M_stride, __t); }
|
||||
|
||||
template<typename _T>
|
||||
inline void
|
||||
slice_array<_T>::operator= (const valarray<_T>& __v) const
|
||||
{ __valarray_copy (_Array<_T> (__v), _M_array, _M_sz, _M_stride); }
|
||||
|
||||
template<typename _T>
|
||||
template<class _Dom>
|
||||
inline void
|
||||
slice_array<_T>::operator= (const _Expr<_Dom,_T>& __e) const
|
||||
{ __valarray_copy (__e, _M_sz, _M_array, _M_stride); }
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
#define _DEFINE_VALARRAY_OPERATOR(op, name) \
|
||||
template<typename _T> \
|
||||
inline void \
|
||||
slice_array<_T>::operator##op##= (const valarray<_T>& __v) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _M_sz, _M_stride, _Array<_T> (__v));\
|
||||
} \
|
||||
\
|
||||
template<typename _T> template<class _Dom> \
|
||||
inline void \
|
||||
slice_array<_T>::operator##op##= (const _Expr<_Dom,_T>& __e) const \
|
||||
{ \
|
||||
_Array_augmented_##name (_M_array, _M_stride, __e, _M_sz); \
|
||||
}
|
||||
|
||||
|
||||
_DEFINE_VALARRAY_OPERATOR(*, multiplies)
|
||||
_DEFINE_VALARRAY_OPERATOR(/, divides)
|
||||
_DEFINE_VALARRAY_OPERATOR(%, modulus)
|
||||
_DEFINE_VALARRAY_OPERATOR(+, plus)
|
||||
_DEFINE_VALARRAY_OPERATOR(-, minus)
|
||||
_DEFINE_VALARRAY_OPERATOR(^, xor)
|
||||
_DEFINE_VALARRAY_OPERATOR(&, and)
|
||||
_DEFINE_VALARRAY_OPERATOR(|, or)
|
||||
_DEFINE_VALARRAY_OPERATOR(<<, shift_left)
|
||||
_DEFINE_VALARRAY_OPERATOR(>>, shift_right)
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#endif // __SLICE_ARRAY__
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
@@ -0,0 +1,728 @@
|
||||
// The template and inlines for the -*- C++ -*- valarray class.
|
||||
|
||||
// Copyright (C) 1997-1999 Cygnus Solutions
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <[email protected]>
|
||||
|
||||
#ifndef __STD_VALARRAY__
|
||||
#define __STD_VALARRAY__
|
||||
#define _G_NO_VALARRAY_TEMPLATE_EXPORT 1
|
||||
|
||||
#include <cstddef>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include <numeric>
|
||||
#include <functional>
|
||||
#include <algorithm>
|
||||
|
||||
#ifndef alloca
|
||||
#ifdef __GNUC__
|
||||
#define alloca __builtin_alloca
|
||||
#else /* not GNU C. */
|
||||
#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
|
||||
#include <alloca.h>
|
||||
#else /* not sparc */
|
||||
#if defined (MSDOS) && !defined (__TURBOC__)
|
||||
#include <malloc.h>
|
||||
#else /* not MSDOS, or __TURBOC__ */
|
||||
#if defined(_AIX)
|
||||
#include <malloc.h>
|
||||
#pragma alloca
|
||||
#else /* not MSDOS, __TURBOC__, or _AIX */
|
||||
#ifdef __hpux
|
||||
#endif /* __hpux */
|
||||
#endif /* not _AIX */
|
||||
#endif /* not MSDOS, or __TURBOC__ */
|
||||
#endif /* not sparc. */
|
||||
#endif /* not GNU C. */
|
||||
#endif /* alloca not defined. */
|
||||
|
||||
extern "C" {
|
||||
void* alloca(size_t);
|
||||
}
|
||||
|
||||
|
||||
extern "C++" {
|
||||
|
||||
template<class _Clos, typename _Tp> class _Expr;
|
||||
|
||||
template<typename _Tp1, typename _Tp2> class _ValArray;
|
||||
|
||||
template<template<class> class _Oper,
|
||||
template<class, class> class _Meta, class _Dom> struct _UnClos;
|
||||
|
||||
template<template<class> class _Oper,
|
||||
template<class, class> class _Meta1,
|
||||
template<class, class> class _Meta2,
|
||||
class _Dom1, class _Dom2> class _BinClos;
|
||||
|
||||
template<template<class, class> class _Meta, class _Dom> class _SClos;
|
||||
|
||||
template<template<class, class> class _Meta, class _Dom> class _GClos;
|
||||
|
||||
template<template<class, class> class _Meta, class _Dom> class _IClos;
|
||||
|
||||
template<template<class, class> class _Meta, class _Dom> class _ValFunClos;
|
||||
|
||||
template<template<class, class> class _Meta, class _Dom> class _RefFunClos;
|
||||
|
||||
template<class _Tp> struct _Unary_plus;
|
||||
template<class _Tp> struct _Bitwise_and;
|
||||
template<class _Tp> struct _Bitwise_or;
|
||||
template<class _Tp> struct _Bitwise_xor;
|
||||
template<class _Tp> struct _Bitwise_not;
|
||||
template<class _Tp> struct _Shift_left;
|
||||
template<class _Tp> struct _Shift_right;
|
||||
|
||||
template<class _Tp> class valarray; // An array of type _Tp
|
||||
class slice; // BLAS-like slice out of an array
|
||||
template<class _Tp> class slice_array;
|
||||
class gslice; // generalized slice out of an array
|
||||
template<class _Tp> class gslice_array;
|
||||
template<class _Tp> class mask_array; // masked array
|
||||
template<class _Tp> class indirect_array; // indirected array
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#include <std/valarray_array.h>
|
||||
#include <std/valarray_meta.h>
|
||||
|
||||
extern "C++" {
|
||||
|
||||
template<class _Tp> class valarray
|
||||
{
|
||||
public:
|
||||
typedef _Tp value_type;
|
||||
|
||||
// _lib.valarray.cons_ construct/destroy:
|
||||
valarray();
|
||||
explicit valarray(size_t);
|
||||
valarray(const _Tp&, size_t);
|
||||
valarray(const _Tp* __restrict__, size_t);
|
||||
valarray(const valarray&);
|
||||
valarray(const slice_array<_Tp>&);
|
||||
valarray(const gslice_array<_Tp>&);
|
||||
valarray(const mask_array<_Tp>&);
|
||||
valarray(const indirect_array<_Tp>&);
|
||||
template<class _Dom>
|
||||
valarray(const _Expr<_Dom,_Tp>& __e);
|
||||
~valarray();
|
||||
|
||||
// _lib.valarray.assign_ assignment:
|
||||
valarray<_Tp>& operator=(const valarray<_Tp>&);
|
||||
valarray<_Tp>& operator=(const _Tp&);
|
||||
valarray<_Tp>& operator=(const slice_array<_Tp>&);
|
||||
valarray<_Tp>& operator=(const gslice_array<_Tp>&);
|
||||
valarray<_Tp>& operator=(const mask_array<_Tp>&);
|
||||
valarray<_Tp>& operator=(const indirect_array<_Tp>&);
|
||||
|
||||
template<class _Dom> valarray<_Tp>&
|
||||
operator= (const _Expr<_Dom,_Tp>&);
|
||||
|
||||
// _lib.valarray.access_ element access:
|
||||
_Tp operator[](size_t) const;
|
||||
_Tp& operator[](size_t);
|
||||
// _lib.valarray.sub_ subset operations:
|
||||
_Expr<_SClos<_ValArray,_Tp>, _Tp> operator[](slice) const;
|
||||
slice_array<_Tp> operator[](slice);
|
||||
_Expr<_GClos<_ValArray,_Tp>, _Tp> operator[](const gslice&) const;
|
||||
gslice_array<_Tp> operator[](const gslice&);
|
||||
valarray<_Tp> operator[](const valarray<bool>&) const;
|
||||
mask_array<_Tp> operator[](const valarray<bool>&);
|
||||
_Expr<_IClos<_ValArray, _Tp>, _Tp>
|
||||
operator[](const valarray<size_t>&) const;
|
||||
indirect_array<_Tp> operator[](const valarray<size_t>&);
|
||||
|
||||
// _lib.valarray.unary_ unary operators:
|
||||
_Expr<_UnClos<_Unary_plus,_ValArray,_Tp>,_Tp> operator+ () const;
|
||||
_Expr<_UnClos<negate,_ValArray,_Tp>,_Tp> operator- () const;
|
||||
_Expr<_UnClos<_Bitwise_not,_ValArray,_Tp>,_Tp> operator~ () const;
|
||||
_Expr<_UnClos<logical_not,_ValArray,_Tp>,bool> operator! () const;
|
||||
|
||||
// _lib.valarray.cassign_ computed assignment:
|
||||
valarray<_Tp>& operator*= (const _Tp&);
|
||||
valarray<_Tp>& operator/= (const _Tp&);
|
||||
valarray<_Tp>& operator%= (const _Tp&);
|
||||
valarray<_Tp>& operator+= (const _Tp&);
|
||||
valarray<_Tp>& operator-= (const _Tp&);
|
||||
valarray<_Tp>& operator^= (const _Tp&);
|
||||
valarray<_Tp>& operator&= (const _Tp&);
|
||||
valarray<_Tp>& operator|= (const _Tp&);
|
||||
valarray<_Tp>& operator<<=(const _Tp&);
|
||||
valarray<_Tp>& operator>>=(const _Tp&);
|
||||
valarray<_Tp>& operator*= (const valarray<_Tp>&);
|
||||
valarray<_Tp>& operator/= (const valarray<_Tp>&);
|
||||
valarray<_Tp>& operator%= (const valarray<_Tp>&);
|
||||
valarray<_Tp>& operator+= (const valarray<_Tp>&);
|
||||
valarray<_Tp>& operator-= (const valarray<_Tp>&);
|
||||
valarray<_Tp>& operator^= (const valarray<_Tp>&);
|
||||
valarray<_Tp>& operator|= (const valarray<_Tp>&);
|
||||
valarray<_Tp>& operator&= (const valarray<_Tp>&);
|
||||
valarray<_Tp>& operator<<=(const valarray<_Tp>&);
|
||||
valarray<_Tp>& operator>>=(const valarray<_Tp>&);
|
||||
|
||||
template<class _Dom>
|
||||
valarray<_Tp>& operator*= (const _Expr<_Dom,_Tp>&);
|
||||
template<class _Dom>
|
||||
valarray<_Tp>& operator/= (const _Expr<_Dom,_Tp>&);
|
||||
template<class _Dom>
|
||||
valarray<_Tp>& operator%= (const _Expr<_Dom,_Tp>&);
|
||||
template<class _Dom>
|
||||
valarray<_Tp>& operator+= (const _Expr<_Dom,_Tp>&);
|
||||
template<class _Dom>
|
||||
valarray<_Tp>& operator-= (const _Expr<_Dom,_Tp>&);
|
||||
template<class _Dom>
|
||||
valarray<_Tp>& operator^= (const _Expr<_Dom,_Tp>&);
|
||||
template<class _Dom>
|
||||
valarray<_Tp>& operator|= (const _Expr<_Dom,_Tp>&);
|
||||
template<class _Dom>
|
||||
valarray<_Tp>& operator&= (const _Expr<_Dom,_Tp>&);
|
||||
template<class _Dom>
|
||||
valarray<_Tp>& operator<<=(const _Expr<_Dom,_Tp>&);
|
||||
template<class _Dom>
|
||||
valarray<_Tp>& operator>>=(const _Expr<_Dom,_Tp>&);
|
||||
|
||||
|
||||
// _lib.valarray.members_ member functions:
|
||||
size_t size() const;
|
||||
_Tp sum() const;
|
||||
_Tp min() const;
|
||||
_Tp max() const;
|
||||
|
||||
// FIXME: Extension
|
||||
_Tp product () const;
|
||||
|
||||
valarray<_Tp> shift (int) const;
|
||||
valarray<_Tp> cshift(int) const;
|
||||
_Expr<_ValFunClos<_ValArray,_Tp>,_Tp> apply(_Tp func(_Tp)) const;
|
||||
_Expr<_RefFunClos<_ValArray,_Tp>,_Tp> apply(_Tp func(const _Tp&)) const;
|
||||
void resize(size_t __size, _Tp __c = _Tp());
|
||||
|
||||
private:
|
||||
size_t _M_size;
|
||||
_Tp* __restrict__ _M_data;
|
||||
|
||||
friend class _Array<_Tp>;
|
||||
};
|
||||
|
||||
|
||||
template<typename _Tp> struct _Unary_plus : unary_function<_Tp,_Tp> {
|
||||
_Tp operator() (const _Tp& __t) const { return __t; }
|
||||
};
|
||||
|
||||
template<typename _Tp> struct _Bitwise_and : binary_function<_Tp,_Tp,_Tp> {
|
||||
_Tp operator() (_Tp __x, _Tp __y) const { return __x & __y; }
|
||||
};
|
||||
|
||||
template<typename _Tp> struct _Bitwise_or : binary_function<_Tp,_Tp,_Tp> {
|
||||
_Tp operator() (_Tp __x, _Tp __y) const { return __x | __y; }
|
||||
};
|
||||
|
||||
template<typename _Tp> struct _Bitwise_xor : binary_function<_Tp,_Tp,_Tp> {
|
||||
_Tp operator() (_Tp __x, _Tp __y) const { return __x ^ __y; }
|
||||
};
|
||||
|
||||
template<typename _Tp> struct _Bitwise_not : unary_function<_Tp,_Tp> {
|
||||
_Tp operator() (_Tp __t) const { return ~__t; }
|
||||
};
|
||||
|
||||
template<typename _Tp> struct _Shift_left : unary_function<_Tp,_Tp> {
|
||||
_Tp operator() (_Tp __x, _Tp __y) const { return __x << __y; }
|
||||
};
|
||||
|
||||
template<typename _Tp> struct _Shift_right : unary_function<_Tp,_Tp> {
|
||||
_Tp operator() (_Tp __x, _Tp __y) const { return __x >> __y; }
|
||||
};
|
||||
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Tp
|
||||
valarray<_Tp>::operator[] (size_t __i) const
|
||||
{ return _M_data[__i]; }
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Tp&
|
||||
valarray<_Tp>::operator[] (size_t __i)
|
||||
{ return _M_data[__i]; }
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#include <std/slice.h>
|
||||
#include <std/slice_array.h>
|
||||
#include <std/gslice.h>
|
||||
#include <std/gslice_array.h>
|
||||
#include <std/mask_array.h>
|
||||
#include <std/indirect_array.h>
|
||||
|
||||
extern "C++" {
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>::valarray () : _M_size (0), _M_data (0) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>::valarray (size_t __n)
|
||||
: _M_size (__n), _M_data (new _Tp[__n]) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>::valarray (const _Tp& __t, size_t __n)
|
||||
: _M_size (__n), _M_data (new _Tp[__n])
|
||||
{ __valarray_fill (_M_data, _M_size, __t); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>::valarray (const _Tp* __restrict__ __pT, size_t __n)
|
||||
: _M_size (__n), _M_data (new _Tp[__n])
|
||||
{ __valarray_copy (__pT, __n, _M_data); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>::valarray (const valarray<_Tp>& __v)
|
||||
: _M_size (__v._M_size), _M_data (new _Tp[__v._M_size])
|
||||
{ __valarray_copy (__v._M_data, _M_size, _M_data); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>::valarray (const slice_array<_Tp>& __sa)
|
||||
: _M_size (__sa._M_sz), _M_data (new _Tp[__sa._M_sz])
|
||||
{ __valarray_copy (__sa._M_array, __sa._M_sz, __sa._M_stride,
|
||||
_Array<_Tp>(_M_data)); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>::valarray (const gslice_array<_Tp>& __ga)
|
||||
: _M_size (__ga._M_index.size()), _M_data (new _Tp[_M_size])
|
||||
{ __valarray_copy (__ga._M_array, _Array<size_t>(__ga._M_index),
|
||||
_Array<_Tp>(_M_data), _M_size); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>::valarray (const mask_array<_Tp>& __ma)
|
||||
: _M_size (__ma._M_sz), _M_data (new _Tp[__ma._M_sz])
|
||||
{ __valarray_copy (__ma._M_array, __ma._M_mask,
|
||||
_Array<_Tp>(_M_data), _M_size); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>::valarray (const indirect_array<_Tp>& __ia)
|
||||
: _M_size (__ia._M_sz), _M_data (new _Tp[__ia._M_sz])
|
||||
{ __valarray_copy (__ia._M_array, __ia._M_index,
|
||||
_Array<_Tp>(_M_data), _M_size); }
|
||||
|
||||
template<typename _Tp> template<class _Dom>
|
||||
inline valarray<_Tp>::valarray (const _Expr<_Dom, _Tp>& __e)
|
||||
: _M_size (__e.size ()), _M_data (new _Tp[_M_size])
|
||||
{ __valarray_copy (__e, _M_size, _Array<_Tp>(_M_data)); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>::~valarray () { delete[] _M_data; }
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>&
|
||||
valarray<_Tp>::operator= (const valarray<_Tp>& __v)
|
||||
{
|
||||
__valarray_copy(__v._M_data, _M_size, _M_data);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>&
|
||||
valarray<_Tp>::operator= (const _Tp& __t)
|
||||
{
|
||||
__valarray_fill (_M_data, _M_size, __t);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>&
|
||||
valarray<_Tp>::operator= (const slice_array<_Tp>& __sa)
|
||||
{
|
||||
__valarray_copy (__sa._M_array, __sa._M_sz,
|
||||
__sa._M_stride, _Array<_Tp>(_M_data));
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>&
|
||||
valarray<_Tp>::operator= (const gslice_array<_Tp>& __ga)
|
||||
{
|
||||
__valarray_copy (__ga._M_array, _Array<size_t>(__ga._M_index),
|
||||
_Array<_Tp>(_M_data), _M_size);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>&
|
||||
valarray<_Tp>::operator= (const mask_array<_Tp>& __ma)
|
||||
{
|
||||
__valarray_copy (__ma._M_array, __ma._M_mask,
|
||||
_Array<_Tp>(_M_data), _M_size);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>&
|
||||
valarray<_Tp>::operator= (const indirect_array<_Tp>& __ia)
|
||||
{
|
||||
__valarray_copy (__ia._M_array, __ia._M_index,
|
||||
_Array<_Tp>(_M_data), _M_size);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _Tp> template<class _Dom>
|
||||
inline valarray<_Tp>&
|
||||
valarray<_Tp>::operator= (const _Expr<_Dom, _Tp>& __e)
|
||||
{
|
||||
__valarray_copy (__e, _M_size, _Array<_Tp>(_M_data));
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Expr<_SClos<_ValArray,_Tp>, _Tp>
|
||||
valarray<_Tp>::operator[] (slice __s) const
|
||||
{
|
||||
typedef _SClos<_ValArray,_Tp> _Closure;
|
||||
return _Expr<_Closure, _Tp> (_Closure (_Array<_Tp>(_M_data), __s));
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline slice_array<_Tp>
|
||||
valarray<_Tp>::operator[] (slice __s)
|
||||
{
|
||||
return slice_array<_Tp> (_Array<_Tp>(_M_data), __s);
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Expr<_GClos<_ValArray,_Tp>, _Tp>
|
||||
valarray<_Tp>::operator[] (const gslice& __gs) const
|
||||
{
|
||||
typedef _GClos<_ValArray,_Tp> _Closure;
|
||||
return _Expr<_Closure, _Tp>
|
||||
(_Closure (_Array<_Tp>(_M_data), __gs._M_index->_M_index));
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline gslice_array<_Tp>
|
||||
valarray<_Tp>::operator[] (const gslice& __gs)
|
||||
{
|
||||
return gslice_array<_Tp>
|
||||
(_Array<_Tp>(_M_data), __gs._M_index->_M_index);
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline valarray<_Tp>
|
||||
valarray<_Tp>::operator[] (const valarray<bool>& __m) const
|
||||
{
|
||||
size_t __s (0);
|
||||
size_t __e (__m.size ());
|
||||
for (size_t __i=0; __i<__e; ++__i)
|
||||
if (__m[__i]) ++__s;
|
||||
return valarray<_Tp> (mask_array<_Tp> (_Array<_Tp>(_M_data), __s,
|
||||
_Array<bool> (__m)));
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline mask_array<_Tp>
|
||||
valarray<_Tp>::operator[] (const valarray<bool>& __m)
|
||||
{
|
||||
size_t __s (0);
|
||||
size_t __e (__m.size ());
|
||||
for (size_t __i=0; __i<__e; ++__i)
|
||||
if (__m[__i]) ++__s;
|
||||
return mask_array<_Tp> (_Array<_Tp>(_M_data), __s, _Array<bool> (__m));
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Expr<_IClos<_ValArray,_Tp>, _Tp>
|
||||
valarray<_Tp>::operator[] (const valarray<size_t>& __i) const
|
||||
{
|
||||
typedef _IClos<_ValArray,_Tp> _Closure;
|
||||
return _Expr<_Closure, _Tp> (_Closure (*this, __i));
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline indirect_array<_Tp>
|
||||
valarray<_Tp>::operator[] (const valarray<size_t>& __i)
|
||||
{
|
||||
return indirect_array<_Tp> (_Array<_Tp>(_M_data), __i.size(),
|
||||
_Array<size_t> (__i));
|
||||
}
|
||||
|
||||
template<class _Tp>
|
||||
inline size_t valarray<_Tp>::size () const { return _M_size; }
|
||||
|
||||
template<class _Tp>
|
||||
inline _Tp
|
||||
valarray<_Tp>::sum () const
|
||||
{
|
||||
return accumulate (_M_data, _M_data + _M_size, _Tp ());
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Tp
|
||||
valarray<_Tp>::product () const
|
||||
{
|
||||
return accumulate (_M_data, _M_data+_M_size, _Tp(1), multiplies<_Tp> ());
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
inline valarray<_Tp>
|
||||
valarray<_Tp>::shift (int __n) const
|
||||
{
|
||||
_Tp* const __a = static_cast<_Tp*> (alloca (sizeof(_Tp) * _M_size));
|
||||
if (! __n) // __n == 0: no shift
|
||||
__valarray_copy (_M_data, _M_size, __a);
|
||||
else if (__n > 0) { // __n > 0: shift left
|
||||
if (__n > _M_size)
|
||||
__valarray_fill(__a, __n, _Tp());
|
||||
else {
|
||||
__valarray_copy (_M_data+__n, _M_size-__n, __a);
|
||||
__valarray_fill (__a+_M_size-__n, __n, _Tp());
|
||||
}
|
||||
}
|
||||
else { // __n < 0: shift right
|
||||
__valarray_copy (_M_data, _M_size+__n, __a-__n);
|
||||
__valarray_fill(__a, -__n, _Tp());
|
||||
}
|
||||
return valarray<_Tp> (__a, _M_size);
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
inline valarray<_Tp>
|
||||
valarray<_Tp>::cshift (int __n) const
|
||||
{
|
||||
_Tp* const __a = static_cast<_Tp*> (alloca (sizeof(_Tp) * _M_size));
|
||||
if (! __n) // __n == 0: no cshift
|
||||
__valarray_copy(_M_data, _M_size, __a);
|
||||
else if (__n > 0) { // __n > 0: cshift left
|
||||
__valarray_copy (_M_data, __n, __a + _M_size-__n);
|
||||
__valarray_copy (_M_data + __n, _M_size-__n, __a);
|
||||
}
|
||||
else { // __n < 0: cshift right
|
||||
__valarray_copy (_M_data + _M_size + __n, -__n, __a);
|
||||
__valarray_copy (_M_data, _M_size + __n, __a - __n);
|
||||
}
|
||||
return valarray<_Tp> (__a, _M_size);
|
||||
}
|
||||
|
||||
template <class _Tp>
|
||||
inline void
|
||||
valarray<_Tp>::resize (size_t __n, _Tp __c)
|
||||
{
|
||||
if (_M_size != __n) {
|
||||
delete[] _M_data;
|
||||
_M_size = __n;
|
||||
_M_data = new _Tp[_M_size];
|
||||
}
|
||||
__valarray_fill (_M_data, _M_size, __c);
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Tp
|
||||
valarray<_Tp>::min() const
|
||||
{
|
||||
return *min_element (_M_data, _M_data+_M_size);
|
||||
}
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Tp
|
||||
valarray<_Tp>::max() const
|
||||
{
|
||||
return *max_element (_M_data, _M_data+_M_size);
|
||||
}
|
||||
|
||||
template<class _Tp>
|
||||
inline _Expr<_ValFunClos<_ValArray,_Tp>,_Tp>
|
||||
valarray<_Tp>::apply (_Tp func (_Tp)) const
|
||||
{
|
||||
typedef _ValFunClos<_ValArray,_Tp> _Closure;
|
||||
return _Expr<_Closure,_Tp> (_Closure (*this, func));
|
||||
}
|
||||
|
||||
template<class _Tp>
|
||||
inline _Expr<_RefFunClos<_ValArray,_Tp>,_Tp>
|
||||
valarray<_Tp>::apply (_Tp func (const _Tp &)) const
|
||||
{
|
||||
typedef _RefFunClos<_ValArray,_Tp> _Closure;
|
||||
return _Expr<_Closure,_Tp> (_Closure (*this, func));
|
||||
}
|
||||
|
||||
#define _DEFINE_VALARRAY_UNARY_OPERATOR(_Op, _Name) \
|
||||
template<typename _Tp> \
|
||||
inline _Expr<_UnClos<_Name,_ValArray,_Tp>, _Tp> \
|
||||
valarray<_Tp>::operator##_Op() const \
|
||||
{ \
|
||||
typedef _UnClos<_Name,_ValArray,_Tp> _Closure; \
|
||||
return _Expr<_Closure, _Tp> (_Closure (*this)); \
|
||||
}
|
||||
|
||||
_DEFINE_VALARRAY_UNARY_OPERATOR(+, _Unary_plus)
|
||||
_DEFINE_VALARRAY_UNARY_OPERATOR(-, negate)
|
||||
_DEFINE_VALARRAY_UNARY_OPERATOR(~, _Bitwise_not)
|
||||
|
||||
#undef _DEFINE_VALARRAY_UNARY_OPERATOR
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Expr<_UnClos<logical_not,_ValArray,_Tp>, bool>
|
||||
valarray<_Tp>::operator!() const
|
||||
{
|
||||
typedef _UnClos<logical_not,_ValArray,_Tp> _Closure;
|
||||
return _Expr<_Closure, bool> (_Closure (*this));
|
||||
}
|
||||
|
||||
#define _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(_Op, _Name) \
|
||||
template<class _Tp> \
|
||||
inline valarray<_Tp> & \
|
||||
valarray<_Tp>::operator##_Op##= (const _Tp &__t) \
|
||||
{ \
|
||||
_Array_augmented_##_Name (_Array<_Tp>(_M_data), _M_size, __t); \
|
||||
return *this; \
|
||||
} \
|
||||
\
|
||||
template<class _Tp> \
|
||||
inline valarray<_Tp> & \
|
||||
valarray<_Tp>::operator##_Op##= (const valarray<_Tp> &__v) \
|
||||
{ \
|
||||
_Array_augmented_##_Name (_Array<_Tp>(_M_data), _M_size, \
|
||||
_Array<_Tp>(__v._M_data)); \
|
||||
return *this; \
|
||||
}
|
||||
|
||||
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(+, plus)
|
||||
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(-, minus)
|
||||
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(*, multiplies)
|
||||
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(/, divides)
|
||||
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(%, modulus)
|
||||
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(^, xor)
|
||||
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(&, and)
|
||||
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(|, or)
|
||||
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(<<, shift_left)
|
||||
_DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT(>>, shift_right)
|
||||
|
||||
#undef _DEFINE_VALARRAY_AUGMENTED_ASSIGNMENT
|
||||
|
||||
|
||||
#define _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(_Op, _Name) \
|
||||
template<class _Tp> template<class _Dom> \
|
||||
inline valarray<_Tp> & \
|
||||
valarray<_Tp>::operator##_Op##= (const _Expr<_Dom,_Tp> &__e) \
|
||||
{ \
|
||||
_Array_augmented_##_Name (_Array<_Tp>(_M_data), __e, _M_size); \
|
||||
return *this; \
|
||||
}
|
||||
|
||||
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(+, plus)
|
||||
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(-, minus)
|
||||
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(*, multiplies)
|
||||
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(/, divides)
|
||||
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(%, modulus)
|
||||
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(^, xor)
|
||||
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(&, and)
|
||||
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(|, or)
|
||||
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(<<, shift_left)
|
||||
_DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT(>>, shift_right)
|
||||
|
||||
#undef _DEFINE_VALARRAY_EXPR_AUGMENTED_ASSIGNMENT
|
||||
|
||||
|
||||
#define _DEFINE_BINARY_OPERATOR(_Op, _Name) \
|
||||
template<typename _Tp> \
|
||||
inline _Expr<_BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp>, _Tp> \
|
||||
operator##_Op (const valarray<_Tp> &__v, const valarray<_Tp> &__w) \
|
||||
{ \
|
||||
typedef _BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp> _Closure; \
|
||||
return _Expr<_Closure, _Tp> (_Closure (__v, __w)); \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
inline _Expr<_BinClos<_Name,_ValArray,_Constant,_Tp,_Tp>,_Tp> \
|
||||
operator##_Op (const valarray<_Tp> &__v, const _Tp &__t) \
|
||||
{ \
|
||||
typedef _BinClos<_Name,_ValArray,_Constant,_Tp,_Tp> _Closure; \
|
||||
return _Expr<_Closure, _Tp> (_Closure (__v, __t)); \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
inline _Expr<_BinClos<_Name,_Constant,_ValArray,_Tp,_Tp>,_Tp> \
|
||||
operator##_Op (const _Tp &__t, const valarray<_Tp> &__v) \
|
||||
{ \
|
||||
typedef _BinClos<_Name,_Constant,_ValArray,_Tp,_Tp> _Closure; \
|
||||
return _Expr<_Closure, _Tp> (_Closure (__t, __v)); \
|
||||
}
|
||||
|
||||
_DEFINE_BINARY_OPERATOR(+, plus)
|
||||
_DEFINE_BINARY_OPERATOR(-, minus)
|
||||
_DEFINE_BINARY_OPERATOR(*, multiplies)
|
||||
_DEFINE_BINARY_OPERATOR(/, divides)
|
||||
_DEFINE_BINARY_OPERATOR(%, modulus)
|
||||
_DEFINE_BINARY_OPERATOR(^, _Bitwise_xor)
|
||||
_DEFINE_BINARY_OPERATOR(&, _Bitwise_and)
|
||||
_DEFINE_BINARY_OPERATOR(|, _Bitwise_or)
|
||||
_DEFINE_BINARY_OPERATOR(<<, _Shift_left)
|
||||
_DEFINE_BINARY_OPERATOR(>>, _Shift_right)
|
||||
|
||||
#undef _DEFINE_BINARY_OPERATOR
|
||||
|
||||
#define _DEFINE_LOGICAL_OPERATOR(_Op, _Name) \
|
||||
template<typename _Tp> \
|
||||
inline _Expr<_BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp>,bool> \
|
||||
operator##_Op (const valarray<_Tp> &__v, const valarray<_Tp> &__w) \
|
||||
{ \
|
||||
typedef _BinClos<_Name,_ValArray,_ValArray,_Tp,_Tp> _Closure; \
|
||||
return _Expr<_Closure, bool> (_Closure (__v, __w)); \
|
||||
} \
|
||||
\
|
||||
template<class _Tp> \
|
||||
inline _Expr<_BinClos<_Name,_ValArray,_Constant,_Tp,_Tp>,bool> \
|
||||
operator##_Op (const valarray<_Tp> &__v, const _Tp &__t) \
|
||||
{ \
|
||||
typedef _BinClos<_Name,_ValArray,_Constant,_Tp,_Tp> _Closure; \
|
||||
return _Expr<_Closure, bool> (_Closure (__v, __t)); \
|
||||
} \
|
||||
\
|
||||
template<class _Tp> \
|
||||
inline _Expr<_BinClos<_Name,_Constant,_ValArray,_Tp,_Tp>,bool> \
|
||||
operator##_Op (const _Tp &__t, const valarray<_Tp> &__v) \
|
||||
{ \
|
||||
typedef _BinClos<_Name,_Constant,_ValArray,_Tp,_Tp> _Closure; \
|
||||
return _Expr<_Closure, bool> (_Closure (__t, __v)); \
|
||||
}
|
||||
|
||||
_DEFINE_LOGICAL_OPERATOR(&&, logical_and)
|
||||
_DEFINE_LOGICAL_OPERATOR(||, logical_or)
|
||||
_DEFINE_LOGICAL_OPERATOR(==, equal_to)
|
||||
_DEFINE_LOGICAL_OPERATOR(!=, not_equal_to)
|
||||
_DEFINE_LOGICAL_OPERATOR(<, less)
|
||||
_DEFINE_LOGICAL_OPERATOR(>, greater)
|
||||
_DEFINE_LOGICAL_OPERATOR(<=, less_equal)
|
||||
_DEFINE_LOGICAL_OPERATOR(>=, greater_equal)
|
||||
|
||||
#undef _DEFINE_VALARRAY_OPERATOR
|
||||
|
||||
#undef _G_NO_VALARRAY_TEMPLATE_EXPORT
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#endif // __STD_VALARRAY__
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
@@ -0,0 +1,161 @@
|
||||
// Character traits template for the -*- C++ -*- string classes.
|
||||
// Copyright (C) 1994 Free Software Foundation
|
||||
|
||||
// This file is part of the GNU ANSI C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License
|
||||
// along with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
||||
|
||||
// As a special exception, if you link this library with files
|
||||
// compiled with a GNU compiler to produce an executable, this does not cause
|
||||
// the resulting executable to be covered by the GNU General Public License.
|
||||
// This exception does not however invalidate any other reasons why
|
||||
// the executable file might be covered by the GNU General Public License.
|
||||
|
||||
// Written by Jason Merrill based upon the specification by Takanori Adachi
|
||||
// in ANSI X3J16/94-0013R2.
|
||||
|
||||
#ifndef __STRING_CHAR_TRAITS__
|
||||
#define __STRING_CHAR_TRAITS__
|
||||
|
||||
#ifdef __GNUG__
|
||||
// For string_char_traits <char>
|
||||
#pragma interface "std/straits.h"
|
||||
#endif
|
||||
|
||||
#include <cstddef>
|
||||
|
||||
extern "C++" {
|
||||
template <class charT>
|
||||
struct string_char_traits {
|
||||
typedef charT char_type; // for users to acquire the basic character type
|
||||
|
||||
// constraints
|
||||
|
||||
static void assign (char_type& c1, const char_type& c2)
|
||||
{ c1 = c2; }
|
||||
static bool eq (const char_type& c1, const char_type& c2)
|
||||
{ return (c1 == c2); }
|
||||
static bool ne (const char_type& c1, const char_type& c2)
|
||||
{ return !(c1 == c2); }
|
||||
static bool lt (const char_type& c1, const char_type& c2)
|
||||
{ return (c1 < c2); }
|
||||
static char_type eos () { return char_type(); } // the null character
|
||||
static bool is_del(char_type a) { return 0; }
|
||||
// characteristic function for delimiters of charT
|
||||
|
||||
// speed-up functions
|
||||
|
||||
static int compare (const char_type* s1, const char_type* s2, size_t n)
|
||||
{
|
||||
size_t i;
|
||||
for (i = 0; i < n; ++i)
|
||||
if (ne (s1[i], s2[i]))
|
||||
return lt (s1[i], s2[i]) ? -1 : 1;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static size_t length (const char_type* s)
|
||||
{
|
||||
size_t l = 0;
|
||||
while (ne (*s++, eos ()))
|
||||
++l;
|
||||
return l;
|
||||
}
|
||||
|
||||
static char_type* copy (char_type* s1, const char_type* s2, size_t n)
|
||||
{
|
||||
for (; n--; )
|
||||
assign (s1[n], s2[n]);
|
||||
return s1;
|
||||
}
|
||||
|
||||
static char_type* move (char_type* s1, const char_type* s2, size_t n)
|
||||
{
|
||||
char_type a[n];
|
||||
size_t i;
|
||||
for (i = 0; i < n; ++i)
|
||||
assign (a[i], s2[i]);
|
||||
for (i = 0; i < n; ++i)
|
||||
assign (s1[i], a[i]);
|
||||
return s1;
|
||||
}
|
||||
|
||||
static char_type* set (char_type* s1, const char_type& c, size_t n)
|
||||
{
|
||||
for (; n--; )
|
||||
assign (s1[n], c);
|
||||
return s1;
|
||||
}
|
||||
};
|
||||
|
||||
class istream;
|
||||
class ostream;
|
||||
#include <cctype>
|
||||
#include <cstring>
|
||||
|
||||
struct string_char_traits <char> {
|
||||
typedef char char_type;
|
||||
|
||||
static void assign (char_type& c1, const char_type& c2)
|
||||
{ c1 = c2; }
|
||||
static bool eq (const char_type & c1, const char_type& c2)
|
||||
{ return (c1 == c2); }
|
||||
static bool ne (const char_type& c1, const char_type& c2)
|
||||
{ return (c1 != c2); }
|
||||
static bool lt (const char_type& c1, const char_type& c2)
|
||||
{ return (c1 < c2); }
|
||||
static char_type eos () { return 0; }
|
||||
static bool is_del(char_type a) { return isspace(a); }
|
||||
|
||||
static int compare (const char_type* s1, const char_type* s2, size_t n)
|
||||
{ return memcmp (s1, s2, n); }
|
||||
static size_t length (const char_type* s)
|
||||
{ return strlen (s); }
|
||||
static char_type* copy (char_type* s1, const char_type* s2, size_t n)
|
||||
{ return (char_type*) memcpy (s1, s2, n); }
|
||||
static char_type* move (char_type* s1, const char_type* s2, size_t n)
|
||||
{ return (char_type*) memmove (s1, s2, n); }
|
||||
static char_type* set (char_type* s1, const char_type& c, size_t n)
|
||||
{ return (char_type*) memset (s1, c, n); }
|
||||
};
|
||||
|
||||
#if 0
|
||||
#include <cwctype>
|
||||
struct string_char_traits <wchar_t> {
|
||||
typedef wchar_t char_type;
|
||||
|
||||
static void assign (char_type& c1, const char_type& c2)
|
||||
{ c1 = c2; }
|
||||
static bool eq (const char_type & c1, const char_type& c2)
|
||||
{ return (c1 == c2); }
|
||||
static bool ne (const char_type& c1, const char_type& c2)
|
||||
{ return (c1 != c2); }
|
||||
static bool lt (const char_type& c1, const char_type& c2)
|
||||
{ return (c1 < c2); }
|
||||
static char_type eos () { return 0; }
|
||||
static bool is_del(char_type a) { return iswspace(a); }
|
||||
|
||||
static int compare (const char_type* s1, const char_type* s2, size_t n)
|
||||
{ return wmemcmp (s1, s2, n); }
|
||||
static size_t length (const char_type* s)
|
||||
{ return wcslen (s); }
|
||||
static char_type* copy (char_type* s1, const char_type* s2, size_t n)
|
||||
{ return wmemcpy (s1, s2, n); }
|
||||
static char_type* set (char_type* s1, const char_type& c, size_t n)
|
||||
{ return wmemset (s1, c, n); }
|
||||
};
|
||||
#endif
|
||||
} // extern "C++"
|
||||
#endif
|
||||
@@ -0,0 +1,346 @@
|
||||
// The template and inlines for the -*- C++ -*- internal _Array helper class.
|
||||
|
||||
// Copyright (C) 1997-1999 Cygnus Solutions
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <[email protected]>
|
||||
|
||||
#ifndef __VALARRAY_ARRAY__
|
||||
#define __VALARRAY_ARRAY__
|
||||
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
|
||||
extern "C++" {
|
||||
|
||||
//
|
||||
// Helper functions on raw pointers
|
||||
//
|
||||
|
||||
// fill plain array __a[<__n>] with __t
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill (_Tp* __restrict__ __a, size_t __n, const _Tp& __t)
|
||||
{ while (__n--) *__a++ = __t; }
|
||||
|
||||
// fill strided array __a[<__n-1 : __s>] with __t
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill (_Tp* __restrict__ __a, size_t __n,
|
||||
size_t __s, const _Tp& __t)
|
||||
{ for (size_t __i=0; __i<__n; ++__i, __a+=__s) *__a = __t; }
|
||||
|
||||
// fill indirect array __a[__i[<__n>]] with __i
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill(_Tp* __restrict__ __a, const size_t* __restrict__ __i,
|
||||
size_t __n, const _Tp& __t)
|
||||
{ for (size_t __j=0; __j<__n; ++__j, ++__i) __a[*__i] = __t; }
|
||||
|
||||
// copy plain array __a[<__n>] in __b[<__n>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (const _Tp* __restrict__ __a, size_t __n,
|
||||
_Tp* __restrict__ __b)
|
||||
{ memcpy (__b, __a, __n * sizeof(_Tp)); }
|
||||
|
||||
// copy strided array __a[<__n : __s>] in plain __b[<__n>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (const _Tp* __restrict__ __a, size_t __n, size_t __s,
|
||||
_Tp* __restrict__ __b)
|
||||
{ for (size_t __i=0; __i<__n; ++__i, ++__b, __a += __s) *__b = *__a; }
|
||||
|
||||
// copy plain __a[<__n>] in strided __b[<__n : __s>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (const _Tp* __restrict__ __a, _Tp* __restrict__ __b,
|
||||
size_t __n, size_t __s)
|
||||
{ for (size_t __i=0; __i<__n; ++__i, ++__a, __b+=__s) *__b = *__a; }
|
||||
|
||||
// copy indexed __a[__i[<__n>]] in plain __b[<__n>]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (const _Tp* __restrict__ __a,
|
||||
const size_t* __restrict__ __i,
|
||||
_Tp* __restrict__ __b, size_t __n)
|
||||
{ for (size_t __j=0; __j<__n; ++__j, ++__b, ++__i) *__b = __a[*__i]; }
|
||||
|
||||
// copy plain __a[<__n>] in indexed __b[__i[<__n>]]
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (const _Tp* __restrict__ __a, size_t __n,
|
||||
_Tp* __restrict__ __b, const size_t* __restrict__ __i)
|
||||
{ for (size_t __j=0; __j<__n; ++__j, ++__a, ++__i) __b[*__i] = *__a; }
|
||||
|
||||
//
|
||||
// Helper class _Array, first layer of valarray abstraction.
|
||||
// All operations on valarray should be forwarded to this class
|
||||
// whenever possible. -- gdr
|
||||
//
|
||||
|
||||
template<typename _Tp> struct _Array {
|
||||
|
||||
explicit _Array (size_t);
|
||||
explicit _Array (_Tp* const __restrict__);
|
||||
explicit _Array (const valarray<_Tp>&);
|
||||
_Array (const _Tp* __restrict__, size_t);
|
||||
|
||||
void free_data() const;
|
||||
_Tp* begin () const;
|
||||
|
||||
_Tp* const __restrict__ _M_data;
|
||||
};
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill (_Array<_Tp> __a, size_t __n, const _Tp& __t)
|
||||
{ __valarray_fill (__a._M_data, __n, __t); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill (_Array<_Tp> __a, size_t __n, size_t __s, const _Tp& __t)
|
||||
{ __valarray_fill (__a._M_data, __n, __s, __t); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_fill (_Array<_Tp> __a, _Array<size_t> __i,
|
||||
size_t __n, const _Tp& __t)
|
||||
{ __valarray_fill (__a._M_data, __i._M_data, __n, __t); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (_Array<_Tp> __a, size_t __n, _Array<_Tp> __b)
|
||||
{ __valarray_copy (__a._M_data, __n, __b._M_data); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (_Array<_Tp> __a, size_t __n, size_t __s, _Array<_Tp> __b)
|
||||
{ __valarray_copy(__a._M_data, __n, __s, __b._M_data); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (_Array<_Tp> __a, _Array<_Tp> __b, size_t __n, size_t __s)
|
||||
{ __valarray_copy (__a._M_data, __b._M_data, __n, __s); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (_Array<_Tp> __a, _Array<size_t> __i,
|
||||
_Array<_Tp> __b, size_t __n)
|
||||
{ __valarray_copy (__a._M_data, __i._M_data, __b._M_data, __n); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
__valarray_copy (_Array<_Tp> __a, size_t __n, _Array<_Tp> __b,
|
||||
_Array<size_t> __i)
|
||||
{ __valarray_copy (__a._M_data, __n, __b._M_data, __i._M_data); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
_Array<_Tp>::_Array (size_t __n) : _M_data (new _Tp[__n]) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
_Array<_Tp>::_Array (_Tp* const __restrict__ __p) : _M_data (__p) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Array<_Tp>::_Array (const valarray<_Tp>& __v)
|
||||
: _M_data (__v._M_data) {}
|
||||
|
||||
template<typename _Tp>
|
||||
inline
|
||||
_Array<_Tp>::_Array (const _Tp* __restrict__ __b, size_t __s)
|
||||
: _M_data (new _Tp[__s]) { __valarray_copy (__b, __s, _M_data); }
|
||||
|
||||
template<typename _Tp>
|
||||
inline void
|
||||
_Array<_Tp>::free_data() const { delete[] _M_data; }
|
||||
|
||||
template<typename _Tp>
|
||||
inline _Tp*
|
||||
_Array<_Tp>::begin () const
|
||||
{ return _M_data; }
|
||||
|
||||
#define _DEFINE_ARRAY_FUNCTION(_Op, _Name) \
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, const _Tp& __t) \
|
||||
{ \
|
||||
for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p) \
|
||||
*__p _Op##= __t; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, _Array<_Tp> __b) \
|
||||
{ \
|
||||
_Tp* __p (__a._M_data); \
|
||||
for (_Tp* __q=__b._M_data; __q<__b._M_data+__n; ++__p, ++__q) \
|
||||
*__p _Op##= *__q; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp, class _Dom> \
|
||||
void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, \
|
||||
const _Expr<_Dom,_Tp>& __e, size_t __n) \
|
||||
{ \
|
||||
_Tp* __p (__a._M_data); \
|
||||
for (size_t __i=0; __i<__n; ++__i, ++__p) *__p _Op##= __e[__i]; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, size_t __s, \
|
||||
_Array<_Tp> __b) \
|
||||
{ \
|
||||
_Tp* __q (__b._M_data); \
|
||||
for (_Tp* __p=__a._M_data; __p<__a._M_data+__s*__n; __p+=__s, ++__q) \
|
||||
*__p _Op##= *__q; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, _Array<_Tp> __b, \
|
||||
size_t __n, size_t __s) \
|
||||
{ \
|
||||
_Tp* __q (__b._M_data); \
|
||||
for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p, __q+=__s) \
|
||||
*__p _Op##= *__q; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp, class _Dom> \
|
||||
void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, size_t __s, \
|
||||
const _Expr<_Dom,_Tp>& __e, size_t __n) \
|
||||
{ \
|
||||
_Tp* __p (__a._M_data); \
|
||||
for (size_t __i=0; __i<__n; ++__i, __p+=__s) *__p _Op##= __e[__i]; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, _Array<size_t> __i, \
|
||||
_Array<_Tp> __b, size_t __n) \
|
||||
{ \
|
||||
_Tp* __q (__b._M_data); \
|
||||
for (size_t* __j=__i._M_data; __j<__i._M_data+__n; ++__j, ++__q) \
|
||||
__a._M_data[*__j] _Op##= *__q; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
inline void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, \
|
||||
_Array<_Tp> __b, _Array<size_t> __i) \
|
||||
{ \
|
||||
_Tp* __p (__a._M_data); \
|
||||
for (size_t* __j=__i._M_data; __j<__i._M_data+__n; ++__j, ++__p) \
|
||||
*__p _Op##= __b._M_data[*__j]; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp, class _Dom> \
|
||||
void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, _Array<size_t> __i, \
|
||||
const _Expr<_Dom, _Tp>& __e, size_t __n) \
|
||||
{ \
|
||||
size_t* __j (__i._M_data); \
|
||||
for (size_t __k=0; __k<__n; ++__k, ++__j) \
|
||||
__a._M_data[*__j] _Op##= __e[__k]; \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, _Array<bool> __m, \
|
||||
_Array<_Tp> __b, size_t __n) \
|
||||
{ \
|
||||
bool* ok (__m._M_data); \
|
||||
_Tp* __p (__a._M_data); \
|
||||
for (_Tp* __q=__b._M_data; __q<__b._M_data+__n; ++__q, ++ok, ++__p) { \
|
||||
while (! *ok) { \
|
||||
++ok; \
|
||||
++__p; \
|
||||
} \
|
||||
*__p _Op##= *__q; \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp> \
|
||||
void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, size_t __n, \
|
||||
_Array<_Tp> __b, _Array<bool> __m) \
|
||||
{ \
|
||||
bool* ok (__m._M_data); \
|
||||
_Tp* __q (__b._M_data); \
|
||||
for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p, ++ok, ++__q) { \
|
||||
while (! *ok) { \
|
||||
++ok; \
|
||||
++__q; \
|
||||
} \
|
||||
*__p _Op##= *__q; \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
template<typename _Tp, class _Dom> \
|
||||
void \
|
||||
_Array_augmented_##_Name (_Array<_Tp> __a, _Array<bool> __m, \
|
||||
const _Expr<_Dom, _Tp>& __e, size_t __n) \
|
||||
{ \
|
||||
bool* ok(__m._M_data); \
|
||||
_Tp* __p (__a._M_data); \
|
||||
for (size_t __i=0; __i<__n; ++__i, ++ok, ++__p) { \
|
||||
while (! *ok) { \
|
||||
++ok; \
|
||||
++__p; \
|
||||
} \
|
||||
*__p _Op##= __e[__i]; \
|
||||
} \
|
||||
}
|
||||
|
||||
_DEFINE_ARRAY_FUNCTION(+, plus)
|
||||
_DEFINE_ARRAY_FUNCTION(-, minus)
|
||||
_DEFINE_ARRAY_FUNCTION(*, multiplies)
|
||||
_DEFINE_ARRAY_FUNCTION(/, divides)
|
||||
_DEFINE_ARRAY_FUNCTION(%, modulus)
|
||||
_DEFINE_ARRAY_FUNCTION(^, xor)
|
||||
_DEFINE_ARRAY_FUNCTION(|, or)
|
||||
_DEFINE_ARRAY_FUNCTION(&, and)
|
||||
_DEFINE_ARRAY_FUNCTION(<<, shift_left)
|
||||
_DEFINE_ARRAY_FUNCTION(>>, shift_right)
|
||||
|
||||
#undef _DEFINE_ARRAY_FUNCTION
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#ifdef _G_NO_VALARRAY_TEMPLATE_EXPORT
|
||||
# define export
|
||||
# include <std/valarray_array.tcc>
|
||||
#endif
|
||||
|
||||
#endif // __VALARRAY_ARRAY__
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
@@ -0,0 +1,130 @@
|
||||
// The template and inlines for the -*- C++ -*- internal _Array helper class.
|
||||
|
||||
// Copyright (C) 1997-1999 Cygnus Solutions
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
// terms of the GNU General Public License as published by the
|
||||
// Free Software Foundation; either version 2, or (at your option)
|
||||
// any later version.
|
||||
|
||||
// This library is distributed in the hope that it will be useful,
|
||||
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
// GNU General Public License for more details.
|
||||
|
||||
// You should have received a copy of the GNU General Public License along
|
||||
// with this library; see the file COPYING. If not, write to the Free
|
||||
// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
|
||||
// USA.
|
||||
|
||||
// As a special exception, you may use this file as part of a free software
|
||||
// library without restriction. Specifically, if other files instantiate
|
||||
// templates or use macros or inline functions from this file, or you compile
|
||||
// this file and link it with other files to produce an executable, this
|
||||
// file does not by itself cause the resulting executable to be covered by
|
||||
// the GNU General Public License. This exception does not however
|
||||
// invalidate any other reasons why the executable file might be covered by
|
||||
// the GNU General Public License.
|
||||
|
||||
// Written by Gabriel Dos Reis <[email protected]>
|
||||
|
||||
#ifndef __VALARRAY_ARRAY_TCC__
|
||||
#define __VALARRAY_ARRAY_TCC__
|
||||
|
||||
extern "C++" {
|
||||
|
||||
export template<typename _Tp>
|
||||
void
|
||||
__valarray_fill (_Array<_Tp> __a, size_t __n, _Array<bool> __m, const _Tp& __t)
|
||||
{
|
||||
_Tp* __p = __a._M_data;
|
||||
bool* __ok (__m._M_data);
|
||||
for (size_t __i=0; __i<__n; ++__i, ++__ok, ++__p) {
|
||||
while (! *__ok) {
|
||||
++__ok;
|
||||
++__p;
|
||||
}
|
||||
*__p = __t;
|
||||
}
|
||||
}
|
||||
|
||||
export template<typename _Tp>
|
||||
void
|
||||
__valarray_copy (_Array<_Tp> __a, _Array<bool> __m, _Array<_Tp> __b, size_t __n)
|
||||
{
|
||||
_Tp* __p (__a._M_data);
|
||||
bool* __ok (__m._M_data);
|
||||
for (_Tp* __q=__b._M_data; __q<__b._M_data+__n; ++__q, ++__ok, ++__p) {
|
||||
while (! *__ok) {
|
||||
++__ok;
|
||||
++__p;
|
||||
}
|
||||
*__q = *__p;
|
||||
}
|
||||
}
|
||||
|
||||
export template<typename _Tp>
|
||||
void
|
||||
__valarray_copy (_Array<_Tp> __a, size_t __n, _Array<_Tp> __b, _Array<bool> __m)
|
||||
{
|
||||
_Tp* __q (__b._M_data);
|
||||
bool* __ok (__m._M_data);
|
||||
for (_Tp* __p=__a._M_data; __p<__a._M_data+__n; ++__p, ++__ok, ++__q) {
|
||||
while (! *__ok) {
|
||||
++__ok;
|
||||
++__q;
|
||||
}
|
||||
*__q = *__p;
|
||||
}
|
||||
}
|
||||
|
||||
export template<typename _Tp, class _Dom>
|
||||
void
|
||||
__valarray_copy (const _Expr<_Dom, _Tp>& __e, size_t __n, _Array<_Tp> __a)
|
||||
{
|
||||
_Tp* __p (__a._M_data);
|
||||
for (size_t __i=0; __i<__n; ++__i, ++__p) *__p = __e[__i];
|
||||
}
|
||||
|
||||
export template<typename _Tp, class _Dom>
|
||||
void
|
||||
__valarray_copy (const _Expr<_Dom, _Tp>& __e, size_t __n,
|
||||
_Array<_Tp> __a, size_t __s)
|
||||
{
|
||||
_Tp* __p (__a._M_data);
|
||||
for (size_t __i=0; __i<__n; ++__i, __p+=__s) *__p = __e[__i];
|
||||
}
|
||||
|
||||
export template<typename _Tp, class _Dom>
|
||||
void
|
||||
__valarray_copy (const _Expr<_Dom, _Tp>& __e, size_t __n,
|
||||
_Array<_Tp> __a, _Array<size_t> __i)
|
||||
{
|
||||
size_t* __j (__i._M_data);
|
||||
for (size_t __k=0; __k<__n; ++__k, ++__j) __a._M_data[*__j] = __e[__k];
|
||||
}
|
||||
|
||||
export template<typename _Tp, class _Dom>
|
||||
void
|
||||
__valarray_copy (const _Expr<_Dom, _Tp>& __e, size_t __n,
|
||||
_Array<_Tp> __a, _Array<bool> __m)
|
||||
{
|
||||
bool* __ok (__m._M_data);
|
||||
_Tp* __p (__a._M_data);
|
||||
for (size_t __i=0; __i<__n; ++__i, ++__ok, ++__p) {
|
||||
while (! *__ok) {
|
||||
++__ok;
|
||||
++__p;
|
||||
}
|
||||
*__p = __e[__i];
|
||||
}
|
||||
}
|
||||
|
||||
} // extern "C++"
|
||||
|
||||
#endif // __VALARRAY_ARRAY_TCC__
|
||||
|
||||
// Local Variables:
|
||||
// mode:c++
|
||||
// End:
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user