<!DOCTYPE HTML>
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (11.0.4) on Fri Sep 20 12:10:30 CEST 2019 -->
<title>Units (Apache SIS 1.0 API)</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="dc.created" content="2019-09-20">
<meta name="keywords" content="org.apache.sis.measure.Units class">
<meta name="keywords" content="NANOMETRE">
<meta name="keywords" content="MILLIMETRE">
<meta name="keywords" content="CENTIMETRE">
<meta name="keywords" content="METRE">
<meta name="keywords" content="KILOMETRE">
<meta name="keywords" content="NAUTICAL_MILE">
<meta name="keywords" content="STATUTE_MILE">
<meta name="keywords" content="US_SURVEY_FOOT">
<meta name="keywords" content="CLARKE_FOOT">
<meta name="keywords" content="FOOT">
<meta name="keywords" content="INCH">
<meta name="keywords" content="POINT">
<meta name="keywords" content="SQUARE_METRE">
<meta name="keywords" content="HECTARE">
<meta name="keywords" content="CUBIC_METRE">
<meta name="keywords" content="LITRE">
<meta name="keywords" content="STERADIAN">
<meta name="keywords" content="MICRORADIAN">
<meta name="keywords" content="RADIAN">
<meta name="keywords" content="DEGREE">
<meta name="keywords" content="ARC_MINUTE">
<meta name="keywords" content="ARC_SECOND">
<meta name="keywords" content="GRAD">
<meta name="keywords" content="MILLISECOND">
<meta name="keywords" content="SECOND">
<meta name="keywords" content="MINUTE">
<meta name="keywords" content="HOUR">
<meta name="keywords" content="DAY">
<meta name="keywords" content="WEEK">
<meta name="keywords" content="TROPICAL_YEAR">
<meta name="keywords" content="HERTZ">
<meta name="keywords" content="RADIANS_PER_SECOND">
<meta name="keywords" content="METRES_PER_SECOND">
<meta name="keywords" content="KILOMETRES_PER_HOUR">
<meta name="keywords" content="PASCAL">
<meta name="keywords" content="HECTOPASCAL">
<meta name="keywords" content="DECIBAR">
<meta name="keywords" content="BAR">
<meta name="keywords" content="ATMOSPHERE">
<meta name="keywords" content="NEWTON">
<meta name="keywords" content="JOULE">
<meta name="keywords" content="WATT">
<meta name="keywords" content="VOLT">
<meta name="keywords" content="AMPERE">
<meta name="keywords" content="COULOMB">
<meta name="keywords" content="FARAD">
<meta name="keywords" content="OHM">
<meta name="keywords" content="SIEMENS">
<meta name="keywords" content="WEBER">
<meta name="keywords" content="TESLA">
<meta name="keywords" content="HENRY">
<meta name="keywords" content="KELVIN">
<meta name="keywords" content="CELSIUS">
<meta name="keywords" content="FAHRENHEIT">
<meta name="keywords" content="CANDELA">
<meta name="keywords" content="LUMEN">
<meta name="keywords" content="LUX">
<meta name="keywords" content="GRAM">
<meta name="keywords" content="KILOGRAM">
<meta name="keywords" content="MOLE">
<meta name="keywords" content="UNITY">
<meta name="keywords" content="PERCENT">
<meta name="keywords" content="PPM">
<meta name="keywords" content="DECIBEL">
<meta name="keywords" content="PSU">
<meta name="keywords" content="PIXEL">
<meta name="keywords" content="isAngular()">
<meta name="keywords" content="isLinear()">
<meta name="keywords" content="isPressure()">
<meta name="keywords" content="isTemporal()">
<meta name="keywords" content="isScale()">
<meta name="keywords" content="ensureAngular()">
<meta name="keywords" content="ensureLinear()">
<meta name="keywords" content="ensureTemporal()">
<meta name="keywords" content="ensureScale()">
<meta name="keywords" content="multiply()">
<meta name="keywords" content="toStandardUnit()">
<meta name="keywords" content="converter()">
<meta name="keywords" content="coefficients()">
<meta name="keywords" content="derivative()">
<meta name="keywords" content="valueOf()">
<meta name="keywords" content="valueOfEPSG()">
<meta name="keywords" content="getEpsgCode()">
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../sis.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../jquery/jquery-ui.css" title="Style">
<script type="text/javascript" src="../../../../script.js"></script>
<script type="text/javascript" src="../../../../jquery/jszip/dist/jszip.min.js"></script>
<script type="text/javascript" src="../../../../jquery/jszip-utils/dist/jszip-utils.min.js"></script>
<!--[if IE]>
<script type="text/javascript" src="../../../../jquery/jszip-utils/dist/jszip-utils-ie.min.js"></script>
<![endif]-->
<script type="text/javascript" src="../../../../jquery/jquery-3.3.1.js"></script>
<script type="text/javascript" src="../../../../jquery/jquery-migrate-3.0.1.js"></script>
<script type="text/javascript" src="../../../../jquery/jquery-ui.js"></script>
</head>
<body>
<script type="text/javascript"><!--
    try {
        if (location.href.indexOf('is-external=true') == -1) {
            parent.document.title="Units (Apache SIS 1.0 API)";
        }
    }
    catch(err) {
    }
//-->
var data = {"i0":9,"i1":9,"i2":9,"i3":9,"i4":9,"i5":9,"i6":9,"i7":9,"i8":9,"i9":9,"i10":9,"i11":9,"i12":9,"i13":9,"i14":9,"i15":9,"i16":9};
var tabs = {65535:["t0","All Methods"],1:["t1","Static Methods"],8:["t4","Concrete Methods"]};
var altColor = "altColor";
var rowColor = "rowColor";
var tableTab = "tableTab";
var activeTableTab = "activeTableTab";
var pathtoroot = "../../../../";
var useModuleDirectories = false;
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<header role="banner">
<nav role="navigation">
<div class="fixedNav">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a id="navbar.top">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.top" title="Skip navigation links">Skip navigation links</a></div>
<a id="navbar.top.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/Units.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../index-all.html">Index</a></li>
<li><a href="../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../../allclasses.html">All&nbsp;Classes</a></li>
</ul>
<ul class="navListSearch">
<li><label for="search">SEARCH:</label>
<input type="text" id="search" value="search" disabled="disabled">
<input type="reset" id="reset" value="reset" disabled="disabled">
</li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_top");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li><a href="#field.detail">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a id="skip.navbar.top">
<!--   -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
</div>
<div class="navPadding">&nbsp;</div>
<script type="text/javascript"><!--
$('.navPadding').css('padding-top', $('.fixedNav').css("height"));
//-->
</script>
</nav>
</header>
<!-- ======== START OF CLASS DATA ======== -->
<main role="main">
<div class="header">
<div class="subTitle"><span class="packageLabelInType">Package</span>&nbsp;<a href="package-summary.html">org.apache.sis.measure</a></div>
<h2 title="Class Units" class="title">Class Units</h2>
</div>
<div class="contentContainer">
<ul class="inheritance">
<li><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a></li>
<li>
<ul class="inheritance">
<li><a href="../util/Static.html" title="class in org.apache.sis.util">Static</a></li>
<li>
<ul class="inheritance">
<li>Units</li>
</ul>
</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<hr>
<pre>public final class <span class="typeNameLabel">Units</span>
extends <a href="../util/Static.html" title="class in org.apache.sis.util">Static</a></pre>
<div class="block">Provides constants for various Units of Measurement together with static methods working on <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink"><code>Unit</code></a> instances.
 Unit names and definitions in this class follow the definitions provided in the EPSG geodetic dataset
 (when the unit exists in that dataset),
 except “year” which has been renamed “<a href="#TROPICAL_YEAR">tropical year</a>”.
 This class focuses on the most commonly used units in the geospatial domain:
 angular units (<a href="#DEGREE">degree</a>, <a href="#ARC_SECOND">arc-second</a>, …),
 linear units (<a href="#KILOMETRE">kilometre</a>, <a href="#NAUTICAL_MILE">nautical mile</a>, …) and
 temporal units (<a href="#DAY">day</a>, <a href="#TROPICAL_YEAR">year</a>, …),
 but some other kind of units are also provided for completeness.
 The main quantities are listed below, together with some related units:

 <table class="sis">
   <caption>Some quantities and related units</caption>
   <tr><th colspan="2">Quantity type</th><th>System unit</th><th>Some conventional units</th></tr>

   <tr><td style="padding-top:15px" colspan="4"><b>Fundamental:</b></td></tr>
   <tr><td><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink"><code>Length</code></a></td>            <td>(L)</td> <td><a href="#METRE"><code>METRE</code></a></td>    <td><a href="#CENTIMETRE"><code>CENTIMETRE</code></a>, <a href="#KILOMETRE"><code>KILOMETRE</code></a>, <a href="#NAUTICAL_MILE"><code>NAUTICAL_MILE</code></a>, <a href="#STATUTE_MILE"><code>STATUTE_MILE</code></a>, <a href="#FOOT"><code>FOOT</code></a></td></tr>
   <tr><td><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Mass.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink"><code>Mass</code></a></td>              <td>(M)</td> <td><a href="#KILOGRAM"><code>KILOGRAM</code></a></td> <td></td></tr>
   <tr><td><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Time.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink"><code>Time</code></a></td>              <td>(T)</td> <td><a href="#SECOND"><code>SECOND</code></a></td>   <td><a href="#MILLISECOND"><code>MILLISECOND</code></a>, <a href="#MINUTE"><code>MINUTE</code></a>, <a href="#HOUR"><code>HOUR</code></a>, <a href="#DAY"><code>DAY</code></a>, <a href="#WEEK"><code>WEEK</code></a>, <a href="#TROPICAL_YEAR"><code>TROPICAL_YEAR</code></a></td></tr>
   <tr><td><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/ElectricCurrent.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink"><code>ElectricCurrent</code></a></td>   <td>(I)</td> <td><a href="#AMPERE"><code>AMPERE</code></a></td>   <td></td></tr>
   <tr><td><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Temperature.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink"><code>Temperature</code></a></td>       <td>(Θ)</td> <td><a href="#KELVIN"><code>KELVIN</code></a></td>   <td><a href="#CELSIUS"><code>CELSIUS</code></a>, <a href="#FAHRENHEIT"><code>FAHRENHEIT</code></a></td></tr>
   <tr><td><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/AmountOfSubstance.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink"><code>AmountOfSubstance</code></a></td> <td>(N)</td> <td><a href="#MOLE"><code>MOLE</code></a></td>     <td></td></tr>
   <tr><td><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/LuminousIntensity.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink"><code>LuminousIntensity</code></a></td> <td>(J)</td> <td><a href="#CANDELA"><code>CANDELA</code></a></td>  <td></td></tr>

   <tr><td style="padding-top:15px" colspan="4"><b>Dimensionless:</b></td></tr>
   <tr><td><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Angle.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink"><code>Angle</code></a></td>      <td></td> <td><a href="#RADIAN"><code>RADIAN</code></a></td>    <td><a href="#DEGREE"><code>DEGREE</code></a>, <a href="#ARC_MINUTE"><code>ARC_MINUTE</code></a>, <a href="#ARC_SECOND"><code>ARC_SECOND</code></a>, <a href="#GRAD"><code>GRAD</code></a></td></tr>
   <tr><td><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/SolidAngle.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink"><code>SolidAngle</code></a></td> <td></td> <td><a href="#STERADIAN"><code>STERADIAN</code></a></td> <td></td></tr>

   <tr><td style="padding-top:15px" colspan="4"><b>Derived:</b></td></tr>
   <tr><td><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Area.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink"><code>Area</code></a></td>     <td>(A)</td> <td><a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a></td>      <td><a href="#HECTARE"><code>HECTARE</code></a></td></tr>
   <tr><td><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Volume.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink"><code>Volume</code></a></td>   <td>(V)</td> <td><a href="#CUBIC_METRE"><code>CUBIC_METRE</code></a></td>       <td></td></tr>
   <tr><td><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Speed.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink"><code>Speed</code></a></td>    <td>(ν)</td> <td><a href="#METRES_PER_SECOND"><code>METRES_PER_SECOND</code></a></td> <td><a href="#KILOMETRES_PER_HOUR"><code>KILOMETRES_PER_HOUR</code></a></td></tr>
   <tr><td><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Pressure.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink"><code>Pressure</code></a></td> <td></td>    <td><a href="#PASCAL"><code>PASCAL</code></a></td>            <td><a href="#HECTOPASCAL"><code>HECTOPASCAL</code></a>, <a href="#DECIBAR"><code>DECIBAR</code></a>, <a href="#BAR"><code>BAR</code></a>, <a href="#ATMOSPHERE"><code>ATMOSPHERE</code></a></td></tr>
 </table></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.3</dd>

