多语言复数库

class ComplexNumber 
{
    public ComplexNumber()
    {
        // Default
        Real = 0;
        Imaginary = 0;
    }

    public ComplexNumber(double firstVal, double secondVal)
    {
        Real = firstVal;
        Imaginary = secondVal;
    }
}

class ComplexNumber {
    // Constructors
    public ComplexNumber() {
        Real = 0;
        Imaginary = 0;
    }
    
    public ComplexNumber(double firstVal, double secondVal) {
        this.Real = firstVal;
        this.Imaginary = secondVal;
    }
}

Class ComplexNumber
    ' Constructors
    Public Sub New()
        ' Default
        Real = 0
        Imaginary = 0
    End Sub

    Public Sub New(firstVal As Double, secondVal As Double)
        Real = firstVal
        Imaginary = secondVal
    End Sub
End Class

class ComplexNumber {
// Constructors and Destructors of the objects
public:
	// Simple constructor
	ComplexNumber() {
		real = 0;
		imaginary = 0;
	};

	// Constructor with a few values
	ComplexNumber(int firstVal, int secondVal){
		real = firstVal;
		imaginary = secondVal;
	};

	// A destructor for the ComplexNumber class object. 
	~ComplexNumber() {
		
	};
};

一个复数包含两个值，一个实部和一个虚部。我们应该存储这两个变量，然后根据需要，如果想得到极坐标形式的复数，我们可以计算出该复数的角和/或半径。

// Members of the class
public double Real { get; set; }
public double Imaginary { get; set; }

public double Radius()
{
    return Math.Sqrt(Real * Real + Imaginary * Imaginary);
}

public double Angle()
{
    return Math.Atan2(Imaginary, Real);
}

// Members
private double real;
private double imaginary;
    
// Members
double getRadius() {
    return Math.sqrt((real * real) + (imaginary * imaginary));
}
    
double getAngle() {
    return Math.atan2(imaginary, real);
}
    
double getReal() {
    return real;
}
    
void setReal(double r) {
    real = r;
}
    
double getImaginary() {
    return imaginary;
}
    
void setImaginary(double i) {
    imaginary = i;
}

' Hidden private members for the Getters and Setters
Private m_Imaginary As Double
Private m_Real As Double

' Members of the class
Public Property Real() As Double
    Get
        Return m_Real
    End Get
    Set(value As Double)
        m_Real = value
    End Set
End Property 
Public Property Imaginary() As Double
    Get
        Return m_Imaginary
    End Get
    Set(value As Double)
       m_Imaginary = value
    End Set
 End Property

' For the radius and angle
Public Function Radius() As Double
    Return (Real * Real + Imaginary * Imaginary)
End Function

Public Function Angle() As Double
    ' Check for a DivideByZeroException
    If Real <> 0 Then
         ' If the real part is not zero
         Return Math.Atan(Imaginary / Real)
    Else
         Return 0.0
    End If
End Function

private:
	// For complex number
	double real;
	double imaginary;

double getAngle() const {
	return atan2(this->imaginary, this->real);
}

double getRadius() const {
	// Get square root of the value
	return sqrt((real * real) + (imaginary * imaginary));
}

// Member accessing
double getReal() const {
	return real;
}

void setReal(double r) {
	real = r;
}

double getImaginary() const {
	return imaginary;
}

void setImaginary(double i) {
	imaginary = i;
}

ComplexNumber Logarithm()
{
    return new ComplexNumber()
    {
         Real = Math.Log(this.Radius()),
         Imaginary = this.Angle()
    };
}

ComplexNumber getLogarithm() {
    return new ComplexNumber() {{
        this.setReal(Math.log(getRadius()));
        this.setImaginary(getAngle());
    }};
}

Private Function Logarithm() As ComplexNumber
    Dim number As New ComplexNumber()
    number.Real = Math.Log(Me.Radius())
    number.Imaginary = Me.Angle()
    Return number
End Function

