Ad:

C++ Discussion Thread
Unsolved
Views: 1077

Sep 25th, 2008

Fast Conversions

Expand Post »

I am looking for fast conversions. I found out that converting with atof is much more faster than using the stringstream like the below tests.

What I look for now is a fast way to convert from double to char*
I have a problem to find this conversion.

char* to double takes 3.1 sec

C++ Syntax (Toggle Plain Text)
	double Number1;
	char* Num = "8.12";
 
	for(int i = 0; i < 2000000; i++)
	{			
		Number1 = atof(Num);
	}
	MessageBox::Show("Finish");
	double Number1;
	char* Num = "8.12";

	for(int i = 0; i < 2000000; i++)
	{			
		Number1 = atof(Num);
	}
	MessageBox::Show("Finish");

std::string to double takes 35 sec

C++ Syntax (Toggle Plain Text)
	double Number1;
	std::string Num = "8.12";
 
	for(int i = 0; i < 2000000; i++)
	{			
		stringstream v1(Num);
		v1 >> Number1;
	}
	MessageBox::Show("Finish");
	double Number1;
	std::string Num = "8.12";

	for(int i = 0; i < 2000000; i++)
	{			
		stringstream v1(Num);
		v1 >> Number1;
	}
	MessageBox::Show("Finish");

double to std::string takes 51 sec

C++ Syntax (Toggle Plain Text)
	double Number1 = 8.12;
	std::string Num;
 
	for(int i = 0; i < 2000000; i++)
	{			
		stringstream v1;
		v1 << Number1;
		Num = v1.str();
	}
	MessageBox::Show("Finish");
	double Number1 = 8.12;
	std::string Num;

	for(int i = 0; i < 2000000; i++)
	{			
		stringstream v1;
		v1 << Number1;
		Num = v1.str();
	}
	MessageBox::Show("Finish");

Similar Threads

code optimization ... in C++

Jennifer84

Reputation Points: 10

Solved Threads: 1

Posting Pro

Offline

563 posts
since Feb 2008

Permalink

Sep 25th, 2008

Re: Fast Conversions

You test may not be entirely accurate, for example in this part of the code:

(Toggle Plain Text)

for (int i = 0; i < 2000000; i++) {			
   stringstream v1(Num);
   v1 >> Number1;
}

Because here you are constructing stringstream 2000000 times, and destroying it 2000000 times, which obviously is going to add to the total amount of time, if you try making it a global or static variable, and just clear the stream every cycle, then hopefully this should speed it up. Like this:

C++ Syntax (Toggle Plain Text)
double Number1;
std::string Num = "8.12";
stringstream v1;
 
for (int i = 0; i < 2000000; i++) {
   v1 << Num;
   v1 >> Number1;
   v1.clear();
}
double Number1;
std::string Num = "8.12";
stringstream v1;

for (int i = 0; i < 2000000; i++) {
   v1 << Num;
   v1 >> Number1;
   v1.clear();
}

Last edited by William Hemsworth; Sep 25th, 2008 at 1:47 pm.

William Hemsworth

Reputation Points: 1429

Solved Threads: 129

Posting Virtuoso

Offline

1,542 posts
since Mar 2008

Permalink

Sep 25th, 2008

Re: Fast Conversions

Yes you are right. When changing that, the test went down from 35 to 20 seconds.
Great to think about these details !

Jennifer84

Reputation Points: 10

Solved Threads: 1

Posting Pro

Offline

563 posts
since Feb 2008

Permalink

Sep 25th, 2008

Re: Fast Conversions

I don't know about C++, but in C you can use the function fcvt .. which I think is faster than sprintf . See here

stilllearning

Reputation Points: 161

Solved Threads: 43

Posting Whiz

Offline

309 posts
since Oct 2007

Permalink

Sep 25th, 2008

Re: Fast Conversions

(deleted post)

Last edited by Jennifer84; Sep 25th, 2008 at 6:20 pm.

Jennifer84

Reputation Points: 10

Solved Threads: 1

Posting Pro

Offline

563 posts
since Feb 2008

Permalink

Sep 26th, 2008

Re: Fast Conversions

> What I look for now is a fast way to convert from double to char*
> I have a problem to find this conversion.

a. compile C++ source to generate native code, not IL that is interpreted at run-time.
b. enable optimizations.

with these two, this is what i get:

C++ Syntax (Toggle Plain Text)
#include "stdafx.h"
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <string>
#include <sstream>
#include <math.h>
 
#pragma unmanaged   // generate native code
void double_to_string()
{
  std::clock_t start = std::clock() ;
  for(int i = 0; i < 2000000; i++)
  {			
    double Number1 = 8.12;
    static std::string Num;
    static std::stringstream v1;
	  v1 << Number1;
	  v1 >> Num;
  }
  std::clock_t end = std::clock() ;
  std::cout << "double_to_string: "
    << double( end-start ) / CLOCKS_PER_SEC << '\n' ;
}
#pragma managed
 
