Skip to main content
`Ctrl`+`K`

# CartesianDifferential

class astropy.coordinates.CartesianDifferential(d_x, d_y=None, d_z=None, unit=None, xyz_axis=None, copy=True)

  Bases: `BaseDifferential`

  Differentials in of points in 3D cartesian coordinates.

  Parameters:
    d_x, d_y, d_z `Quantity` or `array`

      The x, y, and z coordinates of the differentials. If `d_x`, `d_y`, and `d_z` have different shapes, they should be broadcastable. If not quantities, `unit` should be set. If only `d_x` is given, it is assumed that it contains an array with the 3 coordinates stored along `xyz_axis`.

    unit `Unit` or `python:str`

      If given, the differentials will be converted to this unit (or taken to be in this unit if not given.

    xyz_axis `python:int`, optional

      The axis along which the coordinates are stored when a single array is provided instead of distinct `d_x`, `d_y`, and `d_z` (default: 0).

    copy bool, optional

      If `True` (default), arrays will be copied. If `False`, arrays will be references, though possibly broadcast to ensure matching shapes.

  Attributes Summary

  `attr_classes` |
  `d_x` | Component 'd_x' of the Differential.
  `d_xyz` | Return a vector array of the x, y, and z coordinates.
  `d_y` | Component 'd_y' of the Differential.
  `d_z` | Component 'd_z' of the Differential.
  `name` | Name of the representation or differential.

  Methods Summary

  `from_cartesian`(other[, base]) | Convert the differential from 3D rectangular cartesian coordinates to the desired class.
  `get_d_xyz`([xyz_axis]) | Return a vector array of the x, y, and z coordinates.
  `to_cartesian`([base]) | Convert the differential to 3D rectangular cartesian coordinates.
  `transform`(matrix[, base, transformed_base]) | Transform differentials using a 3x3 matrix in a Cartesian basis.

  Attributes Documentation

  attr_classes = {'d_x': <class 'astropy.units.quantity.Quantity'>, 'd_y': <class 'astropy.units.quantity.Quantity'>, 'd_z': <class 'astropy.units.quantity.Quantity'>}
  d_x

    Component ‘d_x’ of the Differential.

  d_xyz

    Return a vector array of the x, y, and z coordinates.

    Parameters:
      xyz_axis `python:int`, optional

        The axis in the final array along which the x, y, z components should be stored (default: 0).

    Returns:
      d_xyz `Quantity`

        With dimension 3 along `xyz_axis`. Note that, if possible, this will be a view.

  d_y

    Component ‘d_y’ of the Differential.

  d_z

    Component ‘d_z’ of the Differential.

  name = 'cartesian'

    Name of the representation or differential.

    When a subclass is defined, by default, the name is the lower-cased name of the class with with any trailing ‘representation’ or ‘differential’ removed. (E.g., ‘spherical’ for `SphericalRepresentation` or `SphericalDifferential`.)

    This can be customized when defining a subclass by setting the class attribute.

  Methods Documentation

  classmethod from_cartesian(other, base=None)

    Convert the differential from 3D rectangular cartesian coordinates to the desired class.

    Parameters:
      other

        The object to convert into this differential.

      base `BaseRepresentation`

        The points for which the differentials are to be converted: each of the components is multiplied by its unit vectors and scale factors. Will be converted to `cls.base_representation` if needed.

    Returns:
      `BaseDifferential` subclass instance

        A new differential object that is this class’ type.

  get_d_xyz(xyz_axis=0)

    Return a vector array of the x, y, and z coordinates.

    Parameters:
      xyz_axis `python:int`, optional

        The axis in the final array along which the x, y, z components should be stored (default: 0).

    Returns:
      d_xyz `Quantity`

        With dimension 3 along `xyz_axis`. Note that, if possible, this will be a view.

  to_cartesian(base=None)

    Convert the differential to 3D rectangular cartesian coordinates.

    Parameters:
      base instance of `self.base_representation`

        The points for which the differentials are to be converted: each of the components is multiplied by its unit vectors and scale factors.

    Returns:
      `CartesianDifferential`

        This object, converted.

  transform(matrix, base=None, transformed_base=None)

    Transform differentials using a 3x3 matrix in a Cartesian basis.

    This returns a new differential and does not modify the original one.

    Parameters:
      matrix(3,3) numpy:array_like

        A 3x3 (or stack thereof) matrix, such as a rotation matrix.

      base, transformed_base `CartesianRepresentation` or `python:None`, optional

        Not used in the Cartesian transformation.