// Formula for logarithm ln(z) = ln(|z|) + i(arctan"theta")
ComplexNumber getLogarithm() const {

	return ComplexNumber::ComplexNumber(
		log(this->getRadius()),
		this->getAngle()
	);
}

ComplexNumber Conjugate()
{
    return new ComplexNumber(this.Real, -this.Imaginary);
}

ComplexNumber getConjugate() {
    return new ComplexNumber() {{
        this.setReal(this.getReal());
        this.setImaginary(-this.getImaginary());
    }};
}

Private Function Conjugate() As ComplexNumber
    Return New ComplexNumber(Me.Real, -Me.Imaginary)
End Function

ComplexNumber getConjugate() const {
	// Get the conjugate to this ComplexNumber
	return ComplexNumber::ComplexNumber(
		// Change the sign
		this->real,
		-this->imaginary
	);
}

在此之后，我们可以使用它们的函数将数字转换为极坐标表示法，以获取角度或半径。

ComplexNumber Reciprocal()
{
    return new ComplexNumber() { 
        Real = (this.Real) / (this.Real * this.Real + this.Imaginary * this.Imaginary),
        Imaginary = -(this.Imaginary) / (this.Real * this.Real + this.Imaginary * this.Imaginary)
    };
}

ComplexNumber getReciprocal() {
    return new ComplexNumber() {{
        this.setReal(this.getReal() / 
            (this.getReal() * this.getReal()) + 
                 (this.getImaginary() * this.getImaginary()));
        this.setImaginary(-this.getImaginary() / 
            (this.getReal() * this.getReal()) + 
                 (this.getImaginary() * this.getImaginary()));
    }};
}

Private Function Reciprocal() As ComplexNumber
    Dim number As New ComplexNumber()

    number.Real = (Me.Real) / (Me.Real * Me.Real + Me.Imaginary * Me.Imaginary)
    ' Minus sign shows that there is a conjugate of the complex number.
    number.Imaginary = -(Me.Imaginary) / (Me.Real * Me.Real + Me.Imaginary * Me.Imaginary)
    Return number
End Function

ComplexNumber getReciprocal() const {
	// Create a new object
	return ComplexNumber::ComplexNumber(
		// Run the logic
		(this->real) / (this->real * this->real + this->imaginary * this->imaginary),
		// Minus sign shows that there is a conjugate of the complex number.
		-(this->imaginary) / (this->real * this->real + this->imaginary * this->imaginary)
	);
}

public string ToString(bool asPolar)
{
     string str = "";

     if (asPolar)
     {
         // Polar
         if (this.Angle() > 0)
         {
              // Positive angle
              str = this.Radius() + "(cos" + this.Angle() + " + isin" + this.Angle() + ")";
         }
         else
         {
              str = this.Radius() + "(cos" + this.Angle() + " - isin" + -this.Angle() + ")";
         }
     }
     else
     {
         // Rect
         if (this.Imaginary > 0)
         {
             // Positive Imaginary
             str = this.Real + " + i" + this.Imaginary;
         }
         else
         {
             str = this.Real + " - i" + -this.Imaginary;
         }
     }
     return str;
}

public String toString(boolean asPolar) {
        String str;
        
        if(asPolar) {
            // Polar notation
            if(this.getAngle() > 0) {
                str = this.getRadius() + "(cos" + this.getAngle() + 
                        " + isin" + this.getAngle() + ")";
            } else {
                str = this.getRadius() + "(cos" + this.getAngle() + 
                        " - isin" + -this.getAngle() + ")";
            }
        } else {
            // Cartesian notation
            if(this.imaginary > 0) {
                str = this.real + " + i" + this.imaginary;
            } else {
                str = this.real + " + -" + -this.imaginary;
            }
        }
        return str;
    }