#pragma unmanaged   // generate native code
void string_to_double()
{
  std::clock_t start = std::clock() ;
  for(int i = 0; i < 2000000; i++)
  {			
    double Number1 ;
    static std::string Num = "8.12" ;
    static std::stringstream v1;
	  v1 << Num;
	  v1 >> Number1;
  }
  std::clock_t end = std::clock() ;
  std::cout << "string_to_double: " 
    << double( end-start ) / CLOCKS_PER_SEC << '\n' ;
}
#pragma managed
 
#pragma unmanaged   // generate native code
void cstrng_to_double()
{
  std::clock_t start = std::clock() ;
  for(int i = 0; i < 2000000; i++)
  {	
    double Number1 ;
    const char* Num = "8.12";
    Number1 = std::atof(Num);
  }
  std::clock_t end = std::clock() ;
  std::cout << "cstrng_to_double: " 
    << double( end-start ) / CLOCKS_PER_SEC << '\n' ;
}
#pragma managed
 
int main( array< System::String^ >^ args )
{
  for( int i=0 ; i<4 ; ++i )
  {
    double_to_string() ;
    string_to_double() ;
    cstrng_to_double() ;
    std::cout << '\n' ;
  }
}
#include "stdafx.h"
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <string>
#include <sstream>
#include <math.h>

#pragma unmanaged   // generate native code
void double_to_string()
{
  std::clock_t start = std::clock() ;
  for(int i = 0; i < 2000000; i++)
  {			
    double Number1 = 8.12;
    static std::string Num;
    static std::stringstream v1;
	  v1 << Number1;
	  v1 >> Num;
  }
  std::clock_t end = std::clock() ;
  std::cout << "double_to_string: "
    << double( end-start ) / CLOCKS_PER_SEC << '\n' ;
}
#pragma managed

#pragma unmanaged   // generate native code
void string_to_double()
{
  std::clock_t start = std::clock() ;
  for(int i = 0; i < 2000000; i++)
  {			
    double Number1 ;
    static std::string Num = "8.12" ;
    static std::stringstream v1;
	  v1 << Num;
	  v1 >> Number1;
  }
  std::clock_t end = std::clock() ;
  std::cout << "string_to_double: " 
    << double( end-start ) / CLOCKS_PER_SEC << '\n' ;
}
#pragma managed

#pragma unmanaged   // generate native code
void cstrng_to_double()
{
  std::clock_t start = std::clock() ;
  for(int i = 0; i < 2000000; i++)
  {	
    double Number1 ;
    const char* Num = "8.12";
    Number1 = std::atof(Num);
  }
  std::clock_t end = std::clock() ;
  std::cout << "cstrng_to_double: " 
    << double( end-start ) / CLOCKS_PER_SEC << '\n' ;
}
#pragma managed

int main( array< System::String^ >^ args )
{
  for( int i=0 ; i<4 ; ++i )
  {
    double_to_string() ;
    string_to_double() ;
    cstrng_to_double() ;
    std::cout << '\n' ;
  }
}

on T2330 @ 1.6 GHz VC++ Express 2008 SP1 with Full Optimization (/Ox)

C++ Syntax (Toggle Plain Text)
double_to_string: 0.936
string_to_double: 0.905
cstrng_to_double: 1.357
 
double_to_string: 0.936
string_to_double: 0.905
cstrng_to_double: 1.342
 
double_to_string: 0.936
string_to_double: 0.889
cstrng_to_double: 1.326
 
double_to_string: 0.92
string_to_double: 0.905
cstrng_to_double: 1.342
double_to_string: 0.936
string_to_double: 0.905
cstrng_to_double: 1.357

double_to_string: 0.936
string_to_double: 0.905
cstrng_to_double: 1.342

double_to_string: 0.936
string_to_double: 0.889
cstrng_to_double: 1.326

double_to_string: 0.92
string_to_double: 0.905
cstrng_to_double: 1.342

added later: just saw your thread 'fasted way to read a text file'. the two points above apply to that too.

Last edited by vijayan121; Sep 26th, 2008 at 2:06 am.

vijayan121

Reputation Points: 1159

Solved Threads: 285

Posting Virtuoso

Offline

1,606 posts
since Dec 2006

Permalink

Sep 26th, 2008

Re: Fast Conversions

This is off topic, but I'm curious...

Why did you use msiL implementation with unmanaged code? Why not purely managed or purely unmanaged?

Alex Edwards

Reputation Points: 392

Solved Threads: 108

Posting Shark

Offline

971 posts
since Jun 2008

Permalink

Sep 26th, 2008

Re: Fast Conversions

only because the language the OP is using ( MessageBox::Show ) is C++/CLI (not ISO C++).
and purely managed will not give anywhere near native performance.

Last edited by vijayan121; Sep 26th, 2008 at 2:03 am.

vijayan121

Reputation Points: 1159

Solved Threads: 285

Posting Virtuoso

Offline

1,606 posts
since Dec 2006

Permalink

Sep 26th, 2008

Re: Fast Conversions

writing a convert function (with construction and destruction of a stringstream each time it is called) would give more maintainable code. even in this case, the performance seems to be acceptable:

C++ Syntax (Toggle Plain Text)
#include "stdafx.h"
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <string>
#include <sstream>
#include <math.h>
 