<p><font size="-1">Defined in the <code>sis-utility</code> module</font></p>
</dl>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- =========== FIELD SUMMARY =========== -->
<section role="region">
<ul class="blockList">
<li class="blockList"><a id="field.summary">
<!--   -->
</a>
<h3>Field Summary</h3>
<table class="memberSummary">
<caption><span>Fields</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colSecond" scope="col">Field</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/ElectricCurrent.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">ElectricCurrent</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#AMPERE">AMPERE</a></span></code></th>
<td class="colLast">
<div class="block">The SI base unit for electric current (A).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Angle.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Angle</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#ARC_MINUTE">ARC_MINUTE</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 1/60 degree (1′).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Angle.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Angle</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#ARC_SECOND">ARC_SECOND</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 1/(60×60) degree (1″).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Pressure.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Pressure</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#ATMOSPHERE">ATMOSPHERE</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 101325 pascals (1 atm).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Pressure.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Pressure</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#BAR">BAR</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 100000 pascals (1 bar).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/LuminousIntensity.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">LuminousIntensity</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#CANDELA">CANDELA</a></span></code></th>
<td class="colLast">
<div class="block">The SI base unit for luminous intensity (cd).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Temperature.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Temperature</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#CELSIUS">CELSIUS</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as the temperature in Kelvin minus 273.15.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#CENTIMETRE">CENTIMETRE</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 0.01 metres (1 cm).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#CLARKE_FOOT">CLARKE_FOOT</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 0.3047972654 metres.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/ElectricCharge.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">ElectricCharge</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#COULOMB">COULOMB</a></span></code></th>
<td class="colLast">
<div class="block">The SI derived unit for electric charge (C).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Volume.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Volume</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#CUBIC_METRE">CUBIC_METRE</a></span></code></th>
<td class="colLast">
<div class="block">The SI derived unit for volume (m³).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Time.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Time</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#DAY">DAY</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 24×60×60 seconds (1 d).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Pressure.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Pressure</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#DECIBAR">DECIBAR</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 10000 pascals (1 dbar).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Dimensionless.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Dimensionless</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#DECIBEL">DECIBEL</a></span></code></th>
<td class="colLast">
<div class="block">Sub-division of logarithm of ratio of the measured quantity to a reference quantity (dB).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Angle.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Angle</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#DEGREE">DEGREE</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as π/180 radians (1°).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Temperature.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Temperature</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#FAHRENHEIT">FAHRENHEIT</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 1.8 degree Celsius plus 32.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/ElectricCapacitance.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">ElectricCapacitance</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#FARAD">FARAD</a></span></code></th>
<td class="colLast">
<div class="block">The SI derived unit for electric capacitance (F).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#FOOT">FOOT</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as exactly 0.3048 metres (1 ft).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Angle.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Angle</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#GRAD">GRAD</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as π/200 radians (1 grad).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Mass.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Mass</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#GRAM">GRAM</a></span></code></th>
<td class="colLast">
<div class="block">A SI conventional unit for mass (g).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Area.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Area</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#HECTARE">HECTARE</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 10,000 square metres (1 ha).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Pressure.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Pressure</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#HECTOPASCAL">HECTOPASCAL</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 100 pascals (1 hPa).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/ElectricInductance.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">ElectricInductance</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#HENRY">HENRY</a></span></code></th>
<td class="colLast">
<div class="block">The SI derived unit for inductance (H).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Frequency.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Frequency</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#HERTZ">HERTZ</a></span></code></th>
<td class="colLast">
<div class="block">The SI derived unit for frequency (Hz).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Time.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Time</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#HOUR">HOUR</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 60×60 seconds (1 h).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#INCH">INCH</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 2.54 centimetres (1 in).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Energy.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Energy</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#JOULE">JOULE</a></span></code></th>
<td class="colLast">
<div class="block">The SI derived unit for energy (J).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Temperature.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Temperature</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#KELVIN">KELVIN</a></span></code></th>
<td class="colLast">
<div class="block">The SI base unit for thermodynamic temperature (K).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Mass.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Mass</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#KILOGRAM">KILOGRAM</a></span></code></th>
<td class="colLast">
<div class="block">The SI base unit for mass (kg).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#KILOMETRE">KILOMETRE</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 1000 metres (1 km).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Speed.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Speed</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#KILOMETRES_PER_HOUR">KILOMETRES_PER_HOUR</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 1/3.6 metres per second (1 km/h).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Volume.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Volume</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#LITRE">LITRE</a></span></code></th>
<td class="colLast">
<div class="block">The unit for litre volume (L, l or ℓ).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/LuminousFlux.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">LuminousFlux</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#LUMEN">LUMEN</a></span></code></th>
<td class="colLast">
<div class="block">The SI derived unit for luminous flux (lm).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Illuminance.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Illuminance</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#LUX">LUX</a></span></code></th>
<td class="colLast">
<div class="block">The SI derived unit for illuminance (lx).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#METRE">METRE</a></span></code></th>
<td class="colLast">
<div class="block">The SI base unit for distances (m).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Speed.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Speed</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#METRES_PER_SECOND">METRES_PER_SECOND</a></span></code></th>
<td class="colLast">
<div class="block">The SI derived unit for speed (m/s).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Angle.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Angle</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#MICRORADIAN">MICRORADIAN</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 10<sup>-6</sup> radians (1 µrad).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#MILLIMETRE">MILLIMETRE</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 0.001 metres (1 mm).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Time.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Time</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#MILLISECOND">MILLISECOND</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 10<sup>-3</sup> seconds (1 ms).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Time.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Time</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#MINUTE">MINUTE</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 60 seconds (1 min).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/AmountOfSubstance.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">AmountOfSubstance</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#MOLE">MOLE</a></span></code></th>
<td class="colLast">
<div class="block">The SI base unit for amount of substance (mol).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#NANOMETRE">NANOMETRE</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 10<sup>-9</sup> metres (1 nm).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#NAUTICAL_MILE">NAUTICAL_MILE</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as exactly 1852 metres (1 M).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Force.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Force</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#NEWTON">NEWTON</a></span></code></th>
<td class="colLast">
<div class="block">The SI derived unit for force (N).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/ElectricResistance.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">ElectricResistance</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#OHM">OHM</a></span></code></th>
<td class="colLast">
<div class="block">The SI derived unit for electric resistance (Ω).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Pressure.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Pressure</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#PASCAL">PASCAL</a></span></code></th>
<td class="colLast">
<div class="block">The SI derived unit for pressure (Pa).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Dimensionless.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Dimensionless</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#PERCENT">PERCENT</a></span></code></th>
<td class="colLast">
<div class="block">Dimensionless unit for percentages (%).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Dimensionless.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Dimensionless</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#PIXEL">PIXEL</a></span></code></th>
<td class="colLast">
<div class="block">Dimensionless unit for pixels (px).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#POINT">POINT</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 0.013837 inch (1 pt).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Dimensionless.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Dimensionless</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#PPM">PPM</a></span></code></th>
<td class="colLast">
<div class="block">Dimensionless unit for parts per million (ppm).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="Salinity.html" title="interface in org.apache.sis.measure">Salinity</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#PSU">PSU</a></span></code></th>
<td class="colLast">
<div class="block">Salinity measured using PSS-78.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Angle.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Angle</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#RADIAN">RADIAN</a></span></code></th>
<td class="colLast">
<div class="block">The SI unit for plane angles (rad).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="AngularVelocity.html" title="interface in org.apache.sis.measure">AngularVelocity</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#RADIANS_PER_SECOND">RADIANS_PER_SECOND</a></span></code></th>
<td class="colLast">
<div class="block">The unit for angular velocity (rad/s).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Time.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Time</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#SECOND">SECOND</a></span></code></th>
<td class="colLast">
<div class="block">The SI base unit for durations (s).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/ElectricConductance.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">ElectricConductance</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#SIEMENS">SIEMENS</a></span></code></th>
<td class="colLast">
<div class="block">The SI derived unit for electric conductance (S).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Area.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Area</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#SQUARE_METRE">SQUARE_METRE</a></span></code></th>
<td class="colLast">
<div class="block">The SI derived unit for area (m²).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#STATUTE_MILE">STATUTE_MILE</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as exactly 1609.344 metres (1 mi).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/SolidAngle.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">SolidAngle</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#STERADIAN">STERADIAN</a></span></code></th>
<td class="colLast">
<div class="block">The SI unit for solid angles (sr).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/MagneticFluxDensity.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">MagneticFluxDensity</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#TESLA">TESLA</a></span></code></th>
<td class="colLast">
<div class="block">The SI derived unit for magnetic flux density (T).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Time.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Time</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#TROPICAL_YEAR">TROPICAL_YEAR</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement approximately equals to 365.24219 days (1 a).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Dimensionless.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Dimensionless</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#UNITY">UNITY</a></span></code></th>
<td class="colLast">
<div class="block">The base dimensionless unit for scale measurements.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#US_SURVEY_FOOT">US_SURVEY_FOOT</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement approximately equals to 0.3048006096… metres.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/ElectricPotential.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">ElectricPotential</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#VOLT">VOLT</a></span></code></th>
<td class="colLast">
<div class="block">The SI derived unit for electric potential difference (V).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Power.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Power</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#WATT">WATT</a></span></code></th>
<td class="colLast">
<div class="block">The SI derived unit for power (W).</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/MagneticFlux.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">MagneticFlux</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#WEBER">WEBER</a></span></code></th>
<td class="colLast">
<div class="block">The SI derived unit for magnetic flux (Wb).</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Time.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Time</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#WEEK">WEEK</a></span></code></th>
<td class="colLast">
<div class="block">Unit of measurement defined as 7 days (1 wk).</div>
</td>
</tr>
</table>
</li>
</ul>
</section>
<!-- ========== METHOD SUMMARY =========== -->
<section role="region">
<ul class="blockList">
<li class="blockList"><a id="method.summary">
<!--   -->
</a>
<h3>Method Summary</h3>
<table class="memberSummary">
<caption><span id="t0" class="activeTableTab"><span>All Methods</span><span class="tabEnd">&nbsp;</span></span><span id="t1" class="tableTab"><span><a href="javascript:show(1);">Static Methods</a></span><span class="tabEnd">&nbsp;</span></span><span id="t4" class="tableTab"><span><a href="javascript:show(8);">Concrete Methods</a></span><span class="tabEnd">&nbsp;</span></span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colSecond" scope="col">Method</th>
<th class="colLast" scope="col">Description</th>
</tr>
<tr id="i0" class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Number.html?is-external=true" title="class or interface in java.lang" class="externalLink">Number</a>[]</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#coefficients(javax.measure.UnitConverter)">coefficients</a></span>&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/UnitConverter.html?is-external=true" title="class or interface in javax.measure" class="externalLink">UnitConverter</a>&nbsp;converter)</code></th>
<td class="colLast">
<div class="block">Returns the coefficients of the given converter expressed as a polynomial equation.</div>
</td>
</tr>
<tr id="i1" class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/UnitConverter.html?is-external=true" title="class or interface in javax.measure" class="externalLink">UnitConverter</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#converter(java.lang.Number,java.lang.Number)">converter</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Number.html?is-external=true" title="class or interface in java.lang" class="externalLink">Number</a>&nbsp;scale,
         <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Number.html?is-external=true" title="class or interface in java.lang" class="externalLink">Number</a>&nbsp;offset)</code></th>
<td class="colLast">
<div class="block">Creates a linear converter from the given scale and offset.</div>
</td>
</tr>
<tr id="i2" class="altColor">
<td class="colFirst"><code>static double</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#derivative(javax.measure.UnitConverter,double)">derivative</a></span>&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/UnitConverter.html?is-external=true" title="class or interface in javax.measure" class="externalLink">UnitConverter</a>&nbsp;converter,
          double&nbsp;value)</code></th>
<td class="colLast">
<div class="block">Returns the derivative of the given converter at the given value,
 or <code>Na­N</code> if this method can not compute it.</div>
</td>
</tr>
<tr id="i3" class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Angle.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Angle</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#ensureAngular(javax.measure.Unit)">ensureAngular</a></span>&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit)</code></th>
<td class="colLast">
<div class="block">Makes sure that the specified unit is either null or an angular unit.</div>
</td>
</tr>
<tr id="i4" class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#ensureLinear(javax.measure.Unit)">ensureLinear</a></span>&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit)</code></th>
<td class="colLast">
<div class="block">Makes sure that the specified unit is either null or a linear unit.</div>
</td>
</tr>
<tr id="i5" class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Dimensionless.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Dimensionless</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#ensureScale(javax.measure.Unit)">ensureScale</a></span>&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit)</code></th>
<td class="colLast">
<div class="block">Makes sure that the specified unit is either null or a scale unit.</div>
</td>
</tr>
<tr id="i6" class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Time.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Time</a>&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#ensureTemporal(javax.measure.Unit)">ensureTemporal</a></span>&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit)</code></th>
<td class="colLast">
<div class="block">Makes sure that the specified unit is either null or a temporal unit.</div>
</td>
</tr>
<tr id="i7" class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true" title="class or interface in java.lang" class="externalLink">Integer</a></code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#getEpsgCode(javax.measure.Unit,boolean)">getEpsgCode</a></span>&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit,
           boolean&nbsp;inAxis)</code></th>
