available_processes.json

[
  {
    "id": "absolute",
    "summary": "Absolute value",
    "description": "Computes the absolute value of a real number `x`, which is the \"unsigned\" portion of x and often denoted as *|x|*.\n\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "A number.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed absolute value.",
      "schema": {
        "type": [
          "number",
          "null"
        ],
        "minimum": 0
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 0
        },
        "returns": 0
      },
      {
        "arguments": {
          "x": 3.5
        },
        "returns": 3.5
      },
      {
        "arguments": {
          "x": -0.4
        },
        "returns": 0.4
      },
      {
        "arguments": {
          "x": -3.5
        },
        "returns": 3.5
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/AbsoluteValue.html",
        "title": "Absolute value explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "add",
    "summary": "Addition of two numbers",
    "description": "Sums up the two numbers `x` and `y` (*x + y*) and returns the computed sum.\n\nNo-data values are taken into account so that `null` is returned if any element is such a value.\n\nThe computations follow [IEEE Standard 754](https://ieeexplore.ieee.org/document/8766229) whenever the processing environment supports it.",
    "categories": [
      "math"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "The first summand.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      },
      {
        "name": "y",
        "description": "The second summand.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed sum of the two numbers.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 5,
          "y": 2.5
        },
        "returns": 7.5
      },
      {
        "arguments": {
          "x": -2,
          "y": -4
        },
        "returns": -6
      },
      {
        "arguments": {
          "x": 1,
          "y": null
        },
        "returns": null
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/Sum.html",
        "title": "Sum explained by Wolfram MathWorld"
      },
      {
        "rel": "about",
        "href": "https://ieeexplore.ieee.org/document/8766229",
        "title": "IEEE Standard 754-2019 for Floating-Point Arithmetic"
      }
    ]
  },
  {
    "id": "add_dimension",
    "summary": "Add a new dimension",
    "description": "Adds a new named dimension to the data cube.\n\nAfterwards, the dimension can be referenced with the specified `name`. If a dimension with the specified name exists, the process fails with a `DimensionExists` error. The dimension label of the dimension is set to the specified `label`.",
    "categories": [
      "cubes"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "A data cube to add the dimension to.",
        "schema": {
          "type": "object",
          "subtype": "raster-cube"
        }
      },
      {
        "name": "name",
        "description": "Name for the dimension.",
        "schema": {
          "type": "string"
        }
      },
      {
        "name": "label",
        "description": "A dimension label.",
        "schema": [
          {
            "type": "number"
          },
          {
            "type": "string"
          }
        ]
      },
      {
        "name": "type",
        "description": "The type of dimension, defaults to `other`.",
        "schema": {
          "type": "string",
          "enum": [
            "spatial",
            "temporal",
            "bands",
            "other"
          ]
        },
        "default": "other",
        "optional": true
      }
    ],
    "returns": {
      "description": "The data cube with a newly added dimension. The new dimension has exactly one dimension label. All other dimensions remain unchanged.",
      "schema": {
        "type": "object",
        "subtype": "raster-cube"
      }
    },
    "exceptions": {
      "DimensionExists": {
        "message": "A dimension with the specified name already exists."
      }
    }
  },
  {
    "id": "aggregate_temporal_frequency",
    "summary": "Temporal aggregations based on frequencies",
    "description": "Computes a temporal aggregation based on calendar hierarchies such as year, month, week or seasons. For other calendar hierarchies ``aggregate_temporal()`` can be used.\n\nFor each interval, all data along the dimension will be passed through the reducer.\n\nIf the dimension is not set or is set to `null`, the data cube is expected to only have one temporal dimension.",
    "categories": [
      "aggregate & resample",
      "climatology",
      "cubes"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "A data cube.",
        "schema": {
          "type": "object",
          "subtype": "raster-cube"
        }
      },
      {
        "name": "frequency",
        "description": "The time intervals to aggregate. The following pre-defined values are available:\n\n* `hourly`: Hour of the day\n* `daily`: Day of the year\n* `weekly`: Week of the year\n* `monthly`: Month of the year\n* `yearly`: Proleptic years\n* `seasons`: Refers to three month periods of the calendar seasons (December - February, March - May, June - August, September - November).\n* `tropical_seasons`: Refers to the six month periods of the tropical seasons (November - April, Mai - October).",
        "schema": {
          "type": "string",
          "enum": [
            "hourly",
            "daily",
            "weekly",
            "monthly",
            "yearly",
            "seasons",
            "tropical_seasons"
          ]
        }
      },
      {
        "name": "reducer",
        "description": "A reducer to be applied on all values along the specified dimension. A reducer is a single process such as ``mean()`` or a set of processes, which computes a single value for a list of values, see the category 'reducer' for such processes.",
        "schema": {
          "type": "object",
          "subtype": "process-graph",
          "parameters": [
            {
              "name": "data",
              "description": "A labeled array with elements of any type.",
              "schema": {
                "type": "array",
                "subtype": "labeled-array",
                "items": {
                  "description": "Any data type."
                }
              }
            },
            {
              "name": "context",
              "description": "Additional data passed by the user.",
              "schema": {
                "description": "Any data type."
              },
              "optional": true,
              "default": null
            }
          ]
        }
      },
      {
        "name": "dimension",
        "description": "The name of the temporal dimension for aggregation. All data along the dimension will be passed through the specified reducer. If the dimension is not set or set to `null`, the data cube is expected to only have one temporal dimension. Fails with a `TooManyDimensions` error if it has more dimensions. Fails with a `DimensionNotAvailable` error if the specified dimension does not exist.\n\n**Note:** The default dimensions a data cube provides are described in the collection's metadata field `cube:dimensions`.",
        "schema": {
          "type": [
            "string",
            "null"
          ]
        },
        "default": null,
        "optional": true
      },
      {
        "name": "context",
        "description": "Additional data to be passed to the reducer.",
        "schema": {
          "description": "Any data type."
        },
        "optional": true,
        "default": null
      }
    ],
    "returns": {
      "description": "A data cube with potentially lower resolution and cardinality, but the same number of dimensions as the original data cube. The specified temporal dimension has the following dimension labels (`YYYY` = four-digit year, `MM` = two-digit month, `DD` two-digit day of month):\n\n* `hourly`: `YYYY-MM-DD-0` - `YYYY-MM-DD-23`\n* `daily`: `YYYY-1` - `YYYY-365`\n* `weekly`: `YYYY-1` - `YYYY-52`\n* `monthly`: `YYYY-1` - `YYYY-12`\n* `yearly`: `YYYY`\n* `seasons`: `YYYY-djf` (December - February), `YYYY-mam` (March - May), `YYYY-jja` (June - August), `YYYY-son` (September - November).\n* `tropical_seasons`: `YYYY-ndjfma` (November - April), `YYYY-mjjaso` (May - October).",
      "schema": {
        "type": "object",
        "subtype": "raster-cube"
      }
    },
    "exceptions": {
      "TooManyDimensions": {
        "message": "The data cube contains multiple temporal dimensions. The parameter `dimension` must be specified."
      },
      "DimensionNotAvailable": {
        "message": "A dimension with the specified name does not exist."
      },
      "DistinctDimensionLabelsRequired": {
        "message": "The dimension labels have duplicate values. Distinct labels must be specified."
      }
    },
    "links": [
      {
        "href": "https://open-eo.github.io/openeo-api/glossary/#aggregation-and-resampling",
        "rel": "about",
        "title": "Aggregation explained in the openEO glossary"
      }
    ]
  },
  {
    "id": "anomaly",
    "summary": "Computes anomalies",
    "description": "Computes anomalies based on normals for a specific temporal frequency.",
    "categories": [
      "climatology",
      "cubes",
      "math"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "A data cube with exactly one temporal dimension and the following dimension labels for the given frequency (`YYYY` = four-digit year, `MM` = two-digit month, `DD` two-digit day of month):\n\n* `hourly`: `YYYY-MM-DD-0` - `YYYY-MM-DD-23`\n* `daily`: `YYYY-1` - `YYYY-365`\n* `weekly`: `YYYY-1` - `YYYY-52`\n* `monthly`: `YYYY-1` - `YYYY-12`\n* `yearly`: `YYYY`\n* `single_period` / `climatology_period`: A single dimension label with any name is expected.\n* `seasons`: `YYYY-djf` (December - February), `YYYY-mam` (March - May), `YYYY-jja` (June - August), `YYYY-son` (September - November)\n* `tropical_seasons`: `YYYY-ndjfma` (November - April), `YYYY-mjjaso` (May - October)\n\n``aggregate_temporal_frequency()`` can compute such a data cube.",
        "schema": {
          "type": "object",
          "subtype": "raster-cube"
        }
      },
      {
        "name": "normals",
        "description": "A data cube with normals, e.g. daily, monthly or yearly values computed from a process such as ``climatological_normal()``. Must contain exactly one temporal dimension with the following dimension labels for the given frequency:\n\n* `hourly`: `0` - `23`\n* `daily`: `1` - `365`\n* `weekly`: `1` - `52`\n* `monthly`: `1` - `12`\n* `yearly`: Four-digit year numbers\n* `single_period` / `climatology_period`: A single dimension label with any name is expected.\n* `seasons`: `djf` (December - February), `mam` (March - May), `jja` (June - August), `son` (September - November)\n* `tropical_seasons`: `ndjfma` (November - April), `mjjaso` (May - October)",
        "schema": {
          "type": "object",
          "subtype": "raster-cube"
        }
      },
      {
        "name": "frequency",
        "description": "Specifies the time intervals available in the data cubes. The following options are available:\n\n* `hourly`: Hour of the day\n* `daily`: Day of the year\n* `weekly`: Week of the year\n* `monthly`: Month of the year\n* `yearly`: Proleptic years\n* `seasons`: Refers to three month periods of the calendar seasons (December - February, March - May, June - August, September - November).\n* `tropical_seasons`: Refers to the six month periods of the tropical seasons (November - April, Mai - October).",
        "schema": {
          "type": "string",
          "enum": [
            "hourly",
            "daily",
            "weekly",
            "monthly",
            "yearly",
            "single_period",
            "climatology_period",
            "seasons",
            "tropical_seasons"
          ]
        }
      }
    ],
    "returns": {
      "description": "A data cube. The cardinality, resolution, the number of dimensions and the dimension labels are the same as for the original data cube.",
      "schema": {
        "type": "object",
        "subtype": "raster-cube"
      }
    }
  },
  {
    "id": "apply",
    "summary": "Apply a process to each pixel",
    "description": "Applies a *unary* process to each pixel value in the data cube (i.e. a local operation). A unary process takes a single value and returns a single value, for example ``abs()`` or ``linear_scale_range()``. In contrast, the process ``apply_dimension()`` applies a process to all pixel values along a particular dimension.",
    "categories": [
      "cubes"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "A data cube.",
        "schema": {
          "type": "object",
          "subtype": "raster-cube"
        }
      },
      {
        "name": "process",
        "description": "A unary process to be applied on each value, may consist of multiple sub-processes.",
        "schema": {
          "type": "object",
          "subtype": "process-graph",
          "parameters": [
            {
              "name": "x",
              "description": "The value to process.",
              "schema": {
                "description": "Any data type."
              }
            },
            {
              "name": "context",
              "description": "Additional data passed by the user.",
              "schema": {
                "description": "Any data type."
              },
              "optional": true,
              "default": null
            }
          ]
        }
      },
      {
        "name": "context",
        "description": "Additional data to be passed to the process.",
        "schema": {
          "description": "Any data type."
        },
        "optional": true,
        "default": null
      }
    ],
    "returns": {
      "description": "A data cube with the newly computed values and the same dimensions. The dimension properties (name, type, labels, reference system and resolution) remain unchanged.",
      "schema": {
        "type": "object",
        "subtype": "raster-cube"
      }
    }
  },
  {
    "id": "arccos",
    "summary": "Inverse cosine",
    "description": "Computes the arc cosine of `x`. The arc cosine is the inverse function of the cosine so that *arccos(cos(x)) = x*.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math > trigonometric"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "A number.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed angle in radians.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 1
        },
        "returns": 0
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/InverseCosine.html",
        "title": "Inverse cosine explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "arcosh",
    "summary": "Inverse hyperbolic cosine",
    "description": "Computes the inverse hyperbolic cosine of `x`. It is the inverse function of the hyperbolic cosine so that *arcosh(cosh(x)) = x*.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math > trigonometric"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "A number.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed angle in radians.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 1
        },
        "returns": 0
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/InverseHyperbolicCosine.html",
        "title": "Inverse hyperbolic cosine explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "arcsin",
    "summary": "Inverse sine",
    "description": "Computes the arc sine of `x`. The arc sine is the inverse function of the sine so that *arcsin(sin(x)) = x*.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math > trigonometric"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "A number.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed angle in radians.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 0
        },
        "returns": 0
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/InverseSine.html",
        "title": "Inverse sine explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "arctan",
    "summary": "Inverse tangent",
    "description": "Computes the arc tangent of `x`. The arc tangent is the inverse function of the tangent so that *arctan(tan(x)) = x*.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math > trigonometric"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "A number.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed angle in radians.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 0
        },
        "returns": 0
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/InverseTangent.html",
        "title": "Inverse tangent explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "array_element",
    "summary": "Get an element from an array",
    "description": "Returns the element with the specified index or label from the array.\n\nEither the parameter `index` or `label` must be specified, otherwise the `ArrayElementParameterMissing` exception is thrown. If both parameters are set the `ArrayElementParameterConflict` exception is thrown.",
    "categories": [
      "arrays",
      "reducer"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "An array.",
        "schema": {
          "type": "array",
          "items": {
            "description": "Any data type is allowed."
          }
        }
      },
      {
        "name": "index",
        "description": "The zero-based index of the element to retrieve.",
        "schema": {
          "type": "integer"
        },
        "optional": true
      },
      {
        "name": "label",
        "description": "The label of the element to retrieve.",
        "schema": [
          {
            "type": "number"
          },
          {
            "type": "string"
          }
        ],
        "optional": true
      },
      {
        "name": "return_nodata",
        "description": "By default this process throws an `ArrayElementNotAvailable` exception if the index or label is invalid. If you want to return `null` instead, set this flag to `true`.",
        "schema": {
          "type": "boolean"
        },
        "default": false,
        "optional": true
      }
    ],
    "returns": {
      "description": "The value of the requested element.",
      "schema": {
        "description": "Any data type is allowed."
      }
    },
    "exceptions": {
      "ArrayElementNotAvailable": {
        "message": "The array has no element with the specified index or label."
      },
      "ArrayElementParameterMissing": {
        "message": "The process 'array_element' requires either the 'index' or 'labels' parameter to be set."
      },
      "ArrayElementParameterConflict": {
        "message": "The process 'array_element' only allows that either the 'index' or the 'labels' parameter is set."
      }
    },
    "examples": [
      {
        "arguments": {
          "data": [
            9,
            8,
            7,
            6,
            5
          ],
          "index": 2
        },
        "returns": 7
      },
      {
        "arguments": {
          "data": [
            "A",
            "B",
            "C"
          ],
          "index": 0
        },
        "returns": "A"
      },
      {
        "arguments": {
          "data": [],
          "index": 0,
          "return_nodata": true
        },
        "returns": null
      }
    ]
  },
  {
    "id": "arsinh",
    "summary": "Inverse hyperbolic sine",
    "description": "Computes the inverse hyperbolic sine of `x`. It is the inverse function of the hyperbolic sine so that *arsinh(sinh(x)) = x*.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math > trigonometric"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "A number.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed angle in radians.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 0
        },
        "returns": 0
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/InverseHyperbolicSine.html",
        "title": "Inverse hyperbolic sine explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "artanh",
    "summary": "Inverse hyperbolic tangent",
    "description": "Computes the inverse hyperbolic tangent of `x`. It is the inverse function of the hyperbolic tangent so that *artanh(tanh(x)) = x*.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math > trigonometric"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "A number.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed angle in radians.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 0
        },
        "returns": 0
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/InverseHyperbolicTangent.html",
        "title": "Inverse hyperbolic tangent explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "ceil",
    "summary": "Round fractions up",
    "description": "The least integer greater than or equal to the number `x`.\n\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math > rounding"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "A number to round up.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The number rounded up.",
      "schema": {
        "type": [
          "integer",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 0
        },
        "returns": 0
      },
      {
        "arguments": {
          "x": 3.5
        },
        "returns": 4
      },
      {
        "arguments": {
          "x": -0.4
        },
        "returns": 0
      },
      {
        "arguments": {
          "x": -3.5
        },
        "returns": -3
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/CeilingFunction.html",
        "title": "Ceiling explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "climatological_normal",
    "summary": "Computes climatology normals",
    "description": "Climatological normal period is a usually 30-year average of a weather variable. Climatological normals are used as an average or baseline to evaluate climate events and provide context for yearly, monthly, daily or seasonal variability. The default climatology period is from 1981 until 2010 (both inclusive).",
    "categories": [
      "climatology"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "A data cube with exactly one temporal dimension. The datacube must span at least the temporal interval specified in the parameter `climatology_period`.\n\nSeasonal periods may span two consecutive years, e.g. temporal winter that includes months December, January and February. If the required months before the actual climate period are available, the season is taken into account. If not available, the first season is not taken into account and the seasonal mean is based on one year less than the other seasonal normals. The incomplete season at the end of the last year is never taken into account.",
        "schema": {
          "type": "object",
          "subtype": "raster-cube"
        }
      },
      {
        "name": "frequency",
        "description": "The time intervals to aggregate the average value for. The following pre-defined frequencies are supported:\n\n* `daily`: Day of the year\n* `monthly`: Month of the year\n* `climatology_period`: The period specified in the `climatology_period`.\n* `seasons`: Refers to three month periods of the calendar seasons (December - February, March - May, June - August, September - November).\n* `tropical_seasons`: Refers to the six month periods of the tropical seasons (November - April, Mai - October).",
        "schema": {
          "type": "string",
          "enum": [
            "daily",
            "monthly",
            "seasons",
            "tropical_seasons",
            "climatology_period"
          ]
        }
      },
      {
        "name": "climatology_period",
        "description": "Closed temporal interval. The first element of the array is the first year to be fully included in the temporal interval. The second element is the last year to be fully included in the temporal interval. The default period is from 1981 until 2010 (both inclusive).",
        "schema": {
          "type": "array",
          "subtype": "temporal-interval",
          "minItems": 2,
          "maxItems": 2,
          "items": {
            "type": "string",
            "subtype": "year",
            "minLength": 4,
            "maxLength": 4,
            "pattern": "^\\d{4}$"
          }
        },
        "default": [
          "1981",
          "2010"
        ],
        "optional": true
      }
    ],
    "returns": {
      "description": "A data cube with potentially cardinality, but the same resolution and number of dimensions as the original data cube. The temporal dimension has the following dimension labels:\n\n* `daily`: `1` - `365`\n* `monthly`: `1` - `12`\n* `climatology_period`: `climatology_period`\n* `seasons`: `djf` (December - February), `mam` (March - May), `jja` (June - August), `son` (September - November)\n* `tropical_seasons`: `ndjfma` (November - April), `mjjaso` (May - October)",
      "schema": {
        "type": "object",
        "subtype": "raster-cube"
      }
    },
    "links": [
      {
        "rel": "about",
        "href": "https://en.wikipedia.org/wiki/Climatological_normal",
        "title": "Background information on climatology normal by Wikipedia"
      }
    ]
  },
  {
    "id": "clip",
    "summary": "Clip a value between a minimum and a maximum",
    "description": "Clips a number between specified minimum and maximum values. A value larger than the maximal value will have the maximal value, a value lower than minimal value will have the minimal value.\n\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "A number.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      },
      {
        "name": "min",
        "description": "Minimum value. If the value is lower than this value, the process will return the value of this parameter.",
        "schema": {
          "type": "number"
        }
      },
      {
        "name": "max",
        "description": "Maximum value. If the value is greater than this value, the process will return the value of this parameter.",
        "schema": {
          "type": "number"
        }
      }
    ],
    "returns": {
      "description": "The value clipped to the specified range.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": -5,
          "min": -1,
          "max": 1
        },
        "returns": -1
      },
      {
        "arguments": {
          "x": 10.001,
          "min": 1,
          "max": 10
        },
        "returns": 10
      },
      {
        "arguments": {
          "x": 1e-06,
          "min": 0,
          "max": 0.02
        },
        "returns": 1e-06
      },
      {
        "arguments": {
          "x": null,
          "min": 0,
          "max": 1
        },
        "returns": null
      }
    ]
  },
  {
    "id": "cos",
    "summary": "Cosine",
    "description": "Computes the cosine of `x`.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math > trigonometric"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "An angle in radians.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed cosine of `x`.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 0
        },
        "returns": 1
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/Cosine.html",
        "title": "Cosine explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "cosh",
    "summary": "Hyperbolic cosine",
    "description": "Computes the hyperbolic cosine of `x`.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math > trigonometric"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "An angle in radians.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed hyperbolic cosine of `x`.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 0
        },
        "returns": 1
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/HyperbolicCosine.html",
        "title": "Hyperbolic cosine explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "create_raster_cube",
    "summary": "Create an empty raster data cube",
    "description": "Creates a new raster data cube without dimensions. Dimensions can be added with ``add_dimension()``.",
    "categories": [
      "cubes"
    ],
    "parameters": [],
    "returns": {
      "description": "An empty raster data cube with zero dimensions.",
      "schema": {
        "type": "object",
        "subtype": "raster-cube"
      }
    }
  },
  {
    "id": "debug",
    "summary": "Publish debugging information",
    "description": "Sends debugging information about the data to the log output. Passes the data through.",
    "categories": [
      "development"
    ],
    "experimental": true,
    "parameters": [
      {
        "name": "data",
        "description": "Data to publish.",
        "schema": {
          "description": "Any data type is allowed."
        }
      },
      {
        "name": "code",
        "description": "An identifier to help identify the log entry in a bunch of other log entries.",
        "schema": {
          "type": "string"
        },
        "default": "",
        "optional": true
      },
      {
        "name": "level",
        "description": "The severity level of this message, defaults to `info`. Note that the level `error` forces the computation to be stopped!",
        "schema": {
          "type": "string",
          "enum": [
            "error",
            "warning",
            "info",
            "debug"
          ]
        },
        "default": "info",
        "optional": true
      },
      {
        "name": "message",
        "description": "A message to send in addition to the data.",
        "schema": {
          "type": "string"
        },
        "default": "",
        "optional": true
      }
    ],
    "returns": {
      "description": "The data as passed to the `data` parameter without any modification.",
      "schema": {
        "description": "Any data type is allowed."
      }
    }
  },
  {
    "id": "dimension_labels",
    "summary": "Get the dimension labels",
    "description": "Returns all labels for a dimension in the data cube. The labels have the same order as in the data cube.",
    "categories": [
      "cubes"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "The data cube.",
        "schema": {
          "type": "object",
          "subtype": "raster-cube"
        }
      },
      {
        "name": "dimension",
        "description": "The name of the dimension to get the labels for.",
        "schema": {
          "type": "string"
        }
      }
    ],
    "returns": {
      "description": "The labels as array.",
      "schema": {
        "type": "array",
        "items": {
          "anyOf": [
            {
              "type": "number"
            },
            {
              "type": "string"
            }
          ]
        }
      }
    }
  },
  {
    "id": "divide",
    "summary": "Division of two numbers",
    "description": "Divides argument `x` by the argument `y` (*x / y*) and returns the computed result.\n\nNo-data values are taken into account so that `null` is returned if any element is such a value.\n\nThe computations follow [IEEE Standard 754](https://ieeexplore.ieee.org/document/8766229) whenever the processing environment supports it. Therefore, a division by zero results in \u00b1infinity if the processing environment supports it. Otherwise a `DivisionByZero` error must the thrown.",
    "categories": [
      "math"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "The dividend.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      },
      {
        "name": "y",
        "description": "The divisor.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed result.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "exceptions": {
      "DivisionByZero": {
        "message": "Division by zero is not supported."
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 5,
          "y": 2.5
        },
        "returns": 2
      },
      {
        "arguments": {
          "x": -2,
          "y": 4
        },
        "returns": -0.5
      },
      {
        "arguments": {
          "x": 1,
          "y": null
        },
        "returns": null
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/Division.html",
        "title": "Division explained by Wolfram MathWorld"
      },
      {
        "rel": "about",
        "href": "https://ieeexplore.ieee.org/document/8766229",
        "title": "IEEE Standard 754-2019 for Floating-Point Arithmetic"
      }
    ]
  },
  {
    "id": "drop_dimension",
    "summary": "Remove a dimension",
    "description": "Drops a dimension from the data cube.\n\nDropping a dimension only works on dimensions with a single dimension label left, otherwise the process fails with a `DimensionLabelCountMismatch` error. Dimension values can be reduced to a single value with a filter such as ``filter_bands()`` or the ``reduce_dimension()`` process. If a dimension with the specified name does not exist, the process fails with a `DimensionNotAvailable` error.",
    "categories": [
      "cubes"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "The data cube to drop a dimension from.",
        "schema": {
          "type": "object",
          "subtype": "raster-cube"
        }
      },
      {
        "name": "name",
        "description": "Name of the dimension to drop.",
        "schema": {
          "type": "string"
        }
      }
    ],
    "returns": {
      "description": "A data cube without the specified dimension. The number of dimensions decreases by one, but the dimension properties (name, type, labels, reference system and resolution) for all other dimensions remain unchanged.",
      "schema": {
        "type": "object",
        "subtype": "raster-cube"
      }
    },
    "exceptions": {
      "DimensionLabelCountMismatch": {
        "message": "The number of dimension labels exceeds one, which requires a reducer."
      },
      "DimensionNotAvailable": {
        "message": "A dimension with the specified name does not exist."
      }
    }
  },
  {
    "id": "e",
    "summary": "Euler's number (e)",
    "description": "The real number *e* is a mathematical constant that is the base of the natural logarithm such that *ln(e) = 1*. The numerical value is approximately *2.71828*.",
    "categories": [
      "math > constants",
      "math > exponential & logarithmic"
    ],
    "parameters": [],
    "returns": {
      "description": "The numerical value of Euler's number.",
      "schema": {
        "type": "number"
      }
    },
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/e.html",
        "title": "Mathematical constant e explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "exp",
    "summary": "Exponentiation to the base e",
    "description": "Exponential function to the base *e* raised to the power of `p`.\n\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math > exponential & logarithmic"
    ],
    "parameters": [
      {
        "name": "p",
        "description": "The numerical exponent.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed value for *e* raised to the power of `p`.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "p": 0
        },
        "returns": 1
      },
      {
        "arguments": {
          "p": null
        },
        "returns": null
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/ExponentialFunction.html",
        "title": "Exponential function explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "filter_bands",
    "summary": "Filter the bands by name",
    "description": "Filters the bands in the data cube so that bands that don't match any of the criteria are dropped from the data cube. The data cube is expected to have only one dimension of type `bands`. Fails with a `DimensionMissing` error if no such dimension exists.\n\nThe following criteria can be used to select bands:\n\n* `bands`: band name or common band name (e.g. `B01`, `B8A`, `red` or `nir`)\n* `wavelengths`: ranges of wavelengths in micrometres (\u03bcm) (e.g. 0.5 - 0.6)\n\nAll these information are exposed in the band metadata of the collection. To keep algorithms interoperable it is recommended to prefer the common bands names or the wavelengths over collection and/or back-end specific band names.\n\nIf multiple criteria are specified, any of them must match and not all of them, i.e. they are combined with an OR-operation. If no criteria is specified, the `BandFilterParameterMissing` exception must be thrown.\n\n**Important:** The order of the specified array defines the order of the bands in the data cube, which can be important for subsequent processes. If multiple bands are matched by a single criterion (e.g. a range of wavelengths), they stay in the original order.",
    "categories": [
      "cubes",
      "filter"
    ],
    "gee:custom": true,
    "parameters": [
      {
        "name": "data",
        "description": "A data cube with bands.",
        "schema": {
          "type": "object",
          "subtype": "raster-cube"
        }
      },
      {
        "name": "bands",
        "description": "A list of band names. Either the unique band name (metadata field `name` in bands) or one of the common band names (metadata field `common_name` in bands). If unique band name and common name conflict, the unique band name has higher priority.\n\nThe order of the specified array defines the order of the bands in the data cube. If multiple bands match a common name, all matched bands are included in the original order.",
        "schema": {
          "type": "array",
          "items": {
            "type": "string",
            "subtype": "band-name"
          }
        },
        "default": [],
        "optional": true
      }
    ],
    "returns": {
      "description": "A data cube limited to a subset of its original bands. The dimensions and dimension properties (name, type, labels, reference system and resolution) remain unchanged, except that the dimension of type `bands` has less (or the same) dimension labels.",
      "schema": {
        "type": "object",
        "subtype": "raster-cube"
      }
    },
    "exceptions": {
      "BandFilterParameterMissing": {
        "message": "The process 'filter_bands' requires any of the parameters 'bands', 'common_names' or 'wavelengths' to be set."
      },
      "DimensionMissing": {
        "message": "A band dimension is missing."
      }
    },
    "links": [
      {
        "rel": "about",
        "href": "https://github.com/radiantearth/stac-spec/tree/master/extensions/eo#common-band-names",
        "title": "List of common band names as specified by the STAC specification"
      }
    ]
  },
  {
    "id": "filter_bbox",
    "summary": "Spatial filter using a bounding box",
    "description": "Limits the data cube to the specified bounding box.\n\nThe filter retains a pixel in the data cube if the point at the pixel center intersects with the bounding box (as defined in the Simple Features standard by the OGC).",
    "categories": [
      "cubes",
      "filter"
    ],
    "gee:custom": true,
    "parameters": [
      {
        "name": "data",
        "description": "A data cube.",
        "schema": {
          "type": "object",
          "subtype": "raster-cube"
        }
      },
      {
        "name": "extent",
        "description": "A bounding box, which may include a vertical axis (see `base` and `height`).",
        "schema": {
          "type": "object",
          "subtype": "bounding-box",
          "required": [
            "west",
            "south",
            "east",
            "north"
          ],
          "properties": {
            "west": {
              "description": "West (lower left corner, coordinate axis 1).",
              "type": "number"
            },
            "south": {
              "description": "South (lower left corner, coordinate axis 2).",
              "type": "number"
            },
            "east": {
              "description": "East (upper right corner, coordinate axis 1).",
              "type": "number"
            },
            "north": {
              "description": "North (upper right corner, coordinate axis 2).",
              "type": "number"
            },
            "base": {
              "description": "Base (optional, lower left corner, coordinate axis 3).",
              "type": [
                "number",
                "null"
              ],
              "default": null
            },
            "height": {
              "description": "Height (optional, upper right corner, coordinate axis 3).",
              "type": [
                "number",
                "null"
              ],
              "default": null
            },
            "crs": {
              "description": "Coordinate reference system of the extent, specified as as [EPSG code](http://www.epsg-registry.org/), [WKT2 (ISO 19162) string](http://docs.opengeospatial.org/is/18-010r7/18-010r7.html) or [PROJ definition (deprecated)](https://proj.org/usage/quickstart.html). Defaults to `4326` (EPSG code 4326) unless the client explicitly requests a different coordinate reference system.",
              "anyOf": [
                {
                  "title": "EPSG Code",
                  "type": "integer",
                  "subtype": "epsg-code",
                  "minimum": 1000,
                  "examples": [
                    3857
                  ]
                }
              ],
              "default": 4326
            }
          }
        }
      }
    ],
    "returns": {
      "description": "A data cube restricted to the bounding box. The dimensions and dimension properties (name, type, labels, reference system and resolution) remain unchanged, except that the spatial dimensions have less (or the same) dimension labels.",
      "schema": {
        "type": "object",
        "subtype": "raster-cube"
      }
    },
    "links": [
      {
        "rel": "about",
        "href": "https://proj.org/usage/projections.html",
        "title": "PROJ parameters for cartographic projections"
      },
      {
        "rel": "about",
        "href": "http://www.epsg-registry.org",
        "title": "Official EPSG code registry"
      },
      {
        "rel": "about",
        "href": "http://www.epsg.io",
        "title": "Unofficial EPSG code database"
      },
      {
        "href": "http://www.opengeospatial.org/standards/sfa",
        "rel": "about",
        "title": "Simple Features standard by the OGC"
      }
    ]
  },
  {
    "id": "filter_spatial",
    "summary": "Spatial filter using geometries",
    "description": "Limits the data cube over the spatial dimensions to the specified geometries.\n\n- For **polygons**, the filter retains a pixel in the data cube if the point at the pixel center intersects with at least one of the polygons (as defined in the Simple Features standard by the OGC).\n- For **points**, the process considers the closest pixel center.\n- For **lines** (line strings), the process considers all the pixels whose centers are closest to at least one point on the line.\n\nMore specifically, pixels outside of the bounding box of the given geometry will not be available after filtering. All pixels inside the bounding box that are not retained will be set to `null` (no data).",
    "categories": [
      "cubes",
      "filter"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "A data cube.",
        "schema": {
          "type": "object",
          "subtype": "raster-cube"
        }
      },
      {
        "name": "geometries",
        "description": "One or more geometries used for filtering, specified as GeoJSON.",
        "schema": {
          "type": "object",
          "subtype": "geojson"
        }
      }
    ],
    "returns": {
      "description": "A data cube restricted to the specified geometries. The dimensions and dimension properties (name, type, labels, reference system and resolution) remain unchanged, except that the spatial dimensions have less (or the same) dimension labels.",
      "schema": {
        "type": "object",
        "subtype": "raster-cube"
      }
    },
    "links": [
      {
        "href": "http://www.opengeospatial.org/standards/sfa",
        "rel": "about",
        "title": "Simple Features standard by the OGC"
      }
    ]
  },
  {
    "id": "filter_temporal",
    "summary": "Temporal filter for a temporal intervals",
    "description": "Limits the data cube to the specified interval of dates and/or times.\n\nMore precisely, the filter checks whether the temporal dimension label is greater than or equal to the lower boundary (start date/time) and the temporal dimension label is less than the value of the upper boundary (end date/time). This corresponds to a left-closed interval, which contains the lower boundary but not the upper boundary.\n\nIf the dimension is set to `null` (it's the default value), the data cube is expected to only have one temporal dimension.",
    "categories": [
      "cubes",
      "filter"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "A data cube.",
        "schema": {
          "type": "object",
          "subtype": "raster-cube"
        }
      },
      {
        "name": "extent",
        "description": "Left-closed temporal interval, i.e. an array with exactly two elements:\n\n1. The first element is the start of the temporal interval. The specified instance in time is **included** in the interval.\n2. The second element is the end of the temporal interval. The specified instance in time is **excluded** from the interval.\n\nThe specified temporal strings follow [RFC 3339](https://tools.ietf.org/html/rfc3339). Also supports open intervals by setting one of the boundaries to `null`, but never both.",
        "schema": {
          "type": "array",
          "subtype": "temporal-interval",
          "minItems": 2,
          "maxItems": 2,
          "items": {
            "anyOf": [
              {
                "type": "string",
                "format": "date-time",
                "subtype": "date-time"
              },
              {
                "type": "string",
                "format": "date",
                "subtype": "date"
              },
              {
                "type": "string",
                "subtype": "year",
                "minLength": 4,
                "maxLength": 4,
                "pattern": "^\\d{4}$"
              },
              {
                "type": "null"
              }
            ]
          },
          "examples": [
            [
              "2015-01-01T00:00:00Z",
              "2016-01-01T00:00:00Z"
            ],
            [
              "2015-01-01",
              "2016-01-01"
            ]
          ]
        }
      },
      {
        "name": "dimension",
        "description": "The name of the temporal dimension to filter on. If the dimension is not set or is set to `null`, the filter applies to all temporal dimensions. Fails with a `DimensionNotAvailable` error if the specified dimension does not exist.",
        "schema": {
          "type": [
            "string",
            "null"
          ]
        },
        "default": null,
        "optional": true
      }
    ],
    "returns": {
      "description": "A data cube restricted to the specified temporal extent. The dimensions and dimension properties (name, type, labels, reference system and resolution) remain unchanged, except that the given temporal dimension(s) have less (or the same) dimension labels.",
      "schema": {
        "type": "object",
        "subtype": "raster-cube"
      }
    },
    "exceptions": {
      "DimensionNotAvailable": {
        "message": "A dimension with the specified name does not exist."
      }
    }
  },
  {
    "id": "first",
    "summary": "First element",
    "description": "Gives the first element of an array.\n\nAn array without non-`null` elements resolves always with `null`.",
    "categories": [
      "arrays",
      "reducer"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "An array with elements of any data type.",
        "schema": {
          "type": "array",
          "items": {
            "description": "Any data type is allowed."
          }
        }
      },
      {
        "name": "ignore_nodata",
        "description": "Indicates whether no-data values are ignored or not. Ignores them by default. Setting this flag to `false` considers no-data values so that `null` is returned if the first value is such a value.",
        "schema": {
          "type": "boolean"
        },
        "default": true,
        "optional": true
      }
    ],
    "returns": {
      "description": "The first element of the input array.",
      "schema": {
        "description": "Any data type is allowed."
      }
    },
    "examples": [
      {
        "arguments": {
          "data": [
            1,
            0,
            3,
            2
          ]
        },
        "returns": 1
      },
      {
        "arguments": {
          "data": [
            null,
            "A",
            "B"
          ]
        },
        "returns": "A"
      },
      {
        "arguments": {
          "data": [
            null,
            2,
            3
          ],
          "ignore_nodata": false
        },
        "returns": null
      },
      {
        "description": "The input array is empty: return `null`.",
        "arguments": {
          "data": []
        },
        "returns": null
      }
    ]
  },
  {
    "id": "floor",
    "summary": "Round fractions down",
    "description": "The greatest integer less than or equal to the number `x`.\n\nThis process is *not* an alias for the ``int()`` process as defined by some mathematicians, see the examples for negative numbers in both processes for differences.\n\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math > rounding"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "A number to round down.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The number rounded down.",
      "schema": {
        "type": [
          "integer",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 0
        },
        "returns": 0
      },
      {
        "arguments": {
          "x": 3.5
        },
        "returns": 3
      },
      {
        "arguments": {
          "x": -0.4
        },
        "returns": -1
      },
      {
        "arguments": {
          "x": -3.5
        },
        "returns": -4
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/FloorFunction.html",
        "title": "Floor explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "if",
    "summary": "If-Then-Else conditional",
    "description": "If the value passed is `true`, returns the value of the `accept` parameter, otherwise returns the value of the `reject` parameter.\n\nThis is basically an if-then-else construct as in other programming languages.",
    "categories": [
      "logic",
      "comparison",
      "masks"
    ],
    "parameters": [
      {
        "name": "value",
        "description": "A boolean value.",
        "schema": {
          "type": [
            "boolean",
            "null"
          ]
        }
      },
      {
        "name": "accept",
        "description": "A value that is returned if the boolean value is `true`.",
        "schema": {
          "description": "Any data type is allowed."
        }
      },
      {
        "name": "reject",
        "description": "A value that is returned if the boolean value is **not** `true`. Defaults to `null`.",
        "schema": {
          "description": "Any data type is allowed."
        },
        "default": null,
        "optional": true
      }
    ],
    "returns": {
      "description": "Either the `accept` or `reject` argument depending on the given boolean value.",
      "schema": {
        "description": "Any data type is allowed."
      }
    },
    "examples": [
      {
        "arguments": {
          "value": true,
          "accept": "A",
          "reject": "B"
        },
        "returns": "A"
      },
      {
        "arguments": {
          "value": null,
          "accept": "A",
          "reject": "B"
        },
        "returns": "B"
      },
      {
        "arguments": {
          "value": false,
          "accept": [
            1,
            2,
            3
          ],
          "reject": [
            4,
            5,
            6
          ]
        },
        "returns": [
          4,
          5,
          6
        ]
      },
      {
        "arguments": {
          "value": true,
          "accept": 123
        },
        "returns": 123
      },
      {
        "arguments": {
          "value": false,
          "accept": 1
        },
        "returns": null
      }
    ]
  },
  {
    "id": "int",
    "summary": "Integer part of a number",
    "description": "The integer part of the real number `x`.\n\nThis process is *not* an alias for the ``floor()`` process as defined by some mathematicians, see the examples for negative numbers in both processes for differences.\n\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math",
      "math > rounding"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "A number.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "Integer part of the number.",
      "schema": {
        "type": [
          "integer",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 0
        },
        "returns": 0
      },
      {
        "arguments": {
          "x": 3.5
        },
        "returns": 3
      },
      {
        "arguments": {
          "x": -0.4
        },
        "returns": 0
      },
      {
        "arguments": {
          "x": -3.5
        },
        "returns": -3
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/IntegerPart.html",
        "title": "Integer Part explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "last",
    "summary": "Last element",
    "description": "Gives the last element of an array.\n\nAn array without non-`null` elements resolves always with `null`.",
    "categories": [
      "arrays",
      "reducer"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "An array with elements of any data type.",
        "schema": {
          "type": "array",
          "items": {
            "description": "Any data type is allowed."
          }
        }
      },
      {
        "name": "ignore_nodata",
        "description": "Indicates whether no-data values are ignored or not. Ignores them by default. Setting this flag to `false` considers no-data values so that `null` is returned if the last value is such a value.",
        "schema": {
          "type": "boolean"
        },
        "default": true,
        "optional": true
      }
    ],
    "returns": {
      "description": "The last element of the input array.",
      "schema": {
        "description": "Any data type is allowed."
      }
    },
    "examples": [
      {
        "arguments": {
          "data": [
            1,
            0,
            3,
            2
          ]
        },
        "returns": 2
      },
      {
        "arguments": {
          "data": [
            "A",
            "B",
            null
          ]
        },
        "returns": "B"
      },
      {
        "arguments": {
          "data": [
            0,
            1,
            null
          ],
          "ignore_nodata": false
        },
        "returns": null
      },
      {
        "description": "The input array is empty: return `null`.",
        "arguments": {
          "data": []
        },
        "returns": null
      }
    ]
  },
  {
    "id": "linear_scale_range",
    "summary": "Linear transformation between two ranges",
    "description": "Performs a linear transformation between the input and output range.\n\nThe given number in `x` is clipped to the bounds specified in `inputMin` and `inputMax` so that the underlying formula *((x - inputMin) / (inputMax - inputMin)) * (outputMax - outputMin) + outputMin* never returns any value lower than `outputMin` or greater than `outputMax`.\n\nPotential use case include\n\n* scaling values to the 8-bit range (0 - 255) often used for numeric representation of values in one of the channels of the [RGB colour model](https://en.wikipedia.org/wiki/RGB_color_model#Numeric_representations) or\n* calculating percentages (0 - 100).\n\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "A number to transform. The number gets clipped to the bounds specified in `inputMin` and `inputMax`.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      },
      {
        "name": "inputMin",
        "description": "Minimum value the input can obtain.",
        "schema": {
          "type": "number"
        }
      },
      {
        "name": "inputMax",
        "description": "Maximum value the input can obtain.",
        "schema": {
          "type": "number"
        }
      },
      {
        "name": "outputMin",
        "description": "Minimum value of the desired output range.",
        "schema": {
          "type": "number"
        },
        "default": 0,
        "optional": true
      },
      {
        "name": "outputMax",
        "description": "Maximum value of the desired output range.",
        "schema": {
          "type": "number"
        },
        "default": 1,
        "optional": true
      }
    ],
    "returns": {
      "description": "The transformed number.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 0.3,
          "inputMin": -1,
          "inputMax": 1,
          "outputMin": 0,
          "outputMax": 255
        },
        "returns": 165.75
      },
      {
        "arguments": {
          "x": 25.5,
          "inputMin": 0,
          "inputMax": 255
        },
        "returns": 0.1
      },
      {
        "arguments": {
          "x": null,
          "inputMin": 0,
          "inputMax": 100
        },
        "returns": null
      },
      {
        "description": "Shows that the input data is clipped.",
        "arguments": {
          "x": 1.12,
          "inputMin": 0,
          "inputMax": 1,
          "outputMin": 0,
          "outputMax": 255
        },
        "returns": 255
      }
    ]
  },
  {
    "id": "ln",
    "summary": "Natural logarithm",
    "description": "The natural logarithm is the logarithm to the base *e* of the number `x`, which equals to using the *log* process with the base set to *e*. The natural logarithm is the inverse function of taking *e* to the power x.\n\nThe no-data value `null` is passed through.\n\nThe computations follow [IEEE Standard 754](https://ieeexplore.ieee.org/document/8766229) whenever the processing environment supports it. Therefore, `ln(0)` results in \u00b1infinity if the processing environment supports it or otherwise an error is thrown.",
    "categories": [
      "math > exponential & logarithmic"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "A number to compute the natural logarithm for.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed natural logarithm.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 1
        },
        "returns": 0
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/NaturalLogarithm.html",
        "title": "Natural logarithm explained by Wolfram MathWorld"
      },
      {
        "rel": "about",
        "href": "https://ieeexplore.ieee.org/document/8766229",
        "title": "IEEE Standard 754-2019 for Floating-Point Arithmetic"
      }
    ]
  },
  {
    "id": "load_collection",
    "summary": "Load a collection",
    "description": "Loads a collection from the current back-end by its id and returns it as processable data cube. The data that is added to the data cube can be restricted with the additional `spatial_extent`, `temporal_extent`, `bands` and `properties`.\n\n**Remarks:**\n\n* The bands (and all dimensions that specify nominal dimension labels) are expected to be ordered as specified in the metadata if the `bands` parameter is set to `null`.\n* If no additional parameter is specified this would imply that the whole data set is expected to be loaded. Due to the large size of many data sets this is not recommended and may be optimized by back-ends to only load the data that is actually required after evaluating subsequent processes such as filters. This means that the pixel values should be processed only after the data has been limited to the required extents and as a consequence also to a manageable size.",
    "categories": [
      "cubes",
      "import"
    ],
    "gee:custom": true,
    "parameters": [
      {
        "name": "id",
        "description": "The collection id.",
        "schema": {
          "type": "string",
          "subtype": "collection-id",
          "pattern": "^[\\w\\-\\.~/]+$"
        }
      },
      {
        "name": "spatial_extent",
        "description": "Limits the data to load from the collection to the specified bounding box or polygons.\n\nThe process puts a pixel into the data cube if the point at the pixel center intersects with the bounding box or any of the polygons (as defined in the Simple Features standard by the OGC).\n\nThe GeoJSON can be one of the following GeoJSON types:\n\n* A `Polygon` geometry,\n* a `GeometryCollection` containing Polygons,\n* a `Feature` with a `Polygon` geometry or\n* a `FeatureCollection` containing `Feature`s with a `Polygon` geometry.\n\nSet this parameter to `null` to set no limit for the spatial extent. Be careful with this when loading large datasets!",
        "schema": [
          {
            "title": "Bounding Box",
            "type": "object",
            "subtype": "bounding-box",
            "required": [
              "west",
              "south",
              "east",
              "north"
            ],
            "properties": {
              "west": {
                "description": "West (lower left corner, coordinate axis 1).",
                "type": "number"
              },
              "south": {
                "description": "South (lower left corner, coordinate axis 2).",
                "type": "number"
              },
              "east": {
                "description": "East (upper right corner, coordinate axis 1).",
                "type": "number"
              },
              "north": {
                "description": "North (upper right corner, coordinate axis 2).",
                "type": "number"
              },
              "base": {
                "description": "Base (optional, lower left corner, coordinate axis 3).",
                "type": [
                  "number",
                  "null"
                ],
                "default": null
              },
              "height": {
                "description": "Height (optional, upper right corner, coordinate axis 3).",
                "type": [
                  "number",
                  "null"
                ],
                "default": null
              },
              "crs": {
                "description": "Coordinate reference system of the extent, specified as as [EPSG code](http://www.epsg-registry.org/), [WKT2 (ISO 19162) string](http://docs.opengeospatial.org/is/18-010r7/18-010r7.html) or [PROJ definition (deprecated)](https://proj.org/usage/quickstart.html). Defaults to `4326` (EPSG code 4326) unless the client explicitly requests a different coordinate reference system.",
                "anyOf": [
                  {
                    "title": "EPSG Code",
                    "type": "integer",
                    "subtype": "epsg-code",
                    "minimum": 1000,
                    "examples": [
                      3857
                    ]
                  }
                ],
                "default": 4326
              }
            }
          },
          {
            "title": "GeoJSON",
            "type": "object",
            "subtype": "geojson"
          },
          {
            "title": "No filter",
            "description": "Don't filter spatially. All data is included in the data cube.",
            "type": "null"
          }
        ]
      },
      {
        "name": "temporal_extent",
        "description": "Limits the data to load from the collection to the specified left-closed temporal interval. Applies to all temporal dimensions. The interval has to be specified as an array with exactly two elements:\n\n1. The first element is the start of the temporal interval. The specified instance in time is **included** in the interval.\n2. The second element is the end of the temporal interval. The specified instance in time is **excluded** from the interval.\n\nThe specified temporal strings follow [RFC 3339](https://tools.ietf.org/html/rfc3339). Also supports open intervals by setting one of the boundaries to `null`, but never both.\n\nSet this parameter to `null` to set no limit for the spatial extent. Be careful with this when loading large datasets!",
        "schema": [
          {
            "type": "array",
            "subtype": "temporal-interval",
            "minItems": 2,
            "maxItems": 2,
            "items": {
              "anyOf": [
                {
                  "type": "string",
                  "format": "date-time",
                  "subtype": "date-time"
                },
                {
                  "type": "string",
                  "format": "date",
                  "subtype": "date"
                },
                {
                  "type": "string",
                  "subtype": "year",
                  "minLength": 4,
                  "maxLength": 4,
                  "pattern": "^\\d{4}$"
                },
                {
                  "type": "null"
                }
              ]
            },
            "examples": [
              [
                "2015-01-01T00:00:00Z",
                "2016-01-01T00:00:00Z"
              ],
              [
                "2015-01-01",
                "2016-01-01"
              ]
            ]
          },
          {
            "title": "No filter",
            "description": "Don't filter temporally. All data is included in the data cube.",
            "type": "null"
          }
        ]
      },
      {
        "name": "bands",
        "description": "Only adds the specified bands into the data cube so that bands that don't match the list of band names are not available. Applies to all dimensions of type `bands`.\n\nEither the unique band name (metadata field `name` in bands) or one of the common band names (metadata field `common_name` in bands) can be specified. If unique band name and common name conflict, the unique band name has higher priority.\n\nThe order of the specified array defines the order of the bands in the data cube. f multiple bands match a common name, all matched bands are included in the original order.",
        "schema": [
          {
            "type": "array",
            "items": {
              "type": "string",
              "subtype": "band-name"
            }
          },
          {
            "title": "No filter",
            "description": "Don't filter bands. All bands are included in the data cube.",
            "type": "null"
          }
        ],
        "default": null,
        "optional": true
      }
    ],
    "returns": {
      "description": "A data cube for further processing. The dimensions and dimension properties (name, type, labels, reference system and resolution) correspond to the collection's metadata, but the dimension labels are restricted as specified in the parameters.",
      "schema": {
        "type": "object",
        "subtype": "raster-cube"
      }
    },
    "examples": [
      {
        "description": "Loading `Sentinel-2B` data from a `Sentinel-2` collection for 2018, but only with cloud cover between 0 and 50%.",
        "arguments": {
          "id": "COPERNICUS/S2",
          "spatial_extent": {
            "west": 16.1,
            "east": 16.6,
            "north": 48.6,
            "south": 47.2
          },
          "temporal_extent": [
            "2018-01-01",
            "2019-01-01"
          ],
          "properties": {
            "eo:cloud_cover": {
              "process_graph": {
                "cc": {
                  "process_id": "between",
                  "arguments": {
                    "x": {
                      "from_parameter": "value"
                    },
                    "min": 0,
                    "max": 50
                  },
                  "result": true
                }
              }
            },
            "platform": {
              "process_graph": {
                "pf": {
                  "process_id": "eq",
                  "arguments": {
                    "x": {
                      "from_parameter": "value"
                    },
                    "y": "Sentinel-2B",
                    "case_sensitive": false
                  },
                  "result": true
                }
              }
            }
          }
        }
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "https://proj.org/usage/projections.html",
        "title": "PROJ parameters for cartographic projections"
      },
      {
        "rel": "about",
        "href": "http://www.epsg-registry.org",
        "title": "Official EPSG code registry"
      },
      {
        "rel": "about",
        "href": "http://www.epsg.io",
        "title": "Unofficial EPSG code database"
      },
      {
        "href": "http://www.opengeospatial.org/standards/sfa",
        "rel": "about",
        "title": "Simple Features standard by the OGC"
      },
      {
        "rel": "about",
        "href": "https://github.com/radiantearth/stac-spec/tree/master/extensions/eo#common-band-names",
        "title": "List of common band names as specified by the STAC specification"
      }
    ]
  },
  {
    "id": "log",
    "summary": "Logarithm to a base",
    "description": "Logarithm to the base `base` of the number `x` is defined to be the inverse function of taking b to the power of x.\n\nThe no-data value `null` is passed through and therefore gets propagated if any of the arguments is `null`.\n\nThe computations follow [IEEE Standard 754](https://ieeexplore.ieee.org/document/8766229) whenever the processing environment supports it. Therefore, `log(0, 2)` results in \u00b1infinity if the processing environment supports it or otherwise an error is thrown.",
    "categories": [
      "math > exponential & logarithmic"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "A number to compute the logarithm for.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      },
      {
        "name": "base",
        "description": "The numerical base.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed logarithm.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 10,
          "base": 10
        },
        "returns": 1
      },
      {
        "arguments": {
          "x": 2,
          "base": 2
        },
        "returns": 1
      },
      {
        "arguments": {
          "x": 4,
          "base": 2
        },
        "returns": 2
      },
      {
        "arguments": {
          "x": 1,
          "base": 16
        },
        "returns": 0
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/Logarithm.html",
        "title": "Logarithm explained by Wolfram MathWorld"
      },
      {
        "rel": "about",
        "href": "https://ieeexplore.ieee.org/document/8766229",
        "title": "IEEE Standard 754-2019 for Floating-Point Arithmetic"
      }
    ]
  },
  {
    "id": "mask",
    "summary": "Apply a raster mask",
    "description": "Applies a mask to a raster data cube. To apply a vector mask use ``mask_polygon()``.\n\nA mask is a raster data cube for which corresponding pixels among `data` and `mask` are compared and those pixels in `data` are replaced whose pixels in `mask` are non-zero (for numbers) or `true` (for boolean values). The pixel values are replaced with the value specified for `replacement`, which defaults to `null` (no data).\n\nThe data cubes have to be compatible so that each dimension in mask must also be available in the raster data cube with the same name, type, reference system, resolution and labels. Dimensions can be missing in the mask with the result that the mask is applied for each label of the missing dimension in the data cube. The process fails if there's an incompatibility found between the raster data cube and the mask.",
    "categories": [
      "masks"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "A raster data cube.",
        "schema": {
          "type": "object",
          "subtype": "raster-cube"
        }
      },
      {
        "name": "mask",
        "description": "A mask as raster data cube. Every pixel in `data` must have a corresponding element in `mask`.",
        "schema": {
          "type": "object",
          "subtype": "raster-cube"
        }
      },
      {
        "name": "replacement",
        "description": "The value used to replace masked values with.",
        "schema": {
          "type": [
            "number",
            "boolean",
            "string",
            "null"
          ]
        },
        "default": null,
        "optional": true
      }
    ],
    "returns": {
      "description": "A masked raster data cube with the same dimensions. The dimension properties (name, type, labels, reference system and resolution) remain unchanged.",
      "schema": {
        "type": "object",
        "subtype": "raster-cube"
      }
    }
  },
  {
    "id": "max",
    "summary": "Maximum value",
    "description": "Computes the largest value of an array of numbers, which is is equal to the first element of a sorted (i.e., ordered) version the array.\n\nAn array without non-`null` elements resolves always with `null`.",
    "categories": [
      "math",
      "reducer"
    ],
    "gee:custom": true,
    "parameters": [
      {
        "name": "data",
        "description": "An array of numbers.",
        "schema": {
          "type": "array",
          "items": {
            "type": [
              "number",
              "null"
            ]
          }
        }
      }
    ],
    "returns": {
      "description": "The maximum value.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "data": [
            1,
            0,
            3,
            2
          ]
        },
        "returns": 3
      },
      {
        "arguments": {
          "data": [
            5,
            2.5,
            null,
            -0.7
          ]
        },
        "returns": 5
      },
      {
        "description": "The input array is empty: return `null`.",
        "arguments": {
          "data": []
        },
        "returns": null
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/Maximum.html",
        "title": "Maximum explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "mean",
    "summary": "Arithmetic mean (average)",
    "description": "The arithmetic mean of an array of numbers is the quantity commonly called the average. It is defined as the sum of all elements divided by the number of elements.\n\nAn array without non-`null` elements resolves always with `null`.",
    "categories": [
      "math",
      "reducer"
    ],
    "gee:custom": true,
    "parameters": [
      {
        "name": "data",
        "description": "An array of numbers.",
        "schema": {
          "type": "array",
          "items": {
            "type": [
              "number",
              "null"
            ]
          }
        }
      }
    ],
    "returns": {
      "description": "The computed arithmetic mean.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "data": [
            1,
            0,
            3,
            2
          ]
        },
        "returns": 1.5
      },
      {
        "arguments": {
          "data": [
            9,
            2.5,
            null,
            -2.5
          ]
        },
        "returns": 3
      },
      {
        "description": "The input array is empty: return `null`.",
        "arguments": {
          "data": []
        },
        "returns": null
      },
      {
        "description": "The input array has only `null` elements: return `null`.",
        "arguments": {
          "data": [
            null,
            null
          ]
        },
        "returns": null
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/ArithmeticMean.html",
        "title": "Arithmetic mean explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "median",
    "summary": "Statistical median",
    "description": "The statistical median of an array of numbers is the value separating the higher half from the lower half of the data.\n\nAn array without non-`null` elements resolves always with `null`.\n\n**Remarks:**\n\n* For a symmetric arrays, the result is equal to the ``mean()``.\n* The median can also be calculated by computing the ``quantiles()`` with a probability of *0.5*.",
    "categories": [
      "math",
      "reducer"
    ],
    "gee:custom": true,
    "parameters": [
      {
        "name": "data",
        "description": "An array of numbers.",
        "schema": {
          "type": "array",
          "items": {
            "type": [
              "number",
              "null"
            ]
          }
        }
      }
    ],
    "returns": {
      "description": "The computed statistical median.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "data": [
            1,
            3,
            3,
            6,
            7,
            8,
            9
          ]
        },
        "returns": 6
      },
      {
        "arguments": {
          "data": [
            1,
            2,
            3,
            4,
            5,
            6,
            8,
            9
          ]
        },
        "returns": 4.5
      },
      {
        "arguments": {
          "data": [
            -1,
            -0.5,
            null,
            1
          ]
        },
        "returns": -0.5
      },
      {
        "description": "The input array is empty: return `null`.",
        "arguments": {
          "data": []
        },
        "returns": null
      },
      {
        "description": "The input array has only `null` elements: return `null`.",
        "arguments": {
          "data": [
            null,
            null
          ]
        },
        "returns": null
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/StatisticalMedian.html",
        "title": "Statistical Median explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "merge_cubes",
    "summary": "Merging two data cubes",
    "description": "The data cubes have to be compatible. A merge operation without overlap should be reversible with (a set of) filter operations for each of the two cubes. The process performs the join on overlapping dimensions, with the same name and type.\n\nAn overlapping dimension has the same name, type, reference system and resolution in both dimensions, but can have different labels. One of the dimensions can have different labels, for all other dimensions the labels must be equal. If data overlaps, the parameter `overlap_resolver` must be specified to resolve the overlap.\n\n**Examples for merging two data cubes:**\n\n1. Data cubes with the dimensions `x`, `y`, `t` and `bands` have the same dimension labels in `x`,`y` and `t`, but the labels for the dimension `bands` are `B1` and `B2` for the first cube and `B3` and `B4`. An overlap resolver is *not needed*. The merged data cube has the dimensions `x`, `y`, `t` and `bands` and the dimension `bands` has four dimension labels: `B1`, `B2`, `B3`, `B4`.\n2. Data cubes with the dimensions `x`, `y`, `t` and `bands` have the same dimension labels in `x`,`y` and `t`, but the labels for the dimension `bands` are `B1` and `B2` for the first data cube and `B2` and `B3` for the second. An overlap resolver is *required* to resolve overlap in band `B2`. The merged data cube has the dimensions `x`, `y`, `t` and `bands` and the dimension `bands` has three dimension labels: `B1`, `B2`, `B3`.\n3. Data cubes with the dimensions `x`, `y` and `t` have the same dimension labels in `x`,`y` and `t`. There are two options:\n   1. Keep the overlapping values separately in the merged data cube: An overlap resolver is *not needed*, but for each data cube you need to add a new dimension using ``add_dimension()``. The new dimensions must be equal, except that the labels for the new dimensions must differ by name. The merged data cube has the same dimensions and labels as the original data cubes, plus the dimension added with ``add_dimension()``, which has the two dimension labels after the merge.\n   2. Combine the overlapping values into a single value: An overlap resolver is *required* to resolve the overlap for all pixels. The merged data cube has the same dimensions and labels as the original data cubes, but all pixel values have been processed by the overlap resolver.\n4. Merging a data cube with dimensions `x`, `y`, `t` with another cube with dimensions `x`, `y` will join on the `x`, `y` dimension, so the lower dimension cube is merged with each time step in the higher dimensional cube. This can for instance be used to apply a digital elevation model to a spatiotemporal data cube.",
    "categories": [
      "cubes"
    ],
    "gee:custom": true,
    "parameters": [
      {
        "name": "cube1",
        "description": "The first data cube.",
        "schema": {
          "type": "object",
          "subtype": "raster-cube"
        }
      },
      {
        "name": "cube2",
        "description": "The second data cube.",
        "schema": {
          "type": "object",
          "subtype": "raster-cube"
        }
      }
    ],
    "returns": {
      "description": "The merged data cube. See the process description for details regarding the dimensions and dimension properties (name, type, labels, reference system and resolution).",
      "schema": {
        "type": "object",
        "subtype": "raster-cube"
      }
    },
    "exceptions": {
      "OverlapResolverMissing": {
        "message": "Overlapping data cubes, but no overlap resolver has been specified."
      }
    },
    "links": [
      {
        "rel": "about",
        "href": "https://en.wikipedia.org/wiki/Reduction_Operator",
        "title": "Background information on reduction operators (binary reducers) by Wikipedia"
      }
    ]
  },
  {
    "id": "min",
    "summary": "Minimum value",
    "description": "Computes the smallest value of an array of numbers, which is is equal to the last element of a sorted (i.e., ordered) version the array.\n\nAn array without non-`null` elements resolves always with `null`.",
    "categories": [
      "math",
      "reducer"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "An array of numbers.",
        "schema": {
          "type": "array",
          "items": {
            "type": [
              "number",
              "null"
            ]
          }
        }
      }
    ],
    "returns": {
      "description": "The minimum value.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "data": [
            1,
            0,
            3,
            2
          ]
        },
        "returns": 0
      },
      {
        "arguments": {
          "data": [
            5,
            2.5,
            null,
            -0.7
          ]
        },
        "returns": -0.7
      },
      {
        "arguments": {
          "data": []
        },
        "returns": null
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/Minimum.html",
        "title": "Minimum explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "multiply",
    "summary": "Multiplication of two numbers",
    "description": "Multiplies the two numbers `x` and `y` (*x * y*) and returns the computed product.\n\nNo-data values are taken into account so that `null` is returned if any element is such a value.\n\nThe computations follow [IEEE Standard 754](https://ieeexplore.ieee.org/document/8766229) whenever the processing environment supports it.",
    "categories": [
      "math"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "The multiplier.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      },
      {
        "name": "y",
        "description": "The multiplicand.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed product of the two numbers.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "exceptions": {
      "MultiplicandMissing": {
        "message": "Multiplication requires at least two numbers."
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 5,
          "y": 2.5
        },
        "returns": 12.5
      },
      {
        "arguments": {
          "x": -2,
          "y": -4
        },
        "returns": 8
      },
      {
        "arguments": {
          "x": 1,
          "y": null
        },
        "returns": null
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/Product.html",
        "title": "Product explained by Wolfram MathWorld"
      },
      {
        "rel": "about",
        "href": "https://ieeexplore.ieee.org/document/8766229",
        "title": "IEEE Standard 754-2019 for Floating-Point Arithmetic"
      }
    ]
  },
  {
    "id": "normalized_difference",
    "summary": "Normalized difference",
    "description": "Computes the normalized difference for two bands. The normalized difference is computed as *(x - y) / (x + y)*.\n\nThis process could be used for a number of remote sensing indices such as:\n\n* [NDVI](https://eos.com/ndvi/): `x` = NIR band, `y` = red band\n* [NDWI](https://eos.com/ndwi/): `x` = NIR band, `y` = SWIR band\n* [NDSI](https://eos.com/ndsi/): `x` = green band, `y` = SWIR band\n\nSome back-ends may have native processes such as ``ndvi()`` available for convenience.",
    "categories": [
      "math > indices",
      "vegetation indices"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "The value for the first band.",
        "schema": {
          "type": "number"
        }
      },
      {
        "name": "y",
        "description": "The value for the second band.",
        "schema": {
          "type": "number"
        }
      }
    ],
    "returns": {
      "description": "The computed normalized difference.",
      "schema": {
        "type": "number",
        "minimum": -1,
        "maximum": 1
      }
    },
    "links": [
      {
        "rel": "related",
        "href": "https://eos.com/ndvi/",
        "title": "NDVI explained by EOS"
      },
      {
        "rel": "related",
        "href": "https://eos.com/ndwi/",
        "title": "NDWI explained by EOS"
      },
      {
        "rel": "related",
        "href": "https://eos.com/ndsi/",
        "title": "NDSI explained by EOS"
      }
    ]
  },
  {
    "id": "pi",
    "summary": "Pi (\u03c0)",
    "description": "The real number Pi (\u03c0) is a mathematical constant that is the ratio of the circumference of a circle to its diameter. The numerical value is approximately *3.14159*.",
    "categories": [
      "math > constants",
      "math > trigonometric"
    ],
    "parameters": [],
    "returns": {
      "description": "The numerical value of Pi.",
      "schema": {
        "type": "number"
      }
    },
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/Pi.html",
        "title": "Mathematical constant Pi explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "power",
    "summary": "Exponentiation",
    "description": "Computes the exponentiation for the base `base` raised to the power of `p`.\n\nThe no-data value `null` is passed through and therefore gets propagated if any of the arguments is `null`.",
    "categories": [
      "math",
      "math > exponential & logarithmic"
    ],
    "parameters": [
      {
        "name": "base",
        "description": "The numerical base.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      },
      {
        "name": "p",
        "description": "The numerical exponent.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed value for `base` raised to the power of `p`.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "base": 0,
          "p": 2
        },
        "returns": 0
      },
      {
        "arguments": {
          "base": 2.5,
          "p": 0
        },
        "returns": 1
      },
      {
        "arguments": {
          "base": 3,
          "p": 3
        },
        "returns": 27
      },
      {
        "arguments": {
          "base": 5,
          "p": -1
        },
        "returns": 0.2
      },
      {
        "arguments": {
          "base": 1,
          "p": 0.5
        },
        "returns": 1
      },
      {
        "arguments": {
          "base": 1,
          "p": null
        },
        "returns": null
      },
      {
        "arguments": {
          "base": null,
          "p": 2
        },
        "returns": null
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/Power.html",
        "title": "Power explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "product",
    "summary": "Compute the product by multiplying numbers",
    "description": "Multiplies all elements in a sequential array of numbers and returns the computed product.\n\nBy default no-data values are ignored. Setting `ignore_nodata` to `false` considers no-data values so that `null` is returned if any element is such a value.\n\nThe computations follow [IEEE Standard 754](https://ieeexplore.ieee.org/document/8766229) whenever the processing environment supports it.",
    "categories": [
      "math",
      "reducer"
    ],
    "gee:custom": true,
    "parameters": [
      {
        "name": "data",
        "description": "An array of numbers.",
        "schema": {
          "type": "array",
          "items": {
            "type": [
              "number",
              "null"
            ]
          }
        }
      }
    ],
    "returns": {
      "description": "The computed product of the sequence of numbers.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "data": [
            5,
            0
          ]
        },
        "returns": 0
      },
      {
        "arguments": {
          "data": [
            -2,
            4,
            2.5
          ]
        },
        "returns": -20
      },
      {
        "arguments": {
          "data": [
            -1
          ]
        },
        "returns": -1
      },
      {
        "arguments": {
          "data": []
        },
        "returns": null
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/Product.html",
        "title": "Product explained by Wolfram MathWorld"
      },
      {
        "rel": "about",
        "href": "https://ieeexplore.ieee.org/document/8766229",
        "title": "IEEE Standard 754-2019 for Floating-Point Arithmetic"
      }
    ]
  },
  {
    "id": "reduce_dimension",
    "summary": "Reduce dimensions",
    "description": "Applies a unary reducer to a data cube dimension by collapsing all the pixel values along the specified dimension into an output value computed by the reducer. This process passes a list of values to the reducer. In contrast, ``reduce_dimension_binary()`` passes two values, which may be better suited especially for UDFs in case the number of values gets too large to be processed at once.\n\nThe dimension is dropped. To avoid this, use ``apply_dimension()`` instead.",
    "categories": [
      "cubes",
      "reducer"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "A data cube.",
        "schema": {
          "type": "object",
          "subtype": "raster-cube"
        }
      },
      {
        "name": "reducer",
        "description": "A reducer to apply on the specified dimension. A reducer is a single process such as ``mean()`` or a set of processes, which computes a single value for a list of values, see the category 'reducer' for such processes.",
        "schema": {
          "type": "object",
          "subtype": "process-graph",
          "parameters": [
            {
              "name": "data",
              "description": "A labeled array with elements of any type.",
              "schema": {
                "type": "array",
                "subtype": "labeled-array",
                "items": {
                  "description": "Any data type."
                }
              }
            },
            {
              "name": "context",
              "description": "Additional data passed by the user.",
              "schema": {
                "description": "Any data type."
              },
              "optional": true,
              "default": null
            }
          ]
        }
      },
      {
        "name": "dimension",
        "description": "The name of the dimension over which to reduce. Fails with a `DimensionNotAvailable` error if the specified dimension does not exist.",
        "schema": {
          "type": "string"
        }
      },
      {
        "name": "context",
        "description": "Additional data to be passed to the reducer.",
        "schema": {
          "description": "Any data type."
        },
        "optional": true,
        "default": null
      }
    ],
    "returns": {
      "description": "A data cube with the newly computed values. It is missing the given dimension, the number of dimensions decreases by one. The dimension properties (name, type, labels, reference system and resolution) for all other dimensions remain unchanged.",
      "schema": {
        "type": "object",
        "subtype": "raster-cube"
      }
    },
    "exceptions": {
      "DimensionNotAvailable": {
        "message": "A dimension with the specified name does not exist."
      }
    }
  },
  {
    "id": "rename_dimension",
    "summary": "Rename a dimension",
    "description": "Renames a dimension in the data cube while preserving all other properties.",
    "categories": [
      "cubes"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "The data cube.",
        "schema": {
          "type": "object",
          "subtype": "raster-cube"
        }
      },
      {
        "name": "source",
        "description": "The current name of the dimension. Fails with a `DimensionNotAvailable` error if the specified dimension does not exist.",
        "schema": {
          "type": "string"
        }
      },
      {
        "name": "target",
        "description": "A new Name for the dimension. Fails with a `DimensionExists` error if a dimension with the specified name exists.",
        "schema": {
          "type": "string"
        }
      }
    ],
    "returns": {
      "description": "A data cube with the same dimensions, but the name of one of the dimensions changes. The old name can not be referred to any longer. The dimension properties (name, type, labels, reference system and resolution) remain unchanged.",
      "schema": {
        "type": "object",
        "subtype": "raster-cube"
      }
    },
    "exceptions": {
      "DimensionNotAvailable": {
        "message": "A dimension with the specified name does not exist."
      },
      "DimensionExists": {
        "message": "A dimension with the specified name already exists."
      }
    }
  },
  {
    "id": "rename_labels",
    "summary": "Rename dimension labels",
    "description": "Renames the labels of the specified dimension in the data cube from `source` to `target`.\n\nIf the array for the source labels is empty (the default), the dimension labels are expected to be enumerated with zero-based numbering (0,1,2,3,...) so that the dimension labels directly map to the indices of the array specified for the parameter `target`. If the dimension labels are not enumerated and the `target` parameter is not specified, a `LabelsNotEnumerated` is thrown. The number of source and target labels must be equal, otherwise the error `LabelMismatch` is thrown.\n\nThis process doesn't change the order of the labels and their corresponding data.",
    "categories": [
      "cubes"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "The data cube.",
        "schema": {
          "type": "object",
          "subtype": "raster-cube"
        }
      },
      {
        "name": "dimension",
        "description": "The name of the dimension to rename the labels for.",
        "schema": {
          "type": "string"
        }
      },
      {
        "name": "target",
        "description": "The new names for the labels. The dimension labels in the data cube are expected to be enumerated, if the parameter `target` is not specified. If a target dimension label already exists in the data cube, a `LabelExists` error is thrown.",
        "schema": {
          "type": "array",
          "items": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "string"
              }
            ]
          }
        }
      },
      {
        "name": "source",
        "description": "The names of the labels as they are currently in the data cube. The array defines an unsorted and potentially incomplete list of labels that should be renamed to the names available in the corresponding array elements in the parameter `target`. If one of the source dimension labels doesn't exist, a `LabelNotAvailable` error is thrown. By default, the array is empty so that the dimension labels in the data cube are expected to be enumerated.",
        "schema": {
          "type": "array",
          "items": {
            "anyOf": [
              {
                "type": "number"
              },
              {
                "type": "string"
              }
            ]
          }
        },
        "default": [],
        "optional": true
      }
    ],
    "returns": {
      "description": "The data cube with the same dimensions. The dimension properties (name, type, labels, reference system and resolution) remain unchanged, except that for the given dimension the labels change. The old labels can not be referred to any longer. The number of labels remains the same.",
      "schema": {
        "type": "object",
        "subtype": "raster-cube"
      }
    },
    "exceptions": {
      "LabelsNotEnumerated": {
        "message": "The dimension labels are not enumerated."
      },
      "LabelMismatch": {
        "message": "The number of labels in the parameters `source` and `target` don't match."
      },
      "LabelNotAvailable": {
        "message": "A label with the specified name does not exist."
      },
      "LabelExists": {
        "message": "A label with the specified name exists."
      }
    },
    "examples": [
      {
        "title": "Rename named labels",
        "description": "Renaming the bands from `B1` to `red`, from `B2` to `green` and from `B3` to `blue`.",
        "arguments": {
          "data": {
            "from_parameter": "data"
          },
          "dimension": "bands",
          "source": [
            "B1",
            "B2",
            "B3"
          ],
          "target": [
            "red",
            "green",
            "blue"
          ]
        }
      }
    ],
    "links": [
      {
        "rel": "example",
        "type": "application/json",
        "href": "https://processes.openeo.org/1.0.0/examples/rename-enumerated-labels.json",
        "title": "Rename enumerated labels"
      }
    ]
  },
  {
    "id": "round",
    "summary": "Round to a specified precision",
    "description": "Rounds a real number `x` to specified precision `p`.\n\nIf the fractional part of `x` is halfway between two integers, one of which is even and the other odd, then the even number is returned.\nThis behaviour follows [IEEE Standard 754](https://ieeexplore.ieee.org/document/8766229). This kind of rounding is also called \"round to nearest (even)\" or \"banker's rounding\". It minimizes rounding errors that result from consistently rounding a midpoint value in a single direction.\n\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math > rounding"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "A number to round.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      },
      {
        "name": "p",
        "description": "A positive number specifies the number of digits after the decimal point to round to. A negative number means rounding to a power of ten, so for example *-2* rounds to the nearest hundred. Defaults to *0*.",
        "schema": {
          "type": "integer"
        },
        "default": 0,
        "optional": true
      }
    ],
    "returns": {
      "description": "The rounded number.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 0
        },
        "returns": 0
      },
      {
        "arguments": {
          "x": 3.56,
          "p": 1
        },
        "returns": 3.6
      },
      {
        "arguments": {
          "x": -0.4444444,
          "p": 2
        },
        "returns": -0.44
      },
      {
        "arguments": {
          "x": -2.5
        },
        "returns": -2
      },
      {
        "arguments": {
          "x": -3.5
        },
        "returns": -4
      },
      {
        "arguments": {
          "x": 1234.5,
          "p": -2
        },
        "returns": 1200
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/AbsoluteValue.html",
        "title": "Absolute value explained by Wolfram MathWorld"
      },
      {
        "rel": "about",
        "href": "https://ieeexplore.ieee.org/document/8766229",
        "title": "IEEE Standard 754-2019 for Floating-Point Arithmetic"
      }
    ]
  },
  {
    "id": "save_result",
    "summary": "Save processed data to storage",
    "description": "Saves processed data to the local user workspace / data store of the authenticated user. This process aims to be compatible to GDAL/OGR formats and options. STAC-compatible metadata should be stored with the processed data.\n\nCalling this process may be rejected by back-ends in the context of secondary web services.",
    "categories": [
      "cubes",
      "export"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "The data to save.",
        "schema": [
          {
            "type": "object",
            "subtype": "raster-cube"
          },
          {
            "type": "object",
            "subtype": "vector-cube"
          }
        ]
      },
      {
        "name": "format",
        "description": "The file format to save to. It must be one of the values that the server reports as supported output file formats, which usually correspond to the short GDAL/OGR codes. If the format is not suitable for storing the underlying data structure, a `FormatUnsuitable` exception will be thrown. This parameter is *case insensitive*.",
        "schema": {
          "type": "string",
          "subtype": "output-format"
        }
      },
      {
        "name": "options",
        "description": "The file format parameters to be used to create the file(s). Must correspond to the parameters that the server reports as supported parameters for the chosen `format`. The parameter names and valid values usually correspond to the GDAL/OGR format options.",
        "schema": {
          "type": "object",
          "subtype": "output-format-options"
        },
        "default": {},
        "optional": true
      }
    ],
    "returns": {
      "description": "`false` if saving failed, `true` otherwise.",
      "schema": {
        "type": "boolean"
      }
    },
    "exceptions": {
      "FormatUnsuitable": {
        "message": "Data can't be transformed into the requested output format."
      }
    },
    "links": [
      {
        "rel": "about",
        "href": "https://www.gdal.org/formats_list.html",
        "title": "GDAL Raster Formats"
      },
      {
        "rel": "about",
        "href": "https://www.gdal.org/ogr_formats.html",
        "title": "OGR Vector Formats"
      }
    ]
  },
  {
    "id": "sd",
    "summary": "Standard deviation",
    "description": "Computes the sample standard deviation, which quantifies the amount of variation of an array of numbers. It is defined to be the square root of the corresponding variance (see ``variance()``).\n\nA low standard deviation indicates that the values tend to be close to the expected value, while a high standard deviation indicates that the values are spread out over a wider range.\n\nAn array without non-`null` elements resolves always with `null`.",
    "categories": [
      "math",
      "reducer"
    ],
    "gee:custom": true,
    "parameters": [
      {
        "name": "data",
        "description": "An array of numbers.",
        "schema": {
          "type": "array",
          "items": {
            "type": [
              "number",
              "null"
            ]
          }
        }
      }
    ],
    "returns": {
      "description": "The computed sample standard deviation.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "data": [
            -1,
            1,
            3,
            null
          ]
        },
        "returns": 2
      },
      {
        "description": "The input array is empty: return `null`.",
        "arguments": {
          "data": []
        },
        "returns": null
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/StandardDeviation.html",
        "title": "Standard deviation explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "sin",
    "summary": "Sine",
    "description": "Computes the sine of `x`.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math > trigonometric"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "An angle in radians.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed sine of `x`.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 0
        },
        "returns": 0
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/Sine.html",
        "title": "Sine explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "sinh",
    "summary": "Hyperbolic sine",
    "description": "Computes the hyperbolic sine of `x`.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math > trigonometric"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "An angle in radians.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed hyperbolic sine of `x`.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 0
        },
        "returns": 0
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/HyperbolicSine.html",
        "title": "Hyperbolic sine explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "sqrt",
    "summary": "Square root",
    "description": "Computes the square root of a real number `x`, which is equal to calculating `x` to the power of *0.5*.\n\nA square root of x is a number a such that *a^2^ = x*. Therefore, the square root is the inverse function of a to the power of 2, but only for *a >= 0*.\n\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math",
      "math > exponential & logarithmic"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "A number.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed square root.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 0
        },
        "returns": 0
      },
      {
        "arguments": {
          "x": 1
        },
        "returns": 1
      },
      {
        "arguments": {
          "x": 9
        },
        "returns": 3
      },
      {
        "arguments": {
          "x": null
        },
        "returns": null
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/SquareRoot.html",
        "title": "Square root explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "subtract",
    "summary": "Subtraction of two numbers",
    "description": "Subtracts argument `y` from the argument `x` (*x - y*) and returns the computed result.\n\nNo-data values are taken into account so that `null` is returned if any element is such a value.\n\nThe computations follow [IEEE Standard 754](https://ieeexplore.ieee.org/document/8766229) whenever the processing environment supports it.",
    "categories": [
      "math"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "The minuend.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      },
      {
        "name": "y",
        "description": "The subtrahend.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed result.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 5,
          "y": 2.5
        },
        "returns": 2.5
      },
      {
        "arguments": {
          "x": -2,
          "y": 4
        },
        "returns": -6
      },
      {
        "arguments": {
          "x": 1,
          "y": null
        },
        "returns": null
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/Subtraction.html",
        "title": "Subtraction explained by Wolfram MathWorld"
      },
      {
        "rel": "about",
        "href": "https://ieeexplore.ieee.org/document/8766229",
        "title": "IEEE Standard 754-2019 for Floating-Point Arithmetic"
      }
    ]
  },
  {
    "id": "sum",
    "summary": "Compute the sum by adding up numbers",
    "description": "Sums up all elements in a sequential array of numbers and returns the computed sum.\n\nBy default no-data values are ignored. Setting `ignore_nodata` to `false` considers no-data values so that `null` is returned if any element is such a value.\n\nThe computations follow [IEEE Standard 754](https://ieeexplore.ieee.org/document/8766229) whenever the processing environment supports it.",
    "categories": [
      "math",
      "reducer"
    ],
    "gee:custom": true,
    "parameters": [
      {
        "name": "data",
        "description": "An array of numbers.",
        "schema": {
          "type": "array",
          "items": {
            "type": [
              "number",
              "null"
            ]
          }
        }
      }
    ],
    "returns": {
      "description": "The computed sum of the sequence of numbers.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "data": [
            5,
            1
          ]
        },
        "returns": 6
      },
      {
        "arguments": {
          "data": [
            -2,
            4,
            2.5
          ]
        },
        "returns": 4.5
      },
      {
        "arguments": {
          "data": [
            100
          ]
        },
        "returns": 100
      },
      {
        "arguments": {
          "data": []
        },
        "returns": null
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/Sum.html",
        "title": "Sum explained by Wolfram MathWorld"
      },
      {
        "rel": "about",
        "href": "https://ieeexplore.ieee.org/document/8766229",
        "title": "IEEE Standard 754-2019 for Floating-Point Arithmetic"
      }
    ]
  },
  {
    "id": "tan",
    "summary": "Tangent",
    "description": "Computes the tangent of `x`. The tangent is defined to be the sine of x divided by the cosine of x.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math > trigonometric"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "An angle in radians.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed tangent of `x`.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 0
        },
        "returns": 0
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/Tangent.html",
        "title": "Tangent explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "tanh",
    "summary": "Hyperbolic tangent",
    "description": "Computes the hyperbolic tangent of `x`. The tangent is defined to be the hyperbolic sine of x divided by the hyperbolic cosine of x.\n\nWorks on radians only.\nThe no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "math > trigonometric"
    ],
    "parameters": [
      {
        "name": "x",
        "description": "An angle in radians.",
        "schema": {
          "type": [
            "number",
            "null"
          ]
        }
      }
    ],
    "returns": {
      "description": "The computed hyperbolic tangent of `x`.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "x": 0
        },
        "returns": 0
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/HyperbolicTangent.html",
        "title": "Hyperbolic tangent explained by Wolfram MathWorld"
      }
    ]
  },
  {
    "id": "text_begins",
    "summary": "Text begins with another text",
    "description": "Checks whether the text (also known as *string*) specified for `data` contains the text specified for `pattern` at the beginning. Both are expected to be encoded in UTF-8 by default. The no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "texts",
      "comparison"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "Text in which to find something at the beginning.",
        "schema": {
          "type": [
            "string",
            "null"
          ]
        }
      },
      {
        "name": "pattern",
        "description": "Text to find at the beginning of `data`. Regular expressions are not supported.",
        "schema": {
          "type": "string"
        }
      },
      {
        "name": "case_sensitive",
        "description": "Case sensitive comparison can be disabled by setting this parameter to `false`.",
        "schema": {
          "type": "boolean"
        },
        "default": true,
        "optional": true
      }
    ],
    "returns": {
      "description": "`true` if `data` begins with `pattern`, false` otherwise.",
      "schema": {
        "type": [
          "boolean",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "data": "Lorem ipsum dolor sit amet",
          "pattern": "amet"
        },
        "returns": false
      },
      {
        "arguments": {
          "data": "Lorem ipsum dolor sit amet",
          "pattern": "Lorem"
        },
        "returns": true
      },
      {
        "arguments": {
          "data": "Lorem ipsum dolor sit amet",
          "pattern": "lorem"
        },
        "returns": false
      },
      {
        "arguments": {
          "data": "Lorem ipsum dolor sit amet",
          "pattern": "lorem",
          "case_sensitive": false
        },
        "returns": true
      },
      {
        "arguments": {
          "data": "\u00c4",
          "pattern": "\u00e4",
          "case_sensitive": false
        },
        "returns": true
      },
      {
        "arguments": {
          "data": null,
          "pattern": "null"
        },
        "returns": null
      }
    ]
  },
  {
    "id": "text_contains",
    "summary": "Text contains another text",
    "description": "Checks whether the text (also known as *string*) specified for `data` contains the text specified for `pattern`. Both are expected to be encoded in UTF-8 by default. The no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "texts",
      "comparison"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "Text in which to find something in.",
        "schema": {
          "type": [
            "string",
            "null"
          ]
        }
      },
      {
        "name": "pattern",
        "description": "Text to find in `data`. Regular expressions are not supported.",
        "schema": {
          "type": "string"
        }
      },
      {
        "name": "case_sensitive",
        "description": "Case sensitive comparison can be disabled by setting this parameter to `false`.",
        "schema": {
          "type": "boolean"
        },
        "default": true,
        "optional": true
      }
    ],
    "returns": {
      "description": "`true` if `data` contains the `pattern`, false` otherwise.",
      "schema": {
        "type": [
          "boolean",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "data": "Lorem ipsum dolor sit amet",
          "pattern": "openEO"
        },
        "returns": false
      },
      {
        "arguments": {
          "data": "Lorem ipsum dolor sit amet",
          "pattern": "ipsum dolor"
        },
        "returns": true
      },
      {
        "arguments": {
          "data": "Lorem ipsum dolor sit amet",
          "pattern": "Ipsum Dolor"
        },
        "returns": false
      },
      {
        "arguments": {
          "data": "Lorem ipsum dolor sit amet",
          "pattern": "SIT",
          "case_sensitive": false
        },
        "returns": true
      },
      {
        "arguments": {
          "data": "\u00c4\u00d6\u00dc",
          "pattern": "\u00f6",
          "case_sensitive": false
        },
        "returns": true
      },
      {
        "arguments": {
          "data": null,
          "pattern": "null"
        },
        "returns": null
      }
    ]
  },
  {
    "id": "text_ends",
    "summary": "Text ends with another text",
    "description": "Checks whether the text (also known as *string*) specified for `data` contains the text specified for `pattern` at the end. Both are expected to be encoded in UTF-8 by default. The no-data value `null` is passed through and therefore gets propagated.",
    "categories": [
      "texts",
      "comparison"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "Text in which to find something at the end.",
        "schema": {
          "type": [
            "string",
            "null"
          ]
        }
      },
      {
        "name": "pattern",
        "description": "Text to find at the end of `data`. Regular expressions are not supported.",
        "schema": {
          "type": "string"
        }
      },
      {
        "name": "case_sensitive",
        "description": "Case sensitive comparison can be disabled by setting this parameter to `false`.",
        "schema": {
          "type": "boolean"
        },
        "default": true,
        "optional": true
      }
    ],
    "returns": {
      "description": "`true` if `data` ends with `pattern`, false` otherwise.",
      "schema": {
        "type": [
          "boolean",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "data": "Lorem ipsum dolor sit amet",
          "pattern": "amet"
        },
        "returns": true
      },
      {
        "arguments": {
          "data": "Lorem ipsum dolor sit amet",
          "pattern": "AMET"
        },
        "returns": false
      },
      {
        "arguments": {
          "data": "Lorem ipsum dolor sit amet",
          "pattern": "Lorem"
        },
        "returns": false
      },
      {
        "arguments": {
          "data": "Lorem ipsum dolor sit amet",
          "pattern": "AMET",
          "case_sensitive": false
        },
        "returns": true
      },
      {
        "arguments": {
          "data": "\u00c4",
          "pattern": "\u00e4",
          "case_sensitive": false
        },
        "returns": true
      },
      {
        "arguments": {
          "data": null,
          "pattern": "null"
        },
        "returns": null
      }
    ]
  },
  {
    "id": "text_merge",
    "summary": "Concatenate elements to a string",
    "description": "Merges string representations of a set of elements together to a single string, with the separator between each element.",
    "categories": [
      "texts"
    ],
    "parameters": [
      {
        "name": "data",
        "description": "A set of elements. Numbers, boolean values and null values get converted to their (lower case) string representation. For example: `1` (integer), `-1.5` (number), `true` / `false` (boolean values)",
        "schema": {
          "type": "array",
          "items": {
            "type": [
              "string",
              "number",
              "boolean",
              "null"
            ]
          }
        }
      },
      {
        "name": "separator",
        "description": "A separator to put between each of the individual texts. Defaults to an empty string.",
        "schema": {
          "type": [
            "string",
            "number",
            "boolean",
            "null"
          ]
        },
        "default": "",
        "optional": true
      }
    ],
    "returns": {
      "description": "Returns a string containing a string representation of all the array elements in the same order, with the separator between each element.",
      "schema": {
        "type": "string"
      }
    },
    "examples": [
      {
        "arguments": {
          "data": [
            "Hello",
            "World"
          ],
          "separator": " "
        },
        "returns": "Hello World"
      },
      {
        "arguments": {
          "data": [
            1,
            2,
            3,
            4,
            5,
            6,
            7,
            8,
            9,
            0
          ]
        },
        "returns": "1234567890"
      },
      {
        "arguments": {
          "data": [
            null,
            true,
            false,
            1,
            -1.5,
            "\u00df"
          ],
          "separator": "\n"
        },
        "returns": "null\ntrue\nfalse\n1\n-1.5\n\u00df"
      },
      {
        "arguments": {
          "data": [
            2,
            0
          ],
          "separator": 1
        },
        "returns": "210"
      },
      {
        "arguments": {
          "data": []
        },
        "returns": ""
      }
    ]
  },
  {
    "id": "variance",
    "summary": "Variance",
    "description": "Computes the sample variance of an array of numbers by calculating the square of the standard deviation (see ``sd()``). It is defined to be the expectation of the squared deviation of a random variable from its expected value. Basically, it measures how far the numbers in the array are spread out from their average value.\n\nAn array without non-`null` elements resolves always with `null`.",
    "categories": [
      "math",
      "reducer"
    ],
    "gee:custom": true,
    "parameters": [
      {
        "name": "data",
        "description": "An array of numbers.",
        "schema": {
          "type": "array",
          "items": {
            "type": [
              "number",
              "null"
            ]
          }
        }
      }
    ],
    "returns": {
      "description": "The computed sample variance.",
      "schema": {
        "type": [
          "number",
          "null"
        ]
      }
    },
    "examples": [
      {
        "arguments": {
          "data": [
            -1,
            1,
            3
          ]
        },
        "returns": 4
      },
      {
        "arguments": {
          "data": [
            2,
            3,
            3,
            null,
            4,
            4,
            5
          ]
        },
        "returns": 1.1
      },
      {
        "description": "The input array is empty: return `null`.",
        "arguments": {
          "data": []
        },
        "returns": null
      }
    ],
    "links": [
      {
        "rel": "about",
        "href": "http://mathworld.wolfram.com/Variance.html",
        "title": "Variance explained by Wolfram MathWorld"
      }
    ]
  }
]