Complex Numbers

Complex Numbers QuickStart Sample (Managed C++)

Illustrates the use of the DoubleComplex structure for representing complex numbers 
in Managed Extensions for C++.

C# code VB.NET code Back to QuickStart Samples

// This is the main project file for VC++ application project // generated using an Application Wizard.#include "stdafx.h"#using <mscorlib.dll>

// Illustrates the use of the DoubleComplex class.using namespace System;
// The DoubleComplex class resides in the Extreme.Mathematics namespace.using namespace Extreme::Mathematics;

int _tmain()
{
    //    // DoubleComplex constants:    //    Console::WriteLine("DoubleComplex::Zero = {0}", __box(DoubleComplex::Zero));
    Console::WriteLine("DoubleComplex::One = {0}", __box(DoubleComplex::One));
    // The imaginary unit is given by DoubleComplex::I:    Console::WriteLine("DoubleComplex::I = {0}", __box(DoubleComplex::I));
    Console::WriteLine();

    //    // Construct some complex numbers    //    // Real and imaginary parts:    //   a = 2 + 4i    DoubleComplex a = DoubleComplex(2, 4);
    Console::WriteLine("a = {0}", __box(a));
    //   b = 1 - 3i    DoubleComplex b = DoubleComplex(1, -3);
    Console::WriteLine("b = {0}", __box(b));
    // From a real number:    //   c = -3 + 0i    DoubleComplex c = DoubleComplex(-3);
    Console::WriteLine("c = {0}", __box(c));
    // Polar form:    //   d = 2 (cos(Pi/3) + i sin(Pi/3))    DoubleComplex d = DoubleComplex(2, Constants::Pi/3, true);
    // To print this number, use the overloaded ToString    // method and specify the format string for the real     // and imaginary parts:    Console::WriteLine("d = {0}", __box(d));
    Console::WriteLine();

    //    // Parts of complex numbers    //    Console::WriteLine("Parts of a = {0}:", __box(a));
    Console::WriteLine("Real part of a = {0}", __box(a.Re));
    Console::WriteLine("Imaginary part of a = {0}", __box(a.Im));
    Console::WriteLine("Modulus of a = {0}", __box(a.Modulus));
    Console::WriteLine("Argument of a = {0}", __box(a.Argument));
    Console::WriteLine();

    //    // Basic arithmetic:    //    Console::WriteLine("Basic arithmetic:");
    DoubleComplex e = -a;
    Console::WriteLine("-a = {0}", __box(e));
    e = a + b;
    Console::WriteLine("a + b = {0}", __box(e));
    e = a - b;
    Console::WriteLine("a - b = {0}", __box(e));
    e = a * b;
    Console::WriteLine("a * b = {0}", __box(e));
    e = a / b;
    Console::WriteLine("a / b = {0}", __box(e));
    // The conjugate of a complex number corresponds to    // the "Conjugate" method:    e = a.Conjugate();
    Console::WriteLine("Conjugate(a) = ~a = {0}", __box(e));
    Console::WriteLine();

    //    // Functions of complex numbers    //    // Most of these have corresponding static methods     // in the System.Math class, but are extended to complex     // arguments.    Console::WriteLine("Functions of complex numbers:");

    // Exponentials and logarithms    Console::WriteLine("Exponentials and logarithms:");
    e = DoubleComplex::Exp(a);
    Console::WriteLine("Exp(a) = {0}", __box(e));
    e = DoubleComplex::Log(a);
    Console::WriteLine("Log(a) = {0}", __box(e));
    e = DoubleComplex::Log10(a);
    Console::WriteLine("Log10(a) = {0}", __box(e));
    // You can get a point on the unit circle by calling    // the ExpI method:    e = DoubleComplex::ExpI(2*Constants::Pi/3);
    Console::WriteLine("ExpI(2*Pi/3) = {0}", __box(e));
    // The RootOfUnity method also returns points on the    // unit circle. The above is equivalent to the second    // root of z^6 = 1:    e = DoubleComplex::RootOfUnity(6, 2);
    Console::WriteLine("RootOfUnity(6, 2) = {0}", __box(e));


    // The Pow method is overloaded for integer, double,    // and complex argument:    e = DoubleComplex::Pow(a, 3);
    Console::WriteLine("Pow(a,3) = {0}", __box(e));
    e = DoubleComplex::Pow(a, 1.5);
    Console::WriteLine("Pow(a,1.5) = {0}", __box(e));
    e = DoubleComplex::Pow(a, b);
    Console::WriteLine("Pow(a,b) = {0}", __box(e));

    // Square root    e = DoubleComplex::Sqrt(a);
    Console::WriteLine("Sqrt(a) = {0}", __box(e));
    // The Sqrt method is overloaded. Here's the square     // root of a negative double:    e = DoubleComplex::Sqrt(-4);
    Console::WriteLine("Sqrt(-4) = {0}", __box(e));
    Console::WriteLine();

    //    // Trigonometric functions:    //    Console::WriteLine("Trigonometric function:");
    e = DoubleComplex::Sin(a);
    Console::WriteLine("Sin(a) = {0}", __box(e));
    e = DoubleComplex::Cos(a);
    Console::WriteLine("Cos(a) = {0}", __box(e));
    e = DoubleComplex::Tan(a);
    Console::WriteLine("Tan(a) = {0}", __box(e));

    // Inverse Trigonometric functions:    e = DoubleComplex::Asin(a);
    Console::WriteLine("Asin(a) = {0}", __box(e));
    e = DoubleComplex::Acos(a);
    Console::WriteLine("Acos(a) = {0}", __box(e));
    e = DoubleComplex::Atan(a);
    Console::WriteLine("Atan(a) = {0}", __box(e));

    // Asin and Acos have overloads with real argument    // not restricted to [-1,1]:    e = DoubleComplex::Asin(2);
    Console::WriteLine("Asin(2) = {0}", __box(e));
    e = DoubleComplex::Acos(2);
    Console::WriteLine("Acos(2) = {0}", __box(e));
    Console::WriteLine();
    
    //    // Hyperbolic and inverse hyperbolic functions:    //    Console::WriteLine("Hyperbolic function:");
    e = DoubleComplex::Sinh(a);
    Console::WriteLine("Sinh(a) = {0}", __box(e));
    e = DoubleComplex::Cosh(a);
    Console::WriteLine("Cosh(a) = {0}", __box(e));
    e = DoubleComplex::Tanh(a);
    Console::WriteLine("Tanh(a) = {0}", __box(e));
    e = DoubleComplex::Asinh(a);
    Console::WriteLine("Asinh(a) = {0}", __box(e));
    e = DoubleComplex::Acosh(a);
    Console::WriteLine("Acosh(a) = {0}", __box(e));
    e = DoubleComplex::Atanh(a);
    Console::WriteLine("Atanh(a) = {0}", __box(e));
    Console::WriteLine();

    Console::Write("Press Enter key to exit...");
    Console::ReadLine();
    return 0;
}