jmathlib.toolbox.jmathlib.matrix._private.Jampack
Class Rot

java.lang.Object
  extended by jmathlib.toolbox.jmathlib.matrix._private.Jampack.Rot

public class Rot
extends java.lang.Object

Rot generates and manipulates plane rotations. Given a 2-vector compontents are x and y, there is a unitary matrix P such that

      P|x| =  |   c      s||x| = |z|
       |y|    |-conj(s)  c||y|   |0|
The number c, which is always real, is the cosine of the rotation. The number s, which may be complex is the sine of the rotation.

Comments: This suite will eventually contain methods for real rotations (two are already in place). The only difference between real and complex rotations is that si and zi are zero for the former. The final routines will do the efficient thing.

Version:
Pre-alpha
Author:
G. W. Stewart

Field Summary
protected  double c
          The cosine of the rotation
 double si
          The imaginary part of the sine of the rotation
 double sr
          The real part of the sine of the rotation
 double zi
          The imaginary part of the first component of the transformed vector
 double zr
          The real part of the first component of the transformed vector
 
Constructor Summary
Rot()
           
 
Method Summary
static void ap(Zmat A, Rot P, int ii1, int ii2, int jj1, int jj2)
          Multiplies columns (ii1:ii2,jj1) and A(ii2:ii2,jj1) of a Zmat (altered) by a plane rotation.
static void aph(Zmat A, Rot P, int ii1, int ii2, int jj1, int jj2)
          Multiplies columns (ii1:ii2,jj1) and A(ii2:ii2,jj1) of a Zmat (altered) by the conjugate transpose of plane rotation.
static Rot genc(double x, double y)
          Given a real 2-vector, genc returns a real plane rotation P such that P|x| = | c s||x| = |z| |y| |-s c||y| |0|
static Rot genc(double xr, double xi, double yr, double yi)
          Given the real and imaginary parts of a 2-vector, genc returns a plane rotation P such that P|x| = | c s||x| = |z| |y| |-conj(s) c||y| |0|
static void genc(double xr, double xi, double yr, double yi, Rot P)
          Given the real and imaginary parts of a 2-vector, genc generates a plane rotation P such that P|x| = | c s||x| = |z| |y| |-conj(s) c||y| |0|
static void genc(double x, double y, Rot P)
          Given a real 2-vectc, genc generates a real plane rotation P such that P|x| = | c s||x| = |z| |y| |-s c||y| |0|
static Rot genc(Zmat A, int ii1, int ii2, int jj)
          Given a Zmat A, genc returns a plane rotation that on premultiplication into rows ii1 and ii2 annihilates A(ii2,jj).
static void genc(Zmat A, int ii1, int ii2, int jj, Rot P)
          Given a Zmat A, genc generates a plane rotation that on premultiplication into rows ii1 and ii2 annihilates A(ii2,jj).
static Rot genr(double x, double y)
          Given a real 2-vector, genr returns a plane rotation such that |x y|P = |x y|| c s||x| = |z 0| |-s c||y|
static Rot genr(double xr, double xi, double yr, double yi)
          Given the real and imaginary parts of a 2-vector, genr returns a plane rotation such that |x y|P = |x y|| c s||x| = |z 0| |-conj(s) c||y|
static void genr(double xr, double xi, double yr, double yi, Rot P)
          Given the real and imaginary parts of a 2-vector, genr generates a plane rotation such that |x y|P = |x y|| c s||x| = |z 0| |-conj(s) c||y|
static void genr(double x, double y, Rot P)
          Given a real 2-vector, genr generates a plane rotation such that |x y|P = |x y|| c s||x| = |z 0| |-s c||y|
static Rot genr(Zmat A, int ii, int jj1, int jj2)
          Given a Zmat A, genr returns a plane rotation that on postmultiplication into column jj1 and jj2 annihilates A(ii,jj2).
static void genr(Zmat A, int ii, int jj1, int jj2, Rot P)
          Given a Zmat A, genr generates a plane rotation that on postmultiplication into column jj1 and jj2 annihilates A(ii,jj2).
