<?xml version="1.0"?>
<rdf:RDF
    xmlns:xsp="http://www.owl-ontologies.com/2005/08/07/xsp.owl#"
    xmlns:swrlb="http://www.w3.org/2003/11/swrlb#"
    xmlns:p1="http://iridl.ldeo.columbia.edu/ontologies/cca.owl#"
    xmlns:swrl="http://www.w3.org/2003/11/swrl#"
    xmlns:protege="http://protege.stanford.edu/plugins/owl/protege#"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:xsd="http://www.w3.org/2001/XMLSchema#"
    xmlns:rdfs="http://www.w3.org/2000/01/rdf-schema#"
    xmlns:owl="http://www.w3.org/2002/07/owl#"
    xmlns:fn="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#"
    xmlns="http://iridl.ldeo.columbia.edu/ontologies/functions_ingrid.owl#"
  xml:base="http://iridl.ldeo.columbia.edu/ontologies/functions_ingrid.owl">
  <owl:Ontology rdf:about="">
    <owl:imports rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl"/>
    <owl:imports rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/cca.owl"/>
  </owl:Ontology>
  <fn:Argument rdf:ID="BofAC1">
    <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Variable to be converted</fn:arg_desc>
    <rdfs:label xml:lang="en">BofA=C1</rdfs:label>
    <fn:arg_name xml:lang="en">A</fn:arg_name>
    <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
    <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
    >false</fn:optional>
    <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
    <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
    >1</fn:arg_order>
  </fn:Argument>
  <fn:Argument_Type rdf:ID="Argument_Type_4"/>
  <fn:Argument rdf:ID="readgrib2">
    <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
    <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
    <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
    >false</fn:optional>
    <fn:arg_name xml:lang="en">int</fn:arg_name>
    <rdfs:label xml:lang="en">readgrib2</rdfs:label>
    <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
    >2</fn:arg_order>
  </fn:Argument>
  <fn:Argument rdf:ID="medianover2">
    <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
    >2</fn:arg_order>
    <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
    <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
    >false</fn:optional>
    <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Grids over which median will be derived</fn:arg_desc>
    <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
    <fn:arg_name xml:lang="en">grids</fn:arg_name>
    <rdfs:label xml:lang="en">medianover2</rdfs:label>
  </fn:Argument>
  <fn:Argument_Type rdf:ID="Argument_Type_3"/>
  <fn:Argument rdf:ID="medianover3">
    <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
    <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
    >3</fn:arg_order>
    <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >var'</fn:arg_name>
    <rdfs:label xml:lang="en">medianover3</rdfs:label>
    <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
    >false</fn:optional>
    <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
    <fn:arg_desc xml:lang="en">median over the given grids</fn:arg_desc>
  </fn:Argument>
  <fn:Argument rdf:ID="medianover1">
    <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
    <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
    <rdfs:label xml:lang="en">medianover1</rdfs:label>
    <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >var</fn:arg_name>
    <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
    >false</fn:optional>
    <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
    >1</fn:arg_order>
    <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Variable from which median will be derived</fn:arg_desc>
  </fn:Argument>
  <fn:Function rdf:ID="tsptogauR">
    <fn:hasArgument>
      <fn:Argument rdf:ID="tsptogauR2">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >nx</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc xml:lang="en">number of longitude points</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#tsptogauR"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="tsptogauR3">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ny</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#tsptogauR"/>
        <fn:arg_desc xml:lang="en">number of latitude points</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="tsptogauR4">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var'</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable after conversion</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:isArgumentOf rdf:resource="#tsptogauR"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="tsptogauR1">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to be converted</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#tsptogauR"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy>
      <fn:Keyword rdf:about="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#Spectral_Transformation">
        <fn:describes>
          <fn:Function rdf:ID="gaussianlat">
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >gaussianlat</fn:func_name>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#Spectral_Transformation"/>
            <rdfs:label xml:lang="en">gaussianlat</rdfs:label>
            <rdfs:comment xml:lang="en">returns gaussian grid with n points.</rdfs:comment>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Returns gaussian grid with n points</fn:func_desc>
            <fn:hasArgument>
              <fn:Argument rdf:ID="gaussianlat1">
                <fn:arg_name xml:lang="en">n</fn:arg_name>
                <rdfs:label xml:lang="en">gaussianlat1</rdfs:label>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
                <fn:isArgumentOf rdf:resource="#gaussianlat"/>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="gaussianlat2">
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Gaussian grid with n points</fn:arg_desc>
                <rdfs:label xml:lang="en">gaussianlat2</rdfs:label>
                <fn:arg_name xml:lang="en">grid</fn:arg_name>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
                <fn:isArgumentOf rdf:resource="#gaussianlat"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
              </fn:Argument>
            </fn:hasArgument>
          </fn:Function>
        </fn:describes>
        <fn:describes>
          <fn:Function rdf:ID="partialeast">
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#Spectral_Transformation"/>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Applies zonal derivative to variable in spectral coordinates</fn:func_desc>
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >partialeast</fn:func_name>
            <rdfs:comment xml:lang="en">applies zonal derivative to variable in spectral coordinates</rdfs:comment>
            <fn:hasArgument>
              <fn:Argument rdf:ID="partialeast2">
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Variable after zonal derivative in spectral coordinates has been applied</fn:arg_desc>
                <fn:isArgumentOf rdf:resource="#partialeast"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var'</fn:arg_name>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <rdfs:label xml:lang="en">partialeast2</rdfs:label>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="partialeast1">
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Variable to which zonal derivative will be applied</fn:arg_desc>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var</fn:arg_name>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <rdfs:label xml:lang="en">partialeast</rdfs:label>
                <fn:isArgumentOf rdf:resource="#partialeast"/>
              </fn:Argument>
            </fn:hasArgument>
            <rdfs:label xml:lang="en">partialeast</rdfs:label>
          </fn:Function>
        </fn:describes>
        <fn:describes>
          <fn:Function rdf:ID="changetruncation">
            <rdfs:label xml:lang="en">changetruncation</rdfs:label>
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >changetruncation</fn:func_name>
            <fn:hasArgument>
              <fn:Argument rdf:ID="changetruncation1">
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <rdfs:label xml:lang="en">changetruncation1</rdfs:label>
                <fn:isArgumentOf rdf:resource="#changetruncation"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var</fn:arg_name>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Variable to be changed</fn:arg_desc>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="changetruncation3">
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var'</fn:arg_name>
                <rdfs:label xml:lang="en">changetruncation3</rdfs:label>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >New spectral truncation level</fn:arg_desc>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >3</fn:arg_order>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                <fn:isArgumentOf rdf:resource="#changetruncation"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="changetruncation2">
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
                <fn:arg_name xml:lang="en">nsp</fn:arg_name>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <rdfs:label xml:lang="en">changetruncation2</rdfs:label>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:isArgumentOf rdf:resource="#changetruncation"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Changes variable truncations to nsp</fn:func_desc>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#Spectral_Transformation"/>
            <rdfs:comment xml:lang="en">changes variable truncations to nsp</rdfs:comment>
          </fn:Function>
        </fn:describes>
        <fn:describes>
          <fn:Function rdf:ID="laplacian">
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#Spectral_Transformation"/>
            <rdfs:label xml:lang="en">laplacian</rdfs:label>
            <rdfs:comment xml:lang="en">applies Laplacian to variable in spectral coordinates</rdfs:comment>
            <fn:hasArgument>
              <fn:Argument rdf:ID="laplacian2">
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >New variable to which Laplacian has been appllied</fn:arg_desc>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <rdfs:label xml:lang="en">laplacian2</rdfs:label>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var'</fn:arg_name>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <fn:isArgumentOf rdf:resource="#laplacian"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="laplacian1">
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Variable to which Laplacian will be applied</fn:arg_desc>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
                <rdfs:label xml:lang="en">laplacian1</rdfs:label>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var</fn:arg_name>
                <fn:isArgumentOf rdf:resource="#laplacian"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Applies Laplacian to variable in spectral coordinates</fn:func_desc>
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >laplacian</fn:func_name>
          </fn:Function>
        </fn:describes>
        <fn:describes>
          <fn:Function rdf:ID="tsptogau">
            <fn:hasArgument>
              <fn:Argument rdf:ID="tsptogau3">
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
                <fn:arg_desc xml:lang="en">number of latitude points</fn:arg_desc>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >3</fn:arg_order>
                <fn:isArgumentOf rdf:resource="#tsptogau"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_name xml:lang="en">ny</fn:arg_name>
                <rdfs:label xml:lang="en">tsptogau3</rdfs:label>
              </fn:Argument>
            </fn:hasArgument>
            <rdfs:comment xml:lang="en">converts spectral coefficients to lon/lat</rdfs:comment>
            <rdfs:label xml:lang="en">tsptogau</rdfs:label>
            <fn:hasArgument>
              <fn:Argument rdf:ID="tsptogau2">
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <fn:arg_desc xml:lang="en">number of longitude points</fn:arg_desc>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_name xml:lang="en">nx</fn:arg_name>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
                <rdfs:label xml:lang="en">tsptogau2</rdfs:label>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:isArgumentOf rdf:resource="#tsptogau"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="tsptogau4">
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var'</fn:arg_name>
                <fn:isArgumentOf rdf:resource="#tsptogau"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Variable converted to lon/lat</fn:arg_desc>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >4</fn:arg_order>
                <rdfs:label xml:lang="en">tsptogau4</rdfs:label>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >tsptogau</fn:func_name>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#Spectral_Transformation"/>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Converts spectral coefficients to lon/lat</fn:func_desc>
            <fn:hasArgument>
              <fn:Argument rdf:ID="tsptogau1">
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var</fn:arg_name>
                <fn:isArgumentOf rdf:resource="#tsptogau"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Variable to be converted</fn:arg_desc>
                <rdfs:label xml:lang="en">tsptogau1</rdfs:label>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
              </fn:Argument>
            </fn:hasArgument>
          </fn:Function>
        </fn:describes>
        <rdfs:label rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Spectral Transformation</rdfs:label>
        <fn:describes>
          <fn:Function rdf:ID="gautotspUV">
            <fn:hasArgument>
              <fn:Argument rdf:ID="gautotspUV3">
                <fn:isArgumentOf rdf:resource="#gautotspUV"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Variable converted to spectral coefficients velocity</fn:arg_desc>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var'</fn:arg_name>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >3</fn:arg_order>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="gautotspUV2">
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <fn:isArgumentOf rdf:resource="#gautotspUV"/>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >spectral truncation</fn:arg_desc>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >nwave</fn:arg_name>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="gautotspUV1">
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Variable to be converted</fn:arg_desc>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var</fn:arg_name>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:isArgumentOf rdf:resource="#gautotspUV"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
              </fn:Argument>
            </fn:hasArgument>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#Spectral_Transformation"/>
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >gautotspUV</fn:func_name>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Converts lon/lat to spectral coefficients using spectral harmonics for 
    velocity</fn:func_desc>
          </fn:Function>
        </fn:describes>
        <fn:describes>
          <fn:Function rdf:ID="tsptogauUV">
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >tsptogauUV</fn:func_name>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#Spectral_Transformation"/>
            <fn:hasArgument>
              <fn:Argument rdf:ID="tsptogauUV2">
                <fn:isArgumentOf rdf:resource="#tsptogauUV"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >nx</fn:arg_name>
                <fn:arg_desc xml:lang="en">number of longitude points</fn:arg_desc>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="tsptogauUV1">
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Variable to be converted</fn:arg_desc>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var</fn:arg_name>
                <fn:isArgumentOf rdf:resource="#tsptogauUV"/>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="tsptogauUV4">
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >4</fn:arg_order>
                <fn:isArgumentOf rdf:resource="#tsptogauUV"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var'</fn:arg_name>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Variable converted to lon/lat velocities</fn:arg_desc>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="tsptogauUV3">
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >ny</fn:arg_name>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_desc xml:lang="en">number of latitude points</fn:arg_desc>
                <fn:isArgumentOf rdf:resource="#tsptogauUV"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >3</fn:arg_order>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Converts spectral coefficients to lon/lat using spectral harmonics for velocity</fn:func_desc>
          </fn:Function>
        </fn:describes>
        <fn:describes>
          <fn:Function rdf:ID="partialnorth">
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#Spectral_Transformation"/>
            <fn:hasArgument>
              <fn:Argument rdf:ID="partialnorth2">
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Variable after meridional derivative applied</fn:arg_desc>
                <fn:isArgumentOf rdf:resource="#partialnorth"/>
                <rdfs:label xml:lang="en">partialnorth2</rdfs:label>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var'</fn:arg_name>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="partialnorth1">
                <fn:isArgumentOf rdf:resource="#partialnorth"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Variable to which meridional derivative will be applied to</fn:arg_desc>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var</fn:arg_name>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <rdfs:label xml:lang="en">partialnorth1</rdfs:label>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
              </fn:Argument>
            </fn:hasArgument>
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >partialnorth</fn:func_name>
            <rdfs:comment xml:lang="en">applies meridional derivative to variable in spectral coordinates</rdfs:comment>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Applies meridional derivative to variable in spectral coordinates</fn:func_desc>
            <rdfs:label xml:lang="en">partialnorth</rdfs:label>
          </fn:Function>
        </fn:describes>
        <fn:describes>
          <fn:Function rdf:ID="gautotsp">
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#Spectral_Transformation"/>
            <fn:hasArgument>
              <fn:Argument rdf:ID="gautotsp1">
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Lon/Lat </fn:arg_desc>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <rdfs:label xml:lang="en">gautotsp1</rdfs:label>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var</fn:arg_name>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:isArgumentOf rdf:resource="#gautotsp"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="gautotsp2">
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
                <fn:arg_desc xml:lang="en">spectral truncation</fn:arg_desc>
                <fn:arg_name xml:lang="en">nwave</fn:arg_name>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:isArgumentOf rdf:resource="#gautotsp"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <rdfs:label xml:lang="en">gautotsp2</rdfs:label>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="gautotsp3">
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >3</fn:arg_order>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var'</fn:arg_name>
                <rdfs:label xml:lang="en">gautotsp3</rdfs:label>
                <fn:isArgumentOf rdf:resource="#gautotsp"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Spectral coefficients</fn:arg_desc>
              </fn:Argument>
            </fn:hasArgument>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Converts lon/lat to spectral coefficients</fn:func_desc>
            <rdfs:comment xml:lang="en">converts lon/lat to spectral coefficients</rdfs:comment>
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >gautotsp</fn:func_name>
            <rdfs:label xml:lang="en">gautotsp</rdfs:label>
          </fn:Function>
        </fn:describes>
        <fn:describes rdf:resource="#tsptogauR"/>
        <fn:describes>
          <fn:Function rdf:ID="invlaplacian">
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >invlaplacian</fn:func_name>
            <fn:hasArgument>
              <fn:Argument rdf:ID="invlaplacian2">
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Inverse laplacian applied to stream in spectral coordinates</fn:arg_desc>
                <rdfs:label xml:lang="en">invlaplacian2</rdfs:label>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var'</fn:arg_name>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                <fn:isArgumentOf rdf:resource="#invlaplacian"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="invlaplacian1">
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:isArgumentOf rdf:resource="#invlaplacian"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var</fn:arg_name>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Varibable to which inverse laplacian will be applied</fn:arg_desc>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
                <rdfs:label xml:lang="en">invlaplacian1</rdfs:label>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
              </fn:Argument>
            </fn:hasArgument>
            <rdfs:label xml:lang="en">invlaplacian</rdfs:label>
            <rdfs:comment xml:lang="en">applies inverse laplacian to variable in spectral coordinates</rdfs:comment>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Applies inverse laplacian to variable in spectral coordinates</fn:func_desc>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#Spectral_Transformation"/>
          </fn:Function>
        </fn:describes>
      </fn:Keyword>
    </fn:isDescribedBy>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >tsptogauR</fn:func_name>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Converts spectral coefficients to lon/lat</fn:func_desc>
  </fn:Function>
  <fn:Function rdf:ID="unsplitstreamgrid">
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Combines two grids (i.e., independent variables) that were created by the splitstreamgrid function (i.e., undoes splitstreamgrid)</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="unsplitstreamgrid_a3">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#unsplitstreamgrid"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >same as &lt;i&gt;var&lt;/i&gt; except now dependent on &lt;i&gt;grid_combined&lt;/i&gt; instead of &lt;i&gt;grid&lt;/i&gt; and &lt;i&gt;grid&lt;/i&gt;2</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >varout</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Combines two grids (i.e., independent variables) that were created by the splitstreamgrid function (i.e., undoes splitstreamgrid)</rdfs:comment>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .NOAA .NCEP .EMC .CMB .GLOBAL .Reyn_SmithOIv2 .monthly .sst
&lt;br&gt;T (Jan 1982) (Dec 2003) RANGE
&lt;br&gt;T 12 splitstreamgrid
&lt;br&gt;T unsplitstreamgrid</fn:syntax_ex>
    <fn:hasArgument>
      <fn:Argument rdf:ID="unsplitstreamgrid_a4">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:isArgumentOf rdf:resource="#unsplitstreamgrid"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid containing combined values of &lt;i&gt;grid&lt;/i&gt; and &lt;i&gt;grid&lt;/i&gt;2</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid_combined</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="unsplitstreamgrid_a1">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable dependent on grids to be combined</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:isArgumentOf rdf:resource="#unsplitstreamgrid"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy>
      <rdf:Description rdf:about="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_modification">
        <fn:describes>
          <fn:Ingrid_Procedure rdf:ID="SAMPLE_MISSING">
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_modification"/>
            <fn:hasArgument>
              <fn:Argument rdf:ID="SAMPLE_MISSING3">
                <fn:isArgumentOf rdf:resource="#SAMPLE_MISSING"/>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >independent variable to be sampled along</fn:arg_desc>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >grid</fn:arg_name>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >3</fn:arg_order>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="SAMPLE_MISSING4">
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >4</fn:arg_order>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >sampled variable -- all values of grid found in var2 have been dropped.</fn:arg_desc>
                <fn:isArgumentOf rdf:resource="#SAMPLE_MISSING"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var1-sampled</fn:arg_name>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >samples variable by keeping only what is missing from a second variable</fn:func_desc>
            <fn:hasArgument>
              <fn:Argument rdf:ID="SAMPLE_MISSING1">
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >variable to be sampled</fn:arg_desc>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var1</fn:arg_name>
                <fn:isArgumentOf rdf:resource="#SAMPLE_MISSING"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:ingrid_code rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >3 /SAMPLE_MISSING publicproc:  dup type /arraytype eq { dup 0 get totype /gridtype eq } if { 0 get .name 2 index 1 index getgridbyname nip        3 1 roll        getgridbyname nip } if {mydataset initial_grid remove_grid}inputs  mydataset initial_grid /districtmap unitmatrix  streamgrids pop remove_grid SAMPLE [streamgrids pop]sum 0 maskgt  streamgrids initial_grid .name cvlit renameGRID SELECT  1output  :publicproc</fn:ingrid_code>
            <fn:hasArgument>
              <fn:Argument rdf:ID="SAMPLE_MISSING2">
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var2</fn:arg_name>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <fn:isArgumentOf rdf:resource="#SAMPLE_MISSING"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >where list of values to remove is taken from</fn:arg_desc>
              </fn:Argument>
            </fn:hasArgument>
            <fn:isDescribedBy>
              <rdf:Description rdf:about="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#independent_variable_modification">
                <fn:describes>
                  <fn:Function rdf:ID="regridAverage">
                    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                    >Regrids a variable by averaging.  Indicated grids of one variable are regridded to match those of another variable.  The function is commonly used when comparing multiple variables that are dependent on different spatial grids (see correlation example below).</fn:func_desc>
                    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_modification"/>
                    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                    >SOURCES .NOAA .NCEP .CPC .Merged_Analysis .monthly .v0407 .ver2 .prcp_est
&lt;br&gt;SOURCES .CDIAC .tr051 .precipitation .anomalies
&lt;br&gt;[X Y] regridAverage
 &lt;p&gt;
