Sets the rotation angle in degree.

@param int $rotationAngle
326126
public function setRotationAngle($rotationAngle) {
        $this->rotationAngle = intval($rotationAngle);
        $this->font->setRotationAngle($this->rotationAngle);
    }
1350448
function setTextRotation($angle)
    {
        switch ($angle)
        {
            case 0:
                $this->_rotation = 0;
                break;
            case 90:
                if ($this->_BIFF_version == 0x0500) {
                $this->_rotation = 3;
                } elseif ($this->_BIFF_version == 0x0600) {
                    $this->_rotation = 180;
                }
                break;
            case 270:
                if ($this->_BIFF_version == 0x0500) {
                $this->_rotation = 2;
                } elseif ($this->_BIFF_version == 0x0600) {
                    $this->_rotation = 90;
                }
                break;
            case -1:
                if ($this->_BIFF_version == 0x0500) {
                $this->_rotation = 1;
                } elseif ($this->_BIFF_version == 0x0600) {
                    $this->_rotation = 255;
                }
                break;
            default :
                return $this->raiseError("Invalid value for angle.".
                                  " Possible values are: 0, 90, 270 and -1 ".
                                  "for stacking top-to-bottom.");
                $this->_rotation = 0;
                break;
        }
    }
668539
public void rotate(Quaternion rotation) {
		Transform3D tr = new Transform3D();
		tr.setRotation(rotation);
		transform(tr);
	}
474126
public Vector setAngle (double angle) {
        double l = length();
        return set(l * Math.cos(angle), l * Math.sin(angle));
    }
1087225
public function rotate($angle) {
    // PHP 5.5 GD bug: https://bugs.php.net/bug.php?id=65148: To prevent buggy
    // behavior on negative multiples of 30 degrees we convert any negative
    // angle to a positive one between 0 and 360 degrees.
    $angle -= floor($angle / 360) * 360;

    // For some rotations that are multiple of 30 degrees, we need to correct
    // an imprecision between GD that uses C floats internally, and PHP that
    // uses C doubles. Also, for rotations that are not multiple of 90 degrees,
    // we need to introduce a correction factor of 0.5 to match the GD
    // algorithm used in PHP 5.5 (and above) to calculate the width and height
    // of the rotated image.
    if ((int) $angle == $angle && $angle % 90 == 0) {
      $imprecision = 0;
      $correction = 0;
    }
    else {
      $imprecision = -0.00001;
      $correction = 0.5;
    }

    // Do the trigonometry, applying imprecision fixes where needed.
    $rad = deg2rad($angle);
    $cos = cos($rad);
    $sin = sin($rad);
    $a = $this->width * $cos;
    $b = $this->height * $sin + $correction;
    $c = $this->width * $sin;
    $d = $this->height * $cos + $correction;
    if ((int) $angle == $angle && in_array($angle, [60, 150, 300])) {
      $a = $this->fixImprecision($a, $imprecision);
      $b = $this->fixImprecision($b, $imprecision);
      $c = $this->fixImprecision($c, $imprecision);
      $d = $this->fixImprecision($d, $imprecision);
    }

    // This is how GD on PHP5.5 calculates the new dimensions.
    $this->boundingWidth = abs((int) $a) + abs((int) $b);
    $this->boundingHeight = abs((int) $c) + abs((int) $d);

    return $this;
  }
1258904
function rotate(angle) {
         if (angle !== 0) {
           var a = this.val,
               a0 = a[0],
               a1 = a[1],
               a3 = a[3],
               a4 = a[4],
               s = Math.sin(angle),
               c = Math.cos(angle);
           a[0] = a0 * c + a3 * s;
           a[1] = a1 * c + a4 * s;
           a[3] = a0 * -s + a3 * c;
           a[4] = a1 * -s + a4 * c;
         }

         return this;
       }
626049
function rotate($angle) {
		$this->data=imagerotate($this->data,$angle,
			imagecolorallocatealpha($this->data,0,0,0,127));
		imagesavealpha($this->data,TRUE);
		return $this->save();
	}
185516
public function rotate($angle)
    {
        $this->setResource(imagerotate($this->resource, $angle , $this->BackgroundColor));
    }
98271
private void setEAxis() {
		Rotation e = rotations.get(0);
		Rotation h = rotations.get(principalAxisIndex);
		e.setAxisAngle(new AxisAngle4d(h.getAxisAngle()));
		e.getAxisAngle().angle = 0.0;
		e.setFold(h.getFold());
	}
1185678
public function rotate($degrees)
    {
        $resampleImageResource =& $this->getResampleImageResource();

        try {

            $resampleImageResource->rotateimage('#000000', $degrees);

            return true;

        } catch (\GmagickException $e) {

            $this->errors[ $e->getCode() ] = $e->getMessage();

        }

        return false;
    }
958866
public function setRound($round)
  {
    if (!is_null($round))
    {
      $round = intval($round);
    }
    $this->round = $round;

    return $this;
  }
79928
def rotateY(self, angle, axis_point=(0, 0, 0), rad=False):
        """"""
        if rad:
            angle *= 57.29578
        self.RotateY(angle)
        if self.trail:
            self.updateTrail()
        return self
450132
public function setRotation(int $rotation): Icon
    {
        $rotas = [
            0,
            90,
            180,
            270
        ];

        if (!in_array($rotation, $rotas)) {
            Throw new IconException('Wrong rotation degree set.');
        }

        if ($rotation == 0) {
            unset($this->rotation);
        }
        else {
            $this->rotation = $rotation;
        }

        return $this;
    }
1092908
def set_rotation(self, rotation):
        """"""
        self._rotation = np.radians(rotation)
        self._polar.set_theta_offset(self._rotation + np.pi / 2.0)
        self.transData.invalidate()
        self.transAxes.invalidate()
        self._set_lim_and_transforms()
1236999
public void setConeOuterAngle (float angle)
    {
        if (_coneOuterAngle != angle) {
            AL10.alSourcef(_id, AL10.AL_CONE_OUTER_ANGLE, _coneOuterAngle = angle);
        }
    }
452305
private void calculateAngles(final int HOUR, final int MINUTE, final int SECOND) {
        secondPointerAngle = SECOND * ANGLE_STEP;
        minutePointerAngle = MINUTE * ANGLE_STEP;
        hourPointerAngle = HOUR * ANGLE_STEP * 5 + (0.5) * minute;
    }
687415
public Quaternionf set(AxisAngle4f axisAngle) {
        return setAngleAxis(axisAngle.angle, axisAngle.x, axisAngle.y, axisAngle.z);
    }