static void pa(Rot P, Zmat A, int ii1, int ii2, int jj1, int jj2)
          Multiplies rows (ii1,jj1:jj2) and (ii2,jj1:jj2) of a Zmat (altered) by a plane rotation.
static void pha(Rot P, Zmat A, int ii1, int ii2, int jj1, int jj2)
          Multiplies rows (ii1,jj1:jj2) and (ii2,jj1:jj2) of a Zmat (altered) by the conjugate transpose of a plane rotation.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

c

protected double c
The cosine of the rotation


sr

public double sr
The real part of the sine of the rotation


si

public double si
The imaginary part of the sine of the rotation


zr

public double zr
The real part of the first component of the transformed vector


zi

public double zi
The imaginary part of the first component of the transformed vector

Constructor Detail

Rot

public Rot()
Method Detail

genc

public static Rot genc(double xr,
                       double xi,
                       double yr,
                       double yi)
Given the real and imaginary parts of a 2-vector, genc returns a plane rotation P such that
      P|x| =  |   c      s||x| = |z|
       |y|    |-conj(s)  c||y|   |0|

Parameters:
xr - The real part of the first component of the 2-vector
xi - The imaginary part of the first component of the 2-vector
yr - The real part of the second component of the 2-vector
yi - The imaginary part of the second component of the 2-vector
Returns:
The rotation

genc

public static void genc(double xr,
                        double xi,
                        double yr,
                        double yi,
                        Rot P)
Given the real and imaginary parts of a 2-vector, genc generates a plane rotation P such that
      P|x| =  |   c      s||x| = |z|
       |y|    |-conj(s)  c||y|   |0|

Parameters:
xr - The real part of the first component of the 2-vector
xi - The imaginary part of the first component of the 2-vector
yr - The real part of the second component of the 2-vector
yi - The imaginary part of the second component of the 2-vector
P - The rotation (must be initialized)

genc

public static Rot genc(double x,
                       double y)
Given a real 2-vector, genc returns a real plane rotation P such that
      P|x| =  | c  s||x| = |z|
       |y|    |-s  c||y|   |0|

Parameters:
x - The first component of the two vector
y - The second component of the two vector
Returns:
The rotation

genc

public static void genc(double x,
                        double y,
                        Rot P)
Given a real 2-vectc, genc generates a real plane rotation P such that
      P|x| =  | c  s||x| = |z|
       |y|    |-s  c||y|   |0|

Parameters:
x - The first component of the two vector
y - The second component of the two vector
P - The plane rotation

genc

public static Rot genc(Zmat A,
                       int ii1,
                       int ii2,
                       int jj)
Given a Zmat A, genc returns a plane rotation that on premultiplication into rows ii1 and ii2 annihilates A(ii2,jj). The element A(ii2,jj) is overwriten by zero and the element A(ii1,jj) is overwritten by its transformed value.