OR
&lt;p&gt;
SOURCES .NOAA .NCEP .CPC .Merged_Analysis .monthly .v0407 .ver2 .prcp_est
&lt;br&gt;T (Jan 1980) (Dec 2003) RANGE
&lt;br&gt;SOURCES .NOAA .NCDC .ERSST .version2 .SST
&lt;br&gt;T (Jan 1980) (Dec 2003) RANGE
&lt;br&gt;[X Y]0.5 regridAverage
&lt;br&gt;[T]correlate
&lt;p&gt;Note that in the second example, the &lt;i&gt;minfrac&lt;/i&gt; value of 0.5 requires that at least half of the input data that go into a particular output gridpoint have non-missing values in order for that gridpoint to receive a non-missing value in the regridding (i.e., keeps land from expanding outward).</fn:syntax_ex>
                    <fn:isDescribedBy>
                      <fn:Keyword rdf:about="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#Regridding">
                        <rdfs:label xml:lang="en">Regridding</rdfs:label>
                        <fn:describes>
                          <fn:Function rdf:ID="regridLB">
                            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#independent_variable_modification"/>
                            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#Regridding"/>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="regridLB2">
                                <rdfs:label xml:lang="en">regridLB2</rdfs:label>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                                <fn:isArgumentOf rdf:resource="#regridLB"/>
                                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >Variable to be regridded</fn:arg_desc>
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >2</fn:arg_order>
                                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >var2</fn:arg_name>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                              </fn:Argument>
                            </fn:hasArgument>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="regridLB5">
                                <fn:isArgumentOf rdf:resource="#regridLB"/>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >Regridded variable</fn:arg_desc>
                                <rdfs:label xml:lang="en">regridLB5</rdfs:label>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >5</fn:arg_order>
                                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >var2'</fn:arg_name>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                              </fn:Argument>
                            </fn:hasArgument>
                            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                            >Regrids variable2 to match variable1 by using left bounds, i.e. grid is 
    ordered, variable2's grid is a subset of variable1's grid, the values of 
    the variable1 grid are bounded by the values of the variable2 grid, and 
    the variable2 values that are on the left of that pair are used as the 
    matching values</fn:func_desc>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="regridLB4">
                                <rdfs:label xml:lang="en">regridLB4</rdfs:label>
                                <fn:isArgumentOf rdf:resource="#regridLB"/>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >4</fn:arg_order>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >Unchanged variable1</fn:arg_desc>
                                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >var1</fn:arg_name>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                              </fn:Argument>
                            </fn:hasArgument>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="regridLB1">
                                <fn:isArgumentOf rdf:resource="#regridLB"/>
                                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >Variable to be compared to</fn:arg_desc>
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >1</fn:arg_order>
                                <rdfs:label xml:lang="en">regridLB1</rdfs:label>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >var1</fn:arg_name>
                              </fn:Argument>
                            </fn:hasArgument>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="regridLB3">
                                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >ivar</fn:arg_name>
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >3</fn:arg_order>
                                <rdfs:label xml:lang="en">regridLB3</rdfs:label>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
                                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >Independent variable to be applied to to variables</fn:arg_desc>
                                <fn:isArgumentOf rdf:resource="#regridLB"/>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                              </fn:Argument>
                            </fn:hasArgument>
                            <rdfs:label xml:lang="en">regridLB</rdfs:label>
                            <rdfs:comment xml:lang="en">regrids variable2 to match variable1 by using left bounds, i.e. grid is 
    ordered, variable2's grid is a subset of variable1's grid, the values of the 
    variable1 grid are bounded by the values of the variable2 grid, and the 
    variable2 values that are on the left of that pair are used as the matching 
    values.</rdfs:comment>  <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                            >regridLB</fn:func_name>
                          </fn:Function>
                        </fn:describes>
                        <fn:describes rdf:resource="#regridAverage"/>
                        <fn:describes>
                          <fn:Function rdf:ID="GRID">
                            <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                            >&lt;br&gt;
    &lt;b&gt;&lt;u&gt;Description&lt;/u&gt;&lt;/b&gt;&lt;br&gt;&lt;br&gt;&lt;b&gt;GRID&lt;/b&gt; regrids an existing 
    independent variable (grid) associated with a data set or variable with a 
    newly-defined evenly-spaced grid based upon user-defined limits and 
    spacing.&lt;br&gt;&lt;br&gt;In the function arguments &amp;quot;var&amp;quot; is a data variable that 
    depends on the independent variable &amp;quot;grid&amp;quot;, &amp;quot;lowbound&amp;quot; is the minimum 
    value of the new grid being defined, &amp;quot;step&amp;quot; is the evenly-spaced interval 
    of the new grid in the units of &amp;quot;grid&amp;quot;, and &amp;quot;highbound&amp;quot; is the upper limit 
    of the new grid.&lt;br&gt;&lt;br&gt;&lt;b&gt;&lt;u&gt;Example&lt;/u&gt;&lt;/b&gt;&lt;br&gt;&lt;br&gt;In the following 
    example, a gridded data set of monthly mean short wave radiances is 
    spatially regridded globally (from -180&amp;#176; to 179&amp;#176; in longitude and -90&amp;#176; to 
    90&amp;#176; in latitude) from 2.5&amp;#176; lat/lon grid spacing to 1&amp;#176; lat/lon spacing. 
    Bi-linear interpolation is used to regrid from the coarser to the finer 
    grid.&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES .ERBE .global .monthly .srb&lt;br&gt;X 
    -180 1 179 GRID&lt;br&gt;Y -90 1 90 GRID&lt;/font&gt;&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.ERBE/.global/.monthly/.srb/X/-180/1/179/GRID/Y/-90/1/90/GRID/"&gt;Live 
    Example Link&lt;/a&gt;</fn:syntax_ex>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="GRID_a6">
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >regridvar</fn:arg_name>
                                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >&lt;i&gt;var&lt;/i&gt; regridded onto newly-defined grid
&lt;p&gt;
Data at new grid points are based on linear interpolation of original &lt;i&gt;var&lt;/i&gt;.</fn:arg_desc>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >6</fn:arg_order>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                                <fn:isArgumentOf rdf:resource="#GRID"/>
                              </fn:Argument>
                            </fn:hasArgument>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="GRID_a2">
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                                <fn:isArgumentOf rdf:resource="#GRID"/>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
                                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >grid</fn:arg_name>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >grid (i.e., independent variable) on which new grid specifications (e.g., lowbound, step, highbound) are to be applied</fn:arg_desc>
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >2</fn:arg_order>
                              </fn:Argument>
                            </fn:hasArgument>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="GRID_a1">
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >1</fn:arg_order>
                                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >var</fn:arg_name>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                                <fn:isArgumentOf rdf:resource="#GRID"/>
                                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >variable to be regridded</fn:arg_desc>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                              </fn:Argument>
                            </fn:hasArgument>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="GRID_a3">
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >3</fn:arg_order>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                                <fn:isArgumentOf rdf:resource="#GRID"/>
                                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >lowbound</fn:arg_name>
                                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >lower limit of new grid definition</fn:arg_desc>
                              </fn:Argument>
                            </fn:hasArgument>
                            <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                            >Regrids a variable onto a newly-defined, evenly-spaced grid (i.e., independent variable)</rdfs:comment>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="GRID_a4">
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >4</fn:arg_order>
                                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >step</fn:arg_name>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                                <fn:isArgumentOf rdf:resource="#GRID"/>
                                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >width (in units of &lt;i&gt;grid&lt;/i&gt;) between new grid points
&lt;p&gt;
If n is not an integer, where n=(&lt;i&gt;highbound&lt;/i&gt;-&lt;i&gt;lowbound&lt;/i&gt;)/&lt;i&gt;step&lt;/i&gt;, then &lt;i&gt;step&lt;/i&gt; is assigned closest value that allows n to be an integer.</fn:arg_desc>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
                              </fn:Argument>
                            </fn:hasArgument>
                            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#Regridding"/>
                            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#independent_variable_modification"/>
                            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_modification"/>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="GRID_a5">
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >5</fn:arg_order>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                                <fn:isArgumentOf rdf:resource="#GRID"/>
                                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >highbound</fn:arg_name>
                                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >upper limit of new grid definition</fn:arg_desc>
                              </fn:Argument>
                            </fn:hasArgument>
                            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                            >GRID</fn:func_name>
                            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                            >Regrids a variable onto a newly-defined, evenly-spaced grid (i.e., independent variable)</fn:func_desc>
                          </fn:Function>
                        </fn:describes>
                        <fn:describes>
                          <fn:Function rdf:ID="regridLinear">
                            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#independent_variable_modification"/>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="regridLinear7">
                                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >var2'</fn:arg_name>
                                <fn:isArgumentOf rdf:resource="#regridLinear"/>
                                <rdfs:label xml:lang="en">regridLinear7</rdfs:label>
                                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >Variable after regridding</fn:arg_desc>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >7</fn:arg_order>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                              </fn:Argument>
                            </fn:hasArgument>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="regridLinear4">
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >4</fn:arg_order>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                                <fn:arg_name xml:lang="en">Wght</fn:arg_name>
                                <fn:isArgumentOf rdf:resource="#regridLinear"/>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                                <rdfs:label xml:lang="en">regridLinear4</rdfs:label>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_proc"/>
                              </fn:Argument>
                            </fn:hasArgument>
                            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#Regridding"/>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="regridLinear2">
                                <fn:isArgumentOf rdf:resource="#regridLinear"/>
                                <rdfs:label xml:lang="en">regridLinear2</rdfs:label>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >Variable to be regridded</fn:arg_desc>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >2</fn:arg_order>
                                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >var2</fn:arg_name>
                              </fn:Argument>
                            </fn:hasArgument>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="regridLinear5">
                                <fn:arg_name xml:lang="en">Wmin</fn:arg_name>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
                                <fn:isArgumentOf rdf:resource="#regridLinear"/>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >true</fn:optional>
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >5</fn:arg_order>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                                <rdfs:label xml:lang="en">regridLinear5</rdfs:label>
                              </fn:Argument>
                            </fn:hasArgument>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="regridLinear3">
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >3</fn:arg_order>
                                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >ivar'</fn:arg_name>
                                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >Independent variable to be applied to variables</fn:arg_desc>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                                <fn:isArgumentOf rdf:resource="#regridLinear"/>
                                <rdfs:label xml:lang="en">regridLinear3</rdfs:label>
                              </fn:Argument>
                            </fn:hasArgument>
                            <rdfs:label xml:lang="en">regridLinear</rdfs:label>
                            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                            >Regrids by averaging</fn:func_desc>
                            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                            >regridLinear</fn:func_name>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="regridLinear6">
                                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >Unchanged variable</fn:arg_desc>
                                <rdfs:label xml:lang="en">regridLinear6</rdfs:label>
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >6</fn:arg_order>
                                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >var1</fn:arg_name>
                                <fn:isArgumentOf rdf:resource="#regridLinear"/>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                              </fn:Argument>
                            </fn:hasArgument>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="regridLinear1">
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >1</fn:arg_order>
                                <rdfs:label xml:lang="en">regridLinear1</rdfs:label>
                                <fn:isArgumentOf rdf:resource="#regridLinear"/>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >var1</fn:arg_name>
                                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >Variable to be regridded</fn:arg_desc>
                              </fn:Argument>
                            </fn:hasArgument>
                            <rdfs:comment xml:lang="en">regrids by two point linear interpretation</rdfs:comment>
                          </fn:Function>
                        </fn:describes>
                        <fn:describes>
                          <fn:Function rdf:ID="transit">
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="transit3">
                                <fn:isArgumentOf rdf:resource="#transit"/>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >3</fn:arg_order>
                                <fn:arg_desc xml:lang="en">ship track</fn:arg_desc>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                                <rdfs:label xml:lang="en">transit3</rdfs:label>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                                <fn:arg_name xml:lang="en">Y(S)</fn:arg_name>
                              </fn:Argument>
                            </fn:hasArgument>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="transit5">
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                                <fn:isArgumentOf rdf:resource="#transit"/>
                                <rdfs:label xml:lang="en">transit5</rdfs:label>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >Returns the position on the given grid of the ship track</fn:arg_desc>
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >5</fn:arg_order>
                                <fn:arg_name xml:lang="en">D(S)</fn:arg_name>
                              </fn:Argument>
                            </fn:hasArgument>
                            <rdfs:comment xml:lang="en">given a variable D(X,Y) and a ship track X(S), Y(S), returns D(S).</rdfs:comment>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="transit2">
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                                <fn:arg_name xml:lang="en">X(S)</fn:arg_name>
                                <fn:arg_desc xml:lang="en">ship track</fn:arg_desc>
                                <rdfs:label xml:lang="en">transit2</rdfs:label>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >2</fn:arg_order>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                                <fn:isArgumentOf rdf:resource="#transit"/>
                              </fn:Argument>
                            </fn:hasArgument>
                            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                            >Given a variable D(X,Y) and a ship track X(S), Y(S), returns D(S).</fn:func_desc>
                            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                            >transit</fn:func_name>
                            <rdfs:label xml:lang="en">transit</rdfs:label>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="transit1">
                                <fn:isArgumentOf rdf:resource="#transit"/>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >1</fn:arg_order>
                                <fn:arg_name xml:lang="en">D(X,Y)</fn:arg_name>
                                <rdfs:label xml:lang="en">transit1</rdfs:label>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                              </fn:Argument>
                            </fn:hasArgument>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="transit4">
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >4</fn:arg_order>
                                <rdfs:label xml:lang="en">transit4</rdfs:label>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
                                <fn:isArgumentOf rdf:resource="#transit"/>
                                <fn:arg_name xml:lang="en">S</fn:arg_name>
                              </fn:Argument>
                            </fn:hasArgument>
                            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#Regridding"/>
                          </fn:Function>
                        </fn:describes>
                      </fn:Keyword>
                    </fn:isDescribedBy>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="regridAverage_a5">
                        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >minfrac</fn:arg_name>
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >5</fn:arg_order>
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >true</fn:optional>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >Minimum fraction of data that must be present (i.e., fraction not indicated as missing) within the selected domain in order for the average to be calculated. If minfrac is not present, then a missing value is returned. If minfrac is not given, then the average is calculated regardless of the amount of data present in domain.</fn:arg_desc>
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                        <fn:isArgumentOf rdf:resource="#regridAverage"/>
                      </fn:Argument>
                    </fn:hasArgument>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="regridAverage_a2">
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >variable whose grid(s) are to be regridded</fn:arg_desc>
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >2</fn:arg_order>
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >false</fn:optional>
                        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >var2</fn:arg_name>
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                        <fn:isArgumentOf rdf:resource="#regridAverage"/>
                      </fn:Argument>
                    </fn:hasArgument>
                    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                    >Regrids a variable by averaging.  Indicated grids of one variable are regridded to match those of another variable.  The function is commonly used when comparing multiple variables that are dependent on different spatial grids (see correlation example below).</rdfs:comment>
                    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#independent_variable_modification"/>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="regridAverage_a4">
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#proc"/>
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                        <fn:isArgumentOf rdf:resource="#regridAverage"/>
                        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >weights</fn:arg_name>
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >true</fn:optional>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >weights to be used in the averaging. Note: not generally needed unless regridding to a very coarse spatial grid.</fn:arg_desc>
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >4</fn:arg_order>
                      </fn:Argument>
                    </fn:hasArgument>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="regridAverage_a6">
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >false</fn:optional>
                        <fn:isArgumentOf rdf:resource="#regridAverage"/>
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >var2regridded</fn:arg_name>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >Same as &lt;i&gt;var2&lt;/i&gt; except it is now dependent on &lt;i&gt;grids&lt;/i&gt; as they are defined in &lt;i&gt;var1&lt;/i&gt;.</fn:arg_desc>
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >6</fn:arg_order>
                      </fn:Argument>
                    </fn:hasArgument>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="regridAverage_a3">
                        <fn:isArgumentOf rdf:resource="#regridAverage"/>
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >3</fn:arg_order>
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >grid(s) of &lt;i&gt;var2&lt;/i&gt; to be regridded to match those of &lt;i&gt;var1&lt;/i&gt;. Note: use caution when applying the function to temporal grids to make sure that the desired output is actually returned, particularly when regridding a coarse temporal grid to a relatively fine temporal grid.</fn:arg_desc>
                        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >grids</fn:arg_name>
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >false</fn:optional>
                      </fn:Argument>
                    </fn:hasArgument>
                    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                    >regridAverage</fn:func_name>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="regridAverage_a1">
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >1</fn:arg_order>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >variable (i.e, its grids) on which regridding is based</fn:arg_desc>
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >false</fn:optional>
                        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >var1</fn:arg_name>
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                        <fn:isArgumentOf rdf:resource="#regridAverage"/>
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                      </fn:Argument>
                    </fn:hasArgument>
                  </fn:Function>
                </fn:describes>
                <fn:describes rdf:resource="#regridLinear"/>
                <fn:describes rdf:resource="#SAMPLE_MISSING"/>
                <fn:describes rdf:resource="#regridLB"/>
                <fn:describes>
                  <fn:Ingrid_Procedure rdf:ID="use_as_grid">
                    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#independent_variable_modification"/>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="use_as_grid1">
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >false</fn:optional>
                        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >dataset</fn:arg_name>
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >1</fn:arg_order>
                        <fn:isArgumentOf rdf:resource="#use_as_grid"/>
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >dataset to be altered</fn:arg_desc>
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
                      </fn:Argument>
                    </fn:hasArgument>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="use_as_grid3">
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >true</fn:optional>
                        <fn:isArgumentOf rdf:resource="#use_as_grid"/>
                        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >newname</fn:arg_name>
                        <fn:argument_type>
                          <fn:Argument_Type rdf:ID="string">
                            <rdfs:comment xml:lang="en">character argument</rdfs:comment>
                            <rdfs:label xml:lang="en">string</rdfs:label>
                          </fn:Argument_Type>
                        </fn:argument_type>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >name to use for independent variable</fn:arg_desc>
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >3</fn:arg_order>
                      </fn:Argument>
                    </fn:hasArgument>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="use_as_grid2">
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >false</fn:optional>
                        <fn:isArgumentOf rdf:resource="#use_as_grid"/>
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >var</fn:arg_name>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >1D dependent variable to be used as the new independent variable</fn:arg_desc>
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >2</fn:arg_order>
                      </fn:Argument>
                    </fn:hasArgument>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="use_as_grid4">
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                        <fn:isArgumentOf rdf:resource="#use_as_grid"/>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >new dataset with var as independent variable</fn:arg_desc>
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >4</fn:arg_order>
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >false</fn:optional>
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
                        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >dataset'</fn:arg_name>
                      </fn:Argument>
                    </fn:hasArgument>
                    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                    >use_as_grid</fn:func_name>
                    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                    >uses a 1D variable to replace the independent variable on which it depends</fn:func_desc>
                    <fn:ingrid_code rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                    >&lt;p style="margin-top: 0"&gt;
      dup type /stringtype eq {cvn} if
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      dup type /nametype eq {3}{2} ifelse
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      /use_as_grid publicproc:
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      dup type /nametype eq { cvx exch 1 object exch /name exch def } if
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      streamgrids exch
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      datatype /stringtype eq {toname}if
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      ndim RECHUNK
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      name units ordered 4 -1 roll getrealization NewGRID
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      3 -1 roll 5 object 1 index name exch def 3 1 roll
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      replaceGRID
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      :publicproc
    &lt;/p&gt;</fn:ingrid_code>
                  </fn:Ingrid_Procedure>
                </fn:describes>
              </rdf:Description>
            </fn:isDescribedBy>
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >SAMPLE_MISSING</fn:func_name>
          </fn:Ingrid_Procedure>
        </fn:describes>
        <fn:describes rdf:resource="#regridAverage"/>
      </rdf:Description>
    </fn:isDescribedBy>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >unsplitstreamgrid</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="unsplitstreamgrid_a2">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#unsplitstreamgrid"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid that was split with splitstreamgrid (see &lt;i&gt;grid_in&lt;/i&gt; and &lt;i&gt;gridout&lt;/i&gt; in splitstreamgrid function documentation)</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="evengridAverage">
    <fn:hasArgument>
      <fn:Argument rdf:ID="evengridAverage5">
        <fn:isArgumentOf rdf:resource="#evengridAverage"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >high</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >High value on ivar</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >5</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="evengridAverage7">
        <fn:isArgumentOf rdf:resource="#evengridAverage"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >7</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >New ivar evenly spaced from low to high with step</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var'</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="evengridAverage2">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ivar</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#evengridAverage"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Independent variable to be applied</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >evengridAverage</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="evengridAverage4">
        <fn:isArgumentOf rdf:resource="#evengridAverage"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >step</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Step between low and high on new ivar</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="evengridAverage1">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#evengridAverage"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to be regridded</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="evengridAverage3">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Low value on ivar</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#evengridAverage"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >low</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Regrids a variable to a new grid by averaging</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="evengridAverage6">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >true</fn:optional>
        <fn:isArgumentOf rdf:resource="#evengridAverage"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >6</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Wmin</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="laggedcovariance">
    <fn:hasArgument>
      <fn:Argument rdf:ID="laggedcovariance4">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <rdfs:label xml:lang="en">laggedcovariance4</rdfs:label>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name xml:lang="en">lags</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#numbers"/>
        <fn:isArgumentOf rdf:resource="#laggedcovariance"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="laggedcovariance3">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <rdfs:label xml:lang="en">laggedcovariance3</rdfs:label>
        <fn:isArgumentOf rdf:resource="#laggedcovariance"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:arg_name xml:lang="en">period</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="laggedcovariance6">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:isArgumentOf rdf:resource="#laggedcovariance"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >6</fn:arg_order>
        <rdfs:label xml:lang="en">laggedcovariance6</rdfs:label>
        <fn:arg_name xml:lang="en">cov</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_desc xml:lang="en">lagged covariance</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="laggedcovariance5">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >5</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <rdfs:label xml:lang="en">laggedcovariance5</rdfs:label>
        <fn:arg_name xml:lang="en">Egrid</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#laggedcovariance"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc xml:lang="en">Computes lagged covariance $C(E,E,S,L)$. If Tgrid is a variable, uses the 
    first grid as the time grid</fn:func_desc>
    <rdfs:label xml:lang="en">laggedcovariance</rdfs:label>
    <fn:func_name xml:lang="en">laggedcovariance</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="laggedcovariance2">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#laggedcovariance"/>
        <rdfs:label xml:lang="en">laggedcovariance2</rdfs:label>
        <fn:arg_name xml:lang="en">Tgrid</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment xml:lang="en">computes lagged covariance $C(E,E,S,L)$. If Tgrid is a variable, uses the 
    first grid as the time grid.</rdfs:comment>
    <fn:hasArgument>
      <fn:Argument rdf:ID="laggedcovariance1">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <rdfs:label xml:lang="en">laggedcovariance1</rdfs:label>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#laggedcovariance"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="mag">
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#vector_magnitude"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="mag_a3">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >magnitude of vector with components of &lt;i&gt;var1&lt;/i&gt; and &lt;i&gt;var2&lt;/i&gt;.  &lt;p&gt;&lt;i&gt;vectormag&lt;/i&gt; is dependent on all of the grids on which &lt;i&gt;var1&lt;/i&gt; and &lt;i&gt;var2&lt;/i&gt; are dependent.</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >vectormag</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:isArgumentOf rdf:resource="#mag"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .NOAA .NCEP-NCAR .CDAS-1 .MONTHLY .Intrinsic .PressureLevel .u
&lt;br&gt;SOURCES .NOAA .NCEP-NCAR .CDAS-1 .MONTHLY .Intrinsic .PressureLevel .v
&lt;br&gt;P 850 VALUE
&lt;br&gt;mag</fn:syntax_ex>
    <fn:hasArgument>
      <fn:Argument rdf:ID="mag_a1">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#mag"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var1</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >first component of vector</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Calculates the vector magnitude</fn:func_desc>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#arithmetic_functions"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="mag_a2">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#mag"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >second component of variable</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var2</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >mag</fn:func_name>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Calculates the vector magnitude</rdfs:comment>
  </fn:Function>
  <fn:Function rdf:ID="dens">
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >dens</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="dens3">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Pressure</fn:arg_desc>
        <fn:arg_name xml:lang="en">P</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <rdfs:label xml:lang="en">dens3</rdfs:label>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#dens"/>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment xml:lang="en">unecso '81 density (insitu) of seawater</rdfs:comment>
    <fn:isDescribedBy>
      <fn:Keyword rdf:about="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#oceanic_equation_of_state">
        <rdfs:label xml:lang="en">oceanic equation of state</rdfs:label>
      </fn:Keyword>
    </fn:isDescribedBy>
    <fn:hasArgument>
      <fn:Argument rdf:ID="dens1">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Temperature</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_name xml:lang="en">T</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <rdfs:label xml:lang="en">dens1</rdfs:label>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:isArgumentOf rdf:resource="#dens"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >&lt;p style="margin-top: 0"&gt;
      &lt;br&gt;
      &lt;b&gt;&lt;u&gt;Description&lt;/u&gt;&lt;/b&gt;&lt;br&gt;&lt;br&gt;&lt;b&gt;dens&lt;/b&gt; calculates the density of 
      seawater (in g/cm&lt;sup&gt;3&lt;/sup&gt;) given input variables temperature (T), 
      salinity (S), and pressure (P), in that order, using the international 
      equation of state for seawater, IES80 (UNESCO 1981).&lt;br&gt;&lt;br&gt;&lt;b&gt;&lt;u&gt;Reference&lt;/u&gt;&lt;/b&gt;&lt;br&gt;&lt;br&gt;UNESCO, 
      1981: Tenth report of the joint panel on oceanographic tables and 
      standards. UNESCO Tech. Paper in Marine Science 36, 25pp.&lt;br&gt;&lt;br&gt;&lt;b&gt;&lt;u&gt;Example&lt;/u&gt;&lt;/b&gt;&lt;br&gt;&lt;br&gt;The 
      following example calculates the density of seawater based on samples of 
      measured temperature, salinity, and pressure from the full data set of 
      GEOSECS observational profiles.&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES 
      .GEOSECS .TEMP &lt;/font&gt;
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      &lt;font color="#008000"&gt;SOURCES .GEOSECS .SAL &lt;/font&gt;
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      &lt;font color="#008000"&gt;SOURCES .GEOSECS .PRESS &lt;/font&gt;
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      &lt;font color="#008000"&gt;dens&lt;/font&gt;&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.GEOSECS/.TEMP/SOURCES/.GEOSECS/.SAL/SOURCES/.GEOSECS/.PRESS/dens/"&gt;Live 
      Example Link&lt;/a&gt;
    &lt;/p&gt;</fn:syntax_ex>
    <fn:hasArgument>
      <fn:Argument rdf:ID="dens2">
        <fn:arg_name xml:lang="en">S</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Salinity</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#dens"/>
        <rdfs:label xml:lang="en">dens2</rdfs:label>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:label xml:lang="en">dens</rdfs:label>
    <fn:hasArgument>
      <fn:Argument rdf:ID="dens4">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <rdfs:label xml:lang="en">dens4</rdfs:label>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Unecso '81 density (insitu) of seawater</fn:arg_desc>
        <fn:arg_name xml:lang="en">density</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:isArgumentOf rdf:resource="#dens"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Unecso '81 density (insitu) of seawater</fn:func_desc>
  </fn:Function>
  <fn:Function rdf:ID="cressman">
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >:cressman</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="cressman_a5">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >cressman:</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#cressman"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#delimiter"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >start of cressman scheme parameters</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >5</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Performs a cressman objective analysis to create gridded data from station data</rdfs:comment>
    <fn:hasArgument>
      <fn:Argument rdf:ID="cressman_a2">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >latitude</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >latitude coordinates for stations used in the analysis</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#cressman"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#objective_analysis"/>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#independent_variable_creation"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="cressman_a6">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >griddeddata</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >6</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >returned gridded data</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:isArgumentOf rdf:resource="#cressman"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="cressman_a3">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >data values at the stations</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >data</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#cressman"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="cressman_a4">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
        <fn:isArgumentOf rdf:resource="#cressman"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >IWMO</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >station ids</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="cressman_a1">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >longitude coordinates for stations used in the analysis</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >longitude</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#cressman"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >&lt;br&gt;
    &lt;u&gt;&lt;b&gt;Detailed Syntax&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;&lt;i&gt;longitudes&lt;/i&gt;&lt;br&gt;&lt;i&gt;latitudes&lt;/i&gt;&lt;br&gt;&lt;i&gt;data&lt;/i&gt;&lt;br&gt;&lt;b&gt;[&lt;/b&gt;&lt;i&gt;IWMO&lt;/i&gt;&lt;b&gt;]&lt;/b&gt; 
    &lt;b&gt;cressman:&lt;/b&gt;&lt;br&gt;&lt;i&gt;n&lt;/i&gt; &lt;b&gt;minstns&lt;/b&gt;&lt;br&gt;&lt;b&gt;X&lt;/b&gt; &lt;i&gt;xmin&lt;/i&gt; &lt;i&gt;xmax&lt;/i&gt; 
    &lt;i&gt;xstep&lt;/i&gt; &lt;b&gt;RANGEEDGESTEP&lt;/b&gt;&lt;br&gt;&lt;b&gt;Y&lt;/b&gt; &lt;i&gt;ymin&lt;/i&gt; &lt;i&gt;ymax&lt;/i&gt; &lt;i&gt;ystep&lt;/i&gt; 
    &lt;b&gt;RANGEEDGESTEP&lt;/b&gt;&lt;br&gt;&lt;i&gt;n1&lt;/i&gt; &lt;b&gt;pass1&lt;/b&gt;&lt;br&gt;&lt;i&gt;n2&lt;/i&gt; &lt;b&gt;pass2&lt;/b&gt;&lt;br&gt;&lt;i&gt;n3&lt;/i&gt; 
    &lt;b&gt;pass3&lt;/b&gt;&lt;br&gt;&lt;b&gt;:cressman&lt;/b&gt;&lt;br&gt;&lt;br&gt;&lt;u&gt;&lt;b&gt;Input&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;&lt;i&gt;longitudes&lt;/i&gt; 
    is a stream of longitude coordinates for stations used in the analysis&lt;br&gt;&lt;i&gt;latitudes&lt;/i&gt; 
    is a stream of latitude coordinates for stations used in the analysis&lt;br&gt;&lt;i&gt;data&lt;/i&gt; 
    is a stream of data values at the stations&lt;br&gt;&lt;i&gt;IWMO&lt;/i&gt; is the name of 
    the grid of station identifiers&lt;br&gt;&lt;br&gt;&lt;u&gt;&lt;b&gt;Parameters&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;&lt;i&gt;n 
    &lt;/i&gt;&lt;b&gt;minstns&lt;/b&gt; : &lt;i&gt;n&lt;/i&gt; is the number of station data points that 
    must be included within the influence radius of a gridpoint for an 
    analysis value to be calculated for that gridpoint. The default value is 3.&lt;br&gt;&lt;br&gt;&lt;b&gt;X&lt;/b&gt; 
    &lt;i&gt;xmin&lt;/i&gt; &lt;i&gt;xmax&lt;/i&gt; &lt;i&gt;xstep&lt;/i&gt; &lt;b&gt;RANGEEDGESTEP&lt;/b&gt; : specification 
    of the east-west domain of the analysis to be produced, in terms of 
    minimum and maximum longitude values and the grid step, in degrees. The 
    default values for &lt;i&gt;xmin&lt;/i&gt;, &lt;i&gt;xmax&lt;/i&gt;, and &lt;i&gt;xstep&lt;/i&gt; are -180., 
    180., and 2., respectively.&lt;br&gt;&lt;br&gt;&lt;b&gt;Y&lt;/b&gt; &lt;i&gt;ymin&lt;/i&gt; &lt;i&gt;ymax&lt;/i&gt; &lt;i&gt;ystep&lt;/i&gt; 
    &lt;b&gt;RANGEEDGESTEP&lt;/b&gt; : specification of the north-south domain of the 
    analysis to be produced, in terms of minimum and maximum latitude values 
    and the grid step, in degrees. The default values for &lt;i&gt;ymin&lt;/i&gt;, &lt;i&gt;ymax&lt;/i&gt;, 
    and &lt;i&gt;ystep&lt;/i&gt; are -90., 90., and 2., respectively.&lt;br&gt;&lt;br&gt;&lt;i&gt;n1&lt;/i&gt; &lt;b&gt;pass1&lt;/b&gt;, 
    &lt;i&gt;n2&lt;/i&gt; &lt;b&gt;pass2&lt;/b&gt;, &lt;i&gt;n3&lt;/i&gt; &lt;b&gt;pass3&lt;/b&gt; : &lt;i&gt;n1&lt;/i&gt;, &lt;i&gt;n2&lt;/i&gt;, and &lt;i&gt;n3&lt;/i&gt; 
    are the factors by which the average minimum station separation distance 
    (calculated within the routine) is multiplied on each pass of the cressman 
    scheme (3 passes are automatically done), to establish the influence 
    radius for each pass. The default values for the first, second, and third 
    passes are 4, 2.5, and 1.5, respectively.&lt;br&gt;&lt;br&gt;&lt;u&gt;&lt;b&gt;Description&lt;/b&gt;&lt;/u&gt;&lt;b&gt; 
    &lt;/b&gt;&lt;br&gt;&lt;br&gt;&lt;b&gt;cressman&lt;/b&gt; performs a Cressman (1959) objective analysis 
    of input station data onto a user-defined latitude-longitude grid. A 
    three-pass successive correction scheme is used here, allowing for the 
    influence radius to be tightened on each pass. The influence radius (R) 
    for each pass is calculated as the product of a user-defined constant and 
    the average distance between each station and its nearest neighboring 
    station. On each pass of the analysis, for each gridpoint in the analysis 
    domain, an isotropic distance-based weight is calculated for each station 
    within the influence radius of the gridpoint. This weight is calculated as 
    follows: W = (R&lt;sup&gt;2&lt;/sup&gt; - r&lt;sup&gt;2&lt;/sup&gt;)/(R&lt;sup&gt;2&lt;/sup&gt; + r&lt;sup&gt;2&lt;/sup&gt;) 
    where R = influence radius and r = station-to-gridpoint distance. 
    Distances are calculated along a great circle path. The weighting function 
    is illustrated in the following graph:&lt;br&gt;&lt;br&gt;&lt;img alt="Image of 
    cressman weighting function" src="http://iri.columbia.edu/~mbell/cress_weight.jpg"&gt;&lt;br&gt;&lt;br&gt;The 
    analysis value on the third and final pass at each gridpoint is calculated 
    as:&lt;br&gt;&lt;br&gt;Z&lt;sub&gt;3&lt;/sub&gt; = Z&lt;sub&gt;2&lt;/sub&gt; + sum[W*(zo&lt;sub&gt;j&lt;/sub&gt; - zb&lt;sub&gt;j&lt;/sub&gt;)]/sum[W]&lt;br&gt;&lt;br&gt;where 
    Z&lt;sub&gt;2&lt;/sub&gt; is the value of the analysis on the previous pass, W is the 
    distance-based weight for each station within the influence radius of the 
    gridpoint, zo&lt;sub&gt;j&lt;/sub&gt; is the observed value at station j, zb&lt;sub&gt;j&lt;/sub&gt; 
    is the background value at the station location j calculated via bilinear 
    interpolation from the analysis on the previous pass, and the sums are 
    calculated over the number of stations within the influence radius of each 
    gridpoint.&lt;br&gt;&lt;br&gt;If the minimum station number requirement specified in 
    the &lt;b&gt;minstns&lt;/b&gt; parameter is not met or exceeded, a missing value will 
    be assigned to the gridpoint. This allows the user to restrict the region 
    to which valid analysis values are assigned based upon a simple measure of 
    station density.&lt;br&gt;&lt;br&gt;&lt;u&gt;&lt;b&gt;References&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;Cressman, G. P., 
    1959: An operational objective analysis system. &lt;i&gt;Mon. Wea. Rev.&lt;/i&gt;, &lt;b&gt;87&lt;/b&gt;, 
    367-374.&lt;br&gt;&lt;br&gt;&lt;u&gt;&lt;b&gt;Example&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES 
    .NOAA .NCEP .CPC .CAMS .station .temperature &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;lon 
    lat temp [IWMO] cressman: &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;3 minstns &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;X 
    -180. 180. 2. RANGEEDGESTEP &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;Y -90. 90. 2. 
    RANGEEDGESTEP &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;4. pass1 &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;2.5 
    pass2 &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;1.5 pass3 &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;:cressman&lt;/font&gt;&lt;br&gt;&lt;br&gt;&lt;a href="
    http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCEP/.CPC/.CAMS/.station/.temperature/lon/lat/temp%5BIWMO%5Dcressman:/3/minstns/X/-180./180./2./RANGEEDGESTEP/Y/-90./90./2./RANGEEDGESTEP/4./pass1/2.5/pass2/1.5/pass3/:cressman/"&gt;Live 
    Example Link&lt;/a&gt;&lt;br&gt;</fn:syntax_ex>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Performs a cressman objective analysis to create gridded data from station data</fn:func_desc>
  </fn:Function>
  <fn:Function rdf:ID="replaceNaN">
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#missing_values"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="replaceNaN_a1">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable containing missing values to be replaced
&lt;p&gt;
Note that missing values must be identified with the &lt;i&gt;missing_value&lt;/i&gt; attribute.  If they are not, then the attribute can be defined as in the example below.</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#replaceNaN"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="replaceNaN_a3">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >&lt;i&gt;var&lt;/i&gt; with all missing values identified by the &lt;i&gt;missing_value&lt;/i&gt; attribute replaced by &lt;i&gt;value&lt;/i&gt;</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >varfull</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#replaceNaN"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="replaceNaN_a2">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#replaceNaN"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >value</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >value or variable that will replace missing values</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Replaces missing values in a variable with a selected value (or variable)</rdfs:comment>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Replaces missing values in a variable with a selected value (or variable)</fn:func_desc>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >replaceNaN</fn:func_name>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .NOAA .NODC .WOA01 .Grid-1x1 .Monthly .an .salinity
&lt;br&gt;/missing_value -99.9999 def
&lt;br&gt;0 replaceNaN</fn:syntax_ex>
  </fn:Function>
  <fn:Function rdf:ID="dominant_class">
    <fn:hasArgument>
      <fn:Argument rdf:ID="dominant_class3">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable in categorical form</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >classes</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#dominant_class"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy>
      <fn:Keyword rdf:about="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#complete_disjunctive_form">
        <rdfs:label xml:lang="en">complete disjunctive form</rdfs:label>
        <fn:describes>
          <fn:Function rdf:ID="classify">
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >classify</fn:func_name>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#independent_variable_creation"/>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#complete_disjunctive_form"/>
            <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Classifies data into categories, i.e. labels ranges of values.</rdfs:comment>
            <fn:hasArgument>
              <fn:Argument rdf:ID="classify_a4">
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:isArgumentOf rdf:resource="#classify"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >4</fn:arg_order>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >weights</fn:arg_name>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >output. There is an additional grid consisting of the N+1 names, and the 
    values are 0, 1, or missing depending on whether the data was between the 
    values given in the &lt;i&gt;classify&lt;/i&gt; number set.

This variable is sometimes referred to as being in &lt;i&gt;complete disjunctive form&lt;/i&gt;.</fn:arg_desc>
              </fn:Argument>
            </fn:hasArgument>
            <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >&lt;br&gt;
    &lt;b&gt;&lt;u&gt;Description&lt;/u&gt;&lt;/b&gt;&lt;br&gt;&lt;br&gt;&lt;b&gt;classify&lt;/b&gt; is used to assign ranges 
    of values from a variable into user-defined classes. Given a variable with 
    a given range of values, the classify statement accepts a list of 
    alternating class names and constants which define the boundaries between 
    the classes within that range. As a result, a new grid composed of the 
    defined classes is created, and the values from the input variable are 
    transformed into flags of 0 (not a member of the class), 1 (is a member of 
    the class), or NaN (not a number -- missing). This is best illustrated 
    with an example.&lt;br&gt;&lt;br&gt;&lt;b&gt;&lt;u&gt;Examples&lt;/u&gt;&lt;/b&gt;&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES 
    .KAPLAN .Indices .NINO3 .avOS&lt;br&gt;T (Jan 1901) (Dec 1990) RANGE&lt;br&gt;T 3 
    boxAverage&lt;br&gt;[T]percentileover&lt;br&gt;{LaNina 0.2 Neutral 0.8 ElNino}classify&lt;/font&gt;&lt;br&gt;&lt;br&gt;This 
    example first takes non-overlapping 3-month seasonal averages of sea 
    surface temperature anomalies (SSTA) from the NINO3 region of the 
    equatorial Pacific Ocean over the period January 1901 to December 1990. 
    This gives a single time series of seasonal sea surface temperature 
    anomalies. The first time step is Jan-Mar 1901, the second is Apr-Jun 
    1901, and so on until Oct-Dec 1990.&lt;br&gt;&lt;br&gt;Then, the SSTA values are 
    converted into percentiles, from 0. to 1., using &lt;b&gt;[T]percentileover&lt;/b&gt;. 
    The most negative SSTA values in the distribution are assigned a value 
    near zero, and the most positive values are assigned a value near one, 
    with intermediate values ranging between these extremes.&lt;br&gt;&lt;br&gt;The next 
    line comprises the &lt;b&gt;classify&lt;/b&gt; statement and its parameters. The class 
    names and the boundaries between them are placed within the curly braces. 
    Since the input variable is composed of percentiles that range between 0. 
    and 1. the class boundaries should fall within this range. In this case, 
    any values below 0.2 (in the lowest 20% of the distribution) are 
    classified as 'LaNina', values between 0.2 and 0.8 are classified as 
    'Neutral', and values from 0.8 upward (in the upper 20% of the 
    distribution) are classified as 'ElNino'.&lt;br&gt;&lt;br&gt;Whereas the input 
    variable was a function of time (T) only, after &lt;b&gt;classify&lt;/b&gt; was 
    applied the output variable became a function of both time (T) and class, 
    which was named after the variable (avOS). So, for a given season and a 
    given class, the output variable will have a value of either 0 (not a 
    member of the class), 1 (is a member of the class), or NaN (missing). The 
    Live Example Link below is followed by a link to a table from the same 
    calculation, which will help to illustrate the meaning of the output.&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.KAPLAN/.Indices/.NINO3/.avOS/T/%28Jan%201901%29%28Dec%201990%29RANGE/T/3/boxAverage%5BT%5Dpercentileover/%7BLaNina/0.2/Neutral/0.8/ElNino%7Dclassify/"&gt;Live 
    Example Link&lt;/a&gt;&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.KAPLAN/.Indices/.NINO3/.avOS/T/%28Jan%201901%29%28Dec%201990%29RANGE/T/3/boxAverage%5BT%5Dpercentileover/%7BLaNina/0.2/Neutral/0.8/ElNino%7Dclassify/ngridtable/3+ncoltable.html?tabopt.N=4&amp;tabopt.1=text&amp;tabopt.2=text&amp;tabopt.3=text&amp;tabopt.4=blankNaN&amp;NaNmarker=&amp;tabtype=html&amp;eol=LF+%28unix%29"&gt;Table 
    Link&lt;/a&gt;&lt;br&gt;&lt;br&gt;&lt;b&gt;classify&lt;/b&gt; makes it very handy to calculate 
    composites, such as long-term average seasonal precipitation conditioned 
    upon the state of ENSO. The following example shows an application of the &lt;b&gt;classify&lt;/b&gt; 
    statement to illustrate a relationship between ENSO and monsoon rainfall 
    in India.&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;expert SOURCES .Indices .india 
    .rainfall&lt;br&gt;SOURCES .KAPLAN .Indices .NINO3 .avOS&lt;br&gt;T (Oct 1901) (Dec 
    1990) RANGE&lt;br&gt;T 4 boxAverage&lt;br&gt;T 12 STEP&lt;br&gt;[T]percentileover&lt;br&gt;{LaNina 
    0.2 Neutral 0.8 ElNino}classify&lt;br&gt;T 4 shiftdatashort&lt;br&gt;[T]weighted-average&lt;br&gt;table: 
    1 :table&lt;/font&gt;&lt;br&gt;&lt;br&gt;A weighted average of the June-September all-India 
    rainfall index is taken with the classification (0 or 1) of 
    October-January seasonal SSTAs as either 'LaNina', 'Neutral', or 'ElNino' 
    to illustrate differences in long-term mean June-September Indian monsoon 
    rainfall based upon the state of ENSO later in the year (an ENSO-based 
    composite of seasonal precipitation).&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.Indices/.india/.rainfall/SOURCES/.KAPLAN/.Indices/.NINO3/.avOS/T/%28Oct%201901%29%28Dec%201990%29RANGE/T/4/boxAverage/T/12/STEP%5BT%5Dpercentileover/%7BLaNina/0.2/Neutral/0.8/ElNino%7Dclassify/T/4/shiftdatashort%5BT%5Dweighted-average/table:/1/:table/"&gt;Live 
    Example Link&lt;br&gt;&lt;/a&gt;&lt;br&gt;The following example is similar to the previous 
    one except that instead of using a single precipitation time series for 
    India it uses CMAP gridded precipitation values that vary in space over 
    India. It produces composite maps of June-September 1979-2006 seasonal 
    average precipitation according to ENSO state (LaNina, Neutral, and 
    ElNino) over south Asia.&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES .NOAA .NCEP 
    .CPC .Merged_Analysis .monthly .v0703 .ver2 .prcp_est &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;X 
    60. 100. RANGEEDGES &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;Y 0 40 RANGEEDGES &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;T 
    (Jun 1979) (Sep 2006) RANGE &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;T 4 
    runningAverage &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;T 12 STEP &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES 
    .KAPLAN .Indices .NINO3 .avOS &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;T (Oct 
    1979) (Dec 2006) RANGE &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;T 4 boxAverage &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;T 
    12 STEP &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;[T]percentileover &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;{LaNina 
    0.2 Neutral 0.8 ElNino}classify &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;T 4 
    shiftdatashort &lt;/font&gt;&lt;br&gt;&lt;font color="#008000"&gt;[T]weighted-average&lt;/font&gt;&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCEP/.CPC/.Merged_Analysis/.monthly/.v0703/.ver2/.prcp_est/X/60./100./RANGEEDGES/Y/0/40/RANGEEDGES/T/%28Jun%201979%29%28Sep%202006%29RANGE/T/4/runningAverage/T/12/STEP/SOURCES/.KAPLAN/.Indices/.NINO3/.avOS/T/%28Oct%201979%29%28Dec%202006%29RANGE/T/4/boxAverage/T/12/STEP%5BT%5Dpercentileover/%7BLaNina/0.2/Neutral/0.8/ElNino%7Dclassify/T/4/shiftdatashort%5BT%5Dweighted-average/"&gt;Live 
    Example Link &lt;/a&gt;&lt;br&gt;&lt;br&gt;Note that in the special case of a variable in &lt;i&gt;categorical 
    form&lt;/i&gt; (i.e. which has integral values that are chosen from a list), and 
    that list is given with the variable, then the list of classes and 
    transitions can be omitted. For example,&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCEP/.CPC/.Merged_Analysis/.monthly/.v0703/.ver2/.prcp_est/X/60./100./RANGEEDGES/Y/0/40/RANGEEDGES/T/%28Jun%201979%29%28Sep%202006%29RANGE/T/4/runningAverage/T/12/STEP/SOURCES/.KAPLAN/.Indices/.NINO3/.avOS/T/%28Oct%201979%29%28Dec%202006%29RANGE/T/4/boxAverage/T/12/STEP%5BT%5Dpercentileover/%7BLaNina/0.2/Neutral/0.8/ElNino%7Dclassify/T/4/shiftdatashort%5BT%5Dweighted-average/"&gt;
&lt;/a&gt;&lt;font color="#008000"&gt;SOURCES .NASA .ISLSCP .GDSLAM .Hydrology-Soils 
    .soils .texture classify &lt;/font&gt;&lt;br&gt;&lt;br&gt;transforms the variable from &lt;i&gt;categorical 
    form &lt;/i&gt;(a 3D variable of integer values) to &lt;i&gt;complete disjunctive form&lt;/i&gt; 
    (a 4D variable of weights (0 or 1) where the added dimension has the list 
    of possibilities defined with the original categorical dataset). This 
    dataset can now be regridded or factor-analyzed.&lt;font color="#008000"&gt; &lt;/font&gt;&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NASA/.ISLSCP/.GDSLAM/.Hydrology-Soils/.soils/.texture/classify/"&gt;Live 
    Example Link&lt;/a&gt;</fn:syntax_ex>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Classifies data into categories, i.e. labels ranges of values.</fn:func_desc>
            <fn:hasArgument>
              <fn:Argument rdf:ID="classify_a2">
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#name_and_number_set"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >classes</fn:arg_name>
                <fn:isArgumentOf rdf:resource="#classify"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >true</fn:optional>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >alternating names and numbers, starting and ending with a name, so that there are N+1 names and N numbers</fn:arg_desc>
              </fn:Argument>
            </fn:hasArgument>
            <fn:isDescribedBy>
              <fn:Keyword rdf:about="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#categorical_form">
                <fn:describes rdf:resource="#classify"/>
                <fn:describes rdf:resource="#dominant_class"/>
                <rdfs:label rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >categorical form</rdfs:label>
              </fn:Keyword>
            </fn:isDescribedBy>
            <fn:hasArgument>
              <fn:Argument rdf:ID="classify_a3">
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >3</fn:arg_order>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >facet</fn:arg_name>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >true</fn:optional>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >name of new independent variable (name of var if omitted)</fn:arg_desc>
                <fn:argument_type rdf:resource="#string"/>
                <fn:isArgumentOf rdf:resource="#classify"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:isDescribedBy>
              <fn:Keyword rdf:about="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#categorization">
                <fn:describes rdf:resource="#dominant_class"/>
                <fn:describes rdf:resource="#classify"/>
                <fn:describes>
                  <fn:Function rdf:ID="distrib">
                    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                    >Gives the distributions of values for a given variable d(x,y,z,t) by 
    returning a new variable f(d) which gives the number of occurrences of 
    data points nearest the values d_i which are equally spaced from min to 
    max in steps of step</fn:func_desc>
                    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                    >distrib</fn:func_name>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="distrib2">
                        <fn:arg_name xml:lang="en">f(d)</fn:arg_name>
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >2</fn:arg_order>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >Variable returning the number of occurrences of data points nearest the values d_i which are equally spaced from min to max in steps of step</fn:arg_desc>
                        <fn:isArgumentOf rdf:resource="#distrib"/>
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >false</fn:optional>
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                        <rdfs:label xml:lang="en">distrib2</rdfs:label>
                      </fn:Argument>
                    </fn:hasArgument>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="distrib1">
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >1</fn:arg_order>
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                        <fn:arg_name xml:lang="en">d (x,y,z,t)</fn:arg_name>
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >false</fn:optional>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >Variable to be used</fn:arg_desc>
                        <fn:isArgumentOf rdf:resource="#distrib"/>
                        <rdfs:label xml:lang="en">distrib1</rdfs:label>
                      </fn:Argument>
                    </fn:hasArgument>
                    <rdfs:comment xml:lang="en">gives the distributions of values for a given variable d(x,y,z,t) by 
    returning a new variable f(d) which gives the number of occurrences of data  points nearest the values d_i which are equally spaced from min to max in  steps of step.</rdfs:comment>
                    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#categorization"/>
                    <rdfs:label xml:lang="en">distrib</rdfs:label>
                  </fn:Function>
                </fn:describes>
                <fn:describes>
                  <fn:Function rdf:ID="distrib2D">
                    <rdfs:label xml:lang="en">distrib2D</rdfs:label>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="distrib2D3">
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >3</fn:arg_order>
                        <fn:isArgumentOf rdf:resource="#distrib2D"/>
                        <fn:arg_name xml:lang="en">C</fn:arg_name>
                        <rdfs:label xml:lang="en">distrib2D3</rdfs:label>
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >false</fn:optional>
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >Bivariate counts of the variables above</fn:arg_desc>
                      </fn:Argument>
                    </fn:hasArgument>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="distrib2D2">
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >2</fn:arg_order>
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >false</fn:optional>
                        <fn:arg_name xml:lang="en">B</fn:arg_name>
                        <fn:isArgumentOf rdf:resource="#distrib2D"/>
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                        <rdfs:label xml:lang="en">distrib2D2</rdfs:label>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >Variable to be processed</fn:arg_desc>
                      </fn:Argument>
                    </fn:hasArgument>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="distrib2D1">
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >1</fn:arg_order>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >Variable to be processed</fn:arg_desc>
                        <fn:isArgumentOf rdf:resource="#distrib2D"/>
                        <fn:arg_name xml:lang="en">A</fn:arg_name>
                        <rdfs:label xml:lang="en">distrib2D1</rdfs:label>
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >false</fn:optional>
                      </fn:Argument>
                    </fn:hasArgument>
                    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                    >distrib2D</fn:func_name>
                    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#categorization"/>
                    <rdfs:comment xml:lang="en">returns bivariate counts</rdfs:comment>
                    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                    >Returns bivariate counts</fn:func_desc>
                  </fn:Function>
                </fn:describes>
                <fn:describes>
                  <fn:Function rdf:ID="distrib1D">
                    <fn:isDescribedBy>
                      <rdf:Description rdf:about="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#statistical_functions">
                        <fn:describes>
                          <fn:Function rdf:ID="width96">
                            <rdfs:label xml:lang="en">width96</rdfs:label>
                            <rdfs:comment xml:lang="en">computes the 96 percentile widths</rdfs:comment>
                            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                            >Computes the 96 percentile widths</fn:func_desc>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="width962">
                                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >var'</fn:arg_name>
                                <fn:isArgumentOf rdf:resource="#width96"/>
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >2</fn:arg_order>
                                <fn:arg_desc xml:lang="en">96 percentile widths</fn:arg_desc>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                                <rdfs:label rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >width962</rdfs:label>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                              </fn:Argument>
                            </fn:hasArgument>
                            <fn:hasArgument>
                              <fn:Argument rdf:ID="width961">
                                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                                <fn:isArgumentOf rdf:resource="#width96"/>
                                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                                <rdfs:label xml:lang="en">width961</rdfs:label>
                                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >var</fn:arg_name>
                                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                                >1</fn:arg_order>
                                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                                >Variable the computation will be derived from</fn:arg_desc>
                                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                                >false</fn:optional>
                              </fn:Argument>
                            </fn:hasArgument>
                            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                            >width96</fn:func_name>
                            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#statistical_functions"/>
                          </fn:Function>
                        </fn:describes>
                      </rdf:Description>
                    </fn:isDescribedBy>
                    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                    >Returns the frequency distribution of a set of data for a specified range and step  interval. Commonly used to create histograms.</rdfs:comment>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="distrib1D_a4">
                        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >upper</fn:arg_name>
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >upper bound of range over which distribution is to be found</fn:arg_desc>
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >4</fn:arg_order>
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >false</fn:optional>
                        <fn:isArgumentOf rdf:resource="#distrib1D"/>
                      </fn:Argument>
                    </fn:hasArgument>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="distrib1D_a8">
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                        <fn:isArgumentOf rdf:resource="#distrib1D"/>
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >false</fn:optional>
                        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >dist</fn:arg_name>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >frequency distribution of &lt;i&gt;var&lt;/i&gt; within range and interval specified by &lt;i&gt;lower&lt;/i&gt;, &lt;i&gt;upper&lt;/i&gt;, and &lt;i&gt;step&lt;/i&gt;</fn:arg_desc>
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >8</fn:arg_order>
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                      </fn:Argument>
                    </fn:hasArgument>
                    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                    >Returns the frequency distribution of a set of data for a specified range and step  interval. Commonly used to create histograms.</fn:func_desc>
                    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#frequency_distribution"/>
                    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                    >&lt;br&gt;
    &lt;u&gt;&lt;b&gt;Description&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;&lt;b&gt;distrib1D&lt;/b&gt; returns the frequency 
    distribution (as binned counts) of data from an input variable based upon 
    a user-specified binning interval and range limits defined in the DATA 
    lower upper step RANGESTEP command. In doing this, &lt;b&gt;distrib1D&lt;/b&gt; 
    creates a new grid of bins defined by the RANGESTEP command that has the 
    same name as the input variable.&lt;br&gt;&lt;br&gt;&lt;u&gt;&lt;b&gt;Example&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;In 
    this example soil moisture values from July 1948-2003 and the grid box 
    that includes the coordinates 20&amp;#176; N, 50&amp;#176; E have been selected, leaving 
    soil moisture values that vary only over the time grid. &lt;i&gt;DATA 0 50 2 
    RANGESTEP &lt;/i&gt;specifies a selection of soil moisture values from 0 to 50 
    mm and a binning of 2 mm. &lt;b&gt;distrib1D&lt;/b&gt; uses these specifications to 
    produce a count of the number of soil moisture observations in the 
    selection that fall within each 2 mm bin from 0 to 50 mm. The limits of 
    the RANGESTEP command serve as bin centers. Therefore, in this example, 
    there are 26 bins, namely -1 (actually 0)-1, 1-3, 3-5, ..., 47-49, 49-51 
    (actually 50). The grid of bins is named &amp;quot;w&amp;quot;.&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES 
    .NOAA .NCEP .CPC .GMSM .w&lt;br&gt;Y (20) VALUE&lt;br&gt;X (50) VALUE&lt;br&gt;T (Jul 
    1948-2003) VALUES&lt;br&gt;DATA 0 50 2 RANGESTEP&lt;br&gt;distrib1D&lt;/font&gt;&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCEP/.CPC/.GMSM/.w/Y/%2820%29VALUE/X/%2850%29VALUE/T/%28Jul%201948-2003%29VALUES/DATA/0/50/2/RANGESTEP/distrib1D/"&gt;Live 
    Example Link&lt;/a&gt;&lt;br&gt;&lt;br&gt;In the following example using the GHCN monthly 
    precipitation data set, precipitation values for stations in Madagascar 
    and its vicinity have been selected for January 1971 to December 2000. The &lt;i&gt;DATA 
    0 1200 50 RANGESTEP&lt;/i&gt; command specifies the selection of precipitation 
    values from 0 to 1200 mm and defines 50 mm-wide bins. Finally, in the &lt;b&gt;distrib1D&lt;/b&gt; 
    command, the inclusion of IWMO, the name of the station ID grid, in 
    brackets means that a frequency distribution will be constructed for each 
    station separately. If &amp;quot;[IWMO]&amp;quot; had been excluded, a single frequency 
    distribution would have been produced using the collective precipitation 
    values from all the selected stations.  This can be generalized to 
    multiple grids (if the data depend upon additional grids) as well.&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES 
    .NOAA .NCDC .GHCN .v2beta&lt;br&gt;lon (41.5) (53.0) masknotrange SELECT&lt;br&gt;lat 
    (-28.5) (-8.0) masknotrange SELECT&lt;br&gt;T (Jan 1971) (Dec 2000) RANGE&lt;br&gt;.prcp&lt;br&gt;DATA 
    0 1200 50 RANGESTEP&lt;br&gt;[IWMO]distrib1D&lt;/font&gt;&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCDC/.GHCN/.v2beta/lon/%2841.5%29%2853.0%29masknotrange/SELECT/lat/%28-28.5%29%28-8.0%29masknotrange/SELECT/T/%28Jan%201971%29%28Dec%202000%29RANGE/.prcp/DATA/0/1200/50/RANGESTEP%5BIWMO%5Ddistrib1D/"&gt;Live 
    Example Link&lt;/a&gt;&lt;br&gt;&lt;br&gt;</fn:syntax_ex>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="distrib1D_a5">
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >5</fn:arg_order>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >width of intervals (in units of &lt;i&gt;var&lt;/i&gt;) used in distribution</fn:arg_desc>
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >false</fn:optional>
                        <fn:isArgumentOf rdf:resource="#distrib1D"/>
                        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >step</fn:arg_name>
                      </fn:Argument>
                    </fn:hasArgument>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="distrib1D_a2">
                        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >DATA</fn:arg_name>
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >2</fn:arg_order>
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >false</fn:optional>
                        <fn:isArgumentOf rdf:resource="#distrib1D"/>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        ></fn:arg_desc>
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#delimiter"/>
                      </fn:Argument>
                    </fn:hasArgument>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="distrib1D_a6">
                        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >RANGESTEP</fn:arg_name>
                        <fn:isArgumentOf rdf:resource="#distrib1D"/>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        ></fn:arg_desc>
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >false</fn:optional>
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >6</fn:arg_order>
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#delimiter"/>
                      </fn:Argument>
                    </fn:hasArgument>
                    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#categorization"/>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="distrib1D_a3">
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >3</fn:arg_order>
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >false</fn:optional>
                        <fn:isArgumentOf rdf:resource="#distrib1D"/>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >lower bound of range over which distribution is to be found</fn:arg_desc>
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
                        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >lower</fn:arg_name>
                      </fn:Argument>
                    </fn:hasArgument>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="distrib1D_a7">
                        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >depends_on</fn:arg_name>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >independent variables that the distribution is to depend on.  Default is to compute over all independent variables, thus depends_on is empty</fn:arg_desc>
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >true</fn:optional>
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >7</fn:arg_order>
                        <fn:isArgumentOf rdf:resource="#distrib1D"/>
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
                      </fn:Argument>
                    </fn:hasArgument>
                    <fn:hasArgument>
                      <fn:Argument rdf:ID="distrib1D_a1">
                        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                        >false</fn:optional>
                        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >var</fn:arg_name>
                        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                        >variable (i.e., data) of which distribution is to be found</fn:arg_desc>
                        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                        >1</fn:arg_order>
                        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                        <fn:isArgumentOf rdf:resource="#distrib1D"/>
                      </fn:Argument>
                    </fn:hasArgument>
                    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                    >distrib1D</fn:func_name>
                  </fn:Function>
                </fn:describes>
                <rdfs:label xml:lang="en">Categorization</rdfs:label>
              </fn:Keyword>
            </fn:isDescribedBy>
            <fn:hasArgument>
              <fn:Argument rdf:ID="classify_a1">
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:isArgumentOf rdf:resource="#classify"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >input data to be classified</fn:arg_desc>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var</fn:arg_name>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
              </fn:Argument>
            </fn:hasArgument>
          </fn:Function>
        </fn:describes>
        <fn:describes rdf:resource="#dominant_class"/>
      </fn:Keyword>
    </fn:isDescribedBy>
    <fn:hasArgument>
      <fn:Argument rdf:ID="dominant_class1">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable of weights in complete disjunctive form</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#dominant_class"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >weights</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc xml:lang="en">returns class with the highest weight</fn:func_desc>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >dominant_class</fn:func_name>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >returns class with the highest weight</rdfs:comment>
    <fn:syntax_ex xml:lang="en">&lt;b&gt;dominant_class &lt;/b&gt;transforms the variable from &lt;i&gt;complete disjunctive 
    form&lt;/i&gt; (a variable of weights (0 to 1) with an independent variable that 
    corresponds to the list of classes) to &lt;i&gt;categorical form &lt;/i&gt;(a variable 
    of integer values, numbering the classes from 1 to N) by choosing the 
    class with the highest non-zero weight (first class is used in the case of multiple 
    classes with the same non-zero weight).   When multiple independent variables are specified, dominant_class combines the multiple class sets, creating the multivariate class that corresponds to the combination of the class sets.</fn:syntax_ex>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#categorization"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="dominant_class2">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >one or more independent variables which list the classes</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#dominant_class"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >classlist</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#categorical_form"/>
  </fn:Function>
  <fn:Function rdf:ID="yearly-climatology">
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#climatology"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="yearly-climatology_a1">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >data of which monthly climatology is to be calculated
&lt;p&gt;Note that the data must be monthly (i.e., units of time grid must be months).</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#yearly-climatology"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="yearly-climatology_a2">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >climovar</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >monthly climatology of &lt;i&gt;var&lt;/i&gt; based on all selected years.  &lt;i&gt;climovar&lt;/i&gt; is dependent on a time grid with 12 grid points (i.e., Jan, Feb, ..., Nov, Dec).</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:isArgumentOf rdf:resource="#yearly-climatology"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >yearly-climatology</fn:func_name>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .UNH .CSRC .RivDIS .dischrg
&lt;br&gt;ISTA 518 VALUE
&lt;br&gt;T (Jan 1930) (Dec 1979) RANGE
&lt;br&gt;yearly-climatology</fn:syntax_ex>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Calculates a monthly climatology</fn:func_desc>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Calculates a monthly climatology</rdfs:comment>
  </fn:Function>
  <fn:Function rdf:ID="log">
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >6 log</fn:syntax_ex>
    <fn:hasArgument>
      <fn:Argument rdf:ID="log_a2">
        <fn:isArgumentOf rdf:resource="#log"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Result</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >&lt;i&gt;Result&lt;/i&gt; will be of the same type as &lt;i&gt;A&lt;/i&gt; (i.e., either a variable or constant).</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="log_a1">
        <fn:isArgumentOf rdf:resource="#log"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >A</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable or constant of which the log (base 10) is taken</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#arithmetic_functions"/>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Calculates the logarithm of a number or variable, with base 10</rdfs:comment>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >log</fn:func_name>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Calculates the logarithm of a number or variable, with base 10</fn:func_desc>
  </fn:Function>
  <fn:Function rdf:ID="densa">
    <fn:hasArgument>
      <fn:Argument rdf:ID="densa4">
        <fn:isArgumentOf rdf:resource="#densa"/>
        <fn:arg_name xml:lang="en">density</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Unecso '81 density (insitu) of seawater minus 1</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <rdfs:label xml:lang="en">densa4</rdfs:label>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >&lt;p style="margin-top: 0"&gt;
      &lt;br&gt;
      &lt;b&gt;&lt;u&gt;Description&lt;/u&gt;&lt;/b&gt;&lt;br&gt;&lt;br&gt;&lt;b&gt;densa&lt;/b&gt; calculates the density of 
      seawater above 1 g/cm&lt;sup&gt;3&lt;/sup&gt; given input variables temperature (T), 
      salinity (S), and pressure (P), in that order, using the international 
      equation of state for seawater, IES80 (UNESCO 1981).&lt;br&gt;&lt;br&gt;&lt;b&gt;&lt;u&gt;Reference&lt;/u&gt;&lt;/b&gt;&lt;br&gt;&lt;br&gt;UNESCO, 
      1981: Tenth report of the joint panel on oceanographic tables and 
      standards. UNESCO Tech. Paper in Marine Science 36, 25pp.&lt;br&gt;&lt;br&gt;&lt;b&gt;&lt;u&gt;Example&lt;/u&gt;&lt;/b&gt;&lt;br&gt;&lt;br&gt;The 
      following example calculates the density of seawater based on samples of 
      measured temperature, salinity, and pressure from the full data set of 
      GEOSECS observational profiles.&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES 
      .GEOSECS .TEMP &lt;/font&gt;
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      &lt;font color="#008000"&gt;SOURCES .GEOSECS .SAL &lt;/font&gt;
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      &lt;font color="#008000"&gt;SOURCES .GEOSECS .PRESS &lt;/font&gt;
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      &lt;font color="#008000"&gt;densa&lt;/font&gt;&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.GEOSECS/.TEMP/SOURCES/.GEOSECS/.SAL/SOURCES/.GEOSECS/.PRESS/densa/"&gt;Live 
      Example Link&lt;/a&gt;
    &lt;/p&gt;</fn:syntax_ex>
    <fn:hasArgument>
      <fn:Argument rdf:ID="densa2">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name xml:lang="en">S</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Salinity</fn:arg_desc>
        <rdfs:label xml:lang="en">densa2</rdfs:label>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:isArgumentOf rdf:resource="#densa"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >densa</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="densa3">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#densa"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Pressure</fn:arg_desc>
        <rdfs:label xml:lang="en">densa3</rdfs:label>
        <fn:arg_name xml:lang="en">P</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:label xml:lang="en">densa</rdfs:label>
    <fn:hasArgument>
      <fn:Argument rdf:ID="densa1">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_name xml:lang="en">T</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#densa"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Temperature</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <rdfs:label xml:lang="en">densa1</rdfs:label>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#oceanic_equation_of_state"/>
    <rdfs:comment xml:lang="en">unecso '81 density (insitu) of seawater minus 1</rdfs:comment>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Unecso '81 density (insitu) of seawater minus 1</fn:func_desc>
  </fn:Function>
  <fn:Function rdf:ID="products">
    <fn:func_name xml:lang="en">products</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="products2">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ivar</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#products"/>
        <rdfs:label xml:lang="en">products2</rdfs:label>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Independent variable along which function will be applied</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="products1">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to which function will be applied to</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#products"/>
        <rdfs:label xml:lang="en">products1</rdfs:label>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="products3">
        <fn:isArgumentOf rdf:resource="#products"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <rdfs:label xml:lang="en">products3</rdfs:label>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var'</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Pairwise products along grid of variable</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment xml:lang="en">takes pairwise products along independent variable of variable</rdfs:comment>
    <rdfs:label xml:lang="en">products</rdfs:label>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Takes pairwise products along independent variable of variable</fn:func_desc>
  </fn:Function>
  <fn:Function rdf:ID="pressure">
    <fn:hasArgument>
      <fn:Argument rdf:ID="pressure1">
        <fn:arg_name xml:lang="en">T</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <rdfs:label xml:lang="en">pressure1</rdfs:label>
        <fn:isArgumentOf rdf:resource="#pressure"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Temperature</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#oceanic_equation_of_state"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="pressure2">
        <fn:arg_name xml:lang="en">S</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <rdfs:label xml:lang="en">pressure2</rdfs:label>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Salinity</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#pressure"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Computes hydrostatic pressure by integrating from the surface</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="pressure3">
        <fn:isArgumentOf rdf:resource="#pressure"/>
        <rdfs:label xml:lang="en">pressure3</rdfs:label>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Height</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_name xml:lang="en">Z</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment xml:lang="en">computes hydrostatic pressure by integrating from the surface</rdfs:comment>
    <rdfs:label xml:lang="en">pressure</rdfs:label>
    <fn:hasArgument>
      <fn:Argument rdf:ID="pressure4">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Hydrostatic pressure</fn:arg_desc>
        <fn:arg_name xml:lang="en">P</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#pressure"/>
        <rdfs:label xml:lang="en">pressure4</rdfs:label>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >pressure</fn:func_name>
  </fn:Function>
  <fn:Function rdf:ID="yearlyAverage">
    <fn:hasArgument>
      <fn:Argument rdf:ID="yearlyAverage_a1">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >dailyvar</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#yearlyAverage"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >daily data to be averaged, with units of units</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="yearlyAverage_a2">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >minfrac</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#yearlyAverage"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >true</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Minimum fraction of data that must be present (i.e., fraction not indicated as missing) within each year in order for each average to be calculated. If minfrac is not present, then a missing value is returned. If minfrac is not given, then the average is calculated regardless of the amount of data present.</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="yearlyAverage_a3">
        <fn:isArgumentOf rdf:resource="#yearlyAverage"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >yearlyvar</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >yearly average of dailyvar</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy>
      <rdf:Description rdf:about="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#average">
        <fn:describes>
          <fn:Function rdf:ID="seasonalAverage">
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >seasonalAverage</fn:func_name>
            <fn:hasArgument>
              <fn:Argument rdf:ID="seasonalAverage_a1">
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:isArgumentOf rdf:resource="#seasonalAverage"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >data</fn:arg_name>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >input dataset or variable</fn:arg_desc>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
              </fn:Argument>
            </fn:hasArgument>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >computes seasonal Average over time</fn:func_desc>
            <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >computes seasonal Average over time</rdfs:comment>
            <fn:hasArgument>
              <fn:Argument rdf:ID="seasonalAverage_a2">
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >independent variable that represents time</fn:arg_desc>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
                <fn:isArgumentOf rdf:resource="#seasonalAverage"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                ></fn:arg_name>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
              </fn:Argument>
            </fn:hasArgument>
            <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >&lt;p style="margin-top: 0"&gt;
      seasonalAverage can be used to pick out a season from data that depends 
      on time.
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      For example, consider
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      SOURCES .NOAA .NCEP .EMC .CMB .GLOBAL .Reyn_SmithOIv2 .weekly .ssta
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      T (Nov-Jan) seasonalAverage
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      This is also accessible &lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCEP/.EMC/.CMB/.GLOBAL/.Reyn_SmithOIv2/.weekly/.ssta/T/%28Nov-Jan%29seasonalAverage/"&gt;here&lt;/a&gt;.
    &lt;/p&gt;</fn:syntax_ex>
            <fn:hasArgument>
              <fn:Argument rdf:ID="seasonalAverage_a5">
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >5</fn:arg_order>
                <fn:isArgumentOf rdf:resource="#seasonalAverage"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >seasonally averaged data</fn:arg_name>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >dataset or variable that has been seasonally averaged</fn:arg_desc>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
              </fn:Argument>
            </fn:hasArgument>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#average"/>
            <fn:hasArgument>
              <fn:Argument rdf:ID="seasonalAverage_a3">
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >3</fn:arg_order>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >season length</fn:arg_name>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#numberstring"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                ></fn:arg_desc>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:isArgumentOf rdf:resource="#seasonalAverage"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="seasonalAverage_a4">
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >true</fn:optional>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >minfrac</fn:arg_name>
                <fn:isArgumentOf rdf:resource="#seasonalAverage"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >4</fn:arg_order>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                ></fn:arg_desc>
              </fn:Argument>
            </fn:hasArgument>
          </fn:Function>
        </fn:describes>
      </rdf:Description>
    </fn:isDescribedBy>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >converts daily data to yearly by averaging</rdfs:comment>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >converts daily data to yearly by averaging</fn:func_desc>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >yearlyAverage</fn:func_name>
  </fn:Function>
  <fn:Function rdf:ID="abs">
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#absolute_value"/>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#arithmetic_functions"/>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >&lt;br&gt;
    &lt;b&gt;&lt;u&gt;Description&lt;/u&gt;&lt;/b&gt;&lt;br&gt;&lt;br&gt;&lt;b&gt;abs&lt;/b&gt; applies sqrt[&lt;i&gt;num&lt;/i&gt;&lt;sup&gt;2&lt;/sup&gt;] 
    to a variable stream of real numbers or a constant (&lt;i&gt;num&lt;/i&gt;) to produce 
    its numerical magnitude without regard to its sign.&lt;br&gt;&lt;br&gt;&lt;b&gt;&lt;u&gt;Example&lt;/u&gt;&lt;/b&gt;&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES 
    .NOAA .NCEP-NCAR .CDAS-1 .MONTHLY .Diagnostic .above_ground .u&lt;br&gt;abs &lt;/font&gt;&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCEP-NCAR/.CDAS-1/.MONTHLY/.Diagnostic/.above_ground/.u/abs/"&gt;Live 
    Example Link&lt;/a&gt;&lt;br&gt;</fn:syntax_ex>
    <fn:hasArgument>
      <fn:Argument rdf:ID="abs_a1">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >num</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable or constant of which the absolute value is to be found</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#abs"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="abs_a2">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >absnum</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#abs"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >absolute value of &lt;i&gt;num&lt;/i&gt;</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Returns the absolute value of a variable or a constant</rdfs:comment>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Returns the absolute value of a variable or a constant</fn:func_desc>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >abs</fn:func_name>
  </fn:Function>
  <fn:Function rdf:ID="SAMPLELB">
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Samples variable along ivar1 according to ivar2, returning lowest value in ivar1 greater than or equal to value in ivar2</fn:func_desc>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SAMPLELB</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="SAMPLELB2">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Independent variable from which variable is sampled along</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ivar1</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:isArgumentOf rdf:resource="#SAMPLELB"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="SAMPLELB1">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to be sampled</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:isArgumentOf rdf:resource="#SAMPLELB"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="SAMPLELB4">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable with lowest value in ivar1 greater than or equal to value in ivar2</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var'</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#SAMPLELB"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="SAMPLELB3">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Independent variable from which ivar1 is based</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ivar2</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#SAMPLELB"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="ratios">
    <rdfs:comment xml:lang="en">takes pairwise ratios along independent variable of variable</rdfs:comment>
    <fn:hasArgument>
      <fn:Argument rdf:ID="ratios2">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <rdfs:label xml:lang="en">ratios2</rdfs:label>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Independent variable along which function will be applied</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#ratios"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ivar</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="ratios1">
        <fn:isArgumentOf rdf:resource="#ratios"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <rdfs:label xml:lang="en">ratios1</rdfs:label>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to which function will be applied</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="ratios3">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_name xml:lang="en">stream'</fn:arg_name>
        <rdfs:label xml:lang="en">ratios3</rdfs:label>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#ratios"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Pairwise ratios along grid of variable</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Takes pairwise ratios along independent variable of variable</fn:func_desc>
    <rdfs:label xml:lang="en">ratios</rdfs:label>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >ratios</fn:func_name>
  </fn:Function>
  <fn:Function rdf:ID="monthlyAverage">
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#average"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="monthlyAverage_a3">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:isArgumentOf rdf:resource="#monthlyAverage"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >monthlyvar</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >monthly average of &lt;i&gt;dailyvar&lt;/i&gt;
&lt;p&gt;
&lt;i&gt;monthlyvar&lt;/i&gt; now has a temporal resolution of months.  Note: for variables with units of accumulation (e.g., precipitation), the units are now &lt;i&gt;units&lt;/i&gt;/day.  This should be changed in the interface as shown in the example below.</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="monthlyAverage_a1">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >daily data to be averaged, with units of &lt;i&gt;units&lt;/i&gt;</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#monthlyAverage"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >dailyvar</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="monthlyAverage_a2">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Minimum fraction of data that must be present (i.e., fraction not indicated as missing) within each month in order for each monthly average to be calculated. If minfrac is not present, then a missing value is returned. If minfrac is not given, then the average is calculated regardless of the amount of data present.</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >true</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >minfrac</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#monthlyAverage"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .NOAA .NCEP .CPC .FEWS .DAILY .est_prcp &lt;br&gt;0.9 monthlyAverage
&lt;br&gt;/units (mm/day) def
&lt;p&gt;
OR
&lt;p&gt;
SOURCES .NOAA .NCDC .GDCN .TMAX
&lt;br&gt;ISTA 253175 VALUE
&lt;br&gt;monthlyAverage</fn:syntax_ex>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Converts daily data to monthly data by averaging</rdfs:comment>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >monthlyAverage</fn:func_name>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Converts daily data to monthly data by averaging</fn:func_desc>
  </fn:Function>
  <fn:Function rdf:ID="randomdata">
    <rdfs:comment xml:lang="en">returns a variable of random numbers</rdfs:comment>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >randomdata</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="randomdata2">
        <fn:isArgumentOf rdf:resource="#randomdata"/>
        <rdfs:label xml:lang="en">randomdata2</rdfs:label>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var'</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Random numbers</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="randomdata1">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to be converted</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <rdfs:label xml:lang="en">randomdata1</rdfs:label>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#randomdata"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:label xml:lang="en">randomdata</rdfs:label>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Returns a variable of random numbers</fn:func_desc>
  </fn:Function>
  <fn:Function rdf:ID="integrateddistrib1D">
    <fn:hasArgument>
      <fn:Argument rdf:ID="integrateddistrib1D_a1">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable (i.e., data) of which distribution is to be found</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#integrateddistrib1D"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="integrateddistrib1D_a7">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >dist</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >cumulative frequency distribution of &lt;i&gt;var&lt;/i&gt; within range and intervals specified by &lt;i&gt;lower&lt;/i&gt;, &lt;i&gt;upper&lt;/i&gt;, and &lt;i&gt;step&lt;/i&gt;</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:isArgumentOf rdf:resource="#integrateddistrib1D"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >7</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="integrateddistrib1D_a5">
        <fn:isArgumentOf rdf:resource="#integrateddistrib1D"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >width of intervals (in units of &lt;i&gt;var&lt;/i&gt;) used to find distribution</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >step</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >5</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="integrateddistrib1D_a4">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#integrateddistrib1D"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >upper</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >upper bound of range over which distribution is to be found</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .NOAA .NCEP .CPC .GMSM .w 
&lt;br&gt;Y (20) VALUE 
&lt;br&gt;X (50) VALUE 
&lt;br&gt;T (Jul 1948-2003) VALUES 
&lt;br&gt;DATA 0 50 0.5 RANGESTEP 
&lt;br&gt;integrateddistrib1D</fn:syntax_ex>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#statistical_functions"/>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >integrateddistrib1D</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="integrateddistrib1D_a2">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        ></fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#delimiter"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >DATA</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#integrateddistrib1D"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="integrateddistrib1D_a6">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        ></fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#integrateddistrib1D"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#delimiter"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >6</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >RANGESTEP</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="integrateddistrib1D_a3">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:isArgumentOf rdf:resource="#integrateddistrib1D"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >lower bound of range over which distribution is to be found</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >lower</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Returns the cumulative frequency distribution of a set of data for a specified range and step interval.</rdfs:comment>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#cumulative_frequency_distribution"/>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Returns the cumulative frequency distribution of a set of data for a specified range and step interval.</fn:func_desc>
  </fn:Function>
  <fn:Function rdf:ID="RANGEEDGES">
    <fn:hasArgument>
      <fn:Argument rdf:ID="RANGEEDGES_a5">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >dataset or variable (&lt;i&gt;ds/var&lt;/i&gt;) restricted to only data associated with &lt;i&gt;grid&lt;/i&gt; values within &lt;i&gt;range_low&lt;/i&gt; and &lt;i&gt;range_high&lt;/i&gt;, inclusive;
                                              applied to all variables in the dataset if no variable selected</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >restricted_ds/var</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:isArgumentOf rdf:resource="#RANGEEDGES"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >5</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="RANGEEDGES_a2">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid in which values will be selected</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#RANGEEDGES"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .CAC 
&lt;br&gt;Y (10S) (10N) RANGEEDGES
&lt;p&gt;
OR
&lt;p&gt;
SOURCES .CAC .ssta
&lt;br&gt;Y -10 10 RANGEEDGES</fn:syntax_ex>
    <fn:hasArgument>
      <fn:Argument rdf:ID="RANGEEDGES_a4">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#numberstring"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >upper threshold of range (upper edge of closest grid box)</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >range_high</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#RANGEEDGES"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy>
      <rdf:Description rdf:about="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#domain_selection">
        <fn:describes>
          <fn:Function rdf:ID="removeVALUES">
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >removeVALUES</fn:func_name>
            <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >removes list of VALUES from variable (complement to VALUES)</rdfs:comment>
            <fn:hasArgument>
              <fn:Argument rdf:ID="removeVALUES_4">
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >data_out</fn:arg_name>
                <fn:isArgumentOf rdf:resource="#removeVALUES"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >4</fn:arg_order>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >new variable without listed values</fn:arg_desc>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="removeVALUES_3">
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >value list</fn:arg_name>
                <fn:isArgumentOf rdf:resource="#removeVALUES"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >3</fn:arg_order>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >values to be dropped from set</fn:arg_desc>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#numberstring"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="removeVALUES_2">
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >ivar</fn:arg_name>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >independent variable along which selection is to be performed</fn:arg_desc>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
                <fn:isArgumentOf rdf:resource="#removeVALUES"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="removeVALUES_1">
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >data_variable</fn:arg_name>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >variable on which selection is to be performed</fn:arg_desc>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:isArgumentOf rdf:resource="#removeVALUES"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#domain_selection"/>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >removes list of VALUES from variable (complement to VALUES)</fn:func_desc>
          </fn:Function>
        </fn:describes>
      </rdf:Description>
    </fn:isDescribedBy>
    <fn:hasArgument>
      <fn:Argument rdf:ID="RANGEEDGES_a1">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >dataset or variable dependent on the grid that will be sampled along</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ds/var</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#RANGEEDGES"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Identifies continuous range of values in one grid (i.e., independent variable) for which data will be selected.</fn:func_desc>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >RANGEEDGES</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="RANGEEDGES_a3">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#numberstring"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >lower threshold of range (lower edge of closest grid box)</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#RANGEEDGES"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >range_low</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Identifies continuous range of values in one grid (i.e., independent variable) for which data will be selected.</rdfs:comment>
  </fn:Function>
  <fn:Function rdf:ID="RANGE">
    <fn:hasArgument>
      <fn:Argument rdf:ID="RANGE_a1">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#RANGE"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >dataset or variable dependent on the grid that will be sampled along</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ds/var</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Identifies continuous range of values in one grid (i.e., independent variable) for which data will be selected.</rdfs:comment>
    <fn:hasArgument>
      <fn:Argument rdf:ID="RANGE_a5">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >restricted_ds/var</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >5</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >dataset or variable (&lt;i&gt;ds/var&lt;/i&gt;) restricted to only data associated with &lt;i&gt;grid&lt;/i&gt; values within &lt;i&gt;range_low&lt;/i&gt; and &lt;i&gt;range_high&lt;/i&gt;, inclusive; applied to all variables in the dataset if no variable selected</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#RANGE"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >RANGE</fn:func_name>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .CAC &lt;br&gt;
Y (10S) (10N) RANGE
&lt;p&gt;OR&lt;p&gt;
SOURCES .CAC .ssta&lt;br&gt;
Y -10 10 RANGE</fn:syntax_ex>
    <fn:hasArgument>
      <fn:Argument rdf:ID="RANGE_a3">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#numberstring"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >lower threshold of range (center of closest grid box)</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >range_low</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#RANGE"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#domain_selection"/>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Identifies continuous range of values in one grid (i.e., independent variable) for which data will be selected.</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="RANGE_a4">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#numberstring"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >range_high</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >upper threshold of range (center of closest grid box)</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#RANGE"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="RANGE_a2">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid in which values will be selected</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#RANGE"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="percentileover">
    <fn:hasArgument>
      <fn:Argument rdf:ID="percentileover_a1">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >data of which percentiles are to be found</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#percentileover"/>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Replaces data values with their percentile, based on non-parametric methods.</rdfs:comment>
    <fn:hasArgument>
      <fn:Argument rdf:ID="percentileover_a2">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid(s) over which percentiles  are to be found</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
        <fn:isArgumentOf rdf:resource="#percentileover"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#percentiles"/>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#statistical_functions"/>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .UNH .CSRC .RivDIS .dischrg
&lt;br&gt;ISTA 4 VALUE
&lt;br&gt;T (Aug-Oct 1950-1979) RANGE
&lt;br&gt;[T]percentileover</fn:syntax_ex>
    <fn:hasArgument>
      <fn:Argument rdf:ID="percentileover_a3">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >true</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:isArgumentOf rdf:resource="#percentileover"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >minfrac</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Minimum fraction of data that must be present (i.e., fraction not indicated as missing) within the selected domain in order for the percentiles to be calculated. If minfrac is not present, then a missing value is returned. If minfrac is not given, then the percentiles are calculated regardless of the amount of data present in domain.</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Replaces data values with their percentile, based on non-parametric methods.</fn:func_desc>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >percentileover</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="percentileover_a4">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >percentiles of &lt;i&gt;var&lt;/i&gt; over  &lt;i&gt;grid&lt;/i&gt;. &lt;i&gt;percentilevar&lt;/i&gt; has same name and is dependent on the same grids as &lt;i&gt;var&lt;/i&gt;.</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >percentilevar</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#percentileover"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="svd">
    <fn:hasArgument>
      <fn:Argument rdf:ID="svd_a0">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#svd"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >data to be analyzed</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >0</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="svd_a1">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >true</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >weights</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#proc"/>
        <fn:isArgumentOf rdf:resource="#svd"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >wghts</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="svd_a3">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#svd"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >time grids over which svd is to be found</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >time</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy>
      <rdf:Description rdf:about="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#singular_value_decomposition">
        <fn:describes rdf:resource="#svd"/>
      </rdf:Description>
    </fn:isDescribedBy>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >svd</fn:func_name>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Computes singular value decomposition</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="svd_a2">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >spatial grids over which svd is to be found</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#svd"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >space</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="svd_a4">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >dataset comprised of the singular value decomposition of &lt;i&gt;var&lt;/i&gt;, where     structures (Ss), time series (Ts), singular values (sv), and normalized eigenvalues (evaln) are variables.</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >svd_dataset</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:isArgumentOf rdf:resource="#svd"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy>
      <rdf:Description rdf:about="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#EOF">
        <fn:describes rdf:resource="#svd"/>
        <fn:describes>
          <fn:Function rdf:ID="varimax">
            <fn:hasArgument>
              <fn:Argument rdf:ID="varimax_a2">
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
                <fn:isArgumentOf rdf:resource="#varimax"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >N</fn:arg_name>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >number of modes to include in rotation</fn:arg_desc>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="varimax_a1">
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >svddataset</fn:arg_name>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >dataset of svd results</fn:arg_desc>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:isArgumentOf rdf:resource="#varimax"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="varimax_a3">
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >dataset containing the rotated eofs</fn:arg_desc>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >rotated_eofs</fn:arg_name>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >3</fn:arg_order>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:isArgumentOf rdf:resource="#varimax"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >performs varimax rotation on the results of svd</fn:func_desc>
            <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >performs varimax rotation on the results of svd</rdfs:comment>
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >varimax</fn:func_name>
            <fn:isDescribedBy>
              <rdf:Description rdf:about="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#rotated_eofs">
                <fn:describes rdf:resource="#varimax"/>
              </rdf:Description>
            </fn:isDescribedBy>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#EOF"/>
          </fn:Function>
        </fn:describes>
      </rdf:Description>
    </fn:isDescribedBy>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Computes singular value decomposition</rdfs:comment>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .CAC .ssta
&lt;br&gt;{ Y cosd } [ X Y ] [T]  svd
&lt;p&gt;
As a check of normalization, plot&lt;p&gt;
 Ss
  dup mul
  Y cosd mul
  [X Y]average
&lt;p&gt; or &lt;p&gt;
Ts
   sv div
   dup mul
   [T]average
  &lt;p&gt;
Both should be a constant 1.</fn:syntax_ex>
  </fn:Function>
  <fn:Function rdf:ID="rasterize">
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >rasterizes a geometry to match a gridded variable</rdfs:comment>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >rasterizes a geometry to match a gridded variable</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="rasterize_a2">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >geometry variable which is to be rasterized.</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >geometry</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#rasterize"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="rasterize_a3">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >geometry gridded to match griddedvar</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >griddedgeometry</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#rasterize"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="rasterize_a1">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >griddedvar</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >reference gridded variable to be matched</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#rasterize"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy>
      <rdf:Description rdf:about="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#geometry_functions">
        <fn:describes>
          <fn:Function rdf:ID="rect">
            <fn:hasArgument>
              <fn:Argument rdf:ID="rect_a5">
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:isArgumentOf rdf:resource="#rect"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >rectangular geometry variable</fn:arg_desc>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >5</fn:arg_order>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >rectangle</fn:arg_name>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >&lt;p style="margin-top: 0"&gt;
      &lt;br&gt;
      &lt;u&gt;&lt;b&gt;Description&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;&lt;b&gt;rect&lt;/b&gt; defines a rectangular 
      region from user-defined coordinates within an input variable, creating 
      a geometry variable &amp;quot;&lt;i&gt;rectangle&lt;/i&gt;&amp;quot; as a result. To define the 
      rectangle, the user provides four arguments in the following order: &lt;i&gt;xlo&lt;/i&gt;, 
      &lt;i&gt;ylo&lt;/i&gt;, &lt;i&gt;xhi&lt;/i&gt;, and &lt;i&gt;yhi.&lt;/i&gt;&lt;br&gt;&lt;br&gt;
    &lt;/p&gt;</fn:syntax_ex>
            <fn:hasArgument>
              <fn:Argument rdf:ID="rect_a2">
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <fn:isArgumentOf rdf:resource="#rect"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >low  value of second coordinate</fn:arg_desc>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >ylo</fn:arg_name>
              </fn:Argument>
            </fn:hasArgument>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >defines a rectangle geometry</fn:func_desc>
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >rect</fn:func_name>
            <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >defines a rectangle geometry</rdfs:comment>
            <fn:hasArgument>
              <fn:Argument rdf:ID="rect_a3">
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >3</fn:arg_order>
                <fn:isArgumentOf rdf:resource="#rect"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >xhi</fn:arg_name>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >high value of first coordinate</fn:arg_desc>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="rect_a1">
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >low value of first coordinate</fn:arg_desc>
                <fn:isArgumentOf rdf:resource="#rect"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >xlo</fn:arg_name>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="rect_a4">
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >yhi</fn:arg_name>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >high value of second coordinate</fn:arg_desc>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >4</fn:arg_order>
                <fn:isArgumentOf rdf:resource="#rect"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#geometry_functions"/>
          </fn:Function>
        </fn:describes>
      </rdf:Description>
    </fn:isDescribedBy>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >rasterize</fn:func_name>
  </fn:Function>
  <fn:Function rdf:ID="SM121">
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SM121</fn:func_name>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#smoothing_data"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="SM121_a4">
        <fn:isArgumentOf rdf:resource="#SM121"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >n</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >number of passes of smoothing to be applied</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Applies two-dimensional 121 smoothing to a variable</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="SM121_a2">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grids</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#SM121"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grids (1 or 2) over which 121 smoothing is to be applied</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .NOAA .NCEP .CPC .CAMS_OPI .climatology .prcp
&lt;br&gt;[X Y] 1 SM121</fn:syntax_ex>
    <fn:hasArgument>
      <fn:Argument rdf:ID="SM121_a1">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#SM121"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable to be smoothed</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Applies two-dimensional 121 smoothing to a variable</rdfs:comment>
    <fn:hasArgument>
      <fn:Argument rdf:ID="SM121_a5">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >5</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >smoothvar</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#SM121"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >&lt;i&gt;var&lt;/i&gt; after &lt;i&gt;n&lt;/i&gt; passes of 121 smoothing has been applied over &lt;i&gt;grids&lt;/i&gt;</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="definite-integral">
    <fn:hasArgument>
      <fn:Argument rdf:ID="definite-integral_a4">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >definite integral over &lt;i&gt;ivar&lt;/i&gt; from &lt;i&gt;low&lt;/i&gt; to &lt;i&gt;high&lt;/i&gt;</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#definite-integral"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >integral</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Returns integral evaluated between two limits</fn:func_desc>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Returns integral evaluated between two limits</rdfs:comment>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >definite-integral</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="definite-integral_a0">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >0</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >integrand</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >function to be integrated</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#definite-integral"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="definite-integral_a1">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >independent variable to be integrated over</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ivar</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#definite-integral"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="definite-integral_a2">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >low</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >lower limit</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#definite-integral"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >&lt;br&gt;
    &lt;u&gt;&lt;b&gt;Description&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;&lt;b&gt;definite-integral&lt;/b&gt; calculates the 
    definite integral of the latest variable on the stack over the grid 
    (independent variable) and limits (&lt;i&gt;low&lt;/i&gt; and &lt;i&gt;high&lt;/i&gt;) specified 
    in the command.&lt;br&gt;&lt;br&gt;&lt;u&gt;&lt;b&gt;Example&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES 
    .NOAA .NCEP-NCAR .CDAS-1 .DAILY .Intrinsic .PressureLevel .reld&lt;br&gt;T (1 
    Jan 2007) VALUE&lt;br&gt;P 600 10 definite-integral&lt;/font&gt;&lt;br&gt;&lt;br&gt;In this 
    example global gridded relative divergence values for 1 January 2007 are 
    selected for all available vertical pressure levels from the NCEP/NCAR 
    Reanalysis data set. Then, the integral of the relative divergence values 
    is taken over the vertical pressure grid (P) from 600 to 10 hectopascals 
    (mb), presumably from near the level of non-divergence to the top of the 
    atmosphere in the Reanalysis data set. To the extent that the relative 
    divergence values are accurate, the result of the calculation should be 
    proportional to the vertical velocity at 600 hPa. Maps of the result of 
    this calculation and the Reanalysis pressure vertical velocity for the 
    same day are given here:&lt;br&gt;&lt;br&gt;

    &lt;table border="0" cellpadding="1" cellspacing="1"&gt;
      &lt;tr&gt;
        &lt;td align="center"&gt;
          Vertical Integral of Relative Divergence&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCEP-NCAR/.CDAS-1/.DAILY/.Intrinsic/.PressureLevel/.reld/T/%281%20Jan%202007%29VALUE/P/600/10/definite-integral/figviewer.html?my.help=more+options&amp;map.Y.units=degree_north&amp;map.Y.plotlast=90N&amp;map.url=X+Y+fig-+colors+coasts+lakes+-fig&amp;map.domain=+%7B+Y+-90.+90.+plotrange+%7D&amp;map.domainparam=+%2Fplotaxislength+432+psdef+%2Fplotborder+72+psdef&amp;map.zoom=Zoom&amp;redraw.x=22&amp;redraw.y=9&amp;map.Y.plotfirst=90S&amp;map.X.plotfirst=1.25W&amp;map.X.units=degree_east&amp;map.X.modulus=360&amp;map.X.plotlast=1.25W&amp;map.int_dP.plotfirst=-0.0051178&amp;map.int_dP.units=100+kilogram+meter-1+second-3&amp;map.int_dP.plotlast=0.00511725&amp;map.newurl.grid0=X&amp;map.newurl.grid1=Y&amp;map.newurl.land=draw+coasts&amp;map.newurl.plot=colors&amp;map.plotaxislength=300&amp;map.plotborder=72&amp;map.fnt=Helvetica&amp;map.fntsze=12&amp;map.XOVY=auto&amp;map.color_smoothing=1&amp;map.framelbl=framelabelstart&amp;map.framelabeltext=&amp;map.iftime=25&amp;map.mftime=25&amp;map.fftime=200"&gt;&lt;img src="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCEP-NCAR/.CDAS-1/.DAILY/.Intrinsic/.PressureLevel/.reld/T/%281%20Jan%202007%29VALUE/P/600/10/definite-integral/X+Y+fig-+colors+coasts+-fig+//int_dP/-0.0051178/0.00511725/plotrange/Y/-90/90/plotrange//plotaxislength+300+psdef//plotborder+72+psdef//XOVY+null+psdef+.gif"&gt;&lt;/a&gt;&lt;br&gt;&lt;img src="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCEP-NCAR/.CDAS-1/.DAILY/.Intrinsic/.PressureLevel/.reld/T/%281%20Jan%202007%29VALUE/P/600/10/definite-integral/X+Y+fig-+colors+coasts+-fig+.auxfig+//int_dP/-0.0051178/0.00511725/plotrange/Y/-90/90/plotrange//plotaxislength+300+psdef//plotborder+72+psdef//XOVY+null+psdef+.gif"&gt;
        &lt;/td&gt;
        &lt;td align="center"&gt;
          Pressure Vertical Velocity at 600 hPa&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCEP-NCAR/.CDAS-1/.DAILY/.Intrinsic/.PressureLevel/.vvel/P/600/VALUE/T/%281%20Jan%202007%29VALUE/figviewer.html?my.help=more+options&amp;map.Y.units=degree_north&amp;map.Y.plotlast=90N&amp;map.url=X+Y+fig-+colors+coasts+-fig&amp;map.domain=+%7B+%2Fvvel+-0.6+0.6+plotrange+Y+-90+90+plotrange+%7D&amp;map.domainparam=+%2Fplotaxislength+432+psdef+%2Fplotborder+72+psdef+%2FXOVY+null+psdef&amp;map.zoom=Zoom&amp;redraw.x=24&amp;redraw.y=-3&amp;map.Y.plotfirst=90S&amp;map.X.plotfirst=1.25W&amp;map.X.units=degree_east&amp;map.X.modulus=360&amp;map.X.plotlast=1.25W&amp;map.vvel.plotfirst=-0.6&amp;map.vvel.units=Pa%2Fs&amp;map.vvel.plotlast=0.6&amp;map.newurl.grid0=X&amp;map.newurl.grid1=Y&amp;map.newurl.land=draw+coasts&amp;map.newurl.plot=colors&amp;map.plotaxislength=300&amp;map.plotborder=72&amp;map.fnt=Helvetica&amp;map.fntsze=12&amp;map.XOVY=auto&amp;map.color_smoothing=1&amp;map.framelbl=framelabelstart&amp;map.framelabeltext=&amp;map.iftime=25&amp;map.mftime=25&amp;map.fftime=200"&gt;&lt;img src="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCEP-NCAR/.CDAS-1/.DAILY/.Intrinsic/.PressureLevel/.vvel/P/600/VALUE/T/%281%20Jan%202007%29VALUE/X+Y+fig-+colors+coasts+-fig+//vvel/-0.6/0.6/plotrange/Y/-90/90/plotrange//plotaxislength+300+psdef//plotborder+72+psdef//XOVY+null+psdef+.gif"&gt;&lt;/a&gt;&lt;br&gt;&lt;img src="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCEP-NCAR/.CDAS-1/.DAILY/.Intrinsic/.PressureLevel/.vvel/P/600/VALUE/T/%281%20Jan%202007%29VALUE/X+Y+fig-+colors+coasts+-fig+.auxfig+//vvel/-0.6/0.6/plotrange/Y/-90/90/plotrange//plotaxislength+300+psdef//plotborder+72+psdef//XOVY+null+psdef+.gif"&gt;
        &lt;/td&gt;
      &lt;/tr&gt;
    &lt;/table&gt;
    &lt;p&gt;
      &lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCEP-NCAR/.CDAS-1/.DAILY/.Intrinsic/.PressureLevel/.reld/T/%281%20Jan%202007%29VALUE/P/600/10/definite-integral/"&gt;Live 
      Example Link&lt;/a&gt;
    &lt;/p&gt;
    &lt;p&gt;
      
    &lt;/p&gt;
    &lt;br&gt;</fn:syntax_ex>
    <fn:hasArgument>
      <fn:Argument rdf:ID="definite-integral_a3">
        <fn:isArgumentOf rdf:resource="#definite-integral"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >upper limit</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >high</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="splitstreamgrid">
    <fn:hasArgument>
      <fn:Argument rdf:ID="splitstreamgrid_a1">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#splitstreamgrid"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable dependent on grid to be split</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >splitstreamgrid</fn:func_name>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Splits grid (i.e., independent variable) into two grids. Commonly-used to create climatologies (see live example below).</fn:func_desc>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_modification"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="splitstreamgrid_a3">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >step interval on which grid split is based</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#splitstreamgrid"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >step</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#independent_variable_modification"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="splitstreamgrid_a4">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:isArgumentOf rdf:resource="#splitstreamgrid"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >varout</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >same as &lt;i&gt;var&lt;/i&gt; except now dependent on two newly-defined grids: 
&lt;br&gt;1) &lt;i&gt;grid_in&lt;/i&gt; now contains &lt;i&gt;step&lt;/i&gt; points. In the example below, &lt;i&gt;grid_in&lt;/i&gt; (i.e., T) contains values of Jan, Feb, ..., Dec.
&lt;br&gt;
2) &lt;i&gt;newgrid&lt;/i&gt; contains &lt;i&gt;n&lt;/i&gt;/&lt;i&gt;step&lt;/i&gt; points with a step interval of &lt;i&gt;step&lt;/i&gt;. In the example below, &lt;i&gt;newgrid&lt;/i&gt; (i.e., T2) contains values of 1982, 1983, ..., 2003.</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Splits grid (i.e., independent variable) into two grids. Commonly-used to create climatologies (see live example below).</rdfs:comment>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >&lt;u&gt;&lt;b&gt;Description&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;b&gt;splitstreamgrid&lt;/b&gt; splits grid (i.e., 
    independent variable) into two grids. Commonly used to create 
    climatologies.&lt;br&gt;&lt;u&gt;&lt;b&gt;Example&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES 
    .NOAA .NCEP .EMC .CMB .GLOBAL .Reyn_SmithOIv2 .monthly .sst&lt;br&gt;T (Jan 
    1982) (Dec 2003) RANGE&lt;br&gt;T 12 splitstreamgrid&lt;br&gt;&lt;/font&gt;&lt;font color="#800000"&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCEP/.EMC/.CMB/.GLOBAL/.Reyn_SmithOIv2/.monthly/.sst/T/%28Jan%201982%29%28Dec%202003%29RANGE/T/12/splitstreamgrid%5BT2%5Daverage/"&gt;Live 
    Example Link&lt;/a&gt;&lt;/font&gt;</fn:syntax_ex>
    <fn:hasArgument>
      <fn:Argument rdf:ID="splitstreamgrid_a2">
        <fn:isArgumentOf rdf:resource="#splitstreamgrid"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid_in</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid to be split, containing &lt;i&gt;n&lt;/i&gt; points</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="gridtomatchnamed">
    <fn:hasArgument>
      <fn:Argument rdf:ID="gridtomatchnamed4">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:isArgumentOf rdf:resource="#gridtomatchnamed"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable1 regridded to match variable2</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var1'</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="gridtomatchnamed3">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Name of object</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#gridtomatchnamed"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >object name</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="gridtomatchnamed2">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#gridtomatchnamed"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var2</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to which variable1 will be regridded to</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="gridtomatchnamed1">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#gridtomatchnamed"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var1</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to be regridded</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >gridtomatchnamed</fn:func_name>
  </fn:Function>
  <fn:Function rdf:ID="mulavg">
    <fn:hasArgument>
      <fn:Argument rdf:ID="mulavg2">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:isArgumentOf rdf:resource="#mulavg"/>
        <rdfs:label xml:lang="en">mulavg2</rdfs:label>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to be multiplied and averaged</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var2</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Multiplies and averages over a set of independent variables</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="mulavg4">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >	 Minimum fraction of data that must be present (i.e., fraction not indicated as missing) within the selected domain in order for the average to be calculated. If minfrac is not present, then a missing value is returned. If minfrac is not given, then the average is calculated regardless of the amount of data present in domain</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#mulavg"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >minfrac</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >true</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <rdfs:label xml:lang="en">mulavg4</rdfs:label>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="mulavg3">
        <fn:isArgumentOf rdf:resource="#mulavg"/>
        <rdfs:label xml:lang="en">mulavg3</rdfs:label>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Grids over which variables will be multiplied and averaged</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ivar</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >mulavg</fn:func_name>
    <rdfs:comment xml:lang="en">multiplies and averages over a set of independent variables</rdfs:comment>
    <fn:hasArgument>
      <fn:Argument rdf:ID="mulavg5">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >5</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#mulavg"/>
        <rdfs:label xml:lang="en">mulavg5</rdfs:label>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var'</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable multiplied and avereaged over a set of grids</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:label xml:lang="en">mulavg</rdfs:label>
    <fn:hasArgument>
      <fn:Argument rdf:ID="mulavg1">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#mulavg"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to be multiplied and averaged</fn:arg_desc>
        <rdfs:label xml:lang="en">mulavg1</rdfs:label>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var1</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="cptv10">
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >creates a CPT v10 file from the input dataset/variable</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="cptv10a05">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >5</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >cpt file page which gives links to the CPT files</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >output file</fn:arg_name>
        <fn:argument_type>
          <fn:Argument_Type rdf:about="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#file"/>
        </fn:argument_type>
        <fn:isArgumentOf rdf:resource="#cptv10"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="cptv10a04">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
        <fn:isArgumentOf rdf:resource="#cptv10"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid or variable that gives the time</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >time</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="cptv10a03">
        <fn:isArgumentOf rdf:resource="#cptv10"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >spatial grids</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >either a pair of spatial grids or the station grid</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="cptv10a02">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#cptv10"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >true</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#proc"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >optional list of variables to be extracted from the dataset (default is to include all of them)</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable list</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="cptv10a01">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#cptv10"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >inputdata</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >dataset or variable to be put in cptv10 file</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex xml:lang="en">&lt;p style="margin-top: 0"&gt;
      &lt;b&gt;&lt;font face="SansSerif"&gt;cptv10 &lt;/font&gt;&lt;/b&gt;allows one to explicitly 
      specify variables, spatial, and temporal grids for output to a cptv10 
      file. Since CPT is most useful as a tool to analyze results from Data 
      Library analyses (as opposed to direct downloads of datasets that 
      explicitly exist in the data library), the flexibility of explicitly 
      specifying information for CPT is useful.
    &lt;/p&gt;
    &lt;h4&gt;
      Downloading a precipitation analysis with no explicit time
    &lt;/h4&gt;
    &lt;pre&gt;  
  SOURCES .IRI .FD .ECHAM4p5 .Forecast 
     .ca_sst .ensemble24 .MONTHLY .prec
  (mm/day) unitconvert
  [M]average
  S (1 Dec 1957-2008) VALUES
  L 0.5 2.5 RANGEEDGES
  [L] /keepgrids average
  [X Y][S L add]cptv10
		&lt;/pre&gt;
    This example accesses the precipitation record, changes the units, 
    ensemble averages, selects Dec starts, and averages over the first three 
    lags (retaining the lag (L) grid so that it can be used to compute time 
    later). The last line then specifies X Y as the spatial grids and the sum 
    of start and lead time as time. 
		&lt;p&gt;
		&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.IRI/.FD/.ECHAM4p5/.Forecast/.ca_sst/.ensemble24/.MONTHLY/.prec/(mm/day)unitconvert%5BM%5Daverage/S/(1%20Dec%201957-2008)VALUES/L/0.5/2.5/RANGEEDGES%5BL%5D//keepgrids/average%5BX/Y%5D%5BS/L/add%5Dcptv10/"&gt;Results&lt;/a&gt;

    &lt;h4&gt;
      Downloading two precipitation analyses as a pair of fields for CPT
    &lt;/h4&gt;
    &lt;pre&gt;   
  SOURCES .NOAA .NCEP .EMC .CFS
     .MONTHLY .surface .prate
  L (1.5) (3.5) RANGEEDGES
  S (0000 1 Sep 1982-2008) VALUES
  X (30E) (100E) RANGEEDGES
  Y (30N) (30S) RANGEEDGES
  [M]average
  [L] /keepgrids average   
  c: /name /water_density def 998 (kg/m3) :c
   div
  (mm/day) unitconvert
      
 SOURCES .IRI .MP .RESEARCH .COUPLED .GLOBAL
   .ECHAM4p5-MOM3-realtime .ATM .Surface .prec
   L (1.5) (3.5) RANGEEDGES
   S (0000 1 Sep 1982-2008) VALUES
   X (30E) (100E) RANGEEDGES
   Y (30N) (30S) RANGEEDGES
   [M]average
   [L] /keepgrids average
   (mm/day) unitconvert
      
