Skip to main content
`Ctrl`+`K`

# BaseDifferential

class astropy.coordinates.BaseDifferential(*args, **kwargs)

  Bases: `BaseRepresentationOrDifferential`

  A base class representing differentials of representations.

  These represent differences or derivatives along each component. E.g., for physics spherical coordinates, these would be \(\delta r, \delta \theta, \delta \phi\).

  Parameters:
    d_comp1, d_comp2, d_comp3 `Quantity` or subclass

      The components of the 3D differentials. The names are the keys and the subclasses the values of the `attr_classes` attribute.

    copy bool, optional

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

  Notes

  All differential representation classes should subclass this base class, and define an `base_representation` attribute with the class of the regular `BaseRepresentation` for which differential coordinates are provided. This will set up a default `attr_classes` instance with names equal to the base component names prefixed by `d_`, and all classes set to `Quantity`, plus properties to access those, and a default `__init__` for initialization.

  Attributes Summary

  `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.
  `from_representation`(representation, base) | Create a new instance of this representation from another one.
  `norm`([base]) | Vector norm.
  `represent_as`(other_class, base) | Convert coordinates to another representation.
  `to_cartesian`(base) | Convert the differential to 3D rectangular cartesian coordinates.
  `transform`(matrix, base, transformed_base) | Transform differential using a 3x3 matrix in a Cartesian basis.

  Attributes Documentation

  name = 'base'

    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)

    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.

  classmethod from_representation(representation, base)

    Create a new instance of this representation from another one.

    Parameters:
      representation `BaseRepresentation` instance

        The presentation that should be converted to this class.

      base instance of `cls.base_representation`

        The base relative to which the differentials will be defined. If the representation is a differential itself, the base will be converted to its `base_representation` to help convert it.

  norm(base=None)

    Vector norm.

    The norm is the standard Frobenius norm, i.e., the square root of the sum of the squares of all components with non-angular units.

    Parameters:
      base instance of `self.base_representation`

        Base relative to which the differentials are defined. This is required to calculate the physical size of the differential for all but Cartesian differentials or radial differentials.

    Returns:
      norm `astropy.units.Quantity`

        Vector norm, with the same shape as the representation.

  represent_as(other_class, base)

    Convert coordinates to another representation.

    If the instance is of the requested class, it is returned unmodified. By default, conversion is done via cartesian coordinates.

    Parameters:
      other_class `BaseRepresentation` subclass

        The type of representation to turn the coordinates into.

      base instance of `self.base_representation`

        Base relative to which the differentials are defined. If the other class is a differential representation, the base will be converted to its `base_representation`.

  to_cartesian(base)

    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, transformed_base)

    Transform differential 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 instance of `cls.base_representation`

        Base relative to which the differentials are defined. If the other class is a differential representation, the base will be converted to its `base_representation`.

      transformed_base instance of `cls.base_representation`

        Base relative to which the transformed differentials are defined. If the other class is a differential representation, the base will be converted to its `base_representation`.