# rotate90

`rotate90`

is a transform filter corresponding to the following 4 basic transforms.
**id**, the identity**rotate**: counterclockwise rotation about the board center by 90°_{90}**rotate**: rotation by 180° about the board center_{180}**rotate**: clockwise rotation about the board center by 90°_{270}

`rotate90`

is normally called with a single argument filter, *F*:

rotate90F

`rotate90`

also accepts an optional `count`

parameter.
`rotate90 `

matches the current position if any transformation of *F**F* by one of the 4 basic transforms above matches the current position. These 4 transforms are examples of dihedral transforms.

For example, suppose *F* is the filter `{♔a1 ♚h8}`

, matching a position in which the white king is on `a1`

and the black king is on `h8`

. If we transform this filter by **rotate _{90}** we get the new filter

`{♔h1 ♚a8}`

. That is, if spin the chessboard 90° counterclockwise about the center of the board, the `a1`

square will wind up on `h1`

and the `h8`

square will wind up on `a8`

.
The filters that results from transforming `{♔a1 ♚h8}`

by all the elements of `rotate90`

, which is to say the identity and the three rotations, are:
{♔a1 ♚h8} {♔h1 ♚a8} {♔a8 ♚h1} {♔h8 ♚a1}

The filter `rotate90 {♔a1 ♚h8}`

will thus match a position if any of these 4 filters match the position, that is, if the white and black king are on opposite corners.
(This can also be done, more efficiently, via `♚==diagonal 7 ♔[a1,h1]`

)

If *F* is a set filter then so is

rotate90F

in which case its value is the union of the values of each of the sets represented by each transformed version of *F*.

For example,

`rotate90 a1`

is the set `[a1,h1,a8,h8]`

.

If *F* is a numeric filter then so is `rotate90 `

in which case its value is the maximum of the values of the 4 rotations of *F**F* which match the position.

rotate90 countF

is a numeric filter whose value is the number of distinct matching transformed versions of *F*. For example, if the current position is the initial position, then

rotate90 count find {♕a1 ♛h8}

is equal to 0 if neither `{♕a1 ♛h8}`

nor `{♕h1 ♛a8}`

occur in the game; is equal to 1 if exactly one of these configurations does; and is equal to 2 if both of them do.

The `rotate90`

filter also modifies directions parameters and filters. Thus,

rotate90 ray right (♖ ♔)

will match if and only if

ray orthogonal (♖ ♔)

matches.