[ X Y ] regridLinear      
 {NOAA_prcp IRI_prcp}ds
  [X Y][S L add ]cptv10&lt;/pre&gt;
    In this example, we compute seasonal average precipitation from two 
    different models. Extract data from the monthly CFS, Sep starts averaged 
    from 1.5 to 3.5 month leads. Note that we keep the L grid in the average 
    so that we can use it later to compute time from start time and lead.

    &lt;pre&gt;   
  SOURCES .NOAA .NCEP .EMC .CFS
        .MONTHLY .surface .prate
  L (1.5) (3.5) RANGEEDGES
  S (0000 1 Sep 1982-2008) VALUES
  X (30E) (100E) RANGEEDGES
  Y (30N) (30S) RANGEEDGES
  [M]average
  [L] /keepgrids average
  &lt;/pre&gt;
    Because this model outputs precipitation in kg /m2 /s, we need to divide 
    by water density to allow unit conversion to mm/day.

  &lt;pre&gt;	
    c:  /name /water_density def  998 (kg/m3) :c
   div
  (mm/day) unitconvert
  &lt;/pre&gt;
    Now we extract data from the monthly MOM3, again Sep starts averaged from 
    1.5 to 3.5 month leads. The mm/day unit conversion does not involve water 
    density this time.

&lt;pre&gt;      
 SOURCES .IRI .MP .RESEARCH .COUPLED .GLOBAL
  .ECHAM4p5-MOM3-realtime .ATM .Surface .prec
  L (1.5) (3.5) RANGEEDGES
  S (0000 1 Sep 1982-2008) VALUES
  X (30E) (100E) RANGEEDGES
  Y (30N) (30S) RANGEEDGES
  [M]average
  [L] /keepgrids average
  (mm/day) unitconvert
