I'm trying to create a program in C# that allows for arithmetic of Complex Numbers. Just adding, subtracting, multiplying and dividing. Anyone got any suggestions?
jballen87
- 3 Contributors
- forum2 Replies
- 6 Views
- 8 Years Discussion Span
- comment Latest Post by ddanbe
jonsca 1,059
Create your own class with + - * / overloaded.
This is an example for matrices but it's similar (complex will be less complicated).
Give it a go and post back when you get stuck (or if you have code already post it and someone can look it over).
ddanbe 2,720
This is how I did it some months ago :
using System;
namespace MarMath
{
/// <summary>
///
///
/// struct for complex numbers
///
/// See also [url]http://en.wikipedia.org/wiki/Complex_number[/url]
/// A collection of as much functions and issues I could find about it on the web.
/// Special thanks to Scott Knake for his assistance on IFormattable and IConvertible.
/// © Euler, DeMoivre and others...
///
/// Version 1.00 8 augustus 2009
///
/// Danny Marivoet
///
/// </summary>
struct Complex : IFormattable, IConvertible
{
#region Fields.
/// <summary>
/// The real and imaginary parts of this struct
/// If the imaginary part is zero then a complex number is a real number.
/// The imaginary part is always multiplied with a constant mostly called i.
/// i^2 = -1
/// </summary>
private double _real, _imag;
// A static random field which uses a timeseed
private static Random rnd = new Random();
#endregion
#region Complex contructors.
/// <summary>
/// Initialize a complex number with a real and imaginary part
/// </summary>
/// <param name="real"></param>
/// <param name="imag"></param>
public Complex(double real, double imag)
{
this._real = real; this._imag = imag;
}
/// <summary>
/// Create a new complex number out of an existing one
/// </summary>
/// <param name="z"></param>
public Complex(Complex z)
{
this._real = z.realpart; this._imag = z.imaginarypart;
}
#endregion
#region Properties.
/// <summary>
/// Get the real part of a complex number.
/// </summary>
public double realpart
{
get { return _real; }
set { _real = value; }
}
/// <summary>
/// Get the imaginary part of a complex number.
/// </summary>
public double imaginarypart
{
get { return _imag; }
set { _imag = value; }
}
/// <summary>
/// I^2 is equal to -1.
/// </summary>
public static Complex I
{
get { return new Complex(0.0, 1.0); }
}
/// <summary>
/// Return a zero comlex number
/// </summary>
public static Complex Zero
{
get { return new Complex(0.0, 0.0); }
}
/// <summary>
/// Get the complex conjugate of a complex number.
/// It is obtained by changing the sign of the imaginary part.
/// </summary>
public Complex Conjugate
{
get { return new Complex(_real, -_imag); }
}
/// <summary>
/// Also called Norm or absolute value.
/// </summary>
public double Modulus
{
get { return System.Math.Sqrt(_real * _real + _imag * _imag); }
}
/// <summary>
/// Returns the square of the Modulus
/// </summary>
public double AbsoluteSquare
{
get { return _real * _real + _imag * _imag; }
}
/// <summary>
/// Also called angle.
/// </summary>
public double Argument
{
get
{
if (_imag == 0 && _real < 0)
return Math.PI;
if (_imag == 0 && _real >= 0)
return 0;
return System.Math.Atan2(_imag, _real);
}
}
/// <summary>
/// Returns one divided by the current value.
/// </summary>
public Complex Reciprocal
{
get
{
if (_real == 0d && _imag == 0d)
throw new DivideByZeroException();
double div = _real * _real + _imag * _imag;
return new Complex(_real / div, -_imag / div);
}
}
#endregion
This is just the start and not the complete code. I leave it to you to implement the operator overloading. You will also have to override the ToString method, because of the special format of complex numbers when written.