Parameters:
A - The Zmat (altered)
ii1 - The row index of the first element
ii2 - The row index of the second element (the one that is annihilated
jj - The column index of the elements
Returns:
The plane rotation

genc

public static void genc(Zmat A,
                        int ii1,
                        int ii2,
                        int jj,
                        Rot P)
Given a Zmat A, genc generates a plane rotation that on premultiplication into rows ii1 and ii2 annihilates A(ii2,jj). The element A(ii2,jj) is overwriten by zero and the element A(ii1,jj) is overwritten by its transformed value.

Parameters:
A - The Zmat (altered)
ii1 - The row index of the first element
ii2 - The row index of the second element (the one that is annihilated
jj - The column index of the elements
P - The plane rotation (must be initialized)

genr

public static Rot genr(double xr,
                       double xi,
                       double yr,
                       double yi)
Given the real and imaginary parts of a 2-vector, genr returns a plane rotation such that
      |x y|P = |x y||   c      s||x| = |z 0|
                    |-conj(s)  c||y|

Parameters:
xr - The real part of the first component of the 2-vector
xi - The imaginary part of the first component of the 2-vector
yr - The real part of the second component of the 2-vector
yi - The imaginary part of the second component of the 2-vector
Returns:
The rotation

genr

public static void genr(double xr,
                        double xi,
                        double yr,
                        double yi,
                        Rot P)
Given the real and imaginary parts of a 2-vector, genr generates a plane rotation such that
      |x y|P = |x y||   c      s||x| = |z 0|
                    |-conj(s)  c||y|

Parameters:
xr - The real part of the first component of the 2-vector
xi - The imaginary part of the first component of the 2-vector
yr - The real part of the second component of the 2-vector
yi - The imaginary part of the second component of the 2-vector
P - The plane rotation (must be initialized)

genr

public static Rot genr(Zmat A,
                       int ii,
                       int jj1,
                       int jj2)
Given a Zmat A, genr returns a plane rotation that on postmultiplication into column jj1 and jj2 annihilates A(ii,jj2). The element A(ii,jj2) is overwirten by zero and the element A(ii,jj1) is overwritten by its transformed value.

Parameters:
A - The Zmat (altered)
ii - The index of the row containing the elements
jj1 - The column index of the first element
jj2 - The column index of the second element (the one that is annihilated)
Returns:
The rotation

genr

public static void genr(Zmat A,
                        int ii,
                        int jj1,
                        int jj2,
                        Rot P)
Given a Zmat A, genr generates a plane rotation that on postmultiplication into column jj1 and jj2 annihilates A(ii,jj2). The element A(ii,jj2) is overwirten by zero and the element A(ii,jj1) is overwritten by its transformed value.

Parameters:
A - The Zmat (altered)
ii - The index of the row containing the elements
jj1 - The column index of the first element
jj2 - The column index of the second element (the one that is annihilated)
P - The rotation

genr

public static Rot genr(double x,
                       double y)
Given a real 2-vector, genr returns a plane rotation such that
      |x y|P = |x y|| c  s||x| = |z 0|
                    |-s  c||y|

Parameters:
x - The first component of the 2-vector
y - The second component of the 2-vector
Returns:
The rotation

genr

public static void genr(double x,
                        double y,
                        Rot P)
Given a real 2-vector, genr generates a plane rotation such that
      |x y|P = |x y|| c  s||x| = |z 0|
                    |-s  c||y|

Parameters:
x - The first component of the 2-vector
y - The second component of the 2-vector
P - The rotation

pa

public static void pa(Rot P,
                      Zmat A,
                      int ii1,
                      int ii2,
                      int jj1,
                      int jj2)
Multiplies rows (ii1,jj1:jj2) and (ii2,jj1:jj2) of a Zmat (altered) by a plane rotation.

Parameters:
P - The plane rotation
A - The Zmat (altered)
ii1 - The row index of the first row.
ii2 - The row index of the second row.
jj1 - The first index of the range of the rows
jj2 - The second index of the range of the rows

pha

public static void pha(Rot P,
                       Zmat A,
                       int ii1,
                       int ii2,
                       int jj1,
                       int jj2)
Multiplies rows (ii1,jj1:jj2) and (ii2,jj1:jj2) of a Zmat (altered) by the conjugate transpose of a plane rotation.

Parameters:
P - The plane rotation
A - The Zmat (altered)
ii1 - The row index of the first row.
ii2 - The row index of the second row.
jj1 - The first index of the range of the rows
jj2 - The second index of the range of the rows

ap

public static void ap(Zmat A,
                      Rot P,
                      int ii1,
                      int ii2,
                      int jj1,
                      int jj2)
Multiplies columns (ii1:ii2,jj1) and A(ii2:ii2,jj1) of a Zmat (altered) by a plane rotation.

Parameters:
A - The Zmat (altered)
P - The rotation
ii1 - The first index of the column range
ii2 - The second index of the column range
jj1 - The index of the first column
jj2 - The index of the second column

aph

public static void aph(Zmat A,
                       Rot P,
                       int ii1,
                       int ii2,
                       int jj1,
                       int jj2)
Multiplies columns (ii1:ii2,jj1) and A(ii2:ii2,jj1) of a Zmat (altered) by the conjugate transpose of plane rotation.

Parameters:
A - The Zmat (altered)
P - The rotation
ii1 - The first index of the column range
ii2 - The second index of the column range
jj1 - The index of the first column
jj2 - The index of the second column

FOOTER

BOTTOM