#pragma unmanaged
void double_to_string()
{
  std::clock_t start = std::clock() ;
  for(int i = 0; i < 200000; i++)
  {			
    double Number1 = 8.12;
    static std::string Num ;
    std::ostringstream v1 ;
    v1 << Number1 ;
    Num = v1.str() ;
  }
  std::clock_t end = std::clock() ;
  std::cout << "double_to_string: "
    << double( end-start ) / CLOCKS_PER_SEC << '\n' ;
}
#pragma managed
 
#pragma unmanaged  // generate native code
void string_to_double()
{
  std::clock_t start = std::clock() ;
  for(int i = 0; i < 2000000; i++)
  {			
    double Number1 ;
    static std::string Num = "8.12" ;
    std::istringstream v1(Num);
    v1 >> Number1 ;
  }
  std::clock_t end = std::clock() ;
  std::cout << "string_to_double: " 
    << double( end-start ) / CLOCKS_PER_SEC << '\n' ;
}
#pragma managed
 
#pragma unmanaged
void cstrng_to_double()
{
  std::clock_t start = std::clock() ;
  for(int i = 0; i < 2000000; i++)
  {	
    double Number1 ;
    const char* Num = "8.12";
    Number1 = std::atof(Num);
  }
  std::clock_t end = std::clock() ;
  std::cout << "cstrng_to_double: " 
    << double( end-start ) / CLOCKS_PER_SEC << '\n' ;
}
#pragma managed
 
int main( array< System::String^ >^ args )
{
  for( int i=0 ; i<4 ; ++i )
  {
    double_to_string() ;
    string_to_double() ;
    cstrng_to_double() ;
    std::cout << '\n' ;
  }
}
#include "stdafx.h"
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <string>
#include <sstream>
#include <math.h>

#pragma unmanaged
void double_to_string()
{
  std::clock_t start = std::clock() ;
  for(int i = 0; i < 200000; i++)
  {			
    double Number1 = 8.12;
    static std::string Num ;
    std::ostringstream v1 ;
    v1 << Number1 ;
    Num = v1.str() ;
  }
  std::clock_t end = std::clock() ;
  std::cout << "double_to_string: "
    << double( end-start ) / CLOCKS_PER_SEC << '\n' ;
}
#pragma managed

#pragma unmanaged  // generate native code
void string_to_double()
{
  std::clock_t start = std::clock() ;
  for(int i = 0; i < 2000000; i++)
  {			
    double Number1 ;
    static std::string Num = "8.12" ;
    std::istringstream v1(Num);
    v1 >> Number1 ;
  }
  std::clock_t end = std::clock() ;
  std::cout << "string_to_double: " 
    << double( end-start ) / CLOCKS_PER_SEC << '\n' ;
}
#pragma managed

#pragma unmanaged
void cstrng_to_double()
{
  std::clock_t start = std::clock() ;
  for(int i = 0; i < 2000000; i++)
  {	
    double Number1 ;
    const char* Num = "8.12";
    Number1 = std::atof(Num);
  }
  std::clock_t end = std::clock() ;
  std::cout << "cstrng_to_double: " 
    << double( end-start ) / CLOCKS_PER_SEC << '\n' ;
}
#pragma managed

int main( array< System::String^ >^ args )
{
  for( int i=0 ; i<4 ; ++i )
  {
    double_to_string() ;
    string_to_double() ;
    cstrng_to_double() ;
    std::cout << '\n' ;
  }
}

C++ Syntax (Toggle Plain Text)
double_to_string: 1.186
string_to_double: 9.921
cstrng_to_double: 1.311
 
double_to_string: 1.17
string_to_double: 9.921
cstrng_to_double: 1.295
 
double_to_string: 1.17
string_to_double: 9.906
cstrng_to_double: 1.295
 
double_to_string: 1.17
string_to_double: 9.921
cstrng_to_double: 1.295
double_to_string: 1.186
string_to_double: 9.921
cstrng_to_double: 1.311

double_to_string: 1.17
string_to_double: 9.921
cstrng_to_double: 1.295

double_to_string: 1.17
string_to_double: 9.906
cstrng_to_double: 1.295

double_to_string: 1.17
string_to_double: 9.921
cstrng_to_double: 1.295

vijayan121

Reputation Points: 1159

Solved Threads: 285

Posting Virtuoso

Offline

1,606 posts
since Dec 2006

Permalink

Sep 26th, 2008

Re: Fast Conversions

Results of double_to_string() is somewhat off due to a missing zero ...

Quote ...

void double_to_string()
{
std::clock_t start = std::clock() ;
for(int i = 0; i < 2000000; i++)
{

mitrmkar

Reputation Points: 1105

Solved Threads: 389

Posting Virtuoso

Offline

1,714 posts
since Nov 2007

This thread is more than three months old

No one has posted to this discussion for at least three months. Please let old threads die and do not reply to them unless you feel you have something new and valuable to contribute that absolutely must be added to make the discussion complete. Otherwise, please start a new thread in this forum instead.

Previous Thread in C++ Forum Timeline: Need urgent help

Next Thread in C++ Forum Timeline: Variables changing

DaniWeb Message

Cancel Changes

User Name
Password