&lt;/pre&gt;
    Now we regrid the IRI model analysis to match the NOAA model analysis

&lt;pre&gt;          
[ X Y ] regridLinear
&lt;/pre&gt;
    We bundle the two results into a new dataset, calling them NOAA_prcp and 
    IRI_prcp respectively.
&lt;pre&gt;          
   {NOAA_prcp IRI_prcp}ds
&lt;/pre&gt;
    We then invoke cptv10, specifying X Y spatial grids, and computing time 
    from the sum of start time S and lead time L. Note that the width of three 
    months associated with L is inherited by T, so that the output is 
    correctly labelled as seasonal averages.

    &lt;pre&gt;          
  [X Y][S L add ]cptv10
  &lt;/pre&gt;
    &lt;a href="http://iridl.ldeo.columbia.edu/SOURCES/.NOAA/.NCEP/.EMC/.CFS/.MONTHLY/.surface/.prate/L/(1.5)(3.5)RANGEEDGES/S/(0000%201%20Sep%201982-2008)VALUES/X/(30E)(100E)RANGEEDGES/Y/(30N)(30S)RANGEEDGES%5BM%5Daverage%5BL%5D//keepgrids/average/c://name//water_density/def/998/(kg/m3):c/div/(mm/day)unitconvert/SOURCES/.IRI/.MP/.RESEARCH/.COUPLED/.GLOBAL/.ECHAM4p5-MOM3-realtime/.ATM/.Surface/.prec/L/(1.5)(3.5)RANGEEDGES/S/(0000%201%20Sep%201982-2008)VALUES/X/(30E)(100E)RANGEEDGES/Y/(30N)(30S)RANGEEDGES%5BM%5Daverage%5BL%5D//keepgrids/average/(mm/day)unitconvert%5BX/Y%5DregridLinear/%7BNOAA_prcp/IRI_prcp%7Dds%5BX/Y%5D%5BS/L/add%5Dcptv10/"&gt;Results&lt;/a&gt;&lt;a&gt; 
      &lt;h4&gt;Downloading dual field Station data&lt;/h4&gt;

