ComplexMatrixAddition(ComplexMatrix, ComplexMatrix) Operator

Determines the sum of two matrices.

Definition

Namespace: Novacta.Analytics
Assembly: Novacta.Analytics (in Novacta.Analytics.dll) Version: 2.1.0+428f3840cfab98dda567bb0ed350b302533e273a

C#

public static ComplexMatrix operator +(
	ComplexMatrix left,
	ComplexMatrix right
)

VB

Public Shared Operator + ( 
	left As ComplexMatrix,
	right As ComplexMatrix
) As ComplexMatrix

C++

public:
static ComplexMatrix^ operator +(
	ComplexMatrix^ left, 
	ComplexMatrix^ right
)

F#

static let inline (+)
        left : ComplexMatrix * 
        right : ComplexMatrix  : ComplexMatrix

Parameters

left ComplexMatrix: The left operand.
right ComplexMatrix: The right operand.

Return Value

ComplexMatrix
The result of adding left to right.

Remarks

Let LaTeX equation and be the left number of rows and columns, respectively, and consider its generic entry

Analogously, Let and be the right number of rows and columns, respectively, and let its generic entry given by

LaTeX equation

The method operates as follows.

If left is scalar, then the method returns a matrix having the same dimensions of right, whose generic entry is:
If right is scalar, then the method returns a matrix having the same dimensions of left, whose generic entry is:
If neither left nor right is scalar, then the method returns a matrix whose generic entry is

provided that the dimensions of left agree with those of right; otherwise, an exception is thrown.

Example

In the following example, some matrices are added.

C#

using System;
using System.Numerics;

namespace Novacta.Analytics.CodeExamples
{
    public class ComplexAdditionExample0  
    {
        public void Main()
        {
            // Create the left operand.
            var data = new Complex[6] {
                new(1, -1), new(5, -5),
                new(2, -2), new(6, -6),
                new(3, -3), new(7, -7)
            };
            var left = ComplexMatrix.Dense(3, 2, data, StorageOrder.RowMajor);
            Console.WriteLine("left =");
            Console.WriteLine(left);

            // Create the right operand.
            data = [
                new(10, -1), new(50, -5),
                new(20, -2), new(60, -6),
                new(30, -3), new(70, -7)
            ];
            var right = ComplexMatrix.Dense(3, 2, data, StorageOrder.RowMajor);
            Console.WriteLine("right =");
            Console.WriteLine(right);

            // Compute the sum of left and right.
            var result = left + right;

            Console.WriteLine();
            Console.WriteLine("left + right =");
            Console.WriteLine(result);

            // In .NET languages that do not support overloaded operators,
            // you can use the alternative methods named Add.
            result = ComplexMatrix.Add(left, right);

            Console.WriteLine();
            Console.WriteLine("ComplexMatrix.Add(left, right) returns");
            Console.WriteLine();
            Console.WriteLine(result);

            // Both operators and alternative methods are overloaded to 
            // support read-only matrix arguments.
            // Compute the sum using a read-only wrapper of left.
            ReadOnlyComplexMatrix readOnlyLeft = left.AsReadOnly();
            result = readOnlyLeft + right;

            Console.WriteLine();
            Console.WriteLine("readOnlyLeft + right =");
            Console.WriteLine(result);
        }
    }
}

// Executing method Main() produces the following output:
// 
// left =
// (                1,               -1) (                5,               -5) 
// (                2,               -2) (                6,               -6) 
// (                3,               -3) (                7,               -7) 
// 
// 
// right =
// (               10,               -1) (               50,               -5) 
// (               20,               -2) (               60,               -6) 
// (               30,               -3) (               70,               -7) 
// 
// 
// 
// left + right =
// (               11,               -2) (               55,              -10) 
// (               22,               -4) (               66,              -12) 
// (               33,               -6) (               77,              -14) 
// 
// 
// 
// ComplexMatrix.Add(left, right) returns
// 
// (               11,               -2) (               55,              -10) 
// (               22,               -4) (               66,              -12) 
// (               33,               -6) (               77,              -14) 
// 
// 
// 
// readOnlyLeft + right =
// (               11,               -2) (               55,              -10) 
// (               22,               -4) (               66,              -12) 
// (               33,               -6) (               77,              -14) 
// 
//

Exceptions

ArgumentNullException	left is null. -or- right is null.
ArgumentException	Both left and right are not scalar matrices, and they have not the same number of rows and columns.