---
name: "rot"
section: "3"
platform: "linux"
package: "lapack-doc"
version: "3.12.1-2"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/rot"
---

# rot(3)

rot: apply plane rotation (\[cz\]rot in LAPACK)

## NAME

rot - rot: apply plane rotation (\[cz\]rot in LAPACK)

## SYNOPSIS

### Functions

subroutine **csrot** (n, cx, incx, cy, incy, c, s)\
 **CSROT**  subroutine **drot** (n, dx, incx, dy, incy, c, s)\
 **DROT**  subroutine **srot** (n, sx, incx, sy, incy, c, s)\
 **SROT**  subroutine **zdrot** (n, zx, incx, zy, incy, c, s)\
 **ZDROT**  subroutine **crot** (n, cx, incx, cy, incy, c, s)\
 **CROT** applies a plane rotation with real cosine and complex sine to a pair of complex vectors.  subroutine **zrot** (n, cx, incx, cy, incy, c, s)\
 **ZROT** applies a plane rotation with real cosine and complex sine to a pair of complex vectors.

## Detailed Description

## Function Documentation

### subroutine crot (integer n, complex, dimension( \* ) cx, integer incx, complex, dimension( \* ) cy, integer incy, real c, complex s)

**CROT** applies a plane rotation with real cosine and complex sine to a pair of complex vectors.

**Purpose:**

```
!>
!> CROT applies a plane rotation, where the cos (C) is real and the
!> sin (S) is complex, and the vectors CX and CY are complex.
!>
```

**Parameters**

*N*

```
!>          N is INTEGER
!>          The number of elements in the vectors CX and CY.
!>
```

*CX*

```
!>          CX is COMPLEX array, dimension (N)
!>          On input, the vector X.
!>          On output, CX is overwritten with C*X + S*Y.
!>
```

*INCX*

```
!>          INCX is INTEGER
!>          The increment between successive values of CX.  INCX <> 0.
!>
```

*CY*

```
!>          CY is COMPLEX array, dimension (N)
!>          On input, the vector Y.
!>          On output, CY is overwritten with -CONJG(S)*X + C*Y.
!>
```

*INCY*

```
!>          INCY is INTEGER
!>          The increment between successive values of CY.  INCX <> 0.
!>
```

*C*

```
!>          C is REAL
!>
```

*S*

```
!>          S is COMPLEX
!>          C and S define a rotation
!>             [  C          S  ]
!>             [ -conjg(S)   C  ]
!>          where C*C + S*CONJG(S) = 1.0.
!>
```

**Author**

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Definition at line **102** of file **crot.f**.

### subroutine csrot (integer n, complex, dimension( \* ) cx, integer incx, complex, dimension( \* ) cy, integer incy, real c, real s)

**CSROT**

**Purpose:**

```
!>
!> CSROT applies a plane rotation, where the cos and sin (c and s) are real
!> and the vectors cx and cy are complex.
!> jack dongarra, linpack, 3/11/78.
!>
```

**Parameters**

*N*

```
!>          N is INTEGER
!>           On entry, N specifies the order of the vectors cx and cy.
!>           N must be at least zero.
!>
```

*CX*

```
!>          CX is COMPLEX array, dimension at least
!>           ( 1 + ( N - 1 )*abs( INCX ) ).
!>           Before entry, the incremented array CX must contain the n
!>           element vector cx. On exit, CX is overwritten by the updated
!>           vector cx.
!>
```

*INCX*

```
!>          INCX is INTEGER
!>           On entry, INCX specifies the increment for the elements of
!>           CX. INCX must not be zero.
!>
```

*CY*

```
!>          CY is COMPLEX array, dimension at least
!>           ( 1 + ( N - 1 )*abs( INCY ) ).
!>           Before entry, the incremented array CY must contain the n
!>           element vector cy. On exit, CY is overwritten by the updated
!>           vector cy.
!>
```

*INCY*

```
!>          INCY is INTEGER
!>           On entry, INCY specifies the increment for the elements of
!>           CY. INCY must not be zero.
!>
```

*C*

```
!>          C is REAL
!>           On entry, C specifies the cosine, cos.
!>
```

*S*

```
!>          S is REAL
!>           On entry, S specifies the sine, sin.
!>
```

**Author**

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Definition at line **97** of file **csrot.f**.

### subroutine drot (integer n, double precision, dimension(\*) dx, integer incx, double precision, dimension(\*) dy, integer incy, double precision c, double precision s)

**DROT**

**Purpose:**

```
!>
!>    DROT applies a plane rotation.
!>
```

**Parameters**

*N*

```
!>          N is INTEGER
!>         number of elements in input vector(s)
!>
```

*DX*

```
!>          DX is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
!>
```

*INCX*

```
!>          INCX is INTEGER
!>         storage spacing between elements of DX
!>
```

*DY*

```
!>          DY is DOUBLE PRECISION array, dimension ( 1 + ( N - 1 )*abs( INCY ) )
!>
```

*INCY*