<td class="colLast">
<div class="block">Returns the EPSG code of the given units, or <code>null</code> if unknown.</div>
</td>
</tr>
<tr id="i8" class="altColor">
<td class="colFirst"><code>static boolean</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#isAngular(javax.measure.Unit)">isAngular</a></span>&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit)</code></th>
<td class="colLast">
<div class="block">Returns <code>true</code> if the given unit is a linear unit.</div>
</td>
</tr>
<tr id="i9" class="rowColor">
<td class="colFirst"><code>static boolean</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#isLinear(javax.measure.Unit)">isLinear</a></span>&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit)</code></th>
<td class="colLast">
<div class="block">Returns <code>true</code> if the given unit is a linear unit.</div>
</td>
</tr>
<tr id="i10" class="altColor">
<td class="colFirst"><code>static boolean</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#isPressure(javax.measure.Unit)">isPressure</a></span>&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit)</code></th>
<td class="colLast">
<div class="block">Returns <code>true</code> if the given unit is a pressure unit.</div>
</td>
</tr>
<tr id="i11" class="rowColor">
<td class="colFirst"><code>static boolean</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#isScale(javax.measure.Unit)">isScale</a></span>&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit)</code></th>
<td class="colLast">
<div class="block">Returns <code>true</code> if the given unit is a dimensionless scale unit.</div>
</td>
</tr>
<tr id="i12" class="altColor">
<td class="colFirst"><code>static boolean</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#isTemporal(javax.measure.Unit)">isTemporal</a></span>&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit)</code></th>
<td class="colLast">
<div class="block">Returns <code>true</code> if the given unit is a temporal unit.</div>
</td>
</tr>
<tr id="i13" class="rowColor">
<td class="colFirst"><code>static &lt;Q extends <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Quantity.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Quantity</a>&lt;Q&gt;&gt;<br><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;Q&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#multiply(javax.measure.Unit,double,double)">multiply</a></span>&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;Q&gt;&nbsp;unit,
        double&nbsp;numerator,
        double&nbsp;denominator)</code></th>
<td class="colLast">
<div class="block">Multiplies the given unit by the given ratio.</div>
</td>
</tr>
<tr id="i14" class="altColor">
<td class="colFirst"><code>static &lt;Q extends <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Quantity.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Quantity</a>&lt;Q&gt;&gt;<br>double</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#toStandardUnit(javax.measure.Unit)">toStandardUnit</a></span>&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;Q&gt;&nbsp;unit)</code></th>
<td class="colLast">
<div class="block">Returns the factor by which to multiply the standard unit in order to get the given unit.</div>
</td>
</tr>
<tr id="i15" class="rowColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#valueOf(java.lang.String)">valueOf</a></span>&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;uom)</code></th>
<td class="colLast">
<div class="block">Parses the given symbol.</div>
</td>
</tr>
<tr id="i16" class="altColor">
<td class="colFirst"><code>static <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;</code></td>
<th class="colSecond" scope="row"><code><span class="memberNameLink"><a href="#valueOfEPSG(int)">valueOfEPSG</a></span>&#8203;(int&nbsp;code)</code></th>
<td class="colLast">
<div class="block">Returns a hard-coded unit from an EPSG code.</div>
</td>
</tr>
</table>
<ul class="blockList">
<li class="blockList"><a id="methods.inherited.from.class.Object">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang" class="externalLink">Object</a></h3>
<code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#clone()" title="class or interface in java.lang" class="externalLink">clone</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#equals(java.lang.Object)" title="class or interface in java.lang" class="externalLink">equals</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#finalize()" title="class or interface in java.lang" class="externalLink">finalize</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#getClass()" title="class or interface in java.lang" class="externalLink">get­Class</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#hashCode()" title="class or interface in java.lang" class="externalLink">hash­Code</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notify()" title="class or interface in java.lang" class="externalLink">notify</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#notifyAll()" title="class or interface in java.lang" class="externalLink">notify­All</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#toString()" title="class or interface in java.lang" class="externalLink">to­String</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait()" title="class or interface in java.lang" class="externalLink">wait</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait(long)" title="class or interface in java.lang" class="externalLink">wait</a>, <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Object.html?is-external=true#wait(long,int)" title="class or interface in java.lang" class="externalLink">wait</a></code></li>
</ul>
</li>
</ul>
</section>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ============ FIELD DETAIL =========== -->
<section role="region">
<ul class="blockList">
<li class="blockList"><a id="field.detail">
<!--   -->
</a>
<h3>Field Detail</h3>
<a id="NANOMETRE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NANOMETRE</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt; NANOMETRE</pre>
<div class="block">Unit of measurement defined as 10<sup>-9</sup> metres (1 nm). This unit is often used in
 <a href="../metadata/iso/content/DefaultBand.html#getBoundUnits()">wavelength measurements</a>.
 The system unit is <a href="#METRE"><code>METRE</code></a>
 and the unlocalized name is "nanometre".

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI units:</td>         <td style="word-spacing:1em"><u><code>NANOMETRE</code></u>, <a href="#MILLIMETRE"><code>MILLIMETRE</code></a>, <a href="#CENTIMETRE"><code>CENTIMETRE</code></a>, <b><a href="#METRE"><code>METRE</code></a></b>, <a href="#KILOMETRE"><code>KILOMETRE</code></a>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#POINT"><code>POINT</code></a>, <a href="#INCH"><code>INCH</code></a>, <a href="#FOOT"><code>FOOT</code></a>, <a href="#CLARKE_FOOT"><code>CLARKE_FOOT</code></a>, <a href="#US_SURVEY_FOOT"><code>US_SURVEY_FOOT</code></a>, <a href="#STATUTE_MILE"><code>STATUTE_MILE</code></a>, <a href="#NAUTICAL_MILE"><code>NAUTICAL_MILE</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a>, <a href="#CUBIC_METRE"><code>CUBIC_METRE</code></a>, <a href="#METRES_PER_SECOND"><code>METRES_PER_SECOND</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../metadata/iso/content/DefaultBand.html#getBoundUnits()"><code>Default­Band​.get­Bound­Units()</code></a></dd>
</dl>
</li>
</ul>
<a id="MILLIMETRE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>MILLIMETRE</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt; MILLIMETRE</pre>
<div class="block">Unit of measurement defined as 0.001 metres (1 mm).
 The system unit is <a href="#METRE"><code>METRE</code></a>,
 the unlocalized name is “millimetre” and the identifier is EPSG:1025.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI length units:</td>  <td style="word-spacing:1em"><a href="#NANOMETRE"><code>NANOMETRE</code></a>, <u><code>MILLIMETRE</code></u>, <a href="#CENTIMETRE"><code>CENTIMETRE</code></a>, <b><a href="#METRE"><code>METRE</code></a></b>, <a href="#KILOMETRE"><code>KILOMETRE</code></a>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#POINT"><code>POINT</code></a>, <a href="#INCH"><code>INCH</code></a>, <a href="#FOOT"><code>FOOT</code></a>, <a href="#CLARKE_FOOT"><code>CLARKE_FOOT</code></a>, <a href="#US_SURVEY_FOOT"><code>US_SURVEY_FOOT</code></a>, <a href="#STATUTE_MILE"><code>STATUTE_MILE</code></a>, <a href="#NAUTICAL_MILE"><code>NAUTICAL_MILE</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a>, <a href="#CUBIC_METRE"><code>CUBIC_METRE</code></a>, <a href="#METRES_PER_SECOND"><code>METRES_PER_SECOND</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="CENTIMETRE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>CENTIMETRE</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt; CENTIMETRE</pre>
<div class="block">Unit of measurement defined as 0.01 metres (1 cm).
 The system unit is <a href="#METRE"><code>METRE</code></a>,
 the unlocalized name is “centimetre” and the identifier is EPSG:1033.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI length units:</td>  <td style="word-spacing:1em"><a href="#NANOMETRE"><code>NANOMETRE</code></a>, <a href="#MILLIMETRE"><code>MILLIMETRE</code></a>, <u><code>CENTIMETRE</code></u>, <b><a href="#METRE"><code>METRE</code></a></b>, <a href="#KILOMETRE"><code>KILOMETRE</code></a>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#POINT"><code>POINT</code></a>, <a href="#INCH"><code>INCH</code></a>, <a href="#FOOT"><code>FOOT</code></a>, <a href="#CLARKE_FOOT"><code>CLARKE_FOOT</code></a>, <a href="#US_SURVEY_FOOT"><code>US_SURVEY_FOOT</code></a>, <a href="#STATUTE_MILE"><code>STATUTE_MILE</code></a>, <a href="#NAUTICAL_MILE"><code>NAUTICAL_MILE</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a>, <a href="#CUBIC_METRE"><code>CUBIC_METRE</code></a>, <a href="#METRES_PER_SECOND"><code>METRES_PER_SECOND</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="METRE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>METRE</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt; METRE</pre>
<div class="block">The SI base unit for distances (m).
 The unlocalized name is “metre” and the identifier is EPSG:9001.
 This is the base of all other <a href="#isLinear(javax.measure.Unit)">linear</a> units.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI length units:</td>  <td style="word-spacing:1em"><a href="#NANOMETRE"><code>NANOMETRE</code></a>, <a href="#MILLIMETRE"><code>MILLIMETRE</code></a>, <a href="#CENTIMETRE"><code>CENTIMETRE</code></a>, <u><b><code>METRE</code></b></u>, <a href="#KILOMETRE"><code>KILOMETRE</code></a>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#POINT"><code>POINT</code></a>, <a href="#INCH"><code>INCH</code></a>, <a href="#FOOT"><code>FOOT</code></a>, <a href="#CLARKE_FOOT"><code>CLARKE_FOOT</code></a>, <a href="#US_SURVEY_FOOT"><code>US_SURVEY_FOOT</code></a>, <a href="#STATUTE_MILE"><code>STATUTE_MILE</code></a>, <a href="#NAUTICAL_MILE"><code>NAUTICAL_MILE</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a>, <a href="#CUBIC_METRE"><code>CUBIC_METRE</code></a>, <a href="#METRES_PER_SECOND"><code>METRES_PER_SECOND</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="KILOMETRE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>KILOMETRE</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt; KILOMETRE</pre>
<div class="block">Unit of measurement defined as 1000 metres (1 km).
 The system unit is <a href="#METRE"><code>METRE</code></a>,
 the unlocalized name is “kilometre” and the identifier is EPSG:9036.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI length units:</td>  <td style="word-spacing:1em"><a href="#NANOMETRE"><code>NANOMETRE</code></a>, <a href="#MILLIMETRE"><code>MILLIMETRE</code></a>, <a href="#CENTIMETRE"><code>CENTIMETRE</code></a>, <b><a href="#METRE"><code>METRE</code></a></b>, <u><code>KILOMETRE</code></u>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#POINT"><code>POINT</code></a>, <a href="#INCH"><code>INCH</code></a>, <a href="#FOOT"><code>FOOT</code></a>, <a href="#CLARKE_FOOT"><code>CLARKE_FOOT</code></a>, <a href="#US_SURVEY_FOOT"><code>US_SURVEY_FOOT</code></a>, <a href="#STATUTE_MILE"><code>STATUTE_MILE</code></a>, <a href="#NAUTICAL_MILE"><code>NAUTICAL_MILE</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a>, <a href="#CUBIC_METRE"><code>CUBIC_METRE</code></a>, <a href="#KILOMETRES_PER_HOUR"><code>KILOMETRES_PER_HOUR</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="NAUTICAL_MILE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NAUTICAL_MILE</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt; NAUTICAL_MILE</pre>
<div class="block">Unit of measurement defined as exactly 1852 metres (1 M).
 This is approximately the distance between two parallels of latitude
 separated by one <a href="#ARC_MINUTE">arc-minute</a>.
 The system unit is <a href="#METRE"><code>METRE</code></a>,
 the unlocalized name is “nautical mile” and the identifier is EPSG:9030.

 <p>There is no internationally agreed symbol for nautical mile. Apache SIS uses “M” in agreement with the
 International Hydrographic Organization (IHO) and the International Bureau of Weights and Measures (BIPM).
 But “NM” and “nmi” are also in use.</p>

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI length units:</td>  <td style="word-spacing:1em"><a href="#NANOMETRE"><code>NANOMETRE</code></a>, <a href="#MILLIMETRE"><code>MILLIMETRE</code></a>, <a href="#CENTIMETRE"><code>CENTIMETRE</code></a>, <b><a href="#METRE"><code>METRE</code></a></b>, <a href="#KILOMETRE"><code>KILOMETRE</code></a>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#POINT"><code>POINT</code></a>, <a href="#INCH"><code>INCH</code></a>, <a href="#FOOT"><code>FOOT</code></a>, <a href="#CLARKE_FOOT"><code>CLARKE_FOOT</code></a>, <a href="#US_SURVEY_FOOT"><code>US_SURVEY_FOOT</code></a>, <a href="#STATUTE_MILE"><code>STATUTE_MILE</code></a>, <u><code>NAUTICAL_MILE</code></u>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a>, <a href="#CUBIC_METRE"><code>CUBIC_METRE</code></a>, <a href="#KILOMETRES_PER_HOUR"><code>KILOMETRES_PER_HOUR</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="STATUTE_MILE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STATUTE_MILE</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt; STATUTE_MILE</pre>
<div class="block">Unit of measurement defined as exactly 1609.344 metres (1 mi).
 This unit is often named “mile” without qualifier, but Apache SIS uses “statute mile”
 for emphasing the difference with <a href="#NAUTICAL_MILE">nautical mile</a>.
 The system unit is <a href="#METRE"><code>METRE</code></a>.
 The unlocalized name is “statute mile” but is localized as "international mile" in the US
 for avoiding confusion with the US survey mile.
 The identifier is EPSG:9093.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI length units:</td>  <td style="word-spacing:1em"><a href="#NANOMETRE"><code>NANOMETRE</code></a>, <a href="#MILLIMETRE"><code>MILLIMETRE</code></a>, <a href="#CENTIMETRE"><code>CENTIMETRE</code></a>, <b><a href="#METRE"><code>METRE</code></a></b>, <a href="#KILOMETRE"><code>KILOMETRE</code></a>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#POINT"><code>POINT</code></a>, <a href="#INCH"><code>INCH</code></a>, <a href="#FOOT"><code>FOOT</code></a>, <a href="#CLARKE_FOOT"><code>CLARKE_FOOT</code></a>, <a href="#US_SURVEY_FOOT"><code>US_SURVEY_FOOT</code></a>, <u><code>STATUTE_MILE</code></u>, <a href="#NAUTICAL_MILE"><code>NAUTICAL_MILE</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a>, <a href="#CUBIC_METRE"><code>CUBIC_METRE</code></a>, <a href="#KILOMETRES_PER_HOUR"><code>KILOMETRES_PER_HOUR</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="US_SURVEY_FOOT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>US_SURVEY_FOOT</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt; US_SURVEY_FOOT</pre>