&lt;pre&gt;
SOURCES .NOAA .NCDC .USHCN
  state
   (30) dup masknotrange
   SELECT
  T (Jun 1960-1979) VALUES
  {raw .prcp 
   raw .mean .temp
   lon lat elev Name}[ID][T] cptv10
&lt;/pre&gt;
      This example uses the state code to pick out a subset of the stations,
      picks June data from 1960-1979, then selected prcp and temp data, with
  lon, lat, elev, and Name station information.
      &lt;p&gt;
&lt;a href="http://iridl.ldeo.columbia.edu/SOURCES/.NOAA/.NCDC/.USHCN/state/(30)dup/masknotrange/SELECT/T/(Jun 1960-1979)VALUES/{raw/.prcp/raw/.mean/.temp/lon/lat/elev/Name}[ID][T]/cptv10/"&gt;Results&lt;/a&gt;
</fn:syntax_ex>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >cptv10</fn:func_name>
  </fn:Function>
  <fn:Function rdf:ID="SELECT">
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SELECT</fn:func_name>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Selects values of a grid based on values of the indicated variable.  Commonly used to select stations - station ids (grid) selected based on lat/lon (variables) values (see Live Example).</fn:func_desc>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Selects values of a grid based on values of the indicated variable.  Commonly used to select stations - station ids (grid) selected based on lat/lon (variables) values (see Live Example).</rdfs:comment>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >&lt;u&gt;&lt;b&gt;Description &lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;b&gt;SELECT&lt;/b&gt; is used to select values of a 
    grid based on values of the indicated variable. Commonly used to select 
    stations - station ids (grid) selected based on lat/lon (variables) values&lt;br&gt;&lt;u&gt;&lt;b&gt;Examples&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;font color="#008000"&gt;lat 
    SELECT&lt;/font&gt;&lt;br&gt;&lt;font color="#800000"&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCDC/.GDCN/lon/290/340/masknotrange/SELECT/lat/-10/10/masknotrange/SELECT/"&gt;Live 
    Example Link&lt;/a&gt;&lt;/font&gt;&lt;br&gt;</fn:syntax_ex>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#domain_selection"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="SELECT_a3">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >selected ds</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#SELECT"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >new dataset selected from &lt;i&gt;ds&lt;/i&gt;.  All the values of the independent variable of &lt;i&gt;var&lt;/i&gt; that are marked missing in &lt;i&gt;var&lt;/i&gt; are eliminated</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="SELECT_a1">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ds</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#SELECT"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >dataset to be selected from</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="SELECT_a2">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#SELECT"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable used to make selection of grid values</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="partial">
    <fn:hasArgument>
      <fn:Argument rdf:ID="partial3">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:isArgumentOf rdf:resource="#partial"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var'</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Partial derivative of stream along grid</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <rdfs:label xml:lang="en">partial3</rdfs:label>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="partial2">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#partial"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ivar</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <rdfs:label xml:lang="en">partial2</rdfs:label>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Independent variable along which partial derivative of variable will be taken</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="partial1">
        <fn:isArgumentOf rdf:resource="#partial"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <rdfs:label xml:lang="en">partial1</rdfs:label>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable of which partial derivative will be taken along grid</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:label xml:lang="en">partial</rdfs:label>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >partial</fn:func_name>
    <rdfs:comment xml:lang="en">takes partial derivative of variable along grid</rdfs:comment>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Takes partial derivative of variable along grid</fn:func_desc>
  </fn:Function>
  <fn:Function rdf:ID="minover">
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Returns the minimum value of a variable over a selected grid(s)</fn:func_desc>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .NOAA .NCEP .CPC .CAMS .station .temperature .temp 
&lt;br&gt;IWMO (1001) VALUES 
&lt;br&gt;[T]0.9 minover 
&lt;p&gt;
OR 
&lt;p&gt;
SOURCES .NOAA .NCEP .CPC .GMSM .w 
&lt;br&gt;X 112 153 RANGE 
&lt;br&gt;Y -44 -11 RANGE 
&lt;br&gt;[X Y]minover</fn:syntax_ex>
    <fn:hasArgument>
      <fn:Argument rdf:ID="minover_a2">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid(s) over which minimum value is found</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#minover"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="minover_a1">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable of which minimum value is found</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#minover"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="minover_a4">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >minimum value of &lt;i&gt;var&lt;/i&gt; within selected domain of &lt;i&gt;grid&lt;/i&gt;
&lt;p&gt;
&lt;i&gt;minvar/num&lt;/i&gt; is no longer dependendent on &lt;i&gt;grid&lt;/i&gt;, but is still dependent on any other grids that &lt;i&gt;var&lt;/i&gt; depended on (if any)</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >minvar/num</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#minover"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="minover_a3">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >true</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#minover"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Minimum fraction of data that must be present (i.e., fraction not indicated as missing) within theselected domain in order for the minimum value to be found. If minfrac is not present, then a missing value is returned. If minfrac is not given, then the minimum value is found regardless of the amount of data present in domain.</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >minfrac</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >minover</fn:func_name>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Returns the minimum value of a variable over a selected grid(s)</rdfs:comment>
  </fn:Function>
  <fn:Function rdf:ID="beta">
    <fn:hasArgument>
      <fn:Argument rdf:ID="beta4">
        <rdfs:label xml:lang="en">beta4</rdfs:label>
        <fn:isArgumentOf rdf:resource="#beta"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:arg_name xml:lang="en">beta</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:label xml:lang="en">beta</rdfs:label>
    <fn:hasArgument>
      <fn:Argument rdf:ID="beta3">
        <rdfs:label xml:lang="en">beta3</rdfs:label>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#beta"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Pressure</fn:arg_desc>
        <fn:arg_name xml:lang="en">P</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="beta2">
        <rdfs:label xml:lang="en">beta2</rdfs:label>
        <fn:arg_desc xml:lang="en">Salinity</fn:arg_desc>
        <fn:arg_name xml:lang="en">S</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#beta"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >beta</fn:func_name>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >&lt;br&gt;
    &lt;u&gt;&lt;b&gt;Description&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;&lt;b&gt;beta&lt;/b&gt; uses potential temperature, 
    salinity, and pressure values in the ocean to calculate beta (the saline 
    contraction coefficient).&lt;br&gt;&lt;br&gt;&lt;u&gt;&lt;b&gt;References&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;McDougall, 
    T. J., 1987: Neutral Surfaces. &lt;i&gt;Journal of Physical Oceanography&lt;/i&gt;, &lt;b&gt;17&lt;/b&gt;, 
    1950-1964.&lt;br&gt;&lt;br&gt;&lt;u&gt;&lt;b&gt;Example&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES 
    .GEOSECS .THETA&lt;br&gt;SOURCES .GEOSECS .SAL&lt;br&gt;SOURCES .GEOSECS .PRESS&lt;br&gt;beta&lt;/font&gt;&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.GEOSECS/.THETA/SOURCES/.GEOSECS/.SAL/SOURCES/.GEOSECS/.PRESS/beta/"&gt;Live 
    Example Link&lt;/a&gt;&lt;br&gt;</fn:syntax_ex>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#oceanic_equation_of_state"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="beta1">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
        <fn:arg_name xml:lang="en">theta</fn:arg_name>
        <rdfs:label xml:lang="en">beta1</rdfs:label>
        <fn:isArgumentOf rdf:resource="#beta"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_desc xml:lang="en">Potential Temperature</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >saline contraction coefficient in the ocean</rdfs:comment>
  </fn:Function>
  <fn:Function rdf:ID="removeGRID">
    <fn:hasArgument>
      <fn:Argument rdf:ID="removeGRID_a2">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#removeGRID"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid (i.e., independent variable) to be removed
