Conjugate transpose: Difference between revisions

{{trans|Nim}}

 

 

F to_str(m)

test(M3)

print("\n")

 

{{out}}

 

=={{header|Ada}}==

with Ada.Complex_Text_IO; use Ada.Complex_Text_IO;

with Ada.Numerics.Complex_Types; use Ada.Numerics.Complex_Types;

Put_Line("nmat:"); Examine(nmat); New_Line;

Put_Line("umat:"); Examine(umat);

{{out}}

<pre>hmat:

=={{header|ALGOL 68}}==

Uses the same test cases as the Ada sample.

# returns the conjugate transpose of m #

OP CONJUGATETRANSPOSE = ( [,]COMPL m )[,]COMPL:

)

)

{{out}}

<pre>

 

=={{header|C}}==

 

#include<stdlib.h>

 

return 0;

{{out}}

<pre>

 

=={{header|C++}}==

#include <cmath>

#include <complex>

test(matrix3);

return 0;

 

{{out}}

 

=={{header|Common Lisp}}==

(defun matrix-multiply (m1 m2)

(mapcar

(defun unitary-p (m)

(identity-p (matrix-multiply m (conjugate-transpose m))) )

 

{{out}}

=={{header|D}}==

{{trans|Python}} A well typed and mostly imperative version:

std.numeric;

 

writefln("Unitary? %s.\n", isUnitary(mat, ct));

}

{{out}}

<pre>Matrix:

===Alternative Version===

A more functional version that contains some typing problems (same output).

std.numeric, std.exception, std.traits;

 

writefln("Unitary? %s.\n", isUnitary(mat, ct));

}

 

=={{header|Factor}}==