<div class="block">Unit of measurement approximately equals to 0.3048006096… metres.
 The legal definition is exactly 12/39.37 metres.
 The system unit is <a href="#METRE"><code>METRE</code></a>,
 the unlocalized name is “US survey foot” and the identifier is EPSG:9003.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI length units:</td>  <td style="word-spacing:1em"><a href="#NANOMETRE"><code>NANOMETRE</code></a>, <a href="#MILLIMETRE"><code>MILLIMETRE</code></a>, <a href="#CENTIMETRE"><code>CENTIMETRE</code></a>, <b><a href="#METRE"><code>METRE</code></a></b>, <a href="#KILOMETRE"><code>KILOMETRE</code></a>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#POINT"><code>POINT</code></a>, <a href="#INCH"><code>INCH</code></a>, <a href="#FOOT"><code>FOOT</code></a>, <a href="#CLARKE_FOOT"><code>CLARKE_FOOT</code></a>, <u><code>US_SURVEY_FOOT</code></u>, <a href="#STATUTE_MILE"><code>STATUTE_MILE</code></a>, <a href="#NAUTICAL_MILE"><code>NAUTICAL_MILE</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a>, <a href="#CUBIC_METRE"><code>CUBIC_METRE</code></a>, <a href="#METRES_PER_SECOND"><code>METRES_PER_SECOND</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="CLARKE_FOOT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>CLARKE_FOOT</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt; CLARKE_FOOT</pre>
<div class="block">Unit of measurement defined as 0.3047972654 metres.
 The system unit is <a href="#METRE"><code>METRE</code></a>,
 the unlocalized name is “Clarke’s foot” and the identifier is EPSG:9005.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI length units:</td>  <td style="word-spacing:1em"><a href="#NANOMETRE"><code>NANOMETRE</code></a>, <a href="#MILLIMETRE"><code>MILLIMETRE</code></a>, <a href="#CENTIMETRE"><code>CENTIMETRE</code></a>, <b><a href="#METRE"><code>METRE</code></a></b>, <a href="#KILOMETRE"><code>KILOMETRE</code></a>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#POINT"><code>POINT</code></a>, <a href="#INCH"><code>INCH</code></a>, <a href="#FOOT"><code>FOOT</code></a>, <u><code>CLARKE_FOOT</code></u>, <a href="#US_SURVEY_FOOT"><code>US_SURVEY_FOOT</code></a>, <a href="#STATUTE_MILE"><code>STATUTE_MILE</code></a>, <a href="#NAUTICAL_MILE"><code>NAUTICAL_MILE</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a>, <a href="#CUBIC_METRE"><code>CUBIC_METRE</code></a>, <a href="#METRES_PER_SECOND"><code>METRES_PER_SECOND</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="FOOT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>FOOT</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt; FOOT</pre>
<div class="block">Unit of measurement defined as exactly 0.3048 metres (1 ft).
 The system unit is <a href="#METRE"><code>METRE</code></a>,
 the unlocalized name is “foot” and the identifier is EPSG:9002.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI length units:</td>  <td style="word-spacing:1em"><a href="#NANOMETRE"><code>NANOMETRE</code></a>, <a href="#MILLIMETRE"><code>MILLIMETRE</code></a>, <a href="#CENTIMETRE"><code>CENTIMETRE</code></a>, <b><a href="#METRE"><code>METRE</code></a></b>, <a href="#KILOMETRE"><code>KILOMETRE</code></a>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#POINT"><code>POINT</code></a>, <a href="#INCH"><code>INCH</code></a>, <u><code>FOOT</code></u>, <a href="#CLARKE_FOOT"><code>CLARKE_FOOT</code></a>, <a href="#US_SURVEY_FOOT"><code>US_SURVEY_FOOT</code></a>, <a href="#STATUTE_MILE"><code>STATUTE_MILE</code></a>, <a href="#NAUTICAL_MILE"><code>NAUTICAL_MILE</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a>, <a href="#CUBIC_METRE"><code>CUBIC_METRE</code></a>, <a href="#METRES_PER_SECOND"><code>METRES_PER_SECOND</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="INCH">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>INCH</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt; INCH</pre>
<div class="block">Unit of measurement defined as 2.54 centimetres (1 in).
 The system unit is <a href="#METRE"><code>METRE</code></a>
 and the unlocalized name is “inch”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI length units:</td>  <td style="word-spacing:1em"><a href="#NANOMETRE"><code>NANOMETRE</code></a>, <a href="#MILLIMETRE"><code>MILLIMETRE</code></a>, <a href="#CENTIMETRE"><code>CENTIMETRE</code></a>, <b><a href="#METRE"><code>METRE</code></a></b>, <a href="#KILOMETRE"><code>KILOMETRE</code></a>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#POINT"><code>POINT</code></a>, <u><code>INCH</code></u>, <a href="#FOOT"><code>FOOT</code></a>, <a href="#CLARKE_FOOT"><code>CLARKE_FOOT</code></a>, <a href="#US_SURVEY_FOOT"><code>US_SURVEY_FOOT</code></a>, <a href="#STATUTE_MILE"><code>STATUTE_MILE</code></a>, <a href="#NAUTICAL_MILE"><code>NAUTICAL_MILE</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a>, <a href="#CUBIC_METRE"><code>CUBIC_METRE</code></a>, <a href="#METRES_PER_SECOND"><code>METRES_PER_SECOND</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="POINT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>POINT</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt; POINT</pre>
<div class="block">Unit of measurement defined as 0.013837 inch (1 pt).
 This is commonly used to measure the height of a font.
 The system unit is <a href="#METRE"><code>METRE</code></a>
 and the unlocalized name is “point”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI length units:</td>  <td style="word-spacing:1em"><a href="#NANOMETRE"><code>NANOMETRE</code></a>, <a href="#MILLIMETRE"><code>MILLIMETRE</code></a>, <a href="#CENTIMETRE"><code>CENTIMETRE</code></a>, <b><a href="#METRE"><code>METRE</code></a></b>, <a href="#KILOMETRE"><code>KILOMETRE</code></a>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><u><code>POINT</code></u>, <a href="#INCH"><code>INCH</code></a>, <a href="#FOOT"><code>FOOT</code></a>, <a href="#CLARKE_FOOT"><code>CLARKE_FOOT</code></a>, <a href="#US_SURVEY_FOOT"><code>US_SURVEY_FOOT</code></a>, <a href="#STATUTE_MILE"><code>STATUTE_MILE</code></a>, <a href="#NAUTICAL_MILE"><code>NAUTICAL_MILE</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a>, <a href="#CUBIC_METRE"><code>CUBIC_METRE</code></a>, <a href="#METRES_PER_SECOND"><code>METRES_PER_SECOND</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="SQUARE_METRE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SQUARE_METRE</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Area.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Area</a>&gt; SQUARE_METRE</pre>
<div class="block">The SI derived unit for area (m²).
 The unlocalized name is “square metre”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI area units:</td> <td style="word-spacing:1em"><u><b><code>SQUARE_METRE</code></b></u>, <a href="#HECTARE"><code>HECTARE</code></a>.</td></tr>
   <tr><td>Derived units:</td> <td style="word-spacing:1em"><a href="#CUBIC_METRE"><code>CUBIC_METRE</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="HECTARE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>HECTARE</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Area.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Area</a>&gt; HECTARE</pre>
<div class="block">Unit of measurement defined as 10,000 square metres (1 ha).
 One hectare is exactly equals to one hectometre (1 hm²).
 While not an SI unit, the hectare is often used in the measurement of land.
 The unlocalized name is “hectare”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI area units:</td> <td style="word-spacing:1em"><b><a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a></b>, <u><code>HECTARE</code></u>.</td></tr>
   <tr><td>Derived units:</td> <td style="word-spacing:1em"><a href="#CUBIC_METRE"><code>CUBIC_METRE</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="CUBIC_METRE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>CUBIC_METRE</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Volume.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Volume</a>&gt; CUBIC_METRE</pre>
<div class="block">The SI derived unit for volume (m³).
 The unlocalized name is “cubic metre”.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="LITRE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LITRE</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Volume.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Volume</a>&gt; LITRE</pre>
<div class="block">The unit for litre volume (L, l or ℓ).
 The unlocalized name is “litre”.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="STERADIAN">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>STERADIAN</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/SolidAngle.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">SolidAngle</a>&gt; STERADIAN</pre>
<div class="block">The SI unit for solid angles (sr).
 The unlocalized name is “steradian”.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="MICRORADIAN">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>MICRORADIAN</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Angle.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Angle</a>&gt; MICRORADIAN</pre>
<div class="block">Unit of measurement defined as 10<sup>-6</sup> radians (1 µrad).
 The distance of one microradian of latitude on Earth is approximately 2 millimetres.
 The system unit is <a href="#RADIAN"><code>RADIAN</code></a>,
 the unlocalized name is “microradian” and the identifier is EPSG:9109.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI angle units:</td>   <td style="word-spacing:1em"><u><code>MICRORADIAN</code></u>, <b><a href="#RADIAN"><code>RADIAN</code></a></b>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#DEGREE"><code>DEGREE</code></a>, <a href="#ARC_MINUTE"><code>ARC_MINUTE</code></a>, <a href="#ARC_SECOND"><code>ARC_SECOND</code></a>, <a href="#GRAD"><code>GRAD</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#STERADIAN"><code>STERADIAN</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="RADIAN">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>RADIAN</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Angle.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Angle</a>&gt; RADIAN</pre>
<div class="block">The SI unit for plane angles (rad).
 There is 2π radians in a circle.
 The unlocalized name is “radian” and the identifier is EPSG:9101.
 This is the base of all other <a href="#isAngular(javax.measure.Unit)">angular</a> units.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI angle units:</td>   <td style="word-spacing:1em"><a href="#MICRORADIAN"><code>MICRORADIAN</code></a>, <u><b><code>RADIAN</code></b></u>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#DEGREE"><code>DEGREE</code></a>, <a href="#ARC_MINUTE"><code>ARC_MINUTE</code></a>, <a href="#ARC_SECOND"><code>ARC_SECOND</code></a>, <a href="#GRAD"><code>GRAD</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#STERADIAN"><code>STERADIAN</code></a>, <a href="#RADIANS_PER_SECOND"><code>RADIANS_PER_SECOND</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="DEGREE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DEGREE</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Angle.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Angle</a>&gt; DEGREE</pre>
<div class="block">Unit of measurement defined as π/180 radians (1°).
 There is 360° in a circle.
 The system unit is <a href="#RADIAN"><code>RADIAN</code></a>,
 the unlocalized name is “degree” and the identifier is EPSG:9102.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI angle units:</td>   <td style="word-spacing:1em"><a href="#MICRORADIAN"><code>MICRORADIAN</code></a>, <b><a href="#RADIAN"><code>RADIAN</code></a></b>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><u><code>DEGREE</code></u>, <a href="#ARC_MINUTE"><code>ARC_MINUTE</code></a>, <a href="#ARC_SECOND"><code>ARC_SECOND</code></a>, <a href="#GRAD"><code>GRAD</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#STERADIAN"><code>STERADIAN</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="ARC_MINUTE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ARC_MINUTE</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Angle.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Angle</a>&gt; ARC_MINUTE</pre>
<div class="block">Unit of measurement defined as 1/60 degree (1′).
 The distance of one arc-minute of latitude on Earth is approximately 1852 metres
 (one <a href="#NAUTICAL_MILE">nautical mile</a>).
 The system unit is <a href="#RADIAN"><code>RADIAN</code></a>,
 the unlocalized name is “arc-minute” and the identifier is EPSG:9103.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI angle units:</td>   <td style="word-spacing:1em"><a href="#MICRORADIAN"><code>MICRORADIAN</code></a>, <b><a href="#RADIAN"><code>RADIAN</code></a></b>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#DEGREE"><code>DEGREE</code></a>, <u><code>ARC_MINUTE</code></u>, <a href="#ARC_SECOND"><code>ARC_SECOND</code></a>, <a href="#GRAD"><code>GRAD</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#STERADIAN"><code>STERADIAN</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="ARC_SECOND">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ARC_SECOND</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Angle.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Angle</a>&gt; ARC_SECOND</pre>