Public Function ToString(asPolar As Boolean) As String
    Dim str As String = ""

    If asPolar Then
         ' Polar
         If Me.Angle() > 0 Then
              ' Positive angle
              str = Me.Radius() + "(cos" + Me.Angle() + " + isin" + Me.Angle() + ")"
         Else
              str = Me.Radius() + "(cos" + Me.Angle() + " - isin" + -Me.Angle() + ")"
         End If
    Else
         ' Rect
         If Me.Imaginary > 0 Then
              ' Positive Imaginary
              str = Me.Real + " + i" + Me.Imaginary
         Else
              str = Me.Real + " - i" + -Me.Imaginary
         End If
    End If
    Return str
End Function

std::string toString(bool asPolar) {

	// Check whether the complex number is a polar or non-polar number
	std::stringstream stream;
	if (asPolar) {
		// Polar, write in the form of cos, sin and radius
		if (this->getAngle() > 0) {
			// Angle is positive
			stream << this->getRadius() << "(cos" << this->getAngle() << " + isin" << this->getAngle() << ")";
		}
		else {
			stream << this->getRadius() << "(cos" << this->getAngle() << " - isin" << -(this->getAngle()) << ")";
		}
	}
	else {
		if (this->imaginary > 0) {
			// imaginary is positive
			stream << this->real << " + i" << this->imaginary;
		}
		else {
			stream << this->real << " - i" << -(this->imaginary);
		}
	}

	return stream.str();
}

public static ComplexNumber operator +(ComplexNumber a, ComplexNumber b) {
    return new ComplexNumber(a.Real + b.Real, a.Imaginary + b.Imaginary);
}

ComplexNumber add(final ComplexNumber a) {
    return new ComplexNumber() 
    {{
            this.setReal(this.getReal() + a.real);
            this.setImaginary(this.getImaginary() + a.imaginary);
    \}};
    }

Public Shared Operator +(a As ComplexNumber, b As ComplexNumber) As ComplexNumber
    Return New ComplexNumber(a.Real + b.Real, a.Imaginary + b.Imaginary)
End Operator

ComplexNumber operator + (ComplexNumber a) {
		// Return the sum of the operator
		return ComplexNumber::ComplexNumber(
			this->real + a.real,
			this->imaginary + a.imaginary);
	}

public static ComplexNumber operator -(ComplexNumber a, ComplexNumber b)
{
    return new ComplexNumber(a.Real - b.Real, a.Imaginary - b.Imaginary);
}

ComplexNumber subtract(final ComplexNumber a) {
    return new ComplexNumber() {{
        this.setReal(this.getReal() - a.getReal());
        this.setImaginary(this.getImaginary() - a.getImaginary());
    }};
}

Public Shared Operator -(a As ComplexNumber, b As ComplexNumber) As ComplexNumber
    Return New ComplexNumber(a.Real - b.Real, a.Imaginary - b.Imaginary)
End Operator

ComplexNumber operator - (ComplexNumber a) {
	// Return the answer of the operator
	ComplexNumber number;
	number.real = this->real - a.real;
	number.imaginary = this->imaginary - a.imaginary;
	return number;
}

public static ComplexNumber operator *(ComplexNumber a, ComplexNumber b)
{
     return new ComplexNumber() 
     {
         Real = (a.Real * b.Real) - (a.Imaginary * b.Imaginary),
         Imaginary = (a.Real * b.Imaginary) + (a.Imaginary * b.Real)
     };
}

ComplexNumber multiply(final ComplexNumber a) {
     return new ComplexNumber() {{
          this.setReal((this.getReal() * a.real) - (this.getImaginary() * a.imaginary));
          this.setImaginary((this.getReal() * a.imaginary) + (this.getImaginary() * a.real));
     }};
}

Public Shared Operator *(a As ComplexNumber, b As ComplexNumber) As ComplexNumber
    Dim number As New ComplexNumber()

    number.Real = (a.Real * b.Real) - (a.Imaginary * b.Imaginary)
    number.Imaginary = (a.Real * b.Imaginary) + (a.Imaginary * b.Real)
    Return number