&lt;p&gt;
Must contain only a single value, &lt;i&gt;val&lt;/i&gt;.</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .NOAA .NODC .WOA01 .Grid-1x1 .Annual .an .aou
&lt;br&gt;Z (0.0) VALUE
&lt;br&gt;Z removeGRID</fn:syntax_ex>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Removes a single-valued grid (i.e. independent variable) from a variable</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="removeGRID_a1">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#removeGRID"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable dependent on grid to be removed</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#independent_variable_modification"/>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >removeGRID</fn:func_name>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Removes a single-valued grid (i.e. independent variable) from a variable</rdfs:comment>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_modification"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="removeGRID_a3">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >&lt;i&gt;var&lt;/i&gt; at &lt;i&gt;grid&lt;/i&gt; value &lt;i&gt;val&lt;/i&gt; only
&lt;p&gt;
&lt;i&gt;var_at_val&lt;/i&gt; is no longer explicitly dependent  on &lt;i&gt;grid&lt;/i&gt;.</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var_at_val</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#removeGRID"/>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="matchtruncation">
    <rdfs:comment xml:lang="en">changes second variable to match truncation of the first</rdfs:comment>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Changes second variable to match truncation of the first</fn:func_desc>
    <rdfs:label xml:lang="en">matchtruncation</rdfs:label>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >matchtruncation</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="matchtruncation1">
        <fn:isArgumentOf rdf:resource="#matchtruncation"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to be compared to</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var1</fn:arg_name>
        <rdfs:label xml:lang="en">matchtruncation1</rdfs:label>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="matchtruncation2">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to be truncated to match the first</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var2</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <rdfs:label xml:lang="en">matchtruncation2</rdfs:label>
        <fn:isArgumentOf rdf:resource="#matchtruncation"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="matchtruncation4">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <rdfs:label xml:lang="en">matchtruncation4</rdfs:label>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var2'</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable truncated to match the first</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#matchtruncation"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="matchtruncation3">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Unchanged variable</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var1</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#matchtruncation"/>
        <rdfs:label xml:lang="en">matchtruncation3</rdfs:label>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="abrat">
    <fn:hasArgument>
      <fn:Argument rdf:ID="abrat4">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:isArgumentOf rdf:resource="#abrat"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Ratio of alpha to beta</fn:arg_desc>
        <rdfs:label xml:lang="en">abrat4</rdfs:label>
        <fn:arg_name xml:lang="en">alpha/beta</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#oceanic_equation_of_state"/>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >abrat</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="abrat3">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Pressure</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name xml:lang="en">P</fn:arg_name>
        <rdfs:label xml:lang="en">abrat3</rdfs:label>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
        <fn:isArgumentOf rdf:resource="#abrat"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >&lt;br&gt;
    &lt;u&gt;&lt;b&gt;Description&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;&lt;b&gt;abrat&lt;/b&gt; uses potential temperature, 
    salinity, and pressure values in the ocean to calculate the ratio of alpha 
    (the thermal expansion coefficient) to beta (the saline contraction 
    coefficient).&lt;br&gt;&lt;br&gt;&lt;u&gt;&lt;b&gt;References&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;McDougall, T. J., 
    1987:  Neutral Surfaces.  &lt;i&gt;Journal of Physical Oceanography&lt;/i&gt;, &lt;b&gt;17&lt;/b&gt;, 
    1950-1964.&lt;br&gt;&lt;br&gt;&lt;u&gt;&lt;b&gt;Example&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES 
    .GEOSECS .THETA&lt;br&gt;SOURCES .GEOSECS .SAL&lt;br&gt;SOURCES .GEOSECS .PRESS&lt;br&gt;abrat&lt;/font&gt;&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.GEOSECS/.THETA/SOURCES/.GEOSECS/.SAL/SOURCES/.GEOSECS/.PRESS/abrat/"&gt;Live 
    Example Link&lt;/a&gt;&lt;br&gt;</fn:syntax_ex>
    <fn:hasArgument>
      <fn:Argument rdf:ID="abrat2">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Salinity</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#abrat"/>
        <rdfs:label xml:lang="en">abrat2</rdfs:label>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
        <fn:arg_name xml:lang="en">S</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="abrat1">
        <rdfs:label xml:lang="en">abrat1</rdfs:label>
        <fn:arg_name xml:lang="en">theta</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#abrat"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Potential Temperature</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:label xml:lang="en">abrat</rdfs:label>
    <rdfs:comment xml:lang="en">ratio of alpha to beta (oceanic eq. of state)</rdfs:comment>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Ratio of alpha to beta</fn:func_desc>
  </fn:Function>
  <fn:Function rdf:ID="runningAverage">
    <fn:hasArgument>
      <fn:Argument rdf:ID="runningAverage_a5">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >avgvar</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#runningAverage"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >5</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >running average of &lt;i&gt;var&lt;/i&gt;, where the overlapping intervals are of length &lt;i&gt;interval&lt;/i&gt;</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .NOAA .NCDC .GHCN .v2beta .prcp
&lt;br&gt;IWMO 63450000 VALUE            
&lt;br&gt;T 12 runningAverage</fn:syntax_ex>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >runningAverage</fn:func_name>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#smoothing_data"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="runningAverage_a2">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#runningAverage"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid(s) over which the running average is to be calculated</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Calculates the running average</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="runningAverage_a3">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >width (in units of &lt;i&gt;grid&lt;/i&gt;) of the overlapping interval</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >interval</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#runningAverage"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="runningAverage_a1">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#runningAverage"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable to be averaged</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Calculates the running average</rdfs:comment>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#average"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="runningAverage_a4">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >true</fn:optional>
        <fn:isArgumentOf rdf:resource="#runningAverage"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >minfrac</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Minimum fraction of data that must be present (i.e., fraction not indicated as missing) within the selected domain in order for the running average to be calculated. If minfrac is not present, then a missing value is returned. If minfrac is not given, then the running average is calculated regardless of the amount of data present in domain.</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="CofABbounded">
    <fn:hasArgument>
      <fn:Argument rdf:ID="CofABbounded3">
        <rdfs:label xml:lang="en">CofA=B-bounded3</rdfs:label>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
        <fn:arg_name xml:lang="en">C</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#CofABbounded"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc xml:lang="en">Converts a variable A to a variable B using a table B(C) and linear 
    interpolation. Out of range values are pegged to the extreme values</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="CofABbounded4">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name xml:lang="en">C'</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <rdfs:label xml:lang="en">CofA=B-bounded4</rdfs:label>
        <fn:isArgumentOf rdf:resource="#CofABbounded"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Converted variable using table B(C) and linear interpolation

Out of range values beyond half a grid step are pegged to the extreme values</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >&lt;p style="margin-top: 0"&gt;
      &lt;br&gt;
      &lt;b&gt;&lt;u&gt;Description&lt;/u&gt;&lt;/b&gt;&lt;br&gt;&lt;br&gt;&lt;b&gt;CofA=B-bounded&lt;/b&gt; accepts two 
      variables (A and B) as input and converts variable A values to values 
      expressed in terms of variable B based upon a table of corresponding 
      values (B(C)) in variable B and linear interpolation between the points 
      specified in the table.  Out-of-range values are pegged to the extreme 
      values.&lt;br&gt;&lt;br&gt;&lt;b&gt;&lt;u&gt;Example&lt;/u&gt;&lt;/b&gt;&lt;br&gt;&lt;br&gt;In the following example the 
      input variable A is CAMS-OPI gridded monthly precipitation, which 
      depends upon longitude (X), latitude (Y), and months (T) from Jan 1979 
      to Dec 2000. Input variable B is gridded observed monthly precipitation, 
      which depends upon grids X and Y (which match with X and Y from variable 
      A) and months (T) specified from Jan 1969 to Dec 1998. The purpose of 
      this particular script is to use a specific 30-year set of precipitation 
      values (variable B) to calculate precipitation percentiles by month of 
      year and then express precipitation values from the shorter time series 
      (variable A) in terms of the percentiles from variable B's climatology 
      at each (X,Y) grid point.
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      Here, the time grid for variable B is split into a grid of 12 months per 
      year (T) and a grid of 30 years (T2) from 1969 to 1998. The function 
      &amp;quot;replacebypercentile&amp;quot; is applied to the T2 grid of years in variable B, 
      with the result that the T2 grid is replaced by a new grid named 
      &amp;quot;percentile&amp;quot; that has points at 0.0, 0.33, 0.5, 0.67, and 1, containing 
      the precipitation values that correspond to those percentiles in the 
      30-year climatology for each month of the year at each (X,Y) grid point.
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      Based upon the correspondence between percentile and precipitation 
      values in variable B function (the table B(C)) 
      &amp;quot;[percentile]CofA=B-bounded&amp;quot; then converts the time series of monthly 
      precipitation values in variable A to percentiles by month of year using 
      linear interpolation between the percentile points specified in the 
      &amp;quot;percentile&amp;quot; grid in variable B. The word &amp;quot;bounded&amp;quot; in the name of the 
      function indicates that any precipitation values in variable A that fall 
      outside the range of precipitation values that correspond to percentiles 
      between 0 and 1 in variable B will be assigned to either 0 or 1, 
      depending upon whether the value is beyond the lower or upper end of the 
      range, respectively.&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES .NOAA .NCEP 
      .CPC .CAMS_OPI .v0208 .mean .prcp&lt;br&gt;T (Jan 1979) (Dec 2000) RANGE &lt;/font&gt;
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      &lt;font color="#008000"&gt;SOURCES .IRI .FD .Seasonal_Forecast .Observations 
      .monthly .prcp &lt;/font&gt;
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      &lt;font color="#008000"&gt;T (Jan 1969) (Dec 1998) RANGE &lt;/font&gt;
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      &lt;font color="#008000"&gt;T 12 splitstreamgrid &lt;/font&gt;
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      &lt;font color="#008000"&gt;[T2]0.0 0.33 0.5 0.67 1. 0.5 replacebypercentile &lt;/font&gt;
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      &lt;font color="#008000"&gt;[percentile]CofA=B-bounded&lt;/font&gt;&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCEP/.CPC/.CAMS_OPI/.v0208/.mean/.prcp/T/%28Jan%201979%29%28Dec%202000%29RANGE/SOURCES/.IRI/.FD/.Seasonal_Forecast/.Observations/.monthly/.prcp/T/%28Jan%201969%29%28Dec%201998%29RANGE/T/12/splitstreamgrid%5BT2%5D0.0/0.33/0.5/0.67/1./0.5/replacebypercentile%5Bpercentile%5DCofA=B-bounded/"&gt;Live 
      Example Link&lt;/a&gt;
    &lt;/p&gt;</fn:syntax_ex>
    <rdfs:label xml:lang="en">CofA=B-bounded</rdfs:label>
    <fn:hasArgument>
      <fn:Argument rdf:ID="CofABbounded2">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to be converted</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#CofABbounded"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <rdfs:label xml:lang="en">CofA=B-bounded2</rdfs:label>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name xml:lang="en">B</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="CofABbounded1">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name xml:lang="en">A</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to be converted</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#CofABbounded"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <rdfs:label xml:lang="en">CofA=B-bounded1</rdfs:label>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment xml:lang="en">converts a variable A to a variable C using a table B(C) and linear 
    interpolation. Out of range values are pegged to the extreme values.</rdfs:comment>
    <fn:isDescribedBy>
      <fn:Keyword rdf:about="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#table_lookup">
        <rdfs:label rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Table Lookup</rdfs:label>
        <fn:describes>
          <fn:Function rdf:ID="BofACbounded">
            <rdfs:label xml:lang="en">BofA=C-bounded</rdfs:label>
            <fn:hasArgument>
              <fn:Argument rdf:ID="BofACbounded1">
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:isArgumentOf rdf:resource="#BofACbounded"/>
                <fn:arg_name xml:lang="en">A</fn:arg_name>
                <rdfs:label xml:lang="en">BofA=C-bounded1</rdfs:label>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Variable to be converted</fn:arg_desc>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="BofACbounded4">
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >4</fn:arg_order>
                <fn:isArgumentOf rdf:resource="#BofACbounded"/>
                <rdfs:label xml:lang="en">BofA=C-bounded4</rdfs:label>
                <fn:arg_name xml:lang="en">B'</fn:arg_name>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >&lt;p style="margin-top: 0"&gt;
      Converted stream using table B(C=A) and linear interpolation
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      Out of range values are pegged to the extreme values
    &lt;/p&gt;</fn:arg_desc>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="BofACbounded2">
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:isArgumentOf rdf:resource="#BofACbounded"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <rdfs:label xml:lang="en">BofA=C-bounded2</rdfs:label>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_name xml:lang="en">B</fn:arg_name>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Variable to be converted</fn:arg_desc>
              </fn:Argument>
            </fn:hasArgument>
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >BofA=C-bounded</fn:func_name>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#table_lookup"/>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Converts a variable A to a variable B using a table B(C=A) and linear 
    interpolation. Out of range values are pegged to the extreme values</fn:func_desc>
            <rdfs:comment xml:lang="en">converts a variable A to a variable B using a table B(C=A) and linear 
    interpolation. Out of range values are pegged to the extreme values.</rdfs:comment>
            <fn:hasArgument>
              <fn:Argument rdf:ID="BofACbounded3">
                <fn:arg_name xml:lang="en">C</fn:arg_name>
                <rdfs:label xml:lang="en">BofA=C-bounded3</rdfs:label>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >3</fn:arg_order>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:isArgumentOf rdf:resource="#BofACbounded"/>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
              </fn:Argument>
            </fn:hasArgument>
          </fn:Function>
        </fn:describes>
        <fn:describes rdf:resource="#CofABbounded"/>
        <fn:describes>
          <fn:Function rdf:ID="BofAC">
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Converts a variable A to a variable B using a table B(C=A) and linear      interpolation. Out of range values beyond half a grid step are NaN</fn:func_desc>
            <fn:hasArgument>
              <fn:Argument rdf:ID="BofAC4">
                <rdfs:label xml:lang="en">BofA=C4</rdfs:label>
                <fn:arg_name xml:lang="en">B'</fn:arg_name>
                <fn:isArgumentOf rdf:resource="#BofAC"/>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >4</fn:arg_order>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                <fn:arg_desc xml:lang="en">New stream using a table B(C=A) and linear interpolation.

Out of range values beyond half a grid step are NaN.</fn:arg_desc>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="BofAC3">
                <rdfs:label xml:lang="en">BofA=C3</rdfs:label>
                <fn:isArgumentOf rdf:resource="#BofAC"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >3</fn:arg_order>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
                <fn:arg_name xml:lang="en">C</fn:arg_name>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="BofAC2">
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Variable to be converted</fn:arg_desc>
                <fn:isArgumentOf rdf:resource="#BofAC"/>
                <rdfs:label xml:lang="en">BofA=C2</rdfs:label>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <fn:arg_name xml:lang="en">B</fn:arg_name>
              </fn:Argument>
            </fn:hasArgument>
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >BofA=C</fn:func_name>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#table_lookup"/>
            <rdfs:comment xml:lang="en">converts a variable A to a variable B using a table B(C=A) and linear 
    interpolation. Out of rangevalues beyond half a grid step are NaN.</rdfs:comment>
            <rdfs:label xml:lang="en">BofA=C</rdfs:label>
          </fn:Function>
        </fn:describes>
        <fn:describes>
          <fn:Function rdf:ID="toS">
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#independent_variable_creation"/>
            <fn:hasArgument>
              <fn:Argument rdf:ID="toS_a3">
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >independent variable that is going to be replaced by constant values of &lt;i&gt;S&lt;/i&gt;</fn:arg_desc>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Z</fn:arg_name>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
                <fn:isArgumentOf rdf:resource="#toS"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >3</fn:arg_order>
              </fn:Argument>
            </fn:hasArgument>
            <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Interpolates onto surfaces</rdfs:comment>
            <fn:hasArgument>
              <fn:Argument rdf:ID="toS_a5">
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >A(S)</fn:arg_name>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >output data: A goes  from surfaces of constant Z to surfaces of constant S by linear interpolation</fn:arg_desc>
                <fn:isArgumentOf rdf:resource="#toS"/>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >5</fn:arg_order>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="toS_a2">
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >S(Z)</fn:arg_name>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:isArgumentOf rdf:resource="#toS"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >input surface information (needs to be monotonic in the independent variable &lt;i&gt;Z&lt;/i&gt; so that it can be used as a coordinate)</fn:arg_desc>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="toS_a4">
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#numbers"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >4</fn:arg_order>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >true</fn:optional>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >S</fn:arg_name>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >value(s) of the new &lt;i&gt;S&lt;/i&gt; grid.  If omitted, then it uses a list of S 
    values, in which case S needs to have discrete, repeated values.</fn:arg_desc>
                <fn:isArgumentOf rdf:resource="#toS"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#table_lookup"/>
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >toS</fn:func_name>
            <fn:hasArgument>
              <fn:Argument rdf:ID="toS_a1">
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >input data to be interpolated onto surfaces of &lt;i&gt;S&lt;/i&gt;</fn:arg_desc>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >A(Z)</fn:arg_name>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:isArgumentOf rdf:resource="#toS"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
              </fn:Argument>
            </fn:hasArgument>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Interpolates onto surfaces</fn:func_desc>
          </fn:Function>
        </fn:describes>
        <fn:describes>
          <fn:Function rdf:ID="CofAB">
            <fn:hasArgument>
              <fn:Argument rdf:ID="CofAB2">
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:isArgumentOf rdf:resource="#CofAB"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <rdfs:label xml:lang="en">CofA=B2</rdfs:label>
                <fn:arg_name xml:lang="en">B</fn:arg_name>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Variable to be converted</fn:arg_desc>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
              </fn:Argument>
            </fn:hasArgument>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Converts a variable A to a variable B using a table B(C) and linear 
    interpolation. Out of range values beyond half a grid step are NaN</fn:func_desc>
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >CofA=B</fn:func_name>
            <rdfs:comment xml:lang="en">converts a variable A to a variable C using a table B(C) and linear 
    interpolation. Out of range values beyond half a grid step are NaN.</rdfs:comment>
            <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >&lt;p style="margin-top: 0"&gt;
      &lt;br&gt;
      &lt;b&gt;&lt;u&gt;Description&lt;/u&gt;&lt;/b&gt;&lt;br&gt;&lt;br&gt;&lt;b&gt;CofA=B&lt;/b&gt; accepts two variables (A 
      and B) as input and converts variable A values to values expressed in 
      terms of variable B based upon a table of corresponding values (B(C)) in 
      variable B and linear interpolation between the points specified in the 
      table. Out-of-range values beyond half a grid step are assigned NaN 
      values.&lt;br&gt;&lt;br&gt;&lt;b&gt;&lt;u&gt;Example&lt;/u&gt;&lt;/b&gt;&lt;br&gt;&lt;br&gt;In the following example the 
      input variable A is CAMS-OPI gridded monthly precipitation, which 
      depends upon longitude (X), latitude (Y), and months (T) from Jan 1979 
      to Dec 2000. Input variable B is gridded observed monthly precipitation, 
      which depends upon grids X and Y (which match with X and Y from variable 
      A) and months (T) specified from Jan 1969 to Dec 1998. The purpose of 
      this particular script is to use a specific 30-year set of precipitation 
      values (variable B) to calculate precipitation percentiles by month of 
      year and then express precipitation values from the shorter time series 
      (variable A) in terms of the percentiles from variable B's climatology 
      at each (X,Y) grid point.
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      Here, the time grid for variable B is split into a grid of 12 months per 
      year (T) and a grid of 30 years (T2) from 1969 to 1998. The function 
      &amp;quot;replacebypercentile&amp;quot; is applied to the T2 grid of years in variable B, 
      with the result that the T2 grid is replaced by a new grid named 
      &amp;quot;percentile&amp;quot; that has points at 0.0, 0.33, 0.5, 0.67, and 1, containing 
      the precipitation values that correspond to those percentiles in the 
      30-year climatology for each month of the year at each (X,Y) grid point.
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      Based upon the correspondence between percentile and precipitation 
      values in variable B function (the table B(C)) 
      &amp;quot;[percentile]CofA=B-bounded&amp;quot; then converts the time series of monthly 
      precipitation values in variable A to percentiles by month of year using 
      linear interpolation between the percentile points specified in the 
      &amp;quot;percentile&amp;quot; grid in variable B. Any precipitation values in variable A 
      that fall outside the range of precipitation values that correspond to 
      percentiles between 0 and 1 in variable B will be assigned missing 
      values (NaN).&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES .NOAA .NCEP .CPC 
      .CAMS_OPI .v0208 .mean .prcp&lt;br&gt;T (Jan 1979) (Dec 2000) RANGE &lt;/font&gt;
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      &lt;font color="#008000"&gt;SOURCES .IRI .FD .Seasonal_Forecast .Observations 
      .monthly .prcp &lt;/font&gt;
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      &lt;font color="#008000"&gt;T (Jan 1969) (Dec 1998) RANGE &lt;/font&gt;
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      &lt;font color="#008000"&gt;T 12 splitstreamgrid &lt;/font&gt;
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      &lt;font color="#008000"&gt;[T2]0.0 0.33 0.5 0.67 1. 0.5 replacebypercentile &lt;/font&gt;
    &lt;/p&gt;
    &lt;p style="margin-top: 0"&gt;
      &lt;font color="#008000"&gt;[percentile]CofA=B&lt;/font&gt;&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCEP/.CPC/.CAMS_OPI/.v0208/.mean/.prcp/T/%28Jan%201979%29%28Dec%202000%29RANGE/SOURCES/.IRI/.FD/.Seasonal_Forecast/.Observations/.monthly/.prcp/T/%28Jan%201969%29%28Dec%201998%29RANGE/T/12/splitstreamgrid%5BT2%5D0.0/0.33/0.5/0.67/1./0.5/replacebypercentile%5Bpercentile%5DCofA=B/"&gt;Live 
      Example Link&lt;/a&gt;
    &lt;/p&gt;</fn:syntax_ex>
            <rdfs:label xml:lang="en">CofA=B</rdfs:label>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#table_lookup"/>
            <fn:hasArgument>
              <fn:Argument rdf:ID="CofAB1">
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_name xml:lang="en">A</fn:arg_name>
                <rdfs:label xml:lang="en">CofA=B1</rdfs:label>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Variable to be converted</fn:arg_desc>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
                <fn:isArgumentOf rdf:resource="#CofAB"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="CofAB3">
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:isArgumentOf rdf:resource="#CofAB"/>
                <rdfs:label xml:lang="en">CofA=B3</rdfs:label>
                <fn:arg_name xml:lang="en">C</fn:arg_name>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >3</fn:arg_order>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="CofAB4">
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >Converted variable using table B(C) and linear interpolation

Out of range values beyond half a grid step are NaN</fn:arg_desc>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <rdfs:label xml:lang="en">CofA=B4</rdfs:label>
                <fn:isArgumentOf rdf:resource="#CofAB"/>
                <fn:arg_name xml:lang="en">C'</fn:arg_name>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >4</fn:arg_order>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
              </fn:Argument>
            </fn:hasArgument>
          </fn:Function>
        </fn:describes>
      </fn:Keyword>
    </fn:isDescribedBy>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >CofA=B-bounded</fn:func_name>
  </fn:Function>
  <fn:Function rdf:ID="meansqover">
    <rdfs:comment xml:lang="en">returns mean square of A values. If [ grid1 ... ] is given, then the mean 
    AM will</rdfs:comment>
    <rdfs:label xml:lang="en">meansqover</rdfs:label>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >meansqover</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="meansqover1">
        <rdfs:label xml:lang="en">meansqover1</rdfs:label>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#meansqover"/>
        <fn:arg_name xml:lang="en">A</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="meansqover3">
        <fn:arg_name xml:lang="en">AM</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#meansqover"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <rdfs:label xml:lang="en">meansqover3</rdfs:label>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="meansqover2">
        <fn:isArgumentOf rdf:resource="#meansqover"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_name xml:lang="en">grid</fn:arg_name>
        <rdfs:label xml:lang="en">meansqover2</rdfs:label>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Changes second stream to match truncation of the first</fn:func_desc>
  </fn:Function>
  <fn:Function rdf:ID="maxover">
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >maxover</fn:func_name>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Returns the maximum value of a variable over a selected grid(s)</fn:func_desc>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Returns the maximum value of a variable over a selected grid(s)</rdfs:comment>
    <fn:hasArgument>
      <fn:Argument rdf:ID="maxover_a3">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >true</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >minfrac</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Minimum fraction of data that must be present (i.e., fraction not indicated as missing) within the selected domain in order for the maximum value to  be found.  If  &lt;i&gt;minfrac&lt;/i&gt; is not present, then a missing value is returned. If &lt;i&gt;minfrac&lt;/i&gt; is not given, then the maximum value is found regardless of the amount of data present in domain.</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#maxover"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="maxover_a4">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >maxvar/num</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >maximum value of &lt;i&gt;var&lt;/i&gt; within selected domain of &lt;i&gt;grid&lt;/i&gt;
&lt;p&gt;
&lt;i&gt;maxvar/num&lt;/i&gt; is no longer dependendent on &lt;i&gt;grid&lt;/i&gt;, but is still dependent on any other grids that &lt;i&gt;var&lt;/i&gt; depended on (if any)</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#maxover"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="maxover_a1">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#maxover"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable of which maximum value is found</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="maxover_a2">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#maxover"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid(s) over which maximum value is found</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .NOAA .NCEP .CPC .CAMS .station .temperature .temp
&lt;br&gt;IWMO (1001) VALUES
&lt;br&gt;[T]0.9 maxover
&lt;p&gt;
OR
&lt;p&gt;
SOURCES .NOAA .NCEP .CPC .GMSM .w
&lt;br&gt;X 112 153 RANGE
&lt;br&gt;Y -44 -11 RANGE
&lt;br&gt;[X Y]maxover</fn:syntax_ex>
  </fn:Function>
  <fn:Function rdf:ID="readthredds">
    <rdfs:label xml:lang="en">readthredds</rdfs:label>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >readthredds</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="readthredds1">
        <fn:arg_name xml:lang="en">url</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#readthredds"/>
        <rdfs:label xml:lang="en">readthredds1</rdfs:label>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#string"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="readthredds2">
        <fn:isArgumentOf rdf:resource="#readthredds"/>
        <fn:arg_name xml:lang="en">object</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Normally a dataset containing other net references</fn:arg_desc>
        <rdfs:label xml:lang="en">readthredds2</rdfs:label>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment xml:lang="en">Reads a dataset from a THREDDS server</rdfs:comment>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Reads a dataset from THREDDS server</fn:func_desc>
  </fn:Function>
  <fn:Function rdf:ID="renameGRID">
    <fn:hasArgument>
      <fn:Argument rdf:ID="renameGRID_a3">
        <fn:isArgumentOf rdf:resource="#renameGRID"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >NewName</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#string"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >new name of &lt;i&gt;grid&lt;/i&gt;</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .NASA .GSFC .TOMS .NIMBUS7 .monthly 
&lt;br&gt;T (Time) renameGRID</fn:syntax_ex>
    <fn:hasArgument>
      <fn:Argument rdf:ID="renameGRID_a1">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ds/var</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >dataset or variable (i.e., data) dependent on grid to be renamed</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#renameGRID"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="renameGRID_a4">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:isArgumentOf rdf:resource="#renameGRID"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >&lt;i&gt;ds/var&lt;/i&gt; dependent on renamed grid</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ds_var2</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >renameGRID</fn:func_name>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Assigns new name to an existing grid (i.e., independent variable)</rdfs:comment>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Assigns new name to an existing grid (i.e., independent variable)</fn:func_desc>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_modification"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="renameGRID_a2">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:isArgumentOf rdf:resource="#renameGRID"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid to be renamed</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#independent_variable_modification"/>
  </fn:Function>
  <fn:Function rdf:ID="masklt">
    <fn:hasArgument>
      <fn:Argument rdf:ID="masklt_a1">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable on which mask is to be applied</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:isArgumentOf rdf:resource="#masklt"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Masks out data values less than a specified threshold</rdfs:comment>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .NOAA .NCDC .ERSST .version2 .SST