<div class="block">Unit of measurement defined as 1/(60×60) degree (1″).
 The distance of one arc-second of latitude on Earth is approximately 31 metres.
 This unit of measurement is used for rotation terms in
 <a href="../referencing/datum/BursaWolfParameters.html" title="class in org.apache.sis.referencing.datum">Bursa-Wolf parameters</a>.
 The system unit is <a href="#RADIAN"><code>RADIAN</code></a>,
 the unlocalized name is “arc-second” and the identifier is EPSG:9104.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI angle units:</td>   <td style="word-spacing:1em"><a href="#MICRORADIAN"><code>MICRORADIAN</code></a>, <b><a href="#RADIAN"><code>RADIAN</code></a></b>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#DEGREE"><code>DEGREE</code></a>, <a href="#ARC_MINUTE"><code>ARC_MINUTE</code></a>, <u><code>ARC_SECOND</code></u>, <a href="#GRAD"><code>GRAD</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#STERADIAN"><code>STERADIAN</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="GRAD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>GRAD</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Angle.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Angle</a>&gt; GRAD</pre>
<div class="block">Unit of measurement defined as π/200 radians (1 grad).
 There is 400 grads in a circle.
 The system unit is <a href="#RADIAN"><code>RADIAN</code></a>,
 the unlocalized name is “grad”, but the “gon” alias is also accepted.
 The identifier is EPSG:9105.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI angle units:</td>   <td style="word-spacing:1em"><a href="#MICRORADIAN"><code>MICRORADIAN</code></a>, <b><a href="#RADIAN"><code>RADIAN</code></a></b>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#DEGREE"><code>DEGREE</code></a>, <a href="#ARC_MINUTE"><code>ARC_MINUTE</code></a>, <a href="#ARC_SECOND"><code>ARC_SECOND</code></a>, <u><code>GRAD</code></u>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#STERADIAN"><code>STERADIAN</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="MILLISECOND">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>MILLISECOND</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Time.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Time</a>&gt; MILLISECOND</pre>
<div class="block">Unit of measurement defined as 10<sup>-3</sup> seconds (1 ms).
 This unit is useful for inter-operability with various methods from the standard Java library.
 The system unit is <a href="#SECOND"><code>SECOND</code></a>
 and the unlocalized name is “millisecond”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI time units:</td>    <td style="word-spacing:1em"><u><code>MILLISECOND</code></u>, <b><a href="#SECOND"><code>SECOND</code></a></b>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#MINUTE"><code>MINUTE</code></a>, <a href="#HOUR"><code>HOUR</code></a>, <a href="#DAY"><code>DAY</code></a>, <a href="#WEEK"><code>WEEK</code></a>, <a href="#TROPICAL_YEAR"><code>TROPICAL_YEAR</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#METRES_PER_SECOND"><code>METRES_PER_SECOND</code></a>, <a href="#HERTZ"><code>HERTZ</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.3</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/TimeUnit.html?is-external=true#MILLISECONDS" title="class or interface in java.util.concurrent" class="externalLink"><code>Time­Unit​.MILLISECONDS</code></a></dd>
</dl>
</li>
</ul>
<a id="SECOND">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SECOND</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Time.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Time</a>&gt; SECOND</pre>
<div class="block">The SI base unit for durations (s).
 The unlocalized name is “second” and the identifier is EPSG:1040.
 This is the base of all other <a href="#isTemporal(javax.measure.Unit)">temporal</a> units.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI time units:</td>    <td style="word-spacing:1em"><a href="#MILLISECOND"><code>MILLISECOND</code></a>, <u><b><a href="#SECOND"><code>SECOND</code></a></b></u>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#MINUTE"><code>MINUTE</code></a>, <a href="#HOUR"><code>HOUR</code></a>, <a href="#DAY"><code>DAY</code></a>, <a href="#WEEK"><code>WEEK</code></a>, <a href="#TROPICAL_YEAR"><code>TROPICAL_YEAR</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#METRES_PER_SECOND"><code>METRES_PER_SECOND</code></a>, <a href="#HERTZ"><code>HERTZ</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="MINUTE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>MINUTE</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Time.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Time</a>&gt; MINUTE</pre>
<div class="block">Unit of measurement defined as 60 seconds (1 min).
 The system unit is <a href="#SECOND"><code>SECOND</code></a>
 and the unlocalized name is “minute”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI time units:</td>    <td style="word-spacing:1em"><a href="#MILLISECOND"><code>MILLISECOND</code></a>, <b><a href="#SECOND"><code>SECOND</code></a></b>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><u><code>MINUTE</code></u>, <a href="#HOUR"><code>HOUR</code></a>, <a href="#DAY"><code>DAY</code></a>, <a href="#WEEK"><code>WEEK</code></a>, <a href="#TROPICAL_YEAR"><code>TROPICAL_YEAR</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#METRES_PER_SECOND"><code>METRES_PER_SECOND</code></a>, <a href="#HERTZ"><code>HERTZ</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="HOUR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>HOUR</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Time.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Time</a>&gt; HOUR</pre>
<div class="block">Unit of measurement defined as 60×60 seconds (1 h).
 The system unit is <a href="#SECOND"><code>SECOND</code></a>
 and the unlocalized name is “hour”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI time units:</td>    <td style="word-spacing:1em"><a href="#MILLISECOND"><code>MILLISECOND</code></a>, <b><a href="#SECOND"><code>SECOND</code></a></b>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#MINUTE"><code>MINUTE</code></a>, <u><code>HOUR</code></u>, <a href="#DAY"><code>DAY</code></a>, <a href="#WEEK"><code>WEEK</code></a>, <a href="#TROPICAL_YEAR"><code>TROPICAL_YEAR</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#KILOMETRES_PER_HOUR"><code>KILOMETRES_PER_HOUR</code></a>, <a href="#HERTZ"><code>HERTZ</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="DAY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DAY</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Time.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Time</a>&gt; DAY</pre>
<div class="block">Unit of measurement defined as 24×60×60 seconds (1 d).
 The system unit is <a href="#SECOND"><code>SECOND</code></a>
 and the unlocalized name is “day”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI time units:</td>    <td style="word-spacing:1em"><a href="#MILLISECOND"><code>MILLISECOND</code></a>, <b><a href="#SECOND"><code>SECOND</code></a></b>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#MINUTE"><code>MINUTE</code></a>, <a href="#HOUR"><code>HOUR</code></a>, <u><code>DAY</code></u>, <a href="#WEEK"><code>WEEK</code></a>, <a href="#TROPICAL_YEAR"><code>TROPICAL_YEAR</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#KILOMETRES_PER_HOUR"><code>KILOMETRES_PER_HOUR</code></a>, <a href="#HERTZ"><code>HERTZ</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="WEEK">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>WEEK</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Time.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Time</a>&gt; WEEK</pre>
<div class="block">Unit of measurement defined as 7 days (1 wk).
 The system unit is <a href="#SECOND"><code>SECOND</code></a>
 and the unlocalized name is “week”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI time units:</td>    <td style="word-spacing:1em"><a href="#MILLISECOND"><code>MILLISECOND</code></a>, <b><a href="#SECOND"><code>SECOND</code></a></b>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#MINUTE"><code>MINUTE</code></a>, <a href="#HOUR"><code>HOUR</code></a>, <a href="#DAY"><code>DAY</code></a>, <u><a href="#WEEK"><code>WEEK</code></a></u>, <a href="#TROPICAL_YEAR"><code>TROPICAL_YEAR</code></a>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#KILOMETRES_PER_HOUR"><code>KILOMETRES_PER_HOUR</code></a>, <a href="#HERTZ"><code>HERTZ</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="TROPICAL_YEAR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TROPICAL_YEAR</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Time.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Time</a>&gt; TROPICAL_YEAR</pre>
<div class="block">Unit of measurement approximately equals to 365.24219 days (1 a).
 This is defined by the International Union of Geological Sciences (IUGS) as exactly 31556925.445 seconds,
 taken as the length of the tropical year in the the year 2000.
 The system unit is <a href="#SECOND"><code>SECOND</code></a>,
 the unlocalized name is “year” and the identifier is EPSG:1029.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI time units:</td>    <td style="word-spacing:1em"><a href="#MILLISECOND"><code>MILLISECOND</code></a>, <b><a href="#SECOND"><code>SECOND</code></a></b>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#MINUTE"><code>MINUTE</code></a>, <a href="#HOUR"><code>HOUR</code></a>, <a href="#DAY"><code>DAY</code></a>, <a href="#WEEK"><code>WEEK</code></a>, <u><code>TROPICAL_YEAR</code></u>.</td></tr>
   <tr><td>Derived units:</td>    <td style="word-spacing:1em"><a href="#KILOMETRES_PER_HOUR"><code>KILOMETRES_PER_HOUR</code></a>, <a href="#HERTZ"><code>HERTZ</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="HERTZ">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>HERTZ</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Frequency.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Frequency</a>&gt; HERTZ</pre>
<div class="block">The SI derived unit for frequency (Hz).
 One hertz is equal to one cycle per <a href="#SECOND">second</a>.
 The unlocalized name is “hertz”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>Components:</td><td style="word-spacing:0.5em"><a href="#SECOND"><code>SECOND</code></a><sup>-1</sup></td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="RADIANS_PER_SECOND">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>RADIANS_PER_SECOND</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="AngularVelocity.html" title="interface in org.apache.sis.measure">AngularVelocity</a>&gt; RADIANS_PER_SECOND</pre>
<div class="block">The unit for angular velocity (rad/s).
 The identifier is EPSG:1035.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>Components:</td> <td style="word-spacing:0.5em"><a href="#RADIAN"><code>RADIAN</code></a> ∕ <a href="#SECOND"><code>SECOND</code></a></td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="METRES_PER_SECOND">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>METRES_PER_SECOND</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Speed.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Speed</a>&gt; METRES_PER_SECOND</pre>
<div class="block">The SI derived unit for speed (m/s).
 The unlocalized name is “metres per second” and the identifier is EPSG:1026.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI speed units:</td>   <td style="word-spacing:1em"><u><b><code>METRES_PER_SECOND</code></b></u>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><a href="#KILOMETRES_PER_HOUR"><code>KILOMETRES_PER_HOUR</code></a>.</td></tr>
   <tr><td>Components:</td>       <td style="word-spacing:0.5em"><a href="#METRE"><code>METRE</code></a> ∕ <a href="#SECOND"><code>SECOND</code></a></td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="KILOMETRES_PER_HOUR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>KILOMETRES_PER_HOUR</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Speed.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Speed</a>&gt; KILOMETRES_PER_HOUR</pre>
<div class="block">Unit of measurement defined as 1/3.6 metres per second (1 km/h).
 The system unit is <a href="#METRES_PER_SECOND"><code>METRES_PER_SECOND</code></a>
 and the unlocalized name is “kilometres per hour”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI speed units:</td>   <td style="word-spacing:1em"><b><a href="#METRES_PER_SECOND"><code>METRES_PER_SECOND</code></a></b>.</td></tr>
   <tr><td>In other systems:</td> <td style="word-spacing:1em"><u><code>KILOMETRES_PER_HOUR</code></u>.</td></tr>
   <tr><td>Components:</td>       <td style="word-spacing:0.5em"><a href="#KILOMETRE"><code>KILOMETRE</code></a> ∕ <a href="#HOUR"><code>HOUR</code></a></td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="PASCAL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PASCAL</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Pressure.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Pressure</a>&gt; PASCAL</pre>
<div class="block">The SI derived unit for pressure (Pa).
 One pascal is equal to 1 N/m².
 Pressures are often used in <a href="../referencing/crs/DefaultParametricCRS.html" title="class in org.apache.sis.referencing.crs">parametric CRS</a>
 for height measurements on a vertical axis.
 The unlocalized name is “pascal”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI pressure units:</td> <td style="word-spacing:1em"><u><b><code>PASCAL</code></b></u>, <a href="#HECTOPASCAL"><code>HECTOPASCAL</code></a>.</td></tr>
   <tr><td>In other systems:</td>  <td style="word-spacing:1em"><a href="#DECIBAR"><code>DECIBAR</code></a>, <a href="#BAR"><code>BAR</code></a>, <a href="#ATMOSPHERE"><code>ATMOSPHERE</code></a>.</td></tr>
   <tr><td>Components:</td>        <td style="word-spacing:0.5em"><a href="#NEWTON"><code>NEWTON</code></a> ∕ <a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a></td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="HECTOPASCAL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>HECTOPASCAL</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Pressure.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Pressure</a>&gt; HECTOPASCAL</pre>
