Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C++ > scientific computation (more)

Reply
Thread Tools

scientific computation (more)

 
 
Wing
Guest
Posts: n/a
 
      09-26-2006
Thanks for those who answered my question previously.

Everytime I want to output high precision numbers, I use the following
code:

cout << setprecision (9) << f << endl;

where f is some double number.

However, I don't want to add "setprecision (9)" in every "cout" and
"iofstream" in order to output/input high precision number, because I
need to modify my codes substantially in this case.

What can I do such that my program can output high precision numbers
without modifying the codes substantially?

Thanks.

 
Reply With Quote
 
 
 
 
Stuart Redmann
Guest
Posts: n/a
 
      09-26-2006
Wing wrote:

> Thanks for those who answered my question previously.
>
> Everytime I want to output high precision numbers, I use the following
> code:
>
> cout << setprecision (9) << f << endl;
>
> where f is some double number.
>
> However, I don't want to add "setprecision (9)" in every "cout" and
> "iofstream" in order to output/input high precision number, because I
> need to modify my codes substantially in this case.
>
> What can I do such that my program can output high precision numbers
> without modifying the codes substantially?
>
> Thanks.
>


You could define your own version of cout in the following way:

#include <iostream>
#include <ostream>
#include <iomanip>

class CCustomOutputStream
{
public:
CCustomOutputStream (std:stream& p_refUnderlyingOStream, int
p_iDefaultPrecision)
: m_pInternalOStream (&p_refUnderlyingOStream),
m_iDefaultPrecision (p_iDefaultPrecision),
m_NextPrecision (-1)
{
if (p_iDefaultPrecision < 0 || p_iDefaultPrecision > 20)
throw exception ();
}

CCustomOutputStream& operator<< (std:stream& (__cdecl
*_F)(std:stream&))
{
// Invoke the passed I/O function for the internal stream.
_F (*m_pInternalOStream);
return *this;
}
CCustomOutputStream& operator<< (std::ios& (__cdecl *_F)(std::ios&))
{
// Invoke the passed I/O function for the internal stream.
_F (*m_pInternalOStream);
return *this;
}

/*! \brief This method can be used to access the internal stream.
*/
std:stream* GetInternalStream ()
{
return m_pInternalOStream;
}

protected:
/*! \brief The internal output stream.
*/
std:stream* m_pInternalOStream;

/*! \brief If the user has provided a precision, we will use this
* value for the next floating point value.
* If this value is -1, we should use the default precision for the
* next floating point value.
*/
int m_NextPrecision;

/*! \brief The default precision that should be used for floating
* point values.
*/
int m_iDefaultPrecision;

public:
/*! \brief This is how outputting data is done in general: Just
* forward the call to the internal stream.
*/
template <class T>
CCustomOutputStream& operator<< (T p_RHS)
{
// Forward the call to the internal output stream.
*m_pInternalOStream << p_RHS;
return *this;
}

/*! \brief Template specialization for the setprecision manipulator.
*/
template<>
CCustomOutputStream& operator<< (std::_Smanip<std::streamsize>
p_Manipulator)
{
// If the manipulator function is sbfun (the function that sets
// the precision of a given stream),
// we remember the argument, so that the next print of a floating
// point variable is done with this
// precision (Had we not remembered this, we would print the next
// floating point value with our internal
// default precision.
if (p_Manipulator._Pf == std::setprecision (0)._Pf)
{
m_NextPrecision = p_Manipulator._Manarg;
}
return *this;
}

/*! \brief Template specialization for floating point values.
*/
template<>
CCustomOutputStream& operator<< (float p_RHS)
{
// If the precision was explicitely set by a previous call
// to setprecision, we use this precision. Else
// we use the standard precision of this custom stream.
if (m_NextPrecision > 0)
{
m_pInternalOStream->precision (m_NextPrecision);
m_NextPrecision = -1;
}
else
m_pInternalOStream->precision (m_iDefaultPrecision);

// Print the float value with the set precision.
*m_pInternalOStream << p_RHS;
return *this;
}

template<>
CCustomOutputStream& operator<< (double p_RHS)
{
// If the precision was explicitely set by a previous call to
// setprecision, we use this precision. Else
// we use the standard precision of this custom stream.
if (m_NextPrecision > 0)
{
m_pInternalOStream->precision (m_NextPrecision);
m_NextPrecision = -1;
}
else
m_pInternalOStream->precision (m_iDefaultPrecision);

// Print the float value with the set precision.
*m_pInternalOStream << p_RHS;
return *this;
}
};

CCustomOutputStream Mycout (std::cout, 7);

int main ()
{
Mycout << "Pi with default precision: "
<< 3.1415926535897 << std::endl
<< "Pi with precision 2: "
<< std::setprecision (2) << 3.1415926535897 << std::endl
<< "Pi with default precision: "
<< 3.1415926535897 << std::endl;

return 0;
}

All you have to do is replacing of cout by Mycout (which can be done
with replace-in-files tools). If you use output streams to files, you
have to create one custom output stream for each such stream. If you use
the internals of a stream (like failbit), you may need to add these
features to CCustomOutputStream, so that you don't have to retrieve the
internal stream every time. CCustomOutputStream is also not a template
that can work with UNICODE strings (I didn't want to spend to much time
on this example).

Regards,
Stuart
 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
scientific computation asdf C++ 2 10-10-2006 08:00 PM
scientific computation Wing C++ 3 09-25-2006 09:11 PM
Python advocacy in scientific computation Michael Tobis Python 56 03-09-2006 07:58 PM
Re: Python advocacy in scientific computation David Treadwell Python 2 03-05-2006 06:38 PM
Re: Python advocacy in scientific computation David Treadwell Python 5 03-05-2006 04:09 AM



Advertisments