&lt;br&gt;28 masklt</fn:syntax_ex>
    <fn:hasArgument>
      <fn:Argument rdf:ID="masklt_a2">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >threshold value on which mask is based</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#masklt"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >maskval</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#comparing_data"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="masklt_a3">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >maskedvar</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#masklt"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >&lt;i&gt;var&lt;/i&gt; with data values less than &lt;i&gt;maskval&lt;/i&gt; replaced by missing value indicator</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy>
      <rdf:Description rdf:about="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#masks">
        <fn:describes>
          <fn:Function rdf:ID="flaggt">
            <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Flags data values greater than a specified threshold</rdfs:comment>
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >flaggt</fn:func_name>
            <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >&lt;br&gt;
    &lt;u&gt;&lt;b&gt;Description&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;&lt;b&gt;flaggt&lt;/b&gt; replaces values of the 
    input variable &amp;quot;&lt;i&gt;var&lt;/i&gt;&amp;quot; with a value of &amp;quot;1&amp;quot; if the input values 
    are greater than the user-specified threshold value &amp;quot;&lt;i&gt;flagval&lt;/i&gt;&amp;quot; 
    and replaces values of the input variable &amp;quot;var&amp;quot; with a value of &amp;quot;0&amp;quot; if the 
    input values are less than or equal to the user-specified threshold value &amp;quot;&lt;i&gt;flagval&lt;/i&gt;&amp;quot;.&lt;br&gt;&lt;br&gt;&lt;u&gt;&lt;b&gt;Example&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;In 
    the following example &lt;b&gt;flaggt&lt;/b&gt; is used to mark those months in which 
    stations in the ANEEL daily precipitation data set have no more than one 
    day of precipitation data missing per month. The &amp;quot;dataflag&amp;quot; command is 
    first applied to the daily precipitation data to flag with a &amp;quot;1&amp;quot; those 
    days with non-missing precipitation data, and to flag with a &amp;quot;0&amp;quot; those 
    days with missing data. &amp;quot;monthlyAverage&amp;quot; is applied to these daily flags 
    of &amp;quot;1&amp;quot;s and &amp;quot;0&amp;quot;s to calculate the fraction of days per month with 
    non-missing data, assigning one value per month. &amp;quot;0.96 &lt;b&gt;flaggt&lt;/b&gt;&amp;quot; 
    is applied to these monthly fractional values and replaces them with a 
    value of &amp;quot;1&amp;quot; if at least 96% of days in the month (which is at least all 
    but one day per month, no matter which month) have non-missing 
    precipitation values and a value of &amp;quot;0&amp;quot; if more than one day per month has 
    missing precipitation.&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES .ANEEL 
    .prcp_sta .prcp&lt;br&gt;dataflag&lt;br&gt;monthlyAverage&lt;br&gt;0.96 flaggt&lt;/font&gt;&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.ANEEL/.prcp_sta/.prcp/dataflag/monthlyAverage/0.96/flaggt/"&gt;Live 
    Example Link&lt;/a&gt;&lt;br&gt;</fn:syntax_ex>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#masks"/>
            <fn:hasArgument>
              <fn:Argument rdf:ID="flaggt_a1">
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:isArgumentOf rdf:resource="#flaggt"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var</fn:arg_name>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >variable on which flags are to be applied</fn:arg_desc>
              </fn:Argument>
            </fn:hasArgument>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#binary_data_flags"/>
            <fn:hasArgument>
              <fn:Argument rdf:ID="flaggt_a3">
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >3</fn:arg_order>
                <fn:isArgumentOf rdf:resource="#flaggt"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >binary version of &lt;i&gt;var&lt;/i&gt;, where values greater and less than &lt;i&gt;flagval&lt;/i&gt; are assigned values of 1 and 0, respectively</fn:arg_desc>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >flaggedvar</fn:arg_name>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#comparing_data"/>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Flags data values greater than a specified threshold</fn:func_desc>
            <fn:hasArgument>
              <fn:Argument rdf:ID="flaggt_a2">
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >flagval</fn:arg_name>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >threshold value used to apply flags</fn:arg_desc>
                <fn:isArgumentOf rdf:resource="#flaggt"/>
              </fn:Argument>
            </fn:hasArgument>
          </fn:Function>
        </fn:describes>
        <fn:describes>
          <fn:Function rdf:ID="flagge">
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#masks"/>
            <fn:hasArgument>
              <fn:Argument rdf:ID="flagge_a3">
                <fn:isArgumentOf rdf:resource="#flagge"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >3</fn:arg_order>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >flaggedvar</fn:arg_name>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >binary version of &lt;i&gt;var&lt;/i&gt;, where values greater than and equal to &lt;i&gt;flagval&lt;/i&gt; and less than &lt;i&gt;flagval&lt;/i&gt; are assigned values of 1 and 0, respectively</fn:arg_desc>
              </fn:Argument>
            </fn:hasArgument>
            <fn:hasArgument>
              <fn:Argument rdf:ID="flagge_a2">
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >flagval</fn:arg_name>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >threshold value used to apply flags</fn:arg_desc>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
                <fn:isArgumentOf rdf:resource="#flagge"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Flags data values greater than or equal to a specified threshold</fn:func_desc>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#binary_data_flags"/>
            <fn:hasArgument>
              <fn:Argument rdf:ID="flagge_a1">
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >variable on which flags are to be applied</fn:arg_desc>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var</fn:arg_name>
                <fn:isArgumentOf rdf:resource="#flagge"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#comparing_data"/>
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >flagge</fn:func_name>
            <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >&lt;br&gt;
    &lt;u&gt;&lt;b&gt;Description&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;&lt;b&gt;flagge&lt;/b&gt; replaces values of the 
    input variable &amp;quot;&lt;i&gt;var&lt;/i&gt;&amp;quot; with a value of &amp;quot;1&amp;quot; if the input values 
    are greater than or equal to the user-specified threshold value &amp;quot;&lt;i&gt;flagval&lt;/i&gt;&amp;quot; 
    and replaces values of the input variable &amp;quot;var&amp;quot; with a value of &amp;quot;0&amp;quot; if the 
    input values are less than the user-specified threshold value &amp;quot;&lt;i&gt;flagval&lt;/i&gt;&amp;quot;.&lt;br&gt;&lt;br&gt;&lt;u&gt;&lt;b&gt;Example&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;In 
    the following example flagge is used to identify and help count the number 
    of stations in the GHCN precipitation data set that received precipitation 
    greater than or equal to 500 millimeters in December 2006. &amp;quot;&lt;i&gt;500 
    flagge&lt;/i&gt;&amp;quot; replaces precipitation data values of at least 500 mm with a 
    value of &amp;quot;1&amp;quot; and replaces precipitation values below 500 mm with a value 
    of &amp;quot;0&amp;quot;. &amp;quot;&lt;i&gt;[IWMO] sum&lt;/i&gt;&amp;quot; sums the flagged data values 
    over the station grid &amp;quot;IWMO&amp;quot; to give a count of the number of stations 
    with at least 500 mm of precipitation.&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES 
    .NOAA .NCDC .GHCN .v2beta&lt;br&gt;prcp&lt;br&gt;T (Dec 2006) VALUE&lt;br&gt;500 flagge&lt;br&gt;[IWMO]sum&lt;/font&gt;&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCDC/.GHCN/.v2beta/prcp/T/%28Dec%202006%29VALUE/500/flagge%5BIWMO%5Dsum/"&gt;Live 
    Example Link&lt;/a&gt;</fn:syntax_ex>
            <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Flags data values greater than or equal to a specified threshold</rdfs:comment>
          </fn:Function>
        </fn:describes>
        <fn:describes>
          <fn:Function rdf:ID="flaglt">
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Flags data values less than a specified threshold</fn:func_desc>
            <fn:hasArgument>
              <fn:Argument rdf:ID="flaglt_a1">
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var</fn:arg_name>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
                <fn:isArgumentOf rdf:resource="#flaglt"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >variable on which flags are to  be applied</fn:arg_desc>
              </fn:Argument>
            </fn:hasArgument>
            <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Flags data values less than a specified threshold</rdfs:comment>
            <fn:hasArgument>
              <fn:Argument rdf:ID="flaglt_a2">
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >flagval</fn:arg_name>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >threshold value used to apply flags</fn:arg_desc>
                <fn:isArgumentOf rdf:resource="#flaglt"/>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#masks"/>
            <fn:hasArgument>
              <fn:Argument rdf:ID="flaglt_a3">
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >flaggedvar</fn:arg_name>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >binary version of &lt;i&gt;var&lt;/i&gt;, where values less and greater than &lt;i&gt;flagval&lt;/i&gt; are assigned values of 1 and 0, respectively</fn:arg_desc>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >3</fn:arg_order>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                <fn:isArgumentOf rdf:resource="#flaglt"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#comparing_data"/>
            <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >&lt;br&gt;
    &lt;u&gt;&lt;b&gt;Description&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;&lt;b&gt;flaglt&lt;/b&gt; replaces values of the 
    input variable &amp;quot;&lt;i&gt;var&lt;/i&gt;&amp;quot; with a value of &amp;quot;1&amp;quot; if the input values 
    are less than the user-specified threshold value &amp;quot;&lt;i&gt;flagval&lt;/i&gt;&amp;quot; and 
    replaces values of the input variable &amp;quot;var&amp;quot; with a value of &amp;quot;0&amp;quot; if the 
    input values are greater than or equal to the user-specified threshold 
    value &amp;quot;&lt;i&gt;flagval&lt;/i&gt;&amp;quot;.&lt;br&gt;&lt;br&gt;&lt;u&gt;&lt;b&gt;Example&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;In 
    the following example &amp;quot;12 &lt;b&gt;flaglt&lt;/b&gt;&amp;quot; is applied to monthly 
    climatological precipitation values from the UEA TS2.1 data set to denote 
    very dry locations that receive less than 12 mm of precipitation per 
    month, on average.&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES .UEA .CRU .TS2p1 
    .climatology .c7100 .prcp &lt;br&gt;12 flaglt&lt;/font&gt;&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.UEA/.CRU/.TS2p1/.climatology/.c7100/.prcp/12/flaglt/"&gt;Live 
    Example Link&lt;/a&gt;&lt;br&gt;</fn:syntax_ex>
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >flaglt</fn:func_name>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#binary_data_flags"/>
          </fn:Function>
        </fn:describes>
        <fn:describes>
          <fn:Function rdf:ID="flagle">
            <fn:hasArgument>
              <fn:Argument rdf:ID="flagle_a1">
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >variable on which flags are to be applied</fn:arg_desc>
                <fn:isArgumentOf rdf:resource="#flagle"/>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >1</fn:arg_order>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >var</fn:arg_name>
              </fn:Argument>
            </fn:hasArgument>
            <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Flags data values less than and equal to a specified threshold</rdfs:comment>
            <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >flagle</fn:func_name>
            <fn:hasArgument>
              <fn:Argument rdf:ID="flagle_a2">
                <fn:isArgumentOf rdf:resource="#flagle"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >flagval</fn:arg_name>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >2</fn:arg_order>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >threshold value used to apply flags</fn:arg_desc>
              </fn:Argument>
            </fn:hasArgument>
            <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >Flags data values less than and equal to a specified threshold</fn:func_desc>
            <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
            >&lt;br&gt;
    &lt;u&gt;&lt;b&gt;Description&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;&lt;b&gt;flagle&lt;/b&gt; replaces values of the 
    input variable &amp;quot;&lt;i&gt;var&lt;/i&gt;&amp;quot; with a value of &amp;quot;1&amp;quot; if the input values 
    are less than or equal to the user-specified threshold value &amp;quot;&lt;i&gt;flagval&lt;/i&gt;&amp;quot; 
    and replaces values of the input variable &amp;quot;var&amp;quot; with a value of &amp;quot;0&amp;quot; if the 
    input values are greater than the user-specified threshold value &amp;quot;&lt;i&gt;flagval&lt;/i&gt;&amp;quot;.&lt;br&gt;&lt;br&gt;&lt;u&gt;&lt;b&gt;Example&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;In 
    the following example, &amp;quot;28 flagle&amp;quot; replaces monthly sea surface 
    temperature values less than or equal to 28&amp;#176;C with a &amp;quot;1&amp;quot; and SST values 
    greater than 28&amp;#176;C with a &amp;quot;0&amp;quot;.&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES 
    .NOAA .NCDC .ERSST .version2 .SST&lt;br&gt;28 flagle&lt;/font&gt;&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCDC/.ERSST/.version2/.SST/28/flagle/"&gt;Live 
    Example Link&lt;/a&gt;&lt;br&gt;</fn:syntax_ex>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#binary_data_flags"/>
            <fn:hasArgument>
              <fn:Argument rdf:ID="flagle_a3">
                <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
                <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
                <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >flaggedvar</fn:arg_name>
                <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
                >binary version of &lt;i&gt;var&lt;/i&gt;, where values less than or equal to &lt;i&gt;flagval&lt;/i&gt; and greater than &lt;i&gt;flagval&lt;/i&gt; are assigned values of 1 and 0, respectively</fn:arg_desc>
                <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
                >false</fn:optional>
                <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
                >3</fn:arg_order>
                <fn:isArgumentOf rdf:resource="#flagle"/>
              </fn:Argument>
            </fn:hasArgument>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#masks"/>
            <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#comparing_data"/>
          </fn:Function>
        </fn:describes>
      </rdf:Description>
    </fn:isDescribedBy>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Masks out data values less than a specified threshold</fn:func_desc>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >masklt</fn:func_name>
  </fn:Function>
  <fn:Function rdf:ID="L4cycleendLoop">
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Ends a Lorenz 4-cycle scheme integration loop</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="L4cycleendLoop1">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:isArgumentOf rdf:resource="#L4cycleendLoop"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <rdfs:label xml:lang="en">L4cycle:endLoop1</rdfs:label>
        <fn:arg_name xml:lang="en">dh</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="L4cycleendLoop2">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:isArgumentOf rdf:resource="#L4cycleendLoop"/>
        <rdfs:label xml:lang="en">L4cycle:endLoop2</rdfs:label>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_name xml:lang="en">h</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >L4cycle:endLoop</fn:func_name>
    <rdfs:label xml:lang="en">L4cycle:endLoop</rdfs:label>
    <rdfs:comment xml:lang="en">ends a Lorenz 4-cycle scheme integration loop</rdfs:comment>
  </fn:Function>
  <fn:Function rdf:ID="ginverse">
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Computes the (transposed) generalized inverse with the ivar1 grids as the first dimentsion of the matrix and the ivar2 grids as the second dimension of the matrix</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="ginverse2">
        <fn:isArgumentOf rdf:resource="#ginverse"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >First dimension of the matrix</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ivar1</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="ginverse3">
        <fn:isArgumentOf rdf:resource="#ginverse"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Second dimension of the matrix</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ivar2</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="ginverse4">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >inverse</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Generalized inverse</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#ginverse"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="ginverse1">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable from which inverse will be computed</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#ginverse"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >ginverse</fn:func_name>
  </fn:Function>
  <fn:Function rdf:ID="Fouriertransform">
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Fourier_transform</fn:func_name>
    <rdfs:comment xml:lang="en">computes fouriertransform</rdfs:comment>
    <rdfs:label xml:lang="en">Fourier Transform</rdfs:label>
    <fn:hasArgument>
      <fn:Argument rdf:ID="Fouriertransform3">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >1 or -1</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <rdfs:label xml:lang="en">fourier transform3</rdfs:label>
        <fn:arg_name xml:lang="en">sign</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#Fouriertransform"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="Fouriertransform4">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var'</fn:arg_name>
        <rdfs:label xml:lang="en">fourier transform4</rdfs:label>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_desc xml:lang="en">stream after fouier transform computed</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#Fouriertransform"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="Fouriertransform1">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to be transformed</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <rdfs:label xml:lang="en">fourier transform1</rdfs:label>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#Fouriertransform"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="Fouriertransform2">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Domain to be transformed to frequency or wavelength</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ivar</fn:arg_name>
        <rdfs:label xml:lang="en">fourier transform2</rdfs:label>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#Fouriertransform"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Computes fouriertransform</fn:func_desc>
  </fn:Function>
  <fn:Function rdf:ID="normalizeddistrib1D">
    <fn:hasArgument>
      <fn:Argument rdf:ID="normalizeddistrib1D_a7">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >7</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >normalized frequency distribution of &lt;i&gt;var&lt;/i&gt; within range and intervals specified by &lt;i&gt;lower&lt;/i&gt;, &lt;i&gt;upper&lt;/i&gt;, and &lt;i&gt;step&lt;/i&gt;</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#normalizeddistrib1D"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >dist</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="normalizeddistrib1D_a4">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >upper</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >upper bound of range over which distribution is to be found</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#normalizeddistrib1D"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="normalizeddistrib1D_a2">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        ></fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#delimiter"/>
        <fn:isArgumentOf rdf:resource="#normalizeddistrib1D"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >DATA</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Returns the normalized frequency distribution of a set of data for a specified range and step interval.</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="normalizeddistrib1D_a3">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#normalizeddistrib1D"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >lower</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >lower bound of range over which distribution is to be found</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Returns the normalized frequency distribution of a set of data for a specified range and step interval.</rdfs:comment>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#statistical_functions"/>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >normalizeddistrib1D</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="normalizeddistrib1D_a5">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >width of intervals (in units of var) used to find distribution</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >5</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >step</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#normalizeddistrib1D"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .NOAA .NCEP .CPC .GMSM .w 
&lt;br&gt;Y (20) VALUE 
&lt;br&gt;X (50) VALUE 
&lt;br&gt;T (Jul 1948-2003) VALUES 
&lt;br&gt;DATA 0 50 2 RANGESTEP 
&lt;br&gt;normalizeddistrib1D</fn:syntax_ex>
    <fn:hasArgument>
      <fn:Argument rdf:ID="normalizeddistrib1D_a1">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable (i.e., data) of which distribution is to be found</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#normalizeddistrib1D"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="normalizeddistrib1D_a6">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        ></fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >6</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#normalizeddistrib1D"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >RANGESTEP</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#delimiter"/>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="gaussianinv">
    <fn:hasArgument>
      <fn:Argument rdf:ID="gaussianinv2">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable converted to random data uniformly distributed onto gaussian data</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#gaussianinv"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var'</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="gaussianinv1">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#gaussianinv"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to be converted</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >gaussianinv</fn:func_name>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Converts random data uniformly distributed on to gaussian data</fn:func_desc>
  </fn:Function>
  <fn:Function rdf:ID="sqrt">
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#arithmetic_functions"/>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#square_root"/>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >sqrt</fn:func_name>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Calculates the square root of a number or variable</fn:func_desc>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Calculates the square root of a number or variable</rdfs:comment>
    <fn:hasArgument>
      <fn:Argument rdf:ID="sqrt_a2">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Result</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#sqrt"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >square root of &lt;i&gt;var/num&lt;/i&gt;. &lt;p&gt;
Result will be of the same type as &lt;i&gt;var/num&lt;/i&gt; (i.e., either a variable or constant).</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="sqrt_a1">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#sqrt"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable or constant of which the square root is to be taken</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var/num</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .UEA .CRU .New .CRU05 .monthly .prcp &lt;br&gt;
sqrt</fn:syntax_ex>
  </fn:Function>
  <fn:Function rdf:ID="dekadalAverage">
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >converts daily data to dekadal by averaging</fn:func_desc>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >&lt;p style="margin-top: 0"&gt;
      &lt;br&gt;
      &lt;u&gt;&lt;b&gt;Description&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;A dekad is a unit of time with a 
      peculiar definition. There are three dekads in a calendar month. The 
      first ten days of a month constitute the first dekad of the month. The 
      second ten days constitute the second dekad of the month, and the 
      remaining days (8 to 11 days, depending upon the month) constitute the 
      third dekad.&lt;br&gt;&lt;br&gt;&lt;b&gt;dekadalAverage&lt;/b&gt; calculates dekadal average 
      values from an input variable containing daily data.&lt;br&gt;&lt;br&gt;&lt;u&gt;&lt;b&gt;Example&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES 
      .NOAA .NCEP .CPC .FEWS .SAsia .RFEv2 .DAILY .est_prcp&lt;br&gt;T (1 Jan 2007) 
      (30 Apr 2007) RANGE&lt;br&gt;dekadalAverage&lt;/font&gt;&lt;br&gt;&lt;br&gt;This example selects 
      daily precipitation estimates from the CPC/FEWS South Asia RFE product 
      for the period 1 January to 30 April 2007 and calculates the dekadal 
      averages of the daily values such that there are average precipitation 
      values for 1-10 January, 11-20 January, 21-31 January, 1-10 February 
      2007, etc. The underlying time grid remains a daily grid, but the 
      average values are assigned to the dekadal intervals.&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCEP/.CPC/.FEWS/.SAsia/.RFEv2/.DAILY/.est_prcp/T/%281%20Jan%202007%29%2830%20Apr%202007%29RANGE/dekadalAverage/"&gt;Live 
      Example Link&lt;/a&gt;&lt;br&gt;
    &lt;/p&gt;</fn:syntax_ex>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >dekadalAverage</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="dekadalAverage_a1">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >daily data to be averaged, with units of units</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#dekadalAverage"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >dailyvar</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="dekadalAverage_a2">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Minimum fraction of data that must be present (i.e., fraction not indicated as missing) within each dekad in order for each average to be calculated. If minfrac is not present, then a missing value is returned. If minfrac is not given, then the average is calculated regardless of the amount of data present.</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >minfrac</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#dekadalAverage"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >true</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="dekadalAverage_a3">
        <fn:isArgumentOf rdf:resource="#dekadalAverage"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >data averaged by dekad</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >dekadalvar</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#average"/>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >converts daily data to dekadal by averaging</rdfs:comment>
  </fn:Function>
  <fn:Function rdf:ID="masknotrange">
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Masks out all values of a variable not included in the indicated range.  Commonly used to select stations within a particular lat/lon range (see Live Example).</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="masknotrange_a3">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >range_max</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >upper threshold of range</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#masknotrange"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="masknotrange_a1">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable on which mask will be applied</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#masknotrange"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="masknotrange_a4">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >restricted_var</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >&lt;i&gt;variable&lt;/i&gt; with all values outside of range specified by &lt;i&gt;range_min&lt;/i&gt; and &lt;i&gt;range_max&lt;/i&gt; masked out</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:isArgumentOf rdf:resource="#masknotrange"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >masknotrange</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="masknotrange_a2">
        <fn:isArgumentOf rdf:resource="#masknotrange"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >range_min</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >lower threshold of range</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Masks out all values of a variable not included in the indicated range.  Commonly used to select stations within a particular lat/lon range (see Live Example).</rdfs:comment>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >&lt;u&gt;&lt;b&gt;Description&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;font color="#008000"&gt;&lt;b&gt;masknotrange&lt;/b&gt;&lt;/font&gt;&lt;font color="#000000"&gt; 
    masks out all values of a variable not included in the indicated range. 
    Commonly used to select stations within a particular lat/lon range.&lt;/font&gt;&lt;font color="#008000"&gt;&lt;br&gt;&lt;/font&gt;&lt;u&gt;&lt;b&gt;Example&lt;/b&gt;&lt;/u&gt;&lt;br&gt;&lt;font color="#008000"&gt;lat 
    -20 20 masknotrange&lt;/font&gt;&lt;br&gt;&lt;font color="#800000"&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCDC/.GDCN/lon/290/340/masknotrange/SELECT/lat/-10/10/masknotrange/SELECT/"&gt;Live 
    Example Link&lt;/a&gt;&lt;/font&gt;</fn:syntax_ex>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#masks"/>
  </fn:Function>
  <fn:Function rdf:ID="replaceGRID">
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .NOAA .NCEP-NCAR .CDAS-1 .MONTHLY .Intrinsic .PressureLevel
&lt;br&gt;P
&lt;br&gt;grid:
&lt;br&gt;/name (Pressure) def
&lt;br&gt;/units (hPa) def
&lt;br&gt;values: 1000 925 850 700 600 500 400 300 250 200 150 100 70 50 30 20 10 :values
&lt;br&gt;:grid
&lt;br&gt;replaceGRID</fn:syntax_ex>
    <fn:hasArgument>
      <fn:Argument rdf:ID="replaceGRID_a2">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid1</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid (i.e., independent variable) to be replaced</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#replaceGRID"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >replaceGRID</fn:func_name>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_modification"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="replaceGRID_a1">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >data</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >dataset or variable dependent on grid to be replaced</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
        <fn:isArgumentOf rdf:resource="#replaceGRID"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="replaceGRID_a4">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >&lt;i&gt;data&lt;/i&gt; with &lt;i&gt;grid2&lt;/i&gt; in place of &lt;i&gt;grid1&lt;/i&gt;
&lt;p&gt;
Note that no changes are made to the data itself.</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >data_new</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#replaceGRID"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#independent_variable_modification"/>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Replaces a grid (i.e., independent variable)</rdfs:comment>
    <fn:hasArgument>
      <fn:Argument rdf:ID="replaceGRID_a3">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid2</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid (i.e., independent variable) to replace &lt;i&gt;grid1&lt;/i&gt;.  Can be an existing or newly-defined grid.</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#replaceGRID"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Replaces a grid (i.e., independent variable)</fn:func_desc>
  </fn:Function>
  <fn:Function rdf:ID="rotatedata">
    <fn:hasArgument>
      <fn:Argument rdf:ID="rotatedata3">
        <rdfs:label xml:lang="en">rotatedata3</rdfs:label>
        <fn:isArgumentOf rdf:resource="#rotatedata"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name xml:lang="en">Y</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="rotatedata9">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >9</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#rotatedata"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Rotated variable</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <rdfs:label xml:lang="en">rotatedata9</rdfs:label>
        <fn:arg_name xml:lang="en">D'</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="rotatedata7">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >7</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <rdfs:label xml:lang="en">rotatedata7</rdfs:label>
        <fn:isArgumentOf rdf:resource="#rotatedata"/>
        <fn:arg_name xml:lang="en">ox</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="rotatedata6">
        <rdfs:label xml:lang="en">rotatedata6</rdfs:label>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >6</fn:arg_order>
        <fn:arg_name xml:lang="en">alpha</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#rotatedata"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >rotatedata</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="rotatedata4">
        <fn:isArgumentOf rdf:resource="#rotatedata"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <rdfs:label xml:lang="en">rotatedata4</rdfs:label>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:arg_name xml:lang="en">X'</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:label xml:lang="en">rotatedata</rdfs:label>
    <fn:hasArgument>
      <fn:Argument rdf:ID="rotatedata5">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >5</fn:arg_order>
        <rdfs:label xml:lang="en">rotatedata5</rdfs:label>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#rotatedata"/>
        <fn:arg_name xml:lang="en">Y'</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Rotates a variable onto a new grid (X'Y')</fn:func_desc>
    <rdfs:comment xml:lang="en">rotates a variable onto a new grid (X'Y')</rdfs:comment>
    <fn:hasArgument>
      <fn:Argument rdf:ID="rotatedata1">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to be rotated</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#rotatedata"/>
        <rdfs:label xml:lang="en">rotatedata1</rdfs:label>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name xml:lang="en">D</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="rotatedata8">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >8</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <rdfs:label xml:lang="en">rotatedata8</rdfs:label>
        <fn:isArgumentOf rdf:resource="#rotatedata"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name xml:lang="en">oy</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="rotatedata2">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:isArgumentOf rdf:resource="#rotatedata"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <rdfs:label xml:lang="en">rotatedata2</rdfs:label>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_name xml:lang="en">X</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="invertontogrid">
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#independent_variable_creation"/>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Inverts onto surfaces</rdfs:comment>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >invertontogrid</fn:func_name>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Inverts onto surfaces</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="invertontogrid_a2">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >independent variable that is going to be replaced by S</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Z</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#invertontogrid"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="invertontogrid_a1">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >S(Z)</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >input surface information (needs to be monotonic in the independent variable &lt;i&gt;Z&lt;/i&gt; so that it can be used as a coordinate)</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#invertontogrid"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="invertontogrid_a3">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >value(s) of the new &lt;i&gt;S&lt;/i&gt; grid</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >S</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#invertontogrid"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#numbers"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="invertontogrid_a4">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Z(S)</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:isArgumentOf rdf:resource="#invertontogrid"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >output data: &lt;i&gt;Z&lt;/i&gt; values for surfaces of constant &lt;i&gt;S&lt;/i&gt;</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="normalize">
    <rdfs:label xml:lang="en">normalize</rdfs:label>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >normalize</fn:func_name>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Divides var1 by var2. Points less than minimum in var2 become NaN in the 
    output</fn:func_desc>
    <rdfs:comment xml:lang="en">divides var1 by var2. Points less than minimum in var2 become NaN 
    in the output</rdfs:comment>
    <fn:hasArgument>
      <fn:Argument rdf:ID="normalize1">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#normalize"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var1</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <rdfs:label xml:lang="en">normalize1</rdfs:label>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to be divided by var2</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="normalize2">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#normalize"/>
        <rdfs:label xml:lang="en">normalize2</rdfs:label>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var2</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable dividing var1</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="normalize3">
        <rdfs:label xml:lang="en">normalize3</rdfs:label>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Minimum value allowed before being replaced with NaN</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:isArgumentOf rdf:resource="#normalize"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name xml:lang="en">minimum</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="normalize4">
        <fn:isArgumentOf rdf:resource="#normalize"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Var1 divided by var2