<div class="block">Unit of measurement defined as 100 pascals (1 hPa).
 The hectopascal is the international unit for measuring atmospheric or barometric pressure
 and is exactly equal to one millibar.
 The system unit is <a href="#PASCAL"><code>PASCAL</code></a>
 and the unlocalized name is “hectopascal”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI pressure units:</td> <td style="word-spacing:1em"><b><a href="#PASCAL"><code>PASCAL</code></a></b>, <u><code>HECTOPASCAL</code></u>.</td></tr>
   <tr><td>In other systems:</td>  <td style="word-spacing:1em"><a href="#DECIBAR"><code>DECIBAR</code></a>, <a href="#BAR"><code>BAR</code></a>, <a href="#ATMOSPHERE"><code>ATMOSPHERE</code></a>.</td></tr>
   <tr><td>Components:</td>        <td style="word-spacing:0.5em"><a href="#NEWTON"><code>NEWTON</code></a> ∕ <a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a></td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="DECIBAR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DECIBAR</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Pressure.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Pressure</a>&gt; DECIBAR</pre>
<div class="block">Unit of measurement defined as 10000 pascals (1 dbar).
 This unit is used in oceanography as there is an approximate numerical equivalence
 between pressure changes in decibars and depth changes in metres underwater.
 The system unit is <a href="#PASCAL"><code>PASCAL</code></a>
 and the unlocalized name is “decibar”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI pressure units:</td> <td style="word-spacing:1em"><b><a href="#PASCAL"><code>PASCAL</code></a></b>, <a href="#HECTOPASCAL"><code>HECTOPASCAL</code></a>.</td></tr>
   <tr><td>In other systems:</td>  <td style="word-spacing:1em"><u><code>DECIBAR</code></u>, <a href="#BAR"><code>BAR</code></a>, <a href="#ATMOSPHERE"><code>ATMOSPHERE</code></a>.</td></tr>
   <tr><td>Components:</td>        <td style="word-spacing:0.5em"><a href="#NEWTON"><code>NEWTON</code></a> ∕ <a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a></td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="BAR">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>BAR</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Pressure.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Pressure</a>&gt; BAR</pre>
<div class="block">Unit of measurement defined as 100000 pascals (1 bar).
 One bar is slightly less than the average atmospheric pressure on Earth at sea level.
 One millibar is exactly equal to one <a href="#HECTOPASCAL">hectopascal</a>.
 The system unit is <a href="#PASCAL"><code>PASCAL</code></a>
 and the unlocalized name is “bar”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI pressure units:</td> <td style="word-spacing:1em"><b><a href="#PASCAL"><code>PASCAL</code></a></b>, <a href="#HECTOPASCAL"><code>HECTOPASCAL</code></a>.</td></tr>
   <tr><td>In other systems:</td>  <td style="word-spacing:1em"><a href="#DECIBAR"><code>DECIBAR</code></a>, <u><code>BAR</code></u>, <a href="#ATMOSPHERE"><code>ATMOSPHERE</code></a>.</td></tr>
   <tr><td>Components:</td>        <td style="word-spacing:0.5em"><a href="#NEWTON"><code>NEWTON</code></a> ∕ <a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a></td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="ATMOSPHERE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ATMOSPHERE</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Pressure.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Pressure</a>&gt; ATMOSPHERE</pre>
<div class="block">Unit of measurement defined as 101325 pascals (1 atm).
 One atmosphere reflects the pressure at the mean sea level for countries around 49°N of latitude.
 The system unit is <a href="#PASCAL"><code>PASCAL</code></a>
 and the unlocalized name is “atmosphere”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI pressure units:</td> <td style="word-spacing:1em"><b><a href="#PASCAL"><code>PASCAL</code></a></b>, <a href="#HECTOPASCAL"><code>HECTOPASCAL</code></a>.</td></tr>
   <tr><td>In other systems:</td>  <td style="word-spacing:1em"><a href="#DECIBAR"><code>DECIBAR</code></a>, <a href="#BAR"><code>BAR</code></a>, <u><code>ATMOSPHERE</code></u>.</td></tr>
   <tr><td>Components:</td>        <td style="word-spacing:0.5em"><a href="#NEWTON"><code>NEWTON</code></a> ∕ <a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a></td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="NEWTON">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>NEWTON</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Force.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Force</a>&gt; NEWTON</pre>
<div class="block">The SI derived unit for force (N).
 One newton is the force required to give a mass of 1 kg an acceleration of 1 m/s².
 The unlocalized name is “newton”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>Components:</td>    <td style="word-spacing:0.5em"><a href="#KILOGRAM"><code>KILOGRAM</code></a> ⋅ <a href="#METRES_PER_SECOND"><code>METRES_PER_SECOND</code></a> ∕ <a href="#SECOND"><code>SECOND</code></a></td></tr>
   <tr><td>Derived units:</td> <td style="word-spacing:1em"><a href="#PASCAL"><code>PASCAL</code></a>, <a href="#JOULE"><code>JOULE</code></a>, <a href="#WATT"><code>WATT</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="JOULE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>JOULE</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Energy.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Energy</a>&gt; JOULE</pre>
<div class="block">The SI derived unit for energy (J).
 The unlocalized name is “joule”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>Components:</td>    <td style="word-spacing:0.5em"><a href="#NEWTON"><code>NEWTON</code></a> ⋅ <a href="#METRE"><code>METRE</code></a></td></tr>
   <tr><td>Derived units:</td> <td style="word-spacing:1em"><a href="#WATT"><code>WATT</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="WATT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>WATT</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Power.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Power</a>&gt; WATT</pre>
<div class="block">The SI derived unit for power (W).
 One watt is equal to one joule per second.
 The unlocalized name is “watt”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>Components:</td>    <td style="word-spacing:0.5em"><a href="#JOULE"><code>JOULE</code></a> ∕ <a href="#SECOND"><code>SECOND</code></a></td></tr>
   <tr><td>Derived units:</td> <td style="word-spacing:1em"><a href="#VOLT"><code>VOLT</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="VOLT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>VOLT</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/ElectricPotential.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">ElectricPotential</a>&gt; VOLT</pre>
<div class="block">The SI derived unit for electric potential difference (V).
 The unlocalized name is “volt”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>Components:</td>    <td style="word-spacing:0.5em"><a href="#WATT"><code>WATT</code></a> ∕ <a href="#AMPERE"><code>AMPERE</code></a></td></tr>
   <tr><td>Derived units:</td> <td style="word-spacing:1em"><a href="#FARAD"><code>FARAD</code></a>, <a href="#OHM"><code>OHM</code></a>, <a href="#SIEMENS"><code>SIEMENS</code></a>, <a href="#WEBER"><code>WEBER</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="AMPERE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>AMPERE</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/ElectricCurrent.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">ElectricCurrent</a>&gt; AMPERE</pre>
<div class="block">The SI base unit for electric current (A).
 The unlocalized name is “ampere”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>Derived units:</td> <td style="word-spacing:1em"><a href="#COULOMB"><code>COULOMB</code></a>, <a href="#VOLT"><code>VOLT</code></a>, <a href="#OHM"><code>OHM</code></a>, <a href="#SIEMENS"><code>SIEMENS</code></a>, <a href="#HENRY"><code>HENRY</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="COULOMB">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>COULOMB</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/ElectricCharge.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">ElectricCharge</a>&gt; COULOMB</pre>
<div class="block">The SI derived unit for electric charge (C).
 One coulomb is the charge transfered by a current of one ampere during one second.
 The unlocalized name is “coulomb”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>Components:</td>    <td style="word-spacing:0.5em"><a href="#AMPERE"><code>AMPERE</code></a> ⋅ <a href="#SECOND"><code>SECOND</code></a></td></tr>
   <tr><td>Derived units:</td> <td style="word-spacing:1em"><a href="#FARAD"><code>FARAD</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="FARAD">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>FARAD</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/ElectricCapacitance.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">ElectricCapacitance</a>&gt; FARAD</pre>
<div class="block">The SI derived unit for electric capacitance (F).
 The unlocalized name is “farad”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>Components:</td> <td style="word-spacing:0.5em"><a href="#COULOMB"><code>COULOMB</code></a> ∕ <a href="#VOLT"><code>VOLT</code></a></td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="OHM">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>OHM</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/ElectricResistance.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">ElectricResistance</a>&gt; OHM</pre>
<div class="block">The SI derived unit for electric resistance (Ω).
 This is the inverse of electric conductance.
 The unlocalized name is “ohm”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>Components:</td>    <td style="word-spacing:0.5em"><a href="#VOLT"><code>VOLT</code></a> ∕ <a href="#AMPERE"><code>AMPERE</code></a></td></tr>
   <tr><td>Derived units:</td> <td style="word-spacing:1em"><a href="#SIEMENS"><code>SIEMENS</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="SIEMENS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>SIEMENS</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/ElectricConductance.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">ElectricConductance</a>&gt; SIEMENS</pre>
<div class="block">The SI derived unit for electric conductance (S).
 This is the inverse of electric resistance.
 The unlocalized name is “siemens”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>Components:</td>    <td style="word-spacing:0.5em"><a href="#AMPERE"><code>AMPERE</code></a> ∕ <a href="#VOLT"><code>VOLT</code></a></td></tr>
   <tr><td>Derived units:</td> <td style="word-spacing:1em"><a href="#OHM"><code>OHM</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="WEBER">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>WEBER</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/MagneticFlux.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">MagneticFlux</a>&gt; WEBER</pre>
<div class="block">The SI derived unit for magnetic flux (Wb).
 The unlocalized name is “weber”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>Components:</td>    <td style="word-spacing:0.5em"><a href="#VOLT"><code>VOLT</code></a> ⋅ <a href="#SECOND"><code>SECOND</code></a></td></tr>
   <tr><td>Derived units:</td> <td style="word-spacing:1em"><a href="#TESLA"><code>TESLA</code></a>, <a href="#HENRY"><code>HENRY</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="TESLA">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>TESLA</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/MagneticFluxDensity.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">MagneticFluxDensity</a>&gt; TESLA</pre>
<div class="block">The SI derived unit for magnetic flux density (T).
 The unlocalized name is “tesla”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>Components:</td> <td style="word-spacing:0.5em"><a href="#WEBER"><code>WEBER</code></a> ∕ <a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a></td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="HENRY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>HENRY</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/ElectricInductance.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">ElectricInductance</a>&gt; HENRY</pre>
<div class="block">The SI derived unit for inductance (H).
 The unlocalized name is “henry”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>Components:</td> <td style="word-spacing:0.5em"><a href="#WEBER"><code>WEBER</code></a> ∕ <a href="#AMPERE"><code>AMPERE</code></a></td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="KELVIN">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>KELVIN</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Temperature.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Temperature</a>&gt; KELVIN</pre>
<div class="block">The SI base unit for thermodynamic temperature (K).
 The unlocalized name is “kelvin”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI temperature units:</td> <td style="word-spacing:1em"><u><b><code>KELVIN</code></b></u>.</td></tr>
   <tr><td>In other systems:</td>     <td style="word-spacing:1em"><a href="#CELSIUS"><code>CELSIUS</code></a>, <a href="#FAHRENHEIT"><code>FAHRENHEIT</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="CELSIUS">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>CELSIUS</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Temperature.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Temperature</a>&gt; CELSIUS</pre>
<div class="block">Unit of measurement defined as the temperature in Kelvin minus 273.15.
 The symbol is °C and the unlocalized name is “Celsius”.
 Note that this is the only SI unit with an upper-case letter in its name.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI temperature units:</td> <td style="word-spacing:1em"><b><a href="#KELVIN"><code>KELVIN</code></a></b>.</td></tr>
   <tr><td>In other systems:</td>     <td style="word-spacing:1em"><u><code>CELSIUS</code></u>, <a href="#FAHRENHEIT"><code>FAHRENHEIT</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="FAHRENHEIT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>FAHRENHEIT</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Temperature.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Temperature</a>&gt; FAHRENHEIT</pre>
<div class="block">Unit of measurement defined as 1.8 degree Celsius plus 32.
 The symbol is °F and the unlocalized name is “Fahrenheit”
 (note the upper-case "F" letter).

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>SI temperature units:</td> <td style="word-spacing:1em"><b><a href="#KELVIN"><code>KELVIN</code></a></b>.</td></tr>
   <tr><td>In other systems:</td>     <td style="word-spacing:1em"><a href="#CELSIUS"><code>CELSIUS</code></a>, <u><code>FAHRENHEIT</code></u>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="CANDELA">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>CANDELA</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/LuminousIntensity.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">LuminousIntensity</a>&gt; CANDELA</pre>
<div class="block">The SI base unit for luminous intensity (cd).
 The unlocalized name is “candela”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>Derived units:</td> <td style="word-spacing:1em"><a href="#LUMEN"><code>LUMEN</code></a>, <a href="#LUX"><code>LUX</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="LUMEN">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LUMEN</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/LuminousFlux.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">LuminousFlux</a>&gt; LUMEN</pre>
<div class="block">The SI derived unit for luminous flux (lm).
 The unlocalized name is “lumen”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>Components:</td> <td style="word-spacing:0.5em"><a href="#CANDELA"><code>CANDELA</code></a> ⋅ <a href="#STERADIAN"><code>STERADIAN</code></a></td></tr>
   <tr><td>Derived units:</td> <td style="word-spacing:1em"><a href="#LUX"><code>LUX</code></a>.</td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="LUX">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>LUX</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Illuminance.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Illuminance</a>&gt; LUX</pre>