End Operator

ComplexNumber operator * (ComplexNumber a) {
	// Return the answer of the operator
	return ComplexNumber::ComplexNumber(
		(this->real * a.real) - (this->imaginary * a.imaginary),
		(this->real * a.imaginary) + (this->imaginary * a.real)
	);
}

public static ComplexNumber operator /(ComplexNumber a, ComplexNumber b)
{
     return new ComplexNumber()
     {
          Real = (a.Real * b.Real) + (a.Imaginary * b.Imaginary) /
               ((b.Real * b.Real) + (b.Imaginary * b.Imaginary)),
          Imaginary = (a.Real * b.Real) - (a.Imaginary * b.Imaginary) /
               ((b.Real * b.Real) + (b.Imaginary * b.Imaginary))
     };
}

ComplexNumber divide(final ComplexNumber a) {
     return new ComplexNumber() {{
          this.setReal((this.getReal() * a.real) + (this.getImaginary() * a.imaginary)
                / (a.real * a.real) + (a.imaginary * a.imaginary));
          this.setImaginary((this.getImaginary() * a.real) - (this.getReal() * a.imaginary)
                / (a.real * a.real) + (a.imaginary * a.imaginary));
     }};
}

Public Shared Operator /(a As ComplexNumber, b As ComplexNumber) As ComplexNumber
    Dim number As New ComplexNumber()

    number.Real = (a.Real * b.Real) + (a.Imaginary * b.Imaginary) / ((b.Real * b.Real) + (b.Imaginary * b.Imaginary))
    number.Imaginary = (a.Real * b.Real) - (a.Imaginary * b.Imaginary) / ((b.Real * b.Real) + (b.Imaginary * b.Imaginary))
    Return number
End Operator

ComplexNumber operator / (ComplexNumber a) {
	// Return the answer of the operator
	return ComplexNumber::ComplexNumber(
		(this->real * a.real) + (this->imaginary * a.imaginary) /
		((a.real * a.real) + (a.imaginary * a.imaginary)),
		(this->real * a.real) - (this->imaginary * a.imaginary) /
		((a.real * a.real) + (a.imaginary * a.imaginary))
	);
}

public static bool operator ==(ComplexNumber a, ComplexNumber b)
{
    // Check whether their values are same
    return (b.Real == a.Real && b.Imaginary == a.Imaginary);
}

public static bool operator !=(ComplexNumber a, ComplexNumber b)
{
    return !(b.Real == a.Real && b.Imaginary == a.Imaginary);
}

boolean equals(ComplexNumber a) {
    // Check whether their values are same
    return (this.real == a.real && this.imaginary == a.imaginary);
}

Public Shared Operator =(a As ComplexNumber, b As ComplexNumber) As Boolean
    ' Check whether their values are same
    Return (b.Real = a.Real AndAlso b.Imaginary = a.Imaginary)
End Operator

Public Shared Operator <>(a As ComplexNumber, b As ComplexNumber) As Boolean
    Return Not (b.Real = a.Real AndAlso b.Imaginary = a.Imaginary)
End Operator

bool operator == (ComplexNumber a) {
	return (this->real == a.real && this->imaginary == a.imaginary);
}

bool operator != (ComplexNumber a) {
	return !(this->real == a.real && this->imaginary == a.imaginary);
}

public static ComplexNumber operator -(ComplexNumber a)
{
    return new ComplexNumber(-a.Real, -a.Imaginary);
}

ComplexNumber negate() {
    return new ComplexNumber() {{
        this.setReal(-this.getReal());
        this.setImaginary(-this.getImaginary());
    }};
}

Public Shared Operator -(a As ComplexNumber) As ComplexNumber
    Return New ComplexNumber(-a.Real, -a.Imaginary)
End Operator

ComplexNumber operator - () {
	ComplexNumber number;
	number.real = -(this->real);
	number.imaginary = -(this->imaginary);
	return number;
}