```
!>          INCY is INTEGER
!>         storage spacing between elements of DY
!>
```

*C*

```
!>          C is DOUBLE PRECISION
!>
```

*S*

```
!>          S is DOUBLE PRECISION
!>
```

**Author**

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Further Details:**

```
!>
!>     jack dongarra, linpack, 3/11/78.
!>     modified 12/3/93, array(1) declarations changed to array(*)
!>
```

Definition at line **91** of file **drot.f**.

### subroutine srot (integer n, real, dimension(\*) sx, integer incx, real, dimension(\*) sy, integer incy, real c, real s)

**SROT**

**Purpose:**

```
!>
!>    applies a plane rotation.
!>
```

**Parameters**

*N*

```
!>          N is INTEGER
!>         number of elements in input vector(s)
!>
```

*SX*

```
!>          SX is REAL array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
!>
```

*INCX*

```
!>          INCX is INTEGER
!>         storage spacing between elements of SX
!>
```

*SY*

```
!>          SY is REAL array, dimension ( 1 + ( N - 1 )*abs( INCY ) )
!>
```

*INCY*

```
!>          INCY is INTEGER
!>         storage spacing between elements of SY
!>
```

*C*

```
!>          C is REAL
!>
```

*S*

```
!>          S is REAL
!>
```

**Author**

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Further Details:**

```
!>
!>     jack dongarra, linpack, 3/11/78.
!>     modified 12/3/93, array(1) declarations changed to array(*)
!>
```

Definition at line **91** of file **srot.f**.

### subroutine zdrot (integer n, complex\*16, dimension( \* ) zx, integer incx, complex\*16, dimension( \* ) zy, integer incy, double precision c, double precision s)

**ZDROT**

**Purpose:**

```
!>
!> Applies a plane rotation, where the cos and sin (c and s) are real
!> and the vectors cx and cy are complex.
!> jack dongarra, linpack, 3/11/78.
!>
```

**Parameters**

*N*

```
!>          N is INTEGER
!>           On entry, N specifies the order of the vectors cx and cy.
!>           N must be at least zero.
!>
```

*ZX*

```
!>          ZX is COMPLEX*16 array, dimension at least
!>           ( 1 + ( N - 1 )*abs( INCX ) ).
!>           Before entry, the incremented array ZX must contain the n
!>           element vector cx. On exit, ZX is overwritten by the updated
!>           vector cx.
!>
```

*INCX*

```
!>          INCX is INTEGER
!>           On entry, INCX specifies the increment for the elements of
!>           ZX. INCX must not be zero.
!>
```

*ZY*

```
!>          ZY is COMPLEX*16 array, dimension at least
!>           ( 1 + ( N - 1 )*abs( INCY ) ).
!>           Before entry, the incremented array ZY must contain the n
!>           element vector cy. On exit, ZY is overwritten by the updated
!>           vector cy.
!>
```

*INCY*

```
!>          INCY is INTEGER
!>           On entry, INCY specifies the increment for the elements of
!>           ZY. INCY must not be zero.
!>
```

*C*

```
!>          C is DOUBLE PRECISION
!>           On entry, C specifies the cosine, cos.
!>
```

*S*

```
!>          S is DOUBLE PRECISION
!>           On entry, S specifies the sine, sin.
!>
```

**Author**

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Definition at line **97** of file **zdrot.f**.

### subroutine zrot (integer n, complex\*16, dimension( \* ) cx, integer incx, complex\*16, dimension( \* ) cy, integer incy, double precision c, complex\*16 s)

**ZROT** applies a plane rotation with real cosine and complex sine to a pair of complex vectors.

**Purpose:**

```
!>
!> ZROT applies a plane rotation, where the cos (C) is real and the
!> sin (S) is complex, and the vectors CX and CY are complex.
!>
```

**Parameters**

*N*

```
!>          N is INTEGER
!>          The number of elements in the vectors CX and CY.
!>
```

*CX*

```
!>          CX is COMPLEX*16 array, dimension (N)
!>          On input, the vector X.
!>          On output, CX is overwritten with C*X + S*Y.
!>
```

*INCX*

```
!>          INCX is INTEGER
!>          The increment between successive values of CX.  INCX <> 0.
!>
```

*CY*

```
!>          CY is COMPLEX*16 array, dimension (N)
!>          On input, the vector Y.
!>          On output, CY is overwritten with -CONJG(S)*X + C*Y.
!>
```

*INCY*

```
!>          INCY is INTEGER
!>          The increment between successive values of CY.  INCX <> 0.
!>
```

*C*

```
!>          C is DOUBLE PRECISION
!>
```

*S*

```
!>          S is COMPLEX*16
!>          C and S define a rotation
!>             [  C          S  ]
!>             [ -conjg(S)   C  ]
!>          where C*C + S*CONJG(S) = 1.0.
!>
```

**Author**

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Definition at line **102** of file **zrot.f**.

## Author

Generated automatically by Doxygen for LAPACK from the source code.