<div class="block">The SI derived unit for illuminance (lx).
 The unlocalized name is “lux”.

 <div class="note">
 <table class="compact" style="margin-left:30px; line-height:1.25">
   <caption>Related units</caption>
   <tr><td>Components:</td> <td style="word-spacing:0.5em"><a href="#LUX"><code>LUX</code></a> ∕ <a href="#SQUARE_METRE"><code>SQUARE_METRE</code></a></td></tr>
 </table></div></div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="GRAM">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>GRAM</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Mass.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Mass</a>&gt; GRAM</pre>
<div class="block">A SI conventional unit for mass (g).
 The unlocalized name is “gram”.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="KILOGRAM">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>KILOGRAM</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Mass.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Mass</a>&gt; KILOGRAM</pre>
<div class="block">The SI base unit for mass (kg).
 The unlocalized name is “kilogram”.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="MOLE">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>MOLE</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/AmountOfSubstance.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">AmountOfSubstance</a>&gt; MOLE</pre>
<div class="block">The SI base unit for amount of substance (mol).
 The unlocalized name is “mole”.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="UNITY">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>UNITY</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Dimensionless.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Dimensionless</a>&gt; UNITY</pre>
<div class="block">The base dimensionless unit for scale measurements.
 The unlocalized name is “unity” and the identifier is EPSG:9201.
 This is the base of all other <a href="#isScale(javax.measure.Unit)">scale</a> units:

 <a href="#PERCENT"><code>PERCENT</code></a> (%),
 <a href="#PPM"><code>PPM</code></a> (ppm) and
 <a href="#PIXEL"><code>PIXEL</code></a> (px)
 among others.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="PERCENT">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PERCENT</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Dimensionless.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Dimensionless</a>&gt; PERCENT</pre>
<div class="block">Dimensionless unit for percentages (%).
 The system unit is <a href="#UNITY"><code>UNITY</code></a>
 and the unlocalized name is “percentage”.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#UNITY"><code>UNITY</code></a>, 
<a href="#PPM"><code>PPM</code></a></dd>
</dl>
</li>
</ul>
<a id="PPM">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PPM</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Dimensionless.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Dimensionless</a>&gt; PPM</pre>
<div class="block">Dimensionless unit for parts per million (ppm).
 The system unit is <a href="#UNITY"><code>UNITY</code></a>,
 the unlocalized name is “parts per million” and the identifier is EPSG:9202.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.3</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#UNITY"><code>UNITY</code></a>, 
<a href="#PERCENT"><code>PERCENT</code></a></dd>
</dl>
</li>
</ul>
<a id="DECIBEL">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>DECIBEL</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Dimensionless.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Dimensionless</a>&gt; DECIBEL</pre>
<div class="block">Sub-division of logarithm of ratio of the measured quantity to a reference quantity (dB).</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>1.0</dd>
</dl>
</li>
</ul>
<a id="PSU">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>PSU</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="Salinity.html" title="interface in org.apache.sis.measure">Salinity</a>&gt; PSU</pre>
<div class="block">Salinity measured using PSS-78. While this is a dimensionless measurement, the <code>"psu"</code> symbol
 is sometime added to PSS-78 measurement. However this is officially discouraged.</div>
<dl>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="PIXEL">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>PIXEL</h4>
<pre>public static final&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Dimensionless.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Dimensionless</a>&gt; PIXEL</pre>
<div class="block">Dimensionless unit for pixels (px).
 The unlocalized name is “pixel”.
 This unity should not be confused with <a href="#POINT"><code>POINT</code></a>, which is approximately equal to 1/72 of inch.</div>
<dl>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#POINT"><code>POINT</code></a></dd>
</dl>
</li>
</ul>
</li>
</ul>
</section>
<!-- ============ METHOD DETAIL ========== -->
<section role="region">
<ul class="blockList">
<li class="blockList"><a id="method.detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a id="isAngular(javax.measure.Unit)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isAngular</h4>
<pre class="methodSignature">public static&nbsp;boolean&nbsp;isAngular&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit)</pre>
<div class="block">Returns <code>true</code> if the given unit is a linear unit.
 Linear units are convertible to <a href="#DEGREE"><code>DEGREE</code></a>.

 <p>Angular units are dimensionless, which may be a cause of confusion with other
 dimensionless units like <a href="#UNITY"><code>UNITY</code></a> or <a href="#PPM"><code>PPM</code></a>. This method take care
 of differentiating angular units from other dimensionless units.</p></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>unit</code> - the unit to check (may be <code>null</code>).</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd><code>true</code> if the given unit is non-null and angular.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#ensureAngular(javax.measure.Unit)"><code>ensure­Angular(Unit)</code></a></dd>
</dl>
</li>
</ul>
<a id="isLinear(javax.measure.Unit)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isLinear</h4>
<pre class="methodSignature">public static&nbsp;boolean&nbsp;isLinear&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit)</pre>
<div class="block">Returns <code>true</code> if the given unit is a linear unit.
 Linear units are convertible to <a href="#METRE"><code>METRE</code></a>.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>unit</code> - the unit to check (may be <code>null</code>).</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd><code>true</code> if the given unit is non-null and linear.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#METRE"><code>METRE</code></a>, 
<a href="#ensureLinear(javax.measure.Unit)"><code>ensure­Linear(Unit)</code></a></dd>
</dl>
</li>
</ul>
<a id="isPressure(javax.measure.Unit)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isPressure</h4>
<pre class="methodSignature">public static&nbsp;boolean&nbsp;isPressure&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit)</pre>
<div class="block">Returns <code>true</code> if the given unit is a pressure unit.
 Pressure units are convertible to <a href="#PASCAL"><code>PASCAL</code></a>.
 Those units are sometime used instead of linear units for altitude measurements.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>unit</code> - the unit to check (may be <code>null</code>).</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd><code>true</code> if the given unit is non-null and a pressure unit.</dd>
</dl>
</li>
</ul>
<a id="isTemporal(javax.measure.Unit)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isTemporal</h4>
<pre class="methodSignature">public static&nbsp;boolean&nbsp;isTemporal&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit)</pre>
<div class="block">Returns <code>true</code> if the given unit is a temporal unit.
 Temporal units are convertible to <a href="#SECOND"><code>SECOND</code></a>.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>unit</code> - the unit to check (may be <code>null</code>).</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd><code>true</code> if the given unit is non-null and temporal.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#ensureTemporal(javax.measure.Unit)"><code>ensure­Temporal(Unit)</code></a></dd>
</dl>
</li>
</ul>
<a id="isScale(javax.measure.Unit)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>isScale</h4>
<pre class="methodSignature">public static&nbsp;boolean&nbsp;isScale&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit)</pre>
<div class="block">Returns <code>true</code> if the given unit is a dimensionless scale unit.
 This include <a href="#UNITY"><code>UNITY</code></a> and <a href="#PPM"><code>PPM</code></a>.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>unit</code> - the unit to check (may be <code>null</code>).</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd><code>true</code> if the given unit is non-null and a dimensionless scale.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#UNITY"><code>UNITY</code></a>, 
<a href="#ensureScale(javax.measure.Unit)"><code>ensure­Scale(Unit)</code></a></dd>
</dl>
</li>
</ul>
<a id="ensureAngular(javax.measure.Unit)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ensureAngular</h4>
<pre class="methodSignature">public static&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Angle.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Angle</a>&gt;&nbsp;ensureAngular&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit)
                                 throws <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang" class="externalLink">IllegalArgumentException</a></pre>
<div class="block">Makes sure that the specified unit is either null or an angular unit.
 This method is used for argument checks in constructors and setter methods.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>unit</code> - the unit to check, or <code>null</code> if none.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the given <code>unit</code> argument, which may be null.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang" class="externalLink">Illegal­Argument­Exception</a></code> - if <code>unit</code> is non-null and not an angular unit.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#isAngular(javax.measure.Unit)"><code>is­Angular(Unit)</code></a></dd>
</dl>
</li>
</ul>
<a id="ensureLinear(javax.measure.Unit)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ensureLinear</h4>
<pre class="methodSignature">public static&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Length.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Length</a>&gt;&nbsp;ensureLinear&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit)
                                 throws <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang" class="externalLink">IllegalArgumentException</a></pre>
<div class="block">Makes sure that the specified unit is either null or a linear unit.
 This method is used for argument checks in constructors and setter methods.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>unit</code> - the unit to check, or <code>null</code> if none.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the given <code>unit</code> argument, which may be null.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang" class="externalLink">Illegal­Argument­Exception</a></code> - if <code>unit</code> is non-null and not a linear unit.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#isLinear(javax.measure.Unit)"><code>is­Linear(Unit)</code></a></dd>
</dl>
</li>
</ul>
<a id="ensureTemporal(javax.measure.Unit)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ensureTemporal</h4>
<pre class="methodSignature">public static&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Time.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Time</a>&gt;&nbsp;ensureTemporal&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit)
                                 throws <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang" class="externalLink">IllegalArgumentException</a></pre>
<div class="block">Makes sure that the specified unit is either null or a temporal unit.
 This method is used for argument checks in constructors and setter methods.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>unit</code> - the unit to check, or <code>null</code> if none.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the given <code>unit</code> argument, which may be null.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang" class="externalLink">Illegal­Argument­Exception</a></code> - if <code>unit</code> is non-null and not a temporal unit.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#isTemporal(javax.measure.Unit)"><code>is­Temporal(Unit)</code></a></dd>
</dl>
</li>
</ul>
<a id="ensureScale(javax.measure.Unit)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ensureScale</h4>
<pre class="methodSignature">public static&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/quantity/Dimensionless.html?is-external=true" title="class or interface in javax.measure.quantity" class="externalLink">Dimensionless</a>&gt;&nbsp;ensureScale&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit)
                                       throws <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang" class="externalLink">IllegalArgumentException</a></pre>
<div class="block">Makes sure that the specified unit is either null or a scale unit.
 This method is used for argument checks in constructors and setter methods.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>unit</code> - the unit to check, or <code>null</code> if none.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the given <code>unit</code> argument, which may be null.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="https://docs.oracle.com/javase/8/docs/api/java/lang/IllegalArgumentException.html?is-external=true" title="class or interface in java.lang" class="externalLink">Illegal­Argument­Exception</a></code> - if <code>unit</code> is non-null and not a scale unit.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="#isScale(javax.measure.Unit)"><code>is­Scale(Unit)</code></a></dd>
</dl>
</li>
</ul>
<a id="multiply(javax.measure.Unit,double,double)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>multiply</h4>
<pre class="methodSignature">public static&nbsp;&lt;Q extends <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Quantity.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Quantity</a>&lt;Q&gt;&gt;&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;Q&gt;&nbsp;multiply&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;Q&gt;&nbsp;unit,
                                                       double&nbsp;numerator,
                                                       double&nbsp;denominator)</pre>
<div class="block">Multiplies the given unit by the given ratio. For example multiplying <a href="#CENTIMETRE"><code>CENTIMETRE</code></a> by 254/100 gives
 <a href="#INCH"><code>INCH</code></a>. Invoking this method is equivalent to invoking <code><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true#multiply(double)" title="class or interface in javax.measure" class="externalLink">Unit​.multiply</a>(numerator / denominator)</code> except that the use of a ration of integer values help
 Apache SIS to improve accuracy when more than one arithmetic operation are chained.</div>
<dl>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>Q</code> - the quantity measured by the unit.</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>unit</code> - the unit to multiply.</dd>
<dd><code>numerator</code> - the numerator of the multiplication factor.</dd>
<dd><code>denominator</code> - the denominator of the multiplication factor.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the unit multiplied by the given factor.</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="toStandardUnit(javax.measure.Unit)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>toStandardUnit</h4>
<pre class="methodSignature">public static&nbsp;&lt;Q extends <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Quantity.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Quantity</a>&lt;Q&gt;&gt;&nbsp;double&nbsp;toStandardUnit&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;Q&gt;&nbsp;unit)</pre>
<div class="block">Returns the factor by which to multiply the standard unit in order to get the given unit.
 The "standard" unit is usually the SI unit on which the given unit is based, as given by
 <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true#getSystemUnit()" title="class or interface in javax.measure" class="externalLink"><code>Unit​.get­System­Unit()</code></a>.

 <div class="note"><b>Example:</b>
 if the given unit is <a href="#KILOMETRE"><code>KILOMETRE</code></a>, then this method returns 1000 since a measurement in kilometres
 must be multiplied by 1000 in order to give the equivalent measurement in the "standard" units
 (here <a href="#METRE"><code>METRE</code></a>).</div>

 If the given unit is <code>null</code> or if the conversion to the "standard" unit can not be expressed
 by a single multiplication factor, then this method returns <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Double.html?is-external=true#NaN" title="class or interface in java.lang" class="externalLink"><code>Double​.Na­N</code></a>.</div>
<dl>
<dt><span class="paramLabel">Type Parameters:</span></dt>
<dd><code>Q</code> - the quantity measured by the unit, or <code>null</code>.</dd>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>unit</code> - the unit for which we want the multiplication factor to standard unit, or <code>null</code>.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the factor by which to multiply a measurement in the given unit in order to get an equivalent
         measurement in the standard unit, or NaN if the conversion can not be expressed by a scale factor.</dd>