Before the fix to [https://github.com/slavapestov/factor/issues/484 Factor bug #484], <code>m.</code> gave the wrong answer and this code failed. Factor 0.94 is too old to work.

 

{{works with|Factor|development (future 0.95)}}

IN: rosetta.hermitian

 

 

: unitary-matrix? ( matrix -- ? )

 

Usage:

The examples and algorithms are taken from the j solution, except for UnitaryQ. The j solution uses the matrix inverse verb. Compilation on linux, assuming the program is file f.f08 :<pre>

gfortran -std=f2008 -Wall -fopenmp -ffree-form -fall-intrinsics -fimplicit-none f.f08 -o f</pre>

program conjugate_transpose

 

 

end program conjugate_transpose

<pre>

-*- mode: compilation; default-directory: "/tmp/" -*-

 

=={{header|FreeBASIC}}==

type complex

real as double

print is_hermitian(A), is_normal(A), is_unitary(A)

print is_hermitian(B), is_normal(B), is_unitary(B)

{{out}}

<pre>true true true

 

=={{header|Go}}==

 

import (

}

return m3

Output:

<pre>

=={{header|Haskell}}==

Slow implementation using lists.

import Data.List (transpose)

 

:: Num a

=> Matrix (Complex a) -> Matrix (Complex a)

Output:

<pre>

=={{header|J}}==

 

 

HERMITIAN =: 3 2j1 ,: 2j_1 1

UNITARY =: (-:%:2) * 1 1 0 , 0j_1 0j1 0 ,: 0 0 0j1 * %:2

(ct -: %.) UNITARY NB. A_ct = A^-1

 

+--------+-----+--------------------------+

| 3 2j1|1 1 0| 0.707107 0.707107 0|

+-----+-----+-----+

|1 1 0|0 1 0|0 1 1|

 

=={{header|jq}}==

 

If your jq does not have "transpose" then the following may be used:

# (an array of equal-length arrays):

def transpose:

if (.[0] | length) == 0 then []

else [map(.[0])] + (map(.[1:]) | transpose)

'''(2) Operations on real/complex numbers'''

# always return complex

def plus(x; y):

if type == "number" then [.,0]

else [.[0], -(.[1]) ]

'''(3) Array operations'''

def dot_product(a; b):

a as $a | b as $b

| reduce range(0;$a|length) as $i

'''(4) Matrix operations'''

def to_complex:

def toc: if type == "number" then [.,0] else . end;

reduce range(0;M|length) as $i

(0; reduce range(0; M[0]|length) as $j

====Conjugate transposition====

def conjugate_transpose:

map( map(conjugate) ) | transpose;

| complex_identity(length) as $I

| approximately_equal( $I; matrix_multiply($H;$M); 1e-10)

 

====Examples====

[ [ 3, [2,1]],

[[2,-1], 1 ] ];

;

 

{{out}}

Hermitian example:

 

Normal example: true

 

 

=={{header|Julia}}==

Julia has a built-in matrix type, and the conjugate-transpose of a complex matrix <code>A</code> is simply:

(similar to Matlab). You can check whether <code>A</code> is Hermitian via the built-in function

Ignoring the possibility of roundoff errors for floating-point matrices (like most of the examples in the other languages), you can check whether a matrix is normal or unitary by the following functions

isnormal(A) = size(A,1) == size(A,2) && A'*A == A*A'

 

=={{header|Kotlin}}==

As Kotlin doesn't have built in classes for complex numbers or matrices, some basic functionality needs to be coded in order to tackle this task:

 

typealias C = Complex

println("Unitary? ${mct.isUnitary()}\n")

}

 

{{out}}

=={{header|Maple}}==

The commands <code>HermitianTranspose</code> and <code>IsUnitary</code> are provided by the <code>LinearAlgebra</code> package.

 

with(LinearAlgebra):

type(M,'Matrix'(hermitian));

IsNormal(M);

Output:

<pre> [ 3 2 + I]

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

UnitaryQ[m_List?MatrixQ] := (Conjugate@Transpose@m.m == IdentityMatrix@Length@m)

 

 

{HermitianMatrixQ@#, NormalMatrixQ@#, UnitaryQ@#}&@m

 

=={{header|Nim}}==

The complex type is defined as generic regarding the type of real an imaginary part. We have chosen to use Complex[float] and make only our Matrix type generic regarding the dimensions. Thus, a Matrix has a two dimensions M and N which are static, i.e. known at compile time. We have enforced the condition M = N for square matrices (also at compile time).

 

 

type Matrix[M, N: static Positive] = array[M, array[N, Complex[float]]]

test(M2)

test(M3)

 

{{out}}

 

=={{header|PARI/GP}}==

isHermitian(M)=M==conj(M~)

isnormal(M)=my(H=conj(M~));H*M==M*H

 

=={{header|Perl}}==

In general, using two or more modules which overload operators can be problematic. For this task, using both Math::Complex and Math::MatrixReal gives us the behavior we want for everything except matrix I/O, i.e. parsing and stringification.

use English;

use Math::Complex;

sub identity {

my $N = shift;

$m->one();

return $m;

 

sub example1 {

$m->assign(1, 1, cplx(3, 0));

$m->assign(1, 2, cplx(2, 1));

 

sub example2 {

$m->assign(1, 1, cplx(1, 0));

$m->assign(1, 2, cplx(1, 0));

 

sub example3 {

$m->assign(1, 1, cplx(0.70710677, 0));

$m->assign(1, 2, cplx(0.70710677, 0));

$m->assign(3, 3, cplx(0, 1));

return $m;

{{out}}

<pre>

 

=={{header|Phix}}==

{{out}}

<pre>

Original matrix:

Conjugate transpose:

 

Original matrix:

Conjugate transpose:

 

Original matrix:

[0.5-0.5i,0.5+0.5i]

[0.5+0.5i,0.5-0.5i]

 

Original matrix:

[1,1,0]

[0,1,1]

 

Original matrix:

[0.707107,0.707107,0]

Conjugate transpose:

 

Original matrix:

[2-7i,3-4i]

[9+5i,8+6i]

</pre>

 

=={{header|PL/I}}==

test: procedure options (main); /* 1 October 2012 */

declare n fixed binary;

end MMULT;

end test;

Outputs from separate runs:

<pre>

 

=={{header|PowerShell}}==

function conjugate-transpose($a) {

$arr = @()

"Normal? `$m = $(are-eq $mhm $hmm)"

"Unitary? `$m = $((are-eq $id2 $hmm) -and (are-eq $id2 $mhm))"

<b>Output:</b>

<pre>

=={{header|Python}}==

Internally, matrices must be represented as rectangular tuples of tuples of complex numbers.

return tuple(tuple(n.conjugate() for n in row) for row in zip(*m))

 

print('Hermitian? %s.' % ishermitian(matrix, ct))

print('Normal? %s.' % isnormal(matrix, ct))

 

{{out}}

 

=={{header|Racket}}==

#lang racket

(require math)

(define (hermitian? M)

(equal? (H M) M))

Test:

(define M (matrix [[3.000+0.000i +2.000+1.000i]

[2.000-1.000i +1.000+0.000i]]))

(unitary? M)

(hermitian? M)

Output:

(array #[#[3.0-0.0i 2.0+1.0i] #[2.0-1.0i 1.0-0.0i]])

#t

#f

#f

 

=={{header|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2015-12-13}}

[ 1, 1+i, 2i],

[ 1-i, 5, -3],

}

 

{{out}}

<pre>Matrix:

 

=={{header|REXX}}==

parse arg N elements; if N==''|N=="," then N=3 /*Not specified? Then use the default.*/

k= 0; do r=1 for N

numeric digits; parse value format(x,2,1,,0) 'E0' with g 'E' _ .; g=g *.5'e'_ % 2

m.=9; do j=0 while h>9; m.j=h; h=h%2+1; end /*j*/

{{out|output|text=&nbsp; when using the default input:}}

<pre>

MMH is Unary: yes

MHM is Unary: yes

</pre>

 

=={{header|Ruby}}==

{{works with|Ruby|2.0}}

 

# Start with some matrix.

print ' normal? false'

print ' unitary? false'

Note: Ruby 1.9 had a bug in the Matrix#hermitian? method. It's fixed in 2.0.

 

=={{header|Rust}}==

Uses external crate 'num', version 0.1.34

extern crate num; // crate for complex numbers

 

println!("Unitary?: FALSE");

}

Output:

<pre>

 

=={{header|Scala}}==

case class Complex(re: Double, im: Double) {

}

{{out}}

<pre>

=={{header|Sidef}}==

{{trans|Raku}}

 

func mat_mult (Array a, Array b, Number ε = -3) {

say "Is Normal?\t#{is_Normal(m, t)}"

say "Is Unitary?\t#{is_Unitary(m, t)}"

{{out}}

<pre>

Sparkling has support for basic complex algebraic operations, but complex matrix operations are not in the standard library.

 

let conjTransp = function conjTransp(M) {

return map(range(sizeof M[0]), function(row) {

print("U x U* = ");

printCplxMat(cplxMatMul(U, conjTransp(U)));

 

=={{header|Stata}}==

In Mata, the ' operator is always the conjugate transpose. To get only the matrix transpose without complex conjugate, use the [ transposeonly] function.

 

: a=1,2i\3i,4

 

: a'*a==I(rows(a))

0

 

=={{header|Tcl}}==

{{tcllib|math::complexnumbers}}

{{tcllib|struct::matrix}}

package require math::complexnumbers

 

}

return $mat

Using these tools to test for the properties described in the task:

if {[$matrix rows] != [$matrix columns]} {

# Must be square!

$mmh destroy

return $result

<!-- Wot, no demonstration? -->

 

 

However, if we use the ''almostEquals'' method with the default tolerance of 1.0e-14, then we do get a ''true'' result.

 

var cm1 = CMatrix.new(

var cm4 = cm3 * cm3.conjTranspose

var id = CMatrix.identity(3)

 

{{out}}