# xarray.align

`xarray.``align`(*objects, join='inner', copy=True, indexes=None, exclude=frozenset(), fill_value=<NA>)

  Given any number of Dataset and/or DataArray objects, returns new objects with aligned indexes and dimension sizes.

  Array from the aligned objects are suitable as input to mathematical operators, because along each dimension they have the same index and size.

  Missing values (if `join != 'inner'`) are filled with `fill_value`. The default fill value is NaN.

  Parameters:

  - *objects (Dataset or DataArray) – Objects to align.
  - join ({'outer', 'inner', 'left', 'right', 'exact', 'override'}, optional) –

    Method for joining the indexes of the passed objects along each dimension:

    - ’outer’: use the union of object indexes
    - ’inner’: use the intersection of object indexes
    - ’left’: use indexes from the first object with each dimension
    - ’right’: use indexes from the last object with each dimension
    - ’exact’: instead of aligning, raise ValueError when indexes to be aligned are not equal
    - ’override’: if indexes are of same size, rewrite indexes to be those of the first object with that dimension. Indexes for the same dimension must have the same size in all objects.
  - copy (bool, optional) – If `copy=True`, data in the return values is always copied. If `copy=False` and reindexing is unnecessary, or can be performed with only slice operations, then the output may share memory with the input. In either case, new xarray objects are always returned.
  - indexes (dict-like, optional) – Any indexes explicitly provided with the indexes argument should be used in preference to the aligned indexes.
  - exclude (sequence of str, optional) – Dimensions that must be excluded from alignment
  - fill_value (scalar, optional) – Value to use for newly missing values

  Returns: | aligned – Tuple of objects with aligned coordinates.
  Return type: | same as *objects
  Raises: | `ValueError` – If any dimensions without labels on the arguments have different sizes, or a different size than the size of the aligned dimension labels.

  Examples

      >>> import xarray as xr
      >>> x = xr.DataArray([[25, 35], [10, 24]], dims=('lat', 'lon'),
      ...              coords={'lat': [35., 40.], 'lon': [100., 120.]})
      >>> y = xr.DataArray([[20, 5], [7, 13]], dims=('lat', 'lon'),
      ...              coords={'lat': [35., 42.], 'lon': [100., 120.]})

      >>> x
      <xarray.DataArray (lat: 2, lon: 2)>
      array([[25, 35],
             [10, 24]])
      Coordinates:
      * lat      (lat) float64 35.0 40.0
      * lon      (lon) float64 100.0 120.0

      >>> y
      <xarray.DataArray (lat: 2, lon: 2)>
      array([[20,  5],
             [ 7, 13]])
      Coordinates:
      * lat      (lat) float64 35.0 42.0
      * lon      (lon) float64 100.0 120.0

      >>> a, b = xr.align(x, y)
      >>> a
      <xarray.DataArray (lat: 1, lon: 2)>
      array([[25, 35]])
      Coordinates:
      * lat      (lat) float64 35.0
      * lon      (lon) float64 100.0 120.0
      >>> b
      <xarray.DataArray (lat: 1, lon: 2)>
      array([[20,  5]])
      Coordinates:
      * lat      (lat) float64 35.0
      * lon      (lon) float64 100.0 120.0

      >>> a, b = xr.align(x, y, join='outer')
      >>> a
      <xarray.DataArray (lat: 3, lon: 2)>
      array([[25., 35.],
             [10., 24.],
             [nan, nan]])
      Coordinates:
      * lat      (lat) float64 35.0 40.0 42.0
      * lon      (lon) float64 100.0 120.0
      >>> b
      <xarray.DataArray (lat: 3, lon: 2)>
      array([[20.,  5.],
             [nan, nan],
             [ 7., 13.]])
      Coordinates:
      * lat      (lat) float64 35.0 40.0 42.0
      * lon      (lon) float64 100.0 120.0

      >>> a, b = xr.align(x, y, join='outer', fill_value=-999)
      >>> a
      <xarray.DataArray (lat: 3, lon: 2)>
      array([[  25,   35],
             [  10,   24],
             [-999, -999]])
      Coordinates:
      * lat      (lat) float64 35.0 40.0 42.0
      * lon      (lon) float64 100.0 120.0
      >>> b
      <xarray.DataArray (lat: 3, lon: 2)>
      array([[  20,    5],
             [-999, -999],
             [   7,   13]])
      Coordinates:
      * lat      (lat) float64 35.0 40.0 42.0
      * lon      (lon) float64 100.0 120.0

      >>> a, b = xr.align(x, y, join='left')
      >>> a
      <xarray.DataArray (lat: 2, lon: 2)>
      array([[25, 35],
             [10, 24]])
      Coordinates:
      * lat      (lat) float64 35.0 40.0
      * lon      (lon) float64 100.0 120.0
      >>> b
      <xarray.DataArray (lat: 2, lon: 2)>
      array([[20.,  5.],
             [nan, nan]])
      Coordinates:
      * lat      (lat) float64 35.0 40.0
      * lon      (lon) float64 100.0 120.0

      >>> a, b = xr.align(x, y, join='right')
      >>> a
      <xarray.DataArray (lat: 2, lon: 2)>
      array([[25., 35.],
             [nan, nan]])
      Coordinates:
      * lat      (lat) float64 35.0 42.0
      * lon      (lon) float64 100.0 120.0
      >>> b
      <xarray.DataArray (lat: 2, lon: 2)>
      array([[20,  5],
             [ 7, 13]])
      Coordinates:
      * lat      (lat) float64 35.0 42.0
      * lon      (lon) float64 100.0 120.0

      >>> a, b = xr.align(x, y, join='exact')
      Traceback (most recent call last):
      ...
          "indexes along dimension {!r} are not equal".format(dim)
      ValueError: indexes along dimension 'lat' are not equal

      >>> a, b = xr.align(x, y, join='override')
      >>> a
      <xarray.DataArray (lat: 2, lon: 2)>
      array([[25, 35],
             [10, 24]])
      Coordinates:
      * lat      (lat) float64 35.0 40.0
      * lon      (lon) float64 100.0 120.0
      >>> b
      <xarray.DataArray (lat: 2, lon: 2)>
      array([[20,  5],
             [ 7, 13]])
      Coordinates:
      * lat      (lat) float64 35.0 40.0
      * lon      (lon) float64 100.0 120.0