</dl>
</li>
</ul>
<a id="converter(java.lang.Number,java.lang.Number)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>converter</h4>
<pre class="methodSignature">public static&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/UnitConverter.html?is-external=true" title="class or interface in javax.measure" class="externalLink">UnitConverter</a>&nbsp;converter&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Number.html?is-external=true" title="class or interface in java.lang" class="externalLink">Number</a>&nbsp;scale,
                                      <a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Number.html?is-external=true" title="class or interface in java.lang" class="externalLink">Number</a>&nbsp;offset)</pre>
<div class="block">Creates a linear converter from the given scale and offset.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>scale</code> - the scale factor, or <code>null</code> if none (default value of 1).</dd>
<dd><code>offset</code> - the offset, or <code>null</code> if none (default value of 0).</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>a converter for the given scale and offset.</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>1.0</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../referencing/operation/transform/MathTransforms.html#linear(double,double)"><code>Math­Transforms​.linear(double, double)</code></a></dd>
</dl>
</li>
</ul>
<a id="coefficients(javax.measure.UnitConverter)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>coefficients</h4>
<pre class="methodSignature">public static&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Number.html?is-external=true" title="class or interface in java.lang" class="externalLink">Number</a>[]&nbsp;coefficients&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/UnitConverter.html?is-external=true" title="class or interface in javax.measure" class="externalLink">UnitConverter</a>&nbsp;converter)</pre>
<div class="block">Returns the coefficients of the given converter expressed as a polynomial equation.
 This method returns the first of the following choices that apply:

 <ul>
   <li>If the given converter <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/UnitConverter.html?is-external=true#isIdentity()" title="class or interface in javax.measure" class="externalLink">is identity</a>, returns an empty array.</li>
   <li>If the given converter shifts the values without scaling them (for example the conversion from Kelvin to
       Celsius degrees), returns an array of length 1 containing only the offset.</li>
   <li>If the given converter scales the values (optionally in addition to shifting them), returns an array of
       length 2 containing the offset and scale factor, in that order.</li>
 </ul>

 This method returns <code>null</code> if it can not get the polynomial equation coefficients from the given converter.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>converter</code> - the converter from which to get the coefficients of the polynomial equation, or <code>null</code>.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the polynomial equation coefficients (may be any length, including zero), or <code>null</code> if the given
         converter is <code>null</code> or if this method can not get the coefficients.</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.8</dd>
</dl>
</li>
</ul>
<a id="derivative(javax.measure.UnitConverter,double)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>derivative</h4>
<pre class="methodSignature">public static&nbsp;double&nbsp;derivative&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/UnitConverter.html?is-external=true" title="class or interface in javax.measure" class="externalLink">UnitConverter</a>&nbsp;converter,
                                double&nbsp;value)</pre>
<div class="block">Returns the derivative of the given converter at the given value,
 or <code>Na­N</code> if this method can not compute it.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>converter</code> - the converter for which we want the derivative at a given point, or <code>null</code>.</dd>
<dd><code>value</code> - the point at which to compute the derivative.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the derivative at the given point, or <code>Na­N</code> if unknown.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../referencing/operation/transform/AbstractMathTransform.html#derivative(org.opengis.geometry.DirectPosition)"><code>Abstract­Math­Transform​.derivative(Direct­Position)</code></a></dd>
</dl>
</li>
</ul>
<a id="valueOf(java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>valueOf</h4>
<pre class="methodSignature">public static&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;valueOf&#8203;(<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang" class="externalLink">String</a>&nbsp;uom)
                       throws <a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/format/ParserException.html?is-external=true" title="class or interface in javax.measure.format" class="externalLink">ParserException</a></pre>
<div class="block">Parses the given symbol. Invoking this method is equivalent to invoking
 <a href="UnitFormat.html#parse(java.lang.CharSequence)"><code>Unit­Format​.parse(Char­Sequence)</code></a> on a shared locale-independent instance.
 This method is capable to handle some symbols found during WKT parsing or in XML files.
 The list of symbols supported by this method is implementation-dependent
 and may change in future SIS versions.

 <div class="section">Parsing authority codes</div>
 As a special case, if the given <code>uom</code> arguments is of the form <code>"EPSG:####"</code>
 or <code>"urn:ogc:def:uom:EPSG:####"</code> (ignoring case and whitespaces), then <code>"####"</code>
 is parsed as an integer and forwarded to the <a href="#valueOfEPSG(int)"><code>value­Of­EPSG(int)</code></a> method.

 <div class="section">NetCDF unit symbols</div>
 The attributes in netCDF files often merge the axis direction with the angular unit,
 as in <code>"degrees_east"</code> or <code>"degrees_north"</code>. This <code>value­Of</code> method
 ignores those suffixes and unconditionally returns <a href="#DEGREE"><code>DEGREE</code></a> for all axis directions.
 In particular, the units for <code>"degrees_west"</code> and <code>"degrees_east"</code>
 do <strong>not</strong> have opposite sign.
 It is caller responsibility to handle the direction of axes associated to netCDF units.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>uom</code> - the symbol to parse, or <code>null</code>.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the parsed symbol, or <code>null</code> if <code>uom</code> was null.</dd>
<dt><span class="throwsLabel">Throws:</span></dt>
<dd><code><a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/format/ParserException.html?is-external=true" title="class or interface in javax.measure.format" class="externalLink">Parser­Exception</a></code> - if the given symbol can not be parsed.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="UnitFormat.html#parse(java.lang.CharSequence)"><code>Unit­Format​.parse(Char­Sequence)</code></a></dd>
</dl>
</li>
</ul>
<a id="valueOfEPSG(int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>valueOfEPSG</h4>
<pre class="methodSignature">public static&nbsp;<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;valueOfEPSG&#8203;(int&nbsp;code)</pre>
<div class="block">Returns a hard-coded unit from an EPSG code. The <code>code</code> argument given to this method shall
 be a code identifying a record in the <code>"Unit of Measure"</code> table of the EPSG geodetic dataset.
 If this method does not recognize the given code, then it returns <code>null</code>.

 <p>The list of units recognized by this method is not exhaustive. This method recognizes
 the base units declared in the <code>TARGET_UOM_CODE</code> column of the above-cited table,
 and some frequently-used units. The list of recognized units may be updated in any future
 version of SIS.</p>

 <p>The <a href="../referencing/factory/sql/EPSGDataAccess.html" title="class in org.apache.sis.referencing.factory.sql"><code>EPSGData­Access</code></a> class uses this method
 for fetching the base units, and derives automatically other units from the information
 found in the EPSG database. This method is also used by other classes not directly related
 to the EPSG database, like <a href="../referencing/factory/CommonAuthorityFactory.html" title="class in org.apache.sis.referencing.factory"><code>Common­Authority­Factory</code></a>
 which uses EPSG codes for identifying units.</p>

 <p>The currently recognized values are:</p>
 <table class="sis">
   <caption>EPSG codes for units</caption>
   <tr>
     <td><table class="compact">
       <caption>Angular units</caption>
       <tr><td style="width: 40px"><b>Code</b></td><td><b>Unit</b></td></tr>
       <tr><td>9101</td><td>radian</td></tr>
       <tr><td>9102</td><td>decimal degree</td></tr>
       <tr><td>9103</td><td>minute</td></tr>
       <tr><td>9104</td><td>second</td></tr>
       <tr><td>9105</td><td>grad</td></tr>
       <tr><td>9107</td><td>degree-minute-second</td></tr>
       <tr><td>9108</td><td>degree-minute-second</td></tr>
       <tr><td>9109</td><td>microradian</td></tr>
       <tr><td>9110</td><td>sexagesimal degree-minute-second</td></tr>
       <tr><td>9111</td><td>sexagesimal degree-minute</td></tr>
       <tr><td>9122</td><td>decimal degree</td></tr>
     </table></td>
     <td class="sep"><table class="compact">
       <caption>Linear units</caption>
       <tr><td style="width: 40px"><b>Code</b></td><td><b>Unit</b></td></tr>
       <tr><td>1025</td><td>millimetre</td></tr>
       <tr><td>1033</td><td>centimetre</td></tr>
       <tr><td>9001</td><td>metre</td></tr>
       <tr><td>9002</td><td>foot</td></tr>
       <tr><td>9003</td><td>US survey foot</td></tr>
       <tr><td>9030</td><td>nautical mile</td></tr>
       <tr><td>9036</td><td>kilometre</td></tr>
       <tr><td>9093</td><td>statute mile</td></tr>
     </table></td>
     <td class="sep"><table class="compact">
       <caption>Time units</caption>
       <tr><td style="width: 40px"><b>Code</b></td><td><b>Unit</b></td></tr>
       <tr><td>1029</td><td>year</td></tr>
       <tr><td>1040</td><td>second</td></tr>
     </table></td>
     <td class="sep"><table class="compact">
       <caption>Scale units</caption>
       <tr><td style="width: 40px"><b>Code</b></td><td><b>Unit</b></td></tr>
       <tr><td>9201</td><td>unity</td></tr>
       <tr><td>9202</td><td>parts per million</td></tr>
       <tr><td>9203</td><td>unity</td></tr>
     </table></td>
   </tr>
 </table>

 <div class="note"><b>Note:</b>
 EPSG uses code 9102 (<cite>degree</cite>) for prime meridian and coordinate operation parameters,
 and code 9122 (<cite>degree (supplier to define representation)</cite>) for coordinate system axes.
 But Apache SIS considers those two codes as synonymous.</div></div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>code</code> - the EPSG code for a unit of measurement.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the unit, or <code>null</code> if the code is unrecognized.</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../referencing/factory/GeodeticAuthorityFactory.html#createUnit(java.lang.String)"><code>Geodetic­Authority­Factory​.create­Unit(String)</code></a></dd>
</dl>
</li>
</ul>
<a id="getEpsgCode(javax.measure.Unit,boolean)">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>getEpsgCode</h4>
<pre class="methodSignature">public static&nbsp;<a href="https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html?is-external=true" title="class or interface in java.lang" class="externalLink">Integer</a>&nbsp;getEpsgCode&#8203;(<a href="http://unitsofmeasurement.github.io/unit-api/site/apidocs/javax/measure/Unit.html?is-external=true" title="class or interface in javax.measure" class="externalLink">Unit</a>&lt;?&gt;&nbsp;unit,
                                  boolean&nbsp;inAxis)</pre>
<div class="block">Returns the EPSG code of the given units, or <code>null</code> if unknown.
 This method is the converse of <a href="#valueOfEPSG(int)"><code>value­Of­EPSG(int)</code></a>.

 <p>The same unit may be represented by different EPSG codes depending on the context:</p>
 <ul>
   <li>EPSG:9102 – <cite>degree</cite> – is used for prime meridian and coordinate operation parameters.</li>
   <li>EPSG:9122 – <cite>degree (supplier to define representation)</cite> – is used for coordinate system axes.</li>
 </ul>

 When such choice exists, the code to return is determined by the <code>in­Axis</code> argument,
 which specifies whether the code will be used for axis definition or in other context.</div>
<dl>
<dt><span class="paramLabel">Parameters:</span></dt>
<dd><code>unit</code> - the unit for which to get the EPSG code.</dd>
<dd><code>in­Axis</code> - <code>true</code> for a unit used in Coordinate System Axis definition.</dd>
<dt><span class="returnLabel">Returns:</span></dt>
<dd>the EPSG code of the given units, or <code>null</code> if unknown.</dd>
<dt><span class="simpleTagLabel">Since:</span></dt>
<dd>0.4</dd>
<dt><span class="seeLabel">See Also:</span></dt>
<dd><a href="../referencing/cs/CoordinateSystems.html#getEpsgCode(javax.measure.Unit,org.opengis.referencing.cs.AxisDirection...)"><code>Coordinate­Systems​.get­Epsg­Code(Unit, Axis­Direction...)</code></a></dd>
</dl>
</li>
</ul>
</li>
</ul>
</section>
</li>
</ul>
</div>
</div>
</main>
<!-- ========= END OF CLASS DATA ========= -->
<footer role="contentinfo">
<nav role="navigation">
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a id="navbar.bottom">
<!--   -->
</a>
<div class="skipNav"><a href="#skip.navbar.bottom" title="Skip navigation links">Skip navigation links</a></div>
<a id="navbar.bottom.firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/Units.html">Use</a></li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../index-all.html">Index</a></li>
<li><a href="../../../../help-doc.html">Help</a></li>
</ul>
</div>
<div class="subNav">
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../../allclasses.html">All&nbsp;Classes</a></li>
</ul>
<div>
<script type="text/javascript"><!--
  allClassesLink = document.getElementById("allclasses_navbar_bottom");
  if(window==top) {
    allClassesLink.style.display = "block";
  }
  else {
    allClassesLink.style.display = "none";
  }
  //-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li><a href="#field.summary">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li><a href="#field.detail">Field</a>&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method.detail">Method</a></li>
</ul>
</div>
<a id="skip.navbar.bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
</nav>
<p class="legalCopy"><small>Copyright &#169; 2010&#x2013;2019 <a href="https://www.apache.org/">The Apache Software Foundation</a>. All rights reserved.</small></p>
</footer>
</body>
</html>
