455,513 Members | 1,693 Online Need help? Post your question and get tips & solutions from a community of 455,513 IT Pros & Developers. It's quick & easy.

# Complex number prints wierd

 P: n/a I'm trying to print a complex number and i get this as output: Phi: (1.618034,0.000000). What does it mean? How do I get it to print normally? Here's the code: ----------fib.hpp------------- #ifndef FIB_HPP #define FIB_HPP #include #include #include #include using namespace std; namespace { template class Fib { public: static const long double val=Fib::val+Fib::val; }; template<> class Fib<2> { public: static const long double val=1; }; template<> class Fib<1> { public: static const long double val=1; }; const complex phi= Fib<32>::val/Fib<31>::val; } #endif -------------------------- ------Main.cpp------ #include "fib.hpp" int main() { cout << "Phi: " << fixed << phi << endl; system("PAUSE"); return 0; } ------------------------ Can you help me? Nov 8 '05 #1
9 Replies

 P: n/a Protoman wrote: I'm trying to print a complex number and i get this as output: Phi: (1.618034,0.000000). What does it mean? It means that your complex number has a real part of 1.618034 and an imaginary part of 0.0. How do I get it to print normally? This is the way complex numbers print *normally*. What did you expect? [code snipped] Best Kai-Uwe Bux Nov 8 '05 #2

 P: n/a OK. Is this a fast way to get fibonacci numbers? Nov 8 '05 #3

 P: n/a You are calculating the fibonacci of 32 and 31 at compile time. So, when the program runs, it doesn't have to calculate the sequence. From the executable's standpoint: yes, this is fast. Nov 8 '05 #4

 P: n/a Is there anyway I can make it faster? Do you know if there's a name for what I'm doing for Fib? Nov 8 '05 #5

 P: n/a Chris Goller wrote: You are calculating the fibonacci of 32 and 31 at compile time. So, when the program runs, it doesn't have to calculate the sequence. There is no such thing as the Fibonacci of a number. Granted, there is 32nd and 31st Fibonacci number, but this program is certainly not calculating either of them. Nor is it successfully calculating the golden mean. This program is simply dividing the sum of all integers from 1 to 32 by the sum of all integers from 1 to 31. Greg Nov 8 '05 #6

 P: n/a Greg wrote: Chris Goller wrote: You are calculating the fibonacci of 32 and 31 at compile time. So, when the program runs, it doesn't have to calculate the sequence. There is no such thing as the Fibonacci of a number. Granted, there is 32nd and 31st Fibonacci number, but this program is certainly not calculating either of them. Nor is it successfully calculating the golden mean. Your assesment is a little off, at least if you are referring to the program in the original post: if the program compiled, it would compute Fibonacci numbers and the golden mean; the problem with the code is that it uses in-place initialization for non-integral types. Here is a version that compiles. The algorithm is completely unchanged. #include #include #include #include using namespace std; template class Fib { public: static const unsigned long val=Fib::val+Fib::val; }; template<> class Fib<2> { public: static const unsigned long val=1; }; template<> class Fib<1> { public: static const unsigned long val=1; }; const double phi= double(Fib<32>::val)/double(Fib<31>::val); int main() { cout << "Phi: " << fixed << phi << endl; return 0; } Guess what it prints: Phi: 1.618034 That passes for an approximation of the golden mean. Moreover, you can print the first few terms of the sequence: #include #include #include #include using namespace std; template class Fib { public: static const unsigned long val=Fib::val+Fib::val; }; template<> class Fib<2> { public: static const unsigned long val=1; }; template<> class Fib<1> { public: static const unsigned long val=1; }; const double phi= double(Fib<32>::val)/double(Fib<31>::val); int main() { cout << Fib<1>::val << " " << Fib<2>::val << " " << Fib<3>::val << " " << Fib<4>::val << " " << Fib<5>::val << " " << Fib<6>::val << " " << Fib<7>::val << "\n"; return 0; } And that prints: 1 1 2 3 5 8 13 Looks like Fibonacci numbers to me. Also, it is actually clear from the code that the program computes the Fibonacci sequence. This program is simply dividing the sum of all integers from 1 to 32 by the sum of all integers from 1 to 31. No it does not. The sum of all integers from 1 to 32 is 16*31. The sum of all integers from 1 to 31 is 15*31. The quotient is 16/15. Best Kai-Uwe Bux Nov 8 '05 #7

 P: n/a So, how does the compiler execute the metaprogram? Nov 8 '05 #8

 P: n/a Protoman wrote: So, how does the compiler execute the metaprogram? Well. If *you* were the compiler. What would *you* need to do in order to create an executable program. (Actually: A surprisingly large number of so called 'clever' programming is just an adoption of what people do in real life. So if you direct your thinking into 'What would I do if all I have is paper and pencil?' is surprisingly often an excellent tool in understanding what is going on.) The compiler comes to compiling: const complex phi= Fib<32>::val/Fib<31>::val; This is a declaration of a complex variable called phi. The variable is initialized with the value of Fib<32>::val/Fib<31>::val For this the compiler needs to know Fib<32>::val and Fib<31>::val Fib<32> is the instantiation of a template. Thus the compiler looks up the Fib template and substitutes 32 for N template class Fib { public: static const long double val=Fib::val+Fib::val; }; becomes class Fib { public: static const long double val=Fib<30>::val+Fib<31>::val; }; In order to make this compilable the compiler has to come up with the initial value for val. For this it has to evaluate the initialization part: Fib<30>::val+Fib<31>::val Again: The compiler is looking for an instantiation of Fib<30> and since there is none it creates one, substituting 30 for N class Fib { public: static const long double val=Fib<28>::val+Fib<29>::val; }; Part of compiling that one, makes the compiler look for an instatiation of Fib<28>. Since there is none, the compiler creates one, using 28 for N class Fib { public: static const long double val=Fib<26>::val+Fib<27>::val; }; And so on, and so on. Finally the compiler will have the request to intialize one of the generated classes with: class Fib { public: static const long double val=Fib<1>::val+Fib<2>::val; }; Looking for Fib<1> the compiler figures out, that the programmer specified that one: template<> class Fib<1> { public: static const long double val=1; }; so it doesn't need to create one on its own. Same for Fib<2>. Since those 2 classes are 'complete' the compiler now can use them to continue working on class Fib { public: static const long double val=Fib<1>::val+Fib<2>::val; }; (which was the template instatiation for Fib<3>). Fib<1>::val is known, it equals 1. Fib<2>::val is known, it equals 1 Thus the initialization value for Fib<3>::val thus must be 2 Having this value, the compiler can continue on finishing Fib<4> and so on, and so on, until finally Fib<32>::val can be calculated by the compiler. Now the whole story starts again for Fib<31>. If both values Fib<32>::val and Fib<31>::val are known to the copmiler, it can easily calculate Fib<32>::val / Fib<31>::val and assign that value to phi. However why one would want to do all of that with complex numbers is bejond my imagination. -- Karl Heinz Buchegger kb******@gascad.at Nov 8 '05 #9

 P: n/a So that's how metaprogramming works. Thanks!!! Nov 9 '05 #10

### This discussion thread is closed

Replies have been disabled for this discussion. 