Points less than minimum in var2 replaced with NaN</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var'</fn:arg_name>
        <rdfs:label xml:lang="en">normalize4</rdfs:label>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="correlate">
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#pearson_product-moment_correlation"/>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >&lt;br&gt;
    &lt;b&gt;&lt;u&gt;Description&lt;/u&gt;&lt;/b&gt;&lt;br&gt;&lt;br&gt;&lt;b&gt;correlate&lt;/b&gt; calculates the Pearson 
    product moment correlation for the two latest items on the stack over the 
    indicated grid. For the correlation to be computed, the gridding of the 
    two items on the stack must match.&lt;br&gt;&lt;br&gt;&lt;b&gt;&lt;u&gt;Example&lt;/u&gt;&lt;/b&gt;&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES 
    .NOAA .NCEP .CPC .GMSM .w&lt;br&gt;T (Jan 1969) (Dec 1998) RANGE&lt;br&gt;X (-8) (20) 
    RANGE&lt;br&gt;Y (8) (20) RANGE&lt;br&gt;SOURCES .DEKLIM .VASClimO .PrcpClim 
    .Resolution-0p5x0p5 .prcp&lt;br&gt;T (Jan 1969) (Dec 1998) RANGE&lt;br&gt;X (-8) (20) 
    RANGE&lt;br&gt;Y (8) (20) RANGE&lt;br&gt;[T]correlate&lt;/font&gt;&lt;br&gt;&lt;br&gt;In this example, 
    GMSM monthly soil moisture values are correlated over the time grid with 
    monthly precipitation values from the VASClim0 data set for a region of 
    West Africa over the period January 1969 to December 1998. The gridding of 
    the two data sets matches in both space (0.5 deg. lat/lon resolution) and 
    time. The result is a single map of correlation coefficients over the 
    defined region of West Africa.&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCEP/.CPC/.GMSM/.w/T/%28Jan%201969%29%28Dec%201998%29RANGE/X/%28-8%29%2820%29RANGE/Y/%288%29%2820%29RANGE/SOURCES/.DEKLIM/.VASClimO/.PrcpClim/.Resolution-0p5x0p5/.prcp/T/%28Jan%201969%29%28Dec%201998%29RANGE/X/%28-8%29%2820%29RANGE/Y/%288%29%2820%29RANGE%5BT%5Dcorrelate/"&gt;Live 
    Example Link&lt;/a&gt;&lt;br&gt;

    &lt;p&gt;
      OR
    &lt;/p&gt;
    &lt;p&gt;
      &lt;font color="#008000"&gt;SOURCES .NOAA .NCEP .CPC .CAMS_OPI .v0208 .anomaly 
      .prcp&lt;br&gt;T (Jan 1980) (Dec 2003) RANGE&lt;br&gt;X (-150) (-80) RANGE&lt;br&gt;Y 
      (-10) (10) RANGE&lt;br&gt;SOURCES .NOAA .NCEP .EMC .CMB .GLOBAL 
      .Reyn_SmithOIv2 .monthly .sst&lt;br&gt;T (Jan 1980) (Dec 2003) RANGE&lt;br&gt;X 
      (-150) (-80) RANGE&lt;br&gt;Y (-10) (10) RANGE&lt;br&gt;[X Y]regridAverage&lt;br&gt;[X 
      Y]correlate&lt;/font&gt;&lt;br&gt;&lt;br&gt;In this example, CAMS_OPI monthly 
      precipitation data are correlated in space with Reynolds and Smith OI 
      Version 2 monthly sea surface temperatures over the equatorial Pacific 
      Ocean. The result is a monthly time series of values from January 1980 
      to December 2003. The [X Y]regridAverage command was used to spatially 
      regrid the SST data set (at 1.0 deg. lat/lon resolution) to match the 
      gridding of the precipitation data set (at 2.5 deg. lat/lon resolution) 
      before taking the correlation.&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCEP/.CPC/.CAMS_OPI/.v0208/.anomaly/.prcp/T/%28Jan%201980%29%28Dec%202003%29RANGE/X/%28-150%29%28-80%29RANGE/Y/%28-10%29%2810%29RANGE/SOURCES/.NOAA/.NCEP/.EMC/.CMB/.GLOBAL/.Reyn_SmithOIv2/.monthly/.sst/T/%28Jan%201980%29%28Dec%202003%29RANGE/X/%28-150%29%28-80%29RANGE/Y/%28-10%29%2810%29RANGE%5BX/Y%5DregridAverage%5BX/Y%5Dcorrelate/"&gt;Live 
      Example Link&lt;/a&gt;&lt;br&gt;&lt;br&gt;&lt;br&gt;
    &lt;/p&gt;</fn:syntax_ex>
    <fn:hasArgument>
      <fn:Argument rdf:ID="correlate_a1">
        <fn:isArgumentOf rdf:resource="#correlate"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable to be correlated with &lt;i&gt;var2&lt;/i&gt;</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var1</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >correlate</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="correlate_a5">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >coefficient</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Pearson-Product Moment Correlation coefficient of &lt;i&gt;var1&lt;/i&gt; and &lt;i&gt;var2&lt;/i&gt; over &lt;i&gt;grids&lt;/i&gt;.
&lt;p&gt;
&lt;i&gt;coefficient&lt;/i&gt; is not dependent on &lt;i&gt;grids&lt;/i&gt;, but is dependent on any other grids that &lt;i&gt;var1&lt;/i&gt; or &lt;i&gt;var2&lt;/i&gt; depended on (if any).</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >5</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#correlate"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Calculates the Pearson Product-Moment Correlation coefficient of two variables over specified grids (i.e., independent variables)</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="correlate_a2">
        <fn:isArgumentOf rdf:resource="#correlate"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var2</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable to be correlated with &lt;i&gt;var1&lt;/i&gt;
&lt;p&gt;
Note that &lt;i&gt;var1&lt;/i&gt; and &lt;i&gt;var2&lt;/i&gt; should have similarly-defined &lt;i&gt;grids&lt;/i&gt;. Regridding one variable to match the other may be necessary (see example below).</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="correlate_a3">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid(s) (i.e., independent variables) over which correlation coefficient is to be calculated</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grids</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#correlate"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#statistical_functions"/>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Calculates the Pearson Product-Moment Correlation coefficient of two variables over specified grids (i.e., independent variables)</rdfs:comment>
    <fn:hasArgument>
      <fn:Argument rdf:ID="correlate_a4">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >minfrac</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Minimum fraction of data that must be present (i.e., fraction not indicated as missing) within the selected domain in order for the correlation to be calculated. If minfrac is not present, then a missing value is returned. If minfrac is not given, then the correlation is calculated regardless of the amount of data present in the domain.</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >true</fn:optional>
        <fn:isArgumentOf rdf:resource="#correlate"/>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="samplealong">
    <fn:isDescribedBy>
      <fn:Keyword rdf:ID="sample_by_variable">
        <fn:describes rdf:resource="#samplealong"/>
        <rdfs:label rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Sample by Variable</rdfs:label>
      </fn:Keyword>
    </fn:isDescribedBy>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Samples variable1 along grid using variable2=grid</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="samplealong2">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <rdfs:label xml:lang="en">samplealong2</rdfs:label>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var2</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#samplealong"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to be used</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment xml:lang="en">samples variable1 along grid using variable2=grid</rdfs:comment>
    <fn:hasArgument>
      <fn:Argument rdf:ID="samplealong1">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <rdfs:label xml:lang="en">sample-along1</rdfs:label>
        <fn:isArgumentOf rdf:resource="#samplealong"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var1</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to be sampled</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="samplealong4">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#samplealong"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable after being sampled along grid</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <rdfs:label xml:lang="en">sample-along4</rdfs:label>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var1'</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >sample-along</fn:func_name>
    <rdfs:label xml:lang="en">sample-along</rdfs:label>
    <fn:hasArgument>
      <fn:Argument rdf:ID="samplealong3">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <rdfs:label xml:lang="en">sample-along3</rdfs:label>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#samplealong"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Independent variable=variable2</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ivar</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="maskbybin">
    <fn:func_desc xml:lang="en">Bins data into bins from lo to high by step, returning a mask with an 
    additional grid (the bins) that is either NaN or 1</fn:func_desc>
    <rdfs:comment xml:lang="en">bins data into bins from lo to high by step, returning a mask with an 
    additional grid (the bins) that is either NaN or 1</rdfs:comment>
    <fn:hasArgument>
      <fn:Argument rdf:ID="maskbybin4">
        <rdfs:label xml:lang="en">maskbybin4</rdfs:label>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Mask with additional grid (the bins) that is either NaN or 1</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var'</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#maskbybin"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="maskbybin2">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >bin edges</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <rdfs:label xml:lang="en">maskbybin2</rdfs:label>
        <fn:isArgumentOf rdf:resource="#maskbybin"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#numbers"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="maskbybin1">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to be sorted</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#maskbybin"/>
        <rdfs:label xml:lang="en">maskbybin1</rdfs:label>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:label xml:lang="en">maskbybin</rdfs:label>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >maskbybin</fn:func_name>
  </fn:Function>
  <fn:Function rdf:ID="shiftGRID">
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_modification"/>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Shifts a grid (i.e., independent variable) by a specified number of grid points</fn:func_desc>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >shiftGRID</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="shiftGRID_a3">
        <fn:isArgumentOf rdf:resource="#shiftGRID"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >number of grid points the grid  is to be shifted. &lt;i&gt;num&lt;/i&gt;&gt;0  (&lt;i&gt;num&lt;/i&gt;&lt;0) shifts grid forwards (backwards)</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >num</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#independent_variable_modification"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="shiftGRID_a1">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >data dependent on the grid (i.e., independent variable) to be shifted</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ds/var</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#shiftGRID"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="shiftGRID_a4">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >same as &lt;i&gt;ds/var&lt;/i&gt; with &lt;i&gt;grid&lt;/i&gt; relabeled according to a shift of &lt;i&gt;num&lt;/i&gt; grid points</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ds/varshift</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#shiftGRID"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .IRI .FD .ECHAM4p5 .Forecast .psst .ensemble12 .MONTHLY .PressureLevel-SF .phi
&lt;br&gt;M -12 shiftGRID
&lt;p&gt;OR&lt;p&gt;
SOURCES .IRI .Analyses .SPI .SPI-CMAP0407v1_3-Month
&lt;br&gt;T
   /pointwidth 1 def
&lt;br&gt;pop
&lt;br&gt;T 1 shiftGRID</fn:syntax_ex>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Shifts a grid (i.e., independent variable) by a specified number of grid points</rdfs:comment>
    <fn:hasArgument>
      <fn:Argument rdf:ID="shiftGRID_a2">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid (i.e., independent variable) to be shifted</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:isArgumentOf rdf:resource="#shiftGRID"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="rankcorrelate">
    <fn:hasArgument>
      <fn:Argument rdf:ID="rankcorrelate_a2">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable to be rank correlated with &lt;i&gt;var1&lt;/i&gt;
&lt;p&gt;                                         Note that &lt;i&gt;var1&lt;/i&gt; and &lt;i&gt;var2&lt;/i&gt; should have similarly-defined &lt;i&gt;grids&lt;/i&gt;. Regridding one variable to match the other may be necessary (see example below).</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var2</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#rankcorrelate"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .NOAA .NCEP .CPC .GSOD .MONTHLY .DATA .mean .pan .evaportransporation
&lt;br&gt;SOURCES .NOAA .NCEP .CPC .GSOD .MONTHLY .DATA .maximum .temp
&lt;br&gt;IWMO (105130) VALUE
&lt;br&gt;[T]rankcorrelate
&lt;p&gt;
OR
&lt;p&gt;
SOURCES .NOAA .NCEP .CPC .CAMS_OPI .v0208 .anomaly .prcp
&lt;br&gt;T (Jan 1980) (Dec 2003) RANGE
&lt;br&gt;X (-150) (-80) RANGE
&lt;br&gt;Y (-10) (10) RANGE
&lt;br&gt;SOURCES .NOAA .NCEP .EMC .CMB .GLOBAL .Reyn_SmithOIv2 .monthly .sst
&lt;br&gt;T (Jan 1980) (Dec 2003) RANGE
&lt;br&gt;X (-150) (-80) RANGE
&lt;br&gt;Y (-10) (10) RANGE
&lt;br&gt;[X Y]regridAverage
&lt;br&gt;[X Y]rankcorrelate</fn:syntax_ex>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#spearman_rank_correlation"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="rankcorrelate_a1">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#rankcorrelate"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable to be rank correlated with &lt;i&gt;var2&lt;/i&gt;</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var1</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="rankcorrelate_a4">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >true</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >minfrac</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Minimum fraction of data that must be present (i.e., fraction not indicated as missing) within the selected domain in order for the rank correlation to be calculated. If minfrac is not present, then a missing value is returned. If minfrac is not given, then the rank correlation is calculated regardless of the amount of data present in the domain.</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#rankcorrelate"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="rankcorrelate_a3">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grids</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#rankcorrelate"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid(s) (i.e., independent variables) over which rank correlation coefficient is to be calculated</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Calculates the Spearman rank correlation coefficient of two variables over specified grids (i.e., independent variables)</fn:func_desc>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >rankcorrelate</fn:func_name>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#statistical_functions"/>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Calculates the Spearman rank correlation coefficient of two variables over specified grids (i.e., independent variables)</rdfs:comment>
    <fn:hasArgument>
      <fn:Argument rdf:ID="rankcorrelate_a5">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >coefficient</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Spearman rank correlation coefficient of &lt;i&gt;var1&lt;/i&gt; and &lt;i&gt;var2&lt;/i&gt; over &lt;i&gt;grids&lt;/i&gt;. 
&lt;p&gt;
&lt;i&gt;coefficient&lt;/i&gt; is not dependent on &lt;i&gt;grids&lt;/i&gt;, but is dependent on any other grids that &lt;i&gt;var1&lt;/i&gt; or &lt;i&gt;var2&lt;/i&gt; depended on (if any).</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >5</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
        <fn:isArgumentOf rdf:resource="#rankcorrelate"/>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="sort_by">
    <fn:hasArgument>
      <fn:Argument rdf:ID="sort_by_1">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#sort_by"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset_or_variable"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >dataset to be sorted</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >dataset</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="sort_by_3">
        <fn:isArgumentOf rdf:resource="#sort_by"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >independent variables to be replaced by rank</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="sort_by_2">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#sort_by"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        ></fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="sort_by_4">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#dataset"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >sorteddataset</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#sort_by"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >sorted dataset where &lt;i&gt;grid &lt;/i&gt;is replaced by&lt;i&gt; rank.  &lt;/i&gt;Rank value 1 
    corresponds to the maxium value of variable.</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >sort_by</fn:func_name>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >sorts dataset variables by replacing grid with rank, rank being calculated from variable.</fn:func_desc>
  </fn:Function>
  <fn:Function rdf:ID="RANGESPAN">
    <fn:hasArgument>
      <fn:Argument rdf:ID="RANGESPAN1">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable to be sampled along</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#RANGESPAN"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="RANGESPAN3">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >range_low</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#numberstring"/>
        <fn:isArgumentOf rdf:resource="#RANGESPAN"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Lower threshold of range (center of closest grid box)</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="RANGESPAN2">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#RANGESPAN"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >ivar</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Independent variable to be applied to variable</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="RANGESPAN5">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >5</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var'</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable sampled along one coordinate</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#RANGESPAN"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="RANGESPAN4">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >range_high</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Upper threshold of range (center of closest grid box)</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#numberstring"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#RANGESPAN"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >RANGESPAN</fn:func_name>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Samples variable along one coordinate.  Works by creating a child object of the variable</fn:func_desc>
  </fn:Function>
  <fn:Function rdf:ID="isolines">
    <fn:hasArgument>
      <fn:Argument rdf:ID="isolines2">
        <fn:arg_name xml:lang="en">X</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:isArgumentOf rdf:resource="#isolines"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <rdfs:label xml:lang="en">isolines2</rdfs:label>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="isolines3">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <rdfs:label xml:lang="en">isolines3</rdfs:label>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:arg_name xml:lang="en">Y</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#isolines"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="isolines1">
        <fn:isArgumentOf rdf:resource="#isolines"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable from which data will be computed from</fn:arg_desc>
        <rdfs:label xml:lang="en">isolines1</rdfs:label>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment xml:lang="en">computes isolines from a gridded dataset. Should be changed to output a 
    geometry.</rdfs:comment>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >isolines</fn:func_name>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Computes isolines from a gridded dataset. Should be changed to output a      geometry</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="isolines7">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <rdfs:label xml:lang="en">isolines7</rdfs:label>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >7</fn:arg_order>
        <fn:arg_name xml:lang="en">GRDS</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#isolines"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="isolines6">
        <rdfs:label xml:lang="en">isolines6</rdfs:label>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >6</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_name xml:lang="en">YS</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#isolines"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="isolines5">
        <fn:isArgumentOf rdf:resource="#isolines"/>
        <fn:arg_name xml:lang="en">XS</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <rdfs:label xml:lang="en">isolines5</rdfs:label>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >5</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:label xml:lang="en">isolines</rdfs:label>
    <fn:hasArgument>
      <fn:Argument rdf:ID="isolines4">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#numbers"/>
        <fn:isArgumentOf rdf:resource="#isolines"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name xml:lang="en">levels</fn:arg_name>
        <rdfs:label xml:lang="en">isolines4</rdfs:label>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="erfc">
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >&lt;p style="margin-top: 0"&gt;
      computes complementary error function from variable
    &lt;/p&gt;</fn:func_desc>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >erfc</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="erfc_a2">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        ></fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >C</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:isArgumentOf rdf:resource="#erfc"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="erfc_a1">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >A</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#erfc"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        ></fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    ></fn:syntax_ex>
  </fn:Function>
  <fn:Function rdf:ID="selectbyNaN">
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >selectbyNaN</fn:func_name>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Replaces missing_values in variable2 with variable1. Documentation carried 
    primarily from variable1, however, making it a bit different that a 
    reversed replaceNaN</fn:func_desc>
    <rdfs:comment xml:lang="en">replaces missing_values in variable2 with variable1. Documentation carried 
    primarily from variable1, however, making it a bit different that a reversed 
    replaceNaN.</rdfs:comment>
    <rdfs:label xml:lang="en">selectbyNaN</rdfs:label>
    <fn:hasArgument>
      <fn:Argument rdf:ID="selectbyNaN3">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var1'</fn:arg_name>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable with missing_values replaced</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <rdfs:label xml:lang="en">selectbyNaN3</rdfs:label>
        <fn:isArgumentOf rdf:resource="#selectbyNaN"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="selectbyNaN1">
        <rdfs:label xml:lang="en">selectbyNaN1</rdfs:label>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var1</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#selectbyNaN"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable from which missing values will be replaced</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="selectbyNaN2">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#selectbyNaN"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var2</fn:arg_name>
        <rdfs:label xml:lang="en">selectbyNaN2</rdfs:label>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Variable from which missing values will be replaced with</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="average">
    <fn:hasArgument>
      <fn:Argument rdf:ID="average_a4">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >true</fn:optional>
        <fn:isArgumentOf rdf:resource="#average"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >keepgrids</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#name"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >keeps independent variables averaged over in output as single values grids</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#average"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="average_a1">
        <fn:isArgumentOf rdf:resource="#average"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable to be averaged</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Calculates the average</rdfs:comment>
    <fn:hasArgument>
      <fn:Argument rdf:ID="average_a5">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >avgvar/num</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#average"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >5</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >&lt;i&gt;var&lt;/i&gt; averaged over &lt;i&gt;grid&lt;/i&gt;.  &lt;p&gt;&lt;i&gt;avgvar&lt;/i&gt; is no longer dependent on &lt;i&gt;grid&lt;/i&gt;, but is still dependent on any other grids that &lt;i&gt;var&lt;/i&gt; depended on (if any)</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Calculates the average</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="average_a3">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Minimum fraction of data that must be present (i.e., fraction not indicated as missing) within the selected domain in order for the average to be calculated. If minfrac is not present, then a missing value is returned. If minfrac is not given, then the average is calculated regardless of the amount of data present in domain.</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >true</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:isArgumentOf rdf:resource="#average"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >minfrac</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <rdfs:label rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >average</rdfs:label>
    <fn:hasArgument>
      <fn:Argument rdf:ID="average_a2">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid(s) over which the average is to be calculated</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:isArgumentOf rdf:resource="#average"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >average</fn:func_name>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >&lt;br&gt;
    &lt;b&gt;&lt;u&gt;Description&lt;/u&gt;&lt;/b&gt;&lt;br&gt;&lt;br&gt;&lt;b&gt;average&lt;/b&gt; calculates a simple 
    average, over the grid(s) included in the brackets, of the values in the 
    latest variable on the stack. The optional &lt;i&gt;minfrac&lt;/i&gt; argument is a 
    number between 0. and 1.0 that indicates what fraction of data must be 
    non-missing over the averaging grid in order for a non-missing result to 
    be produced. If &lt;i&gt;minfrac&lt;/i&gt; is not specified, its default value is 0., 
    and an average is produced using all available data over the averaging 
    grid.&lt;br&gt;&lt;br&gt;&lt;b&gt;&lt;u&gt;Example&lt;/u&gt;&lt;/b&gt;&lt;br&gt;&lt;br&gt;&lt;font color="#008000"&gt;SOURCES 
    .NOAA .NCDC .ERSST .version2 .SST&lt;br&gt;X (170W) (120W) RANGE&lt;br&gt;Y (5S) (5N) 
    RANGE&lt;br&gt;[X Y]average&lt;/font&gt;&lt;br&gt;&lt;br&gt;This example averages over both 
    longitude (X) and latitude (Y) to produce an average sea surface 
    temperature value (for each time step) over the equatorial Pacific Ocean.&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCDC/.ERSST/.version2/.SST/X/%28170W%29%28120W%29RANGE/Y/%285S%29%285N%29RANGE%5BX/Y%5Daverage/"&gt;Live 
    Example Link&lt;/a&gt;

    &lt;p&gt;
      OR
    &lt;/p&gt;
    &lt;p&gt;
      &lt;font color="#008000"&gt;SOURCES .NOAA .NCDC .GHCN .v2beta .prcp&lt;br&gt;IWMO 
      60354001 VALUE&lt;br&gt;T (Jan 1960) (Dec 1979) RANGE&lt;br&gt;[T]0.5 average&lt;/font&gt;&lt;br&gt;&lt;br&gt;This 
      example produces the average monthly precipitation value for Algiers, 
      Algeria, over the period January 1960 to December 1979, if at least half 
      the monthly precipitation values over that time period are not missing.&lt;br&gt;&lt;br&gt;&lt;a href="http://iridl.ldeo.columbia.edu/expert/SOURCES/.NOAA/.NCDC/.GHCN/.v2beta/.prcp/IWMO/60354001/VALUE/T/%28Jan%201960%29%28Dec%201979%29RANGE%5BT%5D0.5/average/"&gt;Live 
      Example Link&lt;/a&gt;
    &lt;/p&gt;</fn:syntax_ex>
  </fn:Function>
  <fn:Function rdf:ID="detrend-bfl">
    <fn:hasArgument>
      <fn:Argument rdf:ID="detrend-bfl-arg2">
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grid set describing domain to be detrended over</fn:arg_desc>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#detrend-bfl"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >grids</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#grid_set"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >detrends with a best-fit-line</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="detrend-bfl-arg3">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >minfrac</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >true</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Minimum fraction of data that must be present (i.e., fraction not 
    indicated as missing) within the selected domain in order for the data to 
    be used in the best-fit. If minfrac is not present, then a missing value 
    is returned. If minfrac is not given, then the bestfit is calculated 
    regardless of the amount of data present in the domain.</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:isArgumentOf rdf:resource="#detrend-bfl"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >&lt;p style="margin-top: 0"&gt;       While detrending data can be statistically important, it is important to remember that you could be removing the primary signal. For example, consider   &lt;/p&gt;     &lt;p style="margin-top: 0"&gt;    &lt;img src="http://iridl.ldeo.columbia.edu/SOURCES/.KEELING/.MAUNA_LOA/.co2/T+fig-+line+-fig//plotborder+72+psdef//plotaxislength+432+psdef+.gif"&gt;     &lt;/p&gt;     &lt;p style="margin-top: 0"&gt;            &lt;/p&gt;     &lt;p style="margin-top: 0"&gt;       where the point is that there is a long-term trend in the CO2 levels.        One can, however, easily detrend the line with &lt;/p&gt;     &lt;pre&gt;SOURCES .KEELING .MAUNA_LOA .co2  [T]detrend-bfl&lt;/pre&gt;     &lt;p style="margin-top: 0"&gt;       which would result in     &lt;/p&gt;     &lt;p style="margin-top: 0"&gt;            &lt;/p&gt;     &lt;p style="margin-top: 0"&gt;        &lt;img src="http://iridl.ldeo.columbia.edu/expert/SOURCES/.KEELING/.MAUNA_LOA/.co2%5BT%5Ddetrend-bfl/T+fig-+line+-fig//plotborder+72+psdef//plotaxislength+432+psdef+.gif"&gt;     &lt;/p&gt;     &lt;p style="margin-top: 0"&gt;            &lt;/p&gt;     &lt;p style="margin-top: 0"&gt;       Note that if we were dealing with a multi-dimensional datasets (such as        X Y T representing longitude, latitute, and time), then applying [T]        detrend-bfl results in a separate line being calculated at each spatial point.     &lt;/p&gt;</fn:syntax_ex>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >detrend-bfl</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="detrend-bfl-arg1">
        <fn:arg_desc xml:lang="en">variable to be detrended</fn:arg_desc>
        <fn:isArgumentOf rdf:resource="#detrend-bfl"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="detrend-bfl-arg4">
        <fn:isArgumentOf rdf:resource="#detrend-bfl"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_desc xml:lang="en">detrended version of the variable</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >detrended-var</fn:arg_name>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy>
      <fn:Keyword rdf:about="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#detrending">
        <fn:describes rdf:resource="#detrend-bfl"/>
        <rdfs:label rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >Detrending</rdfs:label>
      </fn:Keyword>
    </fn:isDescribedBy>
    <rdfs:label xml:lang="en">detrend-bfl</rdfs:label>
  </fn:Function>
  <fn:Function rdf:ID="ExplicitendLoop">
    <rdfs:comment xml:lang="en">ends an explicit integration loop</rdfs:comment>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Explicit:endLoop</fn:func_name>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Ends an explicit integration loop</fn:func_desc>
    <rdfs:label xml:lang="en">Explicit:endLoop</rdfs:label>
    <fn:hasArgument>
      <fn:Argument rdf:ID="ExplicitendLoop1">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#ExplicitendLoop"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_name xml:lang="en">dh</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <rdfs:label xml:lang="en">Explicit:endLoop1</rdfs:label>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="ExplicitendLoop2">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <rdfs:label xml:lang="en">Explicit:endLoop2</rdfs:label>
        <fn:isArgumentOf rdf:resource="#ExplicitendLoop"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_name xml:lang="en">h</fn:arg_name>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
  </fn:Function>
  <fn:Function rdf:ID="erfinv">
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >computes inverse error function from variable</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="erfinv_a1">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >A</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:isArgumentOf rdf:resource="#erfinv"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="erfinv_a2">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >C</fn:arg_name>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#erfinv"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >erfinv</fn:func_name>
  </fn:Function>
  <fn:Function rdf:ID="maskrange">
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Masks out all values of a variable included in the indicated range.</rdfs:comment>
    <fn:hasArgument>
      <fn:Argument rdf:ID="maskrange_a2">
        <fn:isArgumentOf rdf:resource="#maskrange"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >range_min</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >lower threshold of range</fn:arg_desc>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="maskrange_a4">
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >restricted_var</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >4</fn:arg_order>
        <fn:isArgumentOf rdf:resource="#maskrange"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >&lt;i&gt;variable&lt;/i&gt; with all values inside range specified by &lt;i&gt;range_min&lt;/i&gt; and &lt;i&gt;range_max&lt;/i&gt; masked out</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:hasArgument>
      <fn:Argument rdf:ID="maskrange_a3">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >upper threshold of range</fn:arg_desc>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >range_max</fn:arg_name>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#number"/>
        <fn:isArgumentOf rdf:resource="#maskrange"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#masks"/>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Masks out all values of a variable included in the indicated range.</fn:func_desc>
    <fn:hasArgument>
      <fn:Argument rdf:ID="maskrange_a1">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#maskrange"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable on which mask will be applied</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >maskrange</fn:func_name>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >lat
-20 20 maskrange</fn:syntax_ex>
  </fn:Function>
  <fn:Function rdf:ID="maskgt">
    <rdfs:comment rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Masks out data values greater than a specified threshold</rdfs:comment>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#masks"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="maskgt_a1">
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >1</fn:arg_order>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >var</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#maskgt"/>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >variable on which mask is to be applied</fn:arg_desc>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >maskgt</fn:func_name>
    <fn:hasArgument>
      <fn:Argument rdf:ID="maskgt_a3">
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >maskvar</fn:arg_name>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >3</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#out"/>
        <fn:isArgumentOf rdf:resource="#maskgt"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >&lt;i&gt;var&lt;/i&gt; with data values greater than &lt;i&gt;maskval&lt;/i&gt; replaced by missing value indicator</fn:arg_desc>
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable"/>
      </fn:Argument>
    </fn:hasArgument>
    <fn:func_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >Masks out data values greater than a specified threshold</fn:func_desc>
    <fn:isDescribedBy rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#comparing_data"/>
    <fn:hasArgument>
      <fn:Argument rdf:ID="maskgt_a2">
        <fn:argument_type rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#variable_or_constant"/>
        <fn:arg_name rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >maskval</fn:arg_name>
        <fn:isArgumentOf rdf:resource="#maskgt"/>
        <fn:arg_order rdf:datatype="http://www.w3.org/2001/XMLSchema#int"
        >2</fn:arg_order>
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:optional rdf:datatype="http://www.w3.org/2001/XMLSchema#boolean"
        >false</fn:optional>
        <fn:arg_desc rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
        >threshold value on which mask is based</fn:arg_desc>
      </fn:Argument>
    </fn:hasArgument>
    <fn:syntax_ex rdf:datatype="http://www.w3.org/2001/XMLSchema#string"
    >SOURCES .NOAA .NCEP .CPC .GMSM .w
&lt;br&gt;100 maskgt</fn:syntax_ex>
  </fn:Function>
  <fn:Function rdf:ID="standardize">
    <fn:hasArgument>
      <fn:Argument rdf:ID="standardize_a3">
        <fn:in_out rdf:resource="http://iridl.ldeo.columbia.edu/ontologies/functions.owl#in"/>
        <fn:isArgumentOf rdf:resource="#standardize"/>
        <fn:arg_desc rdf:datatype="http://www.w3.org