<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!-- NewPage -->
<html lang="en">
<head>
<!-- Generated by javadoc (version 1.7.0_80) on Mon Jun 05 11:32:43 EDT 2017 -->
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Maths (The Eclipse January API Documentation)</title>
<meta name="date" content="2017-06-05">
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
</head>
<body>
<script type="text/javascript"><!--
    if (location.href.indexOf('is-external=true') == -1) {
        parent.document.title="Maths (The Eclipse January API Documentation)";
    }
//-->
</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="topNav"><a name="navbar_top">
<!--   -->
</a><a href="#skip-navbar_top" title="Skip navigation links"></a><a name="navbar_top_firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/Maths.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">
<li><a href="../../../../org/eclipse/january/dataset/LongDataset.html" title="class in org.eclipse.january.dataset"><span class="strong">Prev Class</span></a></li>
<li><a href="../../../../org/eclipse/january/dataset/NullIterator.html" title="class in org.eclipse.january.dataset"><span class="strong">Next Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../index.html?org/eclipse/january/dataset/Maths.html" target="_top">Frames</a></li>
<li><a href="Maths.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_top">
<li><a href="../../../../allclasses-noframe.html">All Classes</a></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>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method_summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method_detail">Method</a></li>
</ul>
</div>
<a name="skip-navbar_top">
<!--   -->
</a></div>
<!-- ========= END OF TOP NAVBAR ========= -->
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="subTitle">org.eclipse.january.dataset</div>
<h2 title="Class Maths" class="title">Class Maths</h2>
</div>
<div class="contentContainer">
<ul class="inheritance">
<li><a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">java.lang.Object</a></li>
<li>
<ul class="inheritance">
<li>org.eclipse.january.dataset.Maths</li>
</ul>
</li>
</ul>
<div class="description">
<ul class="blockList">
<li class="blockList">
<hr>
<br>
<pre>public class <a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.26">Maths</a>
extends <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></pre>
<div class="block">Mathematics class</div>
</li>
</ul>
</div>
<div class="summary">
<ul class="blockList">
<li class="blockList">
<!-- ======== CONSTRUCTOR SUMMARY ======== -->
<ul class="blockList">
<li class="blockList"><a name="constructor_summary">
<!--   -->
</a>
<h3>Constructor Summary</h3>
<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Constructor Summary table, listing constructors, and an explanation">
<caption><span>Constructors</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colOne" scope="col">Constructor and Description</th>
</tr>
<tr class="altColor">
<td class="colOne"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#Maths()">Maths</a></strong>()</code>&nbsp;</td>
</tr>
</table>
</li>
</ul>
<!-- ========== METHOD SUMMARY =========== -->
<ul class="blockList">
<li class="blockList"><a name="method_summary">
<!--   -->
</a>
<h3>Method Summary</h3>
<table class="overviewSummary" border="0" cellpadding="3" cellspacing="0" summary="Method Summary table, listing methods, and an explanation">
<caption><span>Methods</span><span class="tabEnd">&nbsp;</span></caption>
<tr>
<th class="colFirst" scope="col">Modifier and Type</th>
<th class="colLast" scope="col">Method and Description</th>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#abs(java.lang.Object)">abs</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">abs - absolute value of each element</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#abs(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">abs</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
      <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">abs - absolute value of each element</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#add(java.util.Collection,%20boolean)">add</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="../../../../org/eclipse/january/dataset/IDataset.html" title="interface in org.eclipse.january.dataset">IDataset</a>&gt;&nbsp;sets,
      boolean&nbsp;requireClone)</code>
<div class="block">Adds all sets passed in together
 
 The first IDataset must cast to Dataset
 
 For memory efficiency sake if add(...) is called with a
 set of size one, no clone is done, the original object is
 returned directly.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#add(java.lang.Object,%20java.lang.Object)">add</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
      <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>
<div class="block">add operator</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#add(java.lang.Object,%20java.lang.Object,%20org.eclipse.january.dataset.Dataset)">add</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
      <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
      <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">add operator</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>protected static void</code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#addBinaryOperatorName(org.eclipse.january.dataset.Dataset,%20org.eclipse.january.dataset.Dataset,%20org.eclipse.january.dataset.Dataset,%20java.lang.String)">addBinaryOperatorName</a></strong>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;a,
                                          <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;b,
                                          <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;dataset,
                                          <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;oname)</code>&nbsp;</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>protected static void</code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#addFunctionName(org.eclipse.january.dataset.Dataset,%20org.eclipse.january.dataset.Dataset,%20org.eclipse.january.dataset.Dataset,%20java.lang.String)">addFunctionName</a></strong>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;a,
                              <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;b,
                              <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;dataset,
                              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;fname)</code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>protected static void</code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#addFunctionName(org.eclipse.january.dataset.Dataset,%20java.lang.String)">addFunctionName</a></strong>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;dataset,
                              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;fname)</code>&nbsp;</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#angle(java.lang.Object)">angle</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">Create a dataset of the arguments from a complex dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#angle(java.lang.Object,%20boolean)">angle</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
          boolean&nbsp;inDegrees)</code>
<div class="block">Create a dataset of the arguments from a complex dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#angle(java.lang.Object,%20boolean,%20org.eclipse.january.dataset.Dataset)">angle</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
          boolean&nbsp;inDegrees,
          <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">Create a dataset of the arguments from a complex dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#angle(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">angle</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
          <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">Create a dataset of the arguments from a complex dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#arccos(java.lang.Object)">arccos</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">arccos - evaluate the inverse cosine function on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#arccos(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">arccos</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
            <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">arccos - evaluate the inverse cosine function on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#arccosh(java.lang.Object)">arccosh</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">arccosh - evaluate the inverse hyperbolic cosine function on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#arccosh(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">arccosh</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">arccosh - evaluate the inverse hyperbolic cosine function on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#arcsin(java.lang.Object)">arcsin</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">arcsin - evaluate the inverse sine function on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#arcsin(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">arcsin</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
            <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">arcsin - evaluate the inverse sine function on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#arcsinh(java.lang.Object)">arcsinh</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">arcsinh - evaluate the inverse hyperbolic sine function on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#arcsinh(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">arcsinh</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">arcsinh - evaluate the inverse hyperbolic sine function on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#arctan(java.lang.Object)">arctan</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">arctan - evaluate the inverse tangent function on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#arctan(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">arctan</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
            <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">arctan - evaluate the inverse tangent function on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#arctan2(java.lang.Object,%20java.lang.Object)">arctan2</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#arctan2(java.lang.Object,%20java.lang.Object,%20org.eclipse.january.dataset.Dataset)">arctan2</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
              <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>&nbsp;</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#arctanh(java.lang.Object)">arctanh</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">arctanh - evaluate the inverse hyperbolic tangent function on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#arctanh(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">arctanh</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">arctanh - evaluate the inverse hyperbolic tangent function on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#bitwiseAnd(java.lang.Object,%20java.lang.Object)">bitwiseAnd</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                    <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>
<div class="block">bitwiseAnd operator</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#bitwiseAnd(java.lang.Object,%20java.lang.Object,%20org.eclipse.january.dataset.Dataset)">bitwiseAnd</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                    <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                    <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">bitwiseAnd operator</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#bitwiseInvert(java.lang.Object)">bitwiseInvert</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">bitwiseInvert - ~a, bitwise invert (or NOT) each element</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#bitwiseInvert(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">bitwiseInvert</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                          <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">bitwiseInvert - ~a, bitwise invert (or NOT) each element</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#bitwiseOr(java.lang.Object,%20java.lang.Object)">bitwiseOr</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                  <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>
<div class="block">bitwiseOr operator</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#bitwiseOr(java.lang.Object,%20java.lang.Object,%20org.eclipse.january.dataset.Dataset)">bitwiseOr</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                  <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                  <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">bitwiseOr operator</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#bitwiseXor(java.lang.Object,%20java.lang.Object)">bitwiseXor</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                    <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>
<div class="block">bitwiseXor operator</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#bitwiseXor(java.lang.Object,%20java.lang.Object,%20org.eclipse.january.dataset.Dataset)">bitwiseXor</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                    <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                    <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">bitwiseXor operator</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#cbrt(java.lang.Object)">cbrt</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">cbrt - evaluate the cube root function on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#cbrt(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">cbrt</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
        <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">cbrt - evaluate the cube root function on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#ceil(java.lang.Object)">ceil</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">ceil - evaluate the ceiling function on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#ceil(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">ceil</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
        <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">ceil - evaluate the ceiling function on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#centralDifference(org.eclipse.january.dataset.Dataset,%20int)">centralDifference</a></strong>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;a,
                                  int&nbsp;axis)</code>
<div class="block">Discrete difference of dataset along axis using finite central difference</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#clip(java.lang.Object,%20org.eclipse.january.dataset.Dataset,%20java.lang.Object,%20java.lang.Object)">clip</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
        <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o,
        <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;pa,
        <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;pb)</code>
<div class="block">clip - clip elements to limits</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#clip(java.lang.Object,%20java.lang.Object,%20java.lang.Object)">clip</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
        <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;pa,
        <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;pb)</code>
<div class="block">clip - clip elements to limits</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#conjugate(java.lang.Object)">conjugate</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>&nbsp;</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#conjugate(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">conjugate</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                  <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#cos(java.lang.Object)">cos</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">cos - evaluate the cosine function on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#cos(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">cos</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
      <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">cos - evaluate the cosine function on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#cosh(java.lang.Object)">cosh</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">cosh - evaluate the hyperbolic cosine function on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#cosh(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">cosh</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
        <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">cosh - evaluate the hyperbolic cosine function on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#derivative(org.eclipse.january.dataset.Dataset,%20org.eclipse.january.dataset.Dataset,%20int)">derivative</a></strong>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;x,
                    <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;y,
                    int&nbsp;n)</code>
<div class="block">Calculates the derivative of a line described by two datasets (x,y) given a spread of n either
 side of the point</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#difference(org.eclipse.january.dataset.Dataset,%20int,%20int)">difference</a></strong>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;a,
                    int&nbsp;n,
                    int&nbsp;axis)</code>
<div class="block">Discrete difference of dataset along axis using finite difference</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#divide(java.lang.Object,%20java.lang.Object)">divide</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
            <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>
<div class="block">divide operator</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#divide(java.lang.Object,%20java.lang.Object,%20org.eclipse.january.dataset.Dataset)">divide</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
            <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
            <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">divide operator</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#divideTowardsFloor(java.lang.Object,%20java.lang.Object)">divideTowardsFloor</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                                    <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>
<div class="block">divideTowardsFloor operator</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#divideTowardsFloor(java.lang.Object,%20java.lang.Object,%20org.eclipse.january.dataset.Dataset)">divideTowardsFloor</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                                    <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                                    <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">divideTowardsFloor operator</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#dividez(java.lang.Object,%20java.lang.Object)">dividez</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>
<div class="block">dividez operator</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#dividez(java.lang.Object,%20java.lang.Object,%20org.eclipse.january.dataset.Dataset)">dividez</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
              <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">dividez operator</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#exp(java.lang.Object)">exp</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">exp - evaluate the exponential function on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#exp(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">exp</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
      <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">exp - evaluate the exponential function on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#expm1(java.lang.Object)">expm1</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">expm1 - evaluate the exponential function - 1 on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#expm1(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">expm1</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
          <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">expm1 - evaluate the exponential function - 1 on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#floor(java.lang.Object)">floor</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">floor - evaluate the floor function on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#floor(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">floor</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
          <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">floor - evaluate the floor function on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#floorDivide(java.lang.Object,%20java.lang.Object)">floorDivide</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                      <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>&nbsp;</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#floorDivide(java.lang.Object,%20java.lang.Object,%20org.eclipse.january.dataset.Dataset)">floorDivide</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                      <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                      <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#floorRemainder(java.lang.Object,%20java.lang.Object)">floorRemainder</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                            <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>&nbsp;</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#floorRemainder(java.lang.Object,%20java.lang.Object,%20org.eclipse.january.dataset.Dataset)">floorRemainder</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                            <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                            <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#getBilinear(double[],%20org.eclipse.january.dataset.CompoundDataset,%20double,%20double)">getBilinear</a></strong>(double[]&nbsp;values,
                      <a href="../../../../org/eclipse/january/dataset/CompoundDataset.html" title="interface in org.eclipse.january.dataset">CompoundDataset</a>&nbsp;d,
                      double&nbsp;x0,
                      double&nbsp;x1)</code>
<div class="block"><strong>Deprecated.</strong>&nbsp;
<div class="block"><i>Use <a href="../../../../org/eclipse/january/dataset/Maths.html#interpolate(double[],%20org.eclipse.january.dataset.CompoundDataset,%20double,%20double)"><code>interpolate(double[], CompoundDataset, double, double)</code></a></i></div>
</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static double</code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#getBilinear(org.eclipse.january.dataset.IDataset,%20double,%20double)">getBilinear</a></strong>(<a href="../../../../org/eclipse/january/dataset/IDataset.html" title="interface in org.eclipse.january.dataset">IDataset</a>&nbsp;d,
                      double&nbsp;x0,
                      double&nbsp;x1)</code>
<div class="block"><strong>Deprecated.</strong>&nbsp;
<div class="block"><i>Use <a href="../../../../org/eclipse/january/dataset/Maths.html#interpolate(org.eclipse.january.dataset.Dataset,%20double,%20double)"><code>interpolate(Dataset, double, double)</code></a></i></div>
</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static double</code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#getBilinear(org.eclipse.january.dataset.IDataset,%20org.eclipse.january.dataset.IDataset,%20double,%20double)">getBilinear</a></strong>(<a href="../../../../org/eclipse/january/dataset/IDataset.html" title="interface in org.eclipse.january.dataset">IDataset</a>&nbsp;d,
                      <a href="../../../../org/eclipse/january/dataset/IDataset.html" title="interface in org.eclipse.january.dataset">IDataset</a>&nbsp;m,
                      double&nbsp;x0,
                      double&nbsp;x1)</code>
<div class="block"><strong>Deprecated.</strong>&nbsp;
<div class="block"><i>Use <a href="../../../../org/eclipse/january/dataset/Maths.html#interpolate(org.eclipse.january.dataset.Dataset,%20org.eclipse.january.dataset.Dataset,%20double,%20double)"><code>interpolate(Dataset, Dataset, double, double)</code></a></i></div>
</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#getLinear(double[],%20org.eclipse.january.dataset.CompoundDataset,%20double)">getLinear</a></strong>(double[]&nbsp;values,
                  <a href="../../../../org/eclipse/january/dataset/CompoundDataset.html" title="interface in org.eclipse.january.dataset">CompoundDataset</a>&nbsp;d,
                  double&nbsp;x0)</code>
<div class="block"><strong>Deprecated.</strong>&nbsp;
<div class="block"><i>Use <a href="../../../../org/eclipse/january/dataset/Maths.html#interpolate(double[],%20org.eclipse.january.dataset.CompoundDataset,%20double)"><code>interpolate(double[], CompoundDataset, double)</code></a></i></div>
</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static double</code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#getLinear(org.eclipse.january.dataset.IDataset,%20double)">getLinear</a></strong>(<a href="../../../../org/eclipse/january/dataset/IDataset.html" title="interface in org.eclipse.january.dataset">IDataset</a>&nbsp;d,
                  double&nbsp;x0)</code>
<div class="block"><strong>Deprecated.</strong>&nbsp;
<div class="block"><i>Use <a href="../../../../org/eclipse/january/dataset/Maths.html#interpolate(org.eclipse.january.dataset.Dataset,%20double)"><code>interpolate(Dataset, double)</code></a></i></div>
</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&gt;</code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#gradient(org.eclipse.january.dataset.Dataset,%20org.eclipse.january.dataset.Dataset...)">gradient</a></strong>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;y,
                <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>...&nbsp;x)</code>
<div class="block">Calculate gradient (or partial derivatives) by central difference</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#hypot(java.lang.Object,%20java.lang.Object)">hypot</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
          <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>&nbsp;</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#hypot(java.lang.Object,%20java.lang.Object,%20org.eclipse.january.dataset.Dataset)">hypot</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
          <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
          <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static double</code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#interpolate(org.eclipse.january.dataset.Dataset,%20org.eclipse.january.dataset.Dataset,%20double...)">interpolate</a></strong>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;d,
                      <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;m,
                      double...&nbsp;x)</code>
<div class="block">Linearly interpolate a value at a point in a n-D dataset with a mask.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static double</code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#interpolate(org.eclipse.january.dataset.Dataset,%20org.eclipse.january.dataset.Dataset,%20double)">interpolate</a></strong>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;d,
                      <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;m,
                      double&nbsp;x0)</code>
<div class="block">Linearly interpolate a value at a point in a 1D dataset with a mask.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static double</code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#interpolate(org.eclipse.january.dataset.Dataset,%20org.eclipse.january.dataset.Dataset,%20double,%20double)">interpolate</a></strong>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;d,
                      <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;m,
                      double&nbsp;x0,
                      double&nbsp;x1)</code>
<div class="block">Linearly interpolate a value at a point in a 2D dataset with a mask.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#interpolate(org.eclipse.january.dataset.Dataset,%20org.eclipse.january.dataset.Dataset,%20org.eclipse.january.dataset.IDataset,%20java.lang.Number,%20java.lang.Number)">interpolate</a></strong>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;x,
                      <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;d,
                      <a href="../../../../org/eclipse/january/dataset/IDataset.html" title="interface in org.eclipse.january.dataset">IDataset</a>&nbsp;x0,
                      <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Number.html?is-external=true" title="class or interface in java.lang">Number</a>&nbsp;left,
                      <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Number.html?is-external=true" title="class or interface in java.lang">Number</a>&nbsp;right)</code>
<div class="block">Linearly interpolate values at points in a 1D dataset corresponding to given coordinates.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static double</code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#interpolate(org.eclipse.january.dataset.Dataset,%20double...)">interpolate</a></strong>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;d,
                      double...&nbsp;x)</code>
<div class="block">Linearly interpolate a value at a point in a n-D dataset.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static double</code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#interpolate(org.eclipse.january.dataset.Dataset,%20double)">interpolate</a></strong>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;d,
                      double&nbsp;x0)</code>
<div class="block">Linearly interpolate a value at a point in a 1D dataset.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static double</code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#interpolate(org.eclipse.january.dataset.Dataset,%20double,%20double)">interpolate</a></strong>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;d,
                      double&nbsp;x0,
                      double&nbsp;x1)</code>
<div class="block">Linearly interpolate a value at a point in a 2D dataset.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#interpolate(double[],%20org.eclipse.january.dataset.CompoundDataset,%20double...)">interpolate</a></strong>(double[]&nbsp;values,
                      <a href="../../../../org/eclipse/january/dataset/CompoundDataset.html" title="interface in org.eclipse.january.dataset">CompoundDataset</a>&nbsp;d,
                      double...&nbsp;x)</code>
<div class="block">Linearly interpolate an array of values at a point in a compound n-D dataset.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#interpolate(double[],%20org.eclipse.january.dataset.CompoundDataset,%20double)">interpolate</a></strong>(double[]&nbsp;values,
                      <a href="../../../../org/eclipse/january/dataset/CompoundDataset.html" title="interface in org.eclipse.january.dataset">CompoundDataset</a>&nbsp;d,
                      double&nbsp;x0)</code>
<div class="block">Linearly interpolate an array of values at a point in a compound 1D dataset.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static void</code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#interpolate(double[],%20org.eclipse.january.dataset.CompoundDataset,%20double,%20double)">interpolate</a></strong>(double[]&nbsp;values,
                      <a href="../../../../org/eclipse/january/dataset/CompoundDataset.html" title="interface in org.eclipse.january.dataset">CompoundDataset</a>&nbsp;d,
                      double&nbsp;x0,
                      double&nbsp;x1)</code>
<div class="block">Linearly interpolate an array of values at a point in a compound 2D dataset.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#leftShift(java.lang.Object,%20java.lang.Object)">leftShift</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                  <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>
<div class="block">leftShift operator</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#leftShift(java.lang.Object,%20java.lang.Object,%20org.eclipse.january.dataset.Dataset)">leftShift</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                  <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                  <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">leftShift operator</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#log(java.lang.Object)">log</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">log - evaluate the logarithm function on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#log(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">log</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
      <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">log - evaluate the logarithm function on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#log10(java.lang.Object)">log10</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">log10 - evaluate the logarithm function on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#log10(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">log10</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
          <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">log10 - evaluate the logarithm function on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#log1p(java.lang.Object)">log1p</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">log1p - evaluate the logarithm function of 1 plus on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#log1p(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">log1p</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
          <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">log1p - evaluate the logarithm function of 1 plus on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#log2(java.lang.Object)">log2</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">log2 - evaluate the logarithm function on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#log2(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">log2</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
        <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">log2 - evaluate the logarithm function on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#maximum(java.lang.Object,%20java.lang.Object)">maximum</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>
<div class="block">maximum operator</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#maximum(java.lang.Object,%20java.lang.Object,%20org.eclipse.january.dataset.Dataset)">maximum</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
              <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">maximum operator</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#minimum(java.lang.Object,%20java.lang.Object)">minimum</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>
<div class="block">minimum operator</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#minimum(java.lang.Object,%20java.lang.Object,%20org.eclipse.january.dataset.Dataset)">minimum</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
              <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">minimum operator</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#multiply(java.util.Collection,%20boolean)">multiply</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="../../../../org/eclipse/january/dataset/IDataset.html" title="interface in org.eclipse.january.dataset">IDataset</a>&gt;&nbsp;sets,
                boolean&nbsp;requireClone)</code>
<div class="block">Multiplies all sets passed in together
 
 The first IDataset must cast to Dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#multiply(java.lang.Object,%20java.lang.Object)">multiply</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>
<div class="block">multiply operator</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#multiply(java.lang.Object,%20java.lang.Object,%20org.eclipse.january.dataset.Dataset)">multiply</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">multiply operator</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#negative(java.lang.Object)">negative</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">negative - negative value of each element</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#negative(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">negative</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">negative - negative value of each element</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#phaseAsComplexNumber(java.lang.Object,%20boolean)">phaseAsComplexNumber</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                                        boolean&nbsp;keepZeros)</code>
<div class="block">Create a phase only dataset.</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#phaseAsComplexNumber(java.lang.Object,%20org.eclipse.january.dataset.Dataset,%20boolean)">phaseAsComplexNumber</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                                        <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o,
                                        boolean&nbsp;keepZeros)</code>
<div class="block">Create a phase only dataset.</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#power(java.lang.Object,%20java.lang.Object)">power</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
          <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>
<div class="block">power operator</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#power(java.lang.Object,%20java.lang.Object,%20org.eclipse.january.dataset.Dataset)">power</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
          <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
          <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">power operator</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#reciprocal(java.lang.Object)">reciprocal</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">Find reciprocal from dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#reciprocal(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">reciprocal</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                    <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">Find reciprocal from dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#remainder(java.lang.Object,%20java.lang.Object)">remainder</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                  <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>
<div class="block">remainder operator</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#remainder(java.lang.Object,%20java.lang.Object,%20org.eclipse.january.dataset.Dataset)">remainder</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                  <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                  <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">remainder operator</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#rightShift(java.lang.Object,%20java.lang.Object)">rightShift</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                    <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>
<div class="block">rightShift operator</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#rightShift(java.lang.Object,%20java.lang.Object,%20org.eclipse.january.dataset.Dataset)">rightShift</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                    <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                    <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">rightShift operator</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#rint(java.lang.Object)">rint</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">rint - round each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#rint(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">rint</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
        <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">rint - round each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#signum(java.lang.Object)">signum</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">signum - sign of each element</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#signum(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">signum</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
            <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">signum - sign of each element</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#sin(java.lang.Object)">sin</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">sin - evaluate the sine function on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#sin(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">sin</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
      <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">sin - evaluate the sine function on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#sinh(java.lang.Object)">sinh</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">sinh - evaluate the hyperbolic sine function on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#sinh(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">sinh</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
        <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">sinh - evaluate the hyperbolic sine function on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#sqrt(java.lang.Object)">sqrt</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">sqrt - evaluate the square root function on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#sqrt(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">sqrt</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
        <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">sqrt - evaluate the square root function on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#square(java.lang.Object)">square</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">square - square each element</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#square(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">square</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
            <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">square - square each element</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#subtract(java.lang.Object,%20java.lang.Object)">subtract</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>
<div class="block">subtract operator</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#subtract(java.lang.Object,%20java.lang.Object,%20org.eclipse.january.dataset.Dataset)">subtract</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">subtract operator</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#tan(java.lang.Object)">tan</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">tan - evaluate the tangent function on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#tan(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">tan</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
      <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">tan - evaluate the tangent function on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#tanh(java.lang.Object)">tanh</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">tanh - evaluate the tangent hyperbolic function on each element of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#tanh(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">tanh</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
        <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">tanh - evaluate the tangent hyperbolic function on each element of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#toDegrees(java.lang.Object)">toDegrees</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">toDegrees - convert to degrees</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#toDegrees(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">toDegrees</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                  <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">toDegrees - convert to degrees</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>protected static long</code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#toLong(double)">toLong</a></strong>(double&nbsp;d)</code>&nbsp;</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#toRadians(java.lang.Object)">toRadians</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">toRadians - convert to radians</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#toRadians(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">toRadians</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                  <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">toRadians - convert to radians</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#truncate(java.lang.Object)">truncate</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">truncate - truncate each element to integers of the dataset</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#truncate(java.lang.Object,%20org.eclipse.january.dataset.Dataset)">truncate</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">truncate - truncate each element to integers of the dataset</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#unsignedRightShift(java.lang.Object,%20java.lang.Object)">unsignedRightShift</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                                    <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>
<div class="block">unsignedRightShift operator</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#unsignedRightShift(java.lang.Object,%20java.lang.Object,%20org.eclipse.january.dataset.Dataset)">unsignedRightShift</a></strong>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                                    <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                                    <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</code>
<div class="block">unsignedRightShift operator</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#unwrap(org.eclipse.january.dataset.Dataset,%20java.lang.Object...)">unwrap</a></strong>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o,
            <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>...&nbsp;a)</code>
<div class="block">Unwrap result from mathematical methods if necessary</div>
</td>
</tr>
<tr class="altColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#unwrap(org.eclipse.january.dataset.Dataset,%20java.lang.Object)">unwrap</a></strong>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o,
            <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</code>
<div class="block">Unwrap result from mathematical methods if necessary</div>
</td>
</tr>
<tr class="rowColor">
<td class="colFirst"><code>static <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></code></td>
<td class="colLast"><code><strong><a href="../../../../org/eclipse/january/dataset/Maths.html#unwrap(org.eclipse.january.dataset.Dataset,%20java.lang.Object,%20java.lang.Object)">unwrap</a></strong>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o,
            <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
            <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</code>
<div class="block">Unwrap result from mathematical methods if necessary</div>
</td>
</tr>
</table>
<ul class="blockList">
<li class="blockList"><a name="methods_inherited_from_class_java.lang.Object">
<!--   -->
</a>
<h3>Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a></h3>
<code><a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#clone()" title="class or interface in java.lang">clone</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#equals(java.lang.Object)" title="class or interface in java.lang">equals</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#finalize()" title="class or interface in java.lang">finalize</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#getClass()" title="class or interface in java.lang">getClass</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#hashCode()" title="class or interface in java.lang">hashCode</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#notify()" title="class or interface in java.lang">notify</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#notifyAll()" title="class or interface in java.lang">notifyAll</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#toString()" title="class or interface in java.lang">toString</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#wait()" title="class or interface in java.lang">wait</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#wait(long)" title="class or interface in java.lang">wait</a>, <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true#wait(long,%20int)" title="class or interface in java.lang">wait</a></code></li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
<div class="details">
<ul class="blockList">
<li class="blockList">
<!-- ========= CONSTRUCTOR DETAIL ======== -->
<ul class="blockList">
<li class="blockList"><a name="constructor_detail">
<!--   -->
</a>
<h3>Constructor Detail</h3>
<a name="Maths()">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>Maths</h4>
<pre>public&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.26">Maths</a>()</pre>
</li>
</ul>
</li>
</ul>
<!-- ============ METHOD DETAIL ========== -->
<ul class="blockList">
<li class="blockList"><a name="method_detail">
<!--   -->
</a>
<h3>Method Detail</h3>
<a name="unwrap(org.eclipse.january.dataset.Dataset, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>unwrap</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.33">unwrap</a>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o,
            <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">Unwrap result from mathematical methods if necessary</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>o</code> - </dd><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>a dataset if a is a dataset or an object of the same class as o</dd></dl>
</li>
</ul>
<a name="unwrap(org.eclipse.january.dataset.Dataset, java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>unwrap</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.43">unwrap</a>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o,
            <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
            <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<div class="block">Unwrap result from mathematical methods if necessary</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>o</code> - </dd><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>a dataset if either a and b are datasets or an object of the same class as o</dd></dl>
</li>
</ul>
<a name="unwrap(org.eclipse.january.dataset.Dataset, java.lang.Object...)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>unwrap</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.53">unwrap</a>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o,
            <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>...&nbsp;a)</pre>
<div class="block">Unwrap result from mathematical methods if necessary</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>o</code> - </dd><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>a dataset if any inputs are datasets or an object of the same class as o</dd></dl>
</li>
</ul>
<a name="floorDivide(java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>floorDivide</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.69">floorDivide</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                  <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>floor divide of a and b</dd></dl>
</li>
</ul>
<a name="floorDivide(java.lang.Object, java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>floorDivide</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.79">floorDivide</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                  <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                  <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>floor divide of a and b</dd></dl>
</li>
</ul>
<a name="floorRemainder(java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>floorRemainder</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.88">floorRemainder</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                     <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>floor remainder of a and b</dd></dl>
</li>
</ul>
<a name="floorRemainder(java.lang.Object, java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>floorRemainder</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.98">floorRemainder</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                     <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                     <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>floor remainder of a and b</dd></dl>
</li>
</ul>
<a name="reciprocal(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>reciprocal</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.111">reciprocal</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">Find reciprocal from dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>reciprocal dataset</dd></dl>
</li>
</ul>
<a name="reciprocal(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>reciprocal</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.121">reciprocal</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                 <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">Find reciprocal from dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>reciprocal dataset</dd></dl>
</li>
</ul>
<a name="abs(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>abs</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.131">abs</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">abs - absolute value of each element</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="abs(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>abs</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.141">abs</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
          <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">abs - absolute value of each element</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="conjugate(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>conjugate</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.384">conjugate</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>a^*, complex conjugate of a</dd></dl>
</li>
</ul>
<a name="conjugate(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>conjugate</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.393">conjugate</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>a^*, complex conjugate of a</dd></dl>
</li>
</ul>
<a name="hypot(java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>hypot</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.432">hypot</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
            <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - side of right-angled triangle</dd><dd><code>b</code> - side of right-angled triangle</dd>
<dt><span class="strong">Returns:</span></dt><dd>hypotenuse of right-angled triangle: sqrt(a^2 + a^2)</dd></dl>
</li>
</ul>
<a name="hypot(java.lang.Object, java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>hypot</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.442">hypot</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
            <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
            <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - side of right-angled triangle</dd><dd><code>b</code> - side of right-angled triangle</dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>hypotenuse of right-angled triangle: sqrt(a^2 + a^2)</dd></dl>
</li>
</ul>
<a name="arctan2(java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>arctan2</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.696">arctan2</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - opposite side of right-angled triangle</dd><dd><code>b</code> - adjacent side of right-angled triangle</dd>
<dt><span class="strong">Returns:</span></dt><dd>angle of triangle: atan(b/a)</dd></dl>
</li>
</ul>
<a name="arctan2(java.lang.Object, java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>arctan2</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.706">arctan2</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
              <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - opposite side of right-angled triangle</dd><dd><code>b</code> - adjacent side of right-angled triangle</dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>angle of triangle: atan(b/a)</dd></dl>
</li>
</ul>
<a name="angle(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>angle</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.960">angle</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">Create a dataset of the arguments from a complex dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset of angles in radians</dd></dl>
</li>
</ul>
<a name="angle(java.lang.Object, boolean)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>angle</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.970">angle</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
            boolean&nbsp;inDegrees)</pre>
<div class="block">Create a dataset of the arguments from a complex dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>inDegrees</code> - if true then return angles in degrees else in radians</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset of angles</dd></dl>
</li>
</ul>
<a name="angle(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>angle</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.980">angle</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
            <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">Create a dataset of the arguments from a complex dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset of angles in radians</dd></dl>
</li>
</ul>
<a name="angle(java.lang.Object, boolean, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>angle</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.991">angle</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
            boolean&nbsp;inDegrees,
            <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">Create a dataset of the arguments from a complex dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>inDegrees</code> - if true then return angles in degrees else in radians</dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset of angles</dd></dl>
</li>
</ul>
<a name="phaseAsComplexNumber(java.lang.Object, boolean)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>phaseAsComplexNumber</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.1249">phaseAsComplexNumber</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                           boolean&nbsp;keepZeros)</pre>
<div class="block">Create a phase only dataset. NB it will contain NaNs if there are any items with zero amplitude</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - dataset</dd><dd><code>keepZeros</code> - if true then zero items are returned as zero rather than NaNs</dd>
<dt><span class="strong">Returns:</span></dt><dd>complex dataset where items have unit amplitude</dd></dl>
</li>
</ul>
<a name="phaseAsComplexNumber(java.lang.Object, org.eclipse.january.dataset.Dataset, boolean)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>phaseAsComplexNumber</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.1260">phaseAsComplexNumber</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                           <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o,
                           boolean&nbsp;keepZeros)</pre>
<div class="block">Create a phase only dataset. NB it will contain NaNs if there are any items with zero amplitude</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - dataset</dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd><dd><code>keepZeros</code> - if true then zero items are returned as zero rather than NaNs</dd>
<dt><span class="strong">Returns:</span></dt><dd>complex dataset where items have unit amplitude</dd></dl>
</li>
</ul>
<a name="add(java.util.Collection, boolean)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>add</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.1347">add</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="../../../../org/eclipse/january/dataset/IDataset.html" title="interface in org.eclipse.january.dataset">IDataset</a>&gt;&nbsp;sets,
          boolean&nbsp;requireClone)</pre>
<div class="block">Adds all sets passed in together
 
 The first IDataset must cast to Dataset
 
 For memory efficiency sake if add(...) is called with a
 set of size one, no clone is done, the original object is
 returned directly. Otherwise a new data set is returned,
 the sum of those passed in.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>sets</code> - </dd><dd><code>requireClone</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>sum of collection</dd></dl>
</li>
</ul>
<a name="multiply(java.util.Collection, boolean)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>multiply</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.1372">multiply</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/util/Collection.html?is-external=true" title="class or interface in java.util">Collection</a>&lt;<a href="../../../../org/eclipse/january/dataset/IDataset.html" title="interface in org.eclipse.january.dataset">IDataset</a>&gt;&nbsp;sets,
               boolean&nbsp;requireClone)</pre>
<div class="block">Multiplies all sets passed in together
 
 The first IDataset must cast to Dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>sets</code> - </dd><dd><code>requireClone</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>product of collection</dd></dl>
</li>
</ul>
<a name="interpolate(org.eclipse.january.dataset.Dataset, org.eclipse.january.dataset.Dataset, org.eclipse.january.dataset.IDataset, java.lang.Number, java.lang.Number)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>interpolate</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.1396">interpolate</a>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;x,
                  <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;d,
                  <a href="../../../../org/eclipse/january/dataset/IDataset.html" title="interface in org.eclipse.january.dataset">IDataset</a>&nbsp;x0,
                  <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Number.html?is-external=true" title="class or interface in java.lang">Number</a>&nbsp;left,
                  <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Number.html?is-external=true" title="class or interface in java.lang">Number</a>&nbsp;right)</pre>
<div class="block">Linearly interpolate values at points in a 1D dataset corresponding to given coordinates.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>x</code> - input 1-D coordinate dataset (must be ordered)</dd><dd><code>d</code> - input 1-D dataset</dd><dd><code>x0</code> - coordinate values</dd><dd><code>left</code> - value to use when x0 lies left of domain. If null, then interpolate to zero by using leftmost interval</dd><dd><code>right</code> - value to use when x0 lies right of domain. If null, then interpolate to zero by using rightmost interval</dd>
<dt><span class="strong">Returns:</span></dt><dd>interpolated values</dd></dl>
</li>
</ul>
<a name="interpolate(org.eclipse.january.dataset.Dataset, double)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>interpolate</h4>
<pre>public static&nbsp;double&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.1477">interpolate</a>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;d,
                 double&nbsp;x0)</pre>
<div class="block">Linearly interpolate a value at a point in a 1D dataset. The dataset is considered to have
 zero support outside its bounds. Thus points just outside are interpolated from the boundary
 value to zero.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>d</code> - input dataset</dd><dd><code>x0</code> - coordinate</dd>
<dt><span class="strong">Returns:</span></dt><dd>interpolated value</dd></dl>
</li>
</ul>
<a name="interpolate(org.eclipse.january.dataset.Dataset, org.eclipse.january.dataset.Dataset, double)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>interpolate</h4>
<pre>public static&nbsp;double&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.1506">interpolate</a>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;d,
                 <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;m,
                 double&nbsp;x0)</pre>
<div class="block">Linearly interpolate a value at a point in a 1D dataset with a mask. The dataset is considered
 to have zero support outside its bounds. Thus points just outside are interpolated from the
 boundary value to zero.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>d</code> - input dataset</dd><dd><code>m</code> - mask dataset</dd><dd><code>x0</code> - coordinate</dd>
<dt><span class="strong">Returns:</span></dt><dd>interpolated value</dd></dl>
</li>
</ul>
<a name="interpolate(double[], org.eclipse.january.dataset.CompoundDataset, double)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>interpolate</h4>
<pre>public static&nbsp;void&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.1535">interpolate</a>(double[]&nbsp;values,
               <a href="../../../../org/eclipse/january/dataset/CompoundDataset.html" title="interface in org.eclipse.january.dataset">CompoundDataset</a>&nbsp;d,
               double&nbsp;x0)</pre>
<div class="block">Linearly interpolate an array of values at a point in a compound 1D dataset. The dataset is
 considered to have zero support outside its bounds. Thus points just outside are interpolated
 from the boundary value to zero.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>values</code> - interpolated array</dd><dd><code>d</code> - input dataset</dd><dd><code>x0</code> - coordinate</dd></dl>
</li>
</ul>
<a name="interpolate(org.eclipse.january.dataset.Dataset, double, double)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>interpolate</h4>
<pre>public static&nbsp;double&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.1582">interpolate</a>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;d,
                 double&nbsp;x0,
                 double&nbsp;x1)</pre>
<div class="block">Linearly interpolate a value at a point in a 2D dataset. The dataset is considered to have
 zero support outside its bounds. Thus points just outside are interpolated from the boundary
 value to zero.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>d</code> - input dataset</dd><dd><code>x0</code> - coordinate</dd><dd><code>x1</code> - coordinate</dd>
<dt><span class="strong">Returns:</span></dt><dd>bilinear interpolation</dd></dl>
</li>
</ul>
<a name="interpolate(org.eclipse.january.dataset.Dataset, org.eclipse.january.dataset.Dataset, double, double)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>interpolate</h4>
<pre>public static&nbsp;double&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.1641">interpolate</a>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;d,
                 <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;m,
                 double&nbsp;x0,
                 double&nbsp;x1)</pre>
<div class="block">Linearly interpolate a value at a point in a 2D dataset with a mask. The dataset is considered
 to have zero support outside its bounds. Thus points just outside are interpolated from the
 boundary value to zero.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>d</code> - input dataset</dd><dd><code>m</code> - mask dataset</dd><dd><code>x0</code> - coordinate</dd><dd><code>x1</code> - coordinate</dd>
<dt><span class="strong">Returns:</span></dt><dd>bilinear interpolation</dd></dl>
</li>
</ul>
<a name="interpolate(double[], org.eclipse.january.dataset.CompoundDataset, double, double)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>interpolate</h4>
<pre>public static&nbsp;void&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.1698">interpolate</a>(double[]&nbsp;values,
               <a href="../../../../org/eclipse/january/dataset/CompoundDataset.html" title="interface in org.eclipse.january.dataset">CompoundDataset</a>&nbsp;d,
               double&nbsp;x0,
               double&nbsp;x1)</pre>
<div class="block">Linearly interpolate an array of values at a point in a compound 2D dataset. The dataset is
 considered to have zero support outside its bounds. Thus points just outside are interpolated
 from the boundary value to zero.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>values</code> - bilinear interpolated array</dd><dd><code>d</code> - </dd><dd><code>x0</code> - </dd><dd><code>x1</code> - </dd></dl>
</li>
</ul>
<a name="interpolate(org.eclipse.january.dataset.Dataset, double...)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>interpolate</h4>
<pre>public static&nbsp;double&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.1775">interpolate</a>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;d,
                 double...&nbsp;x)</pre>
<div class="block">Linearly interpolate a value at a point in a n-D dataset. The dataset is considered to have
 zero support outside its bounds. Thus points just outside are interpolated from the boundary
 value to zero. The number of coordinates must match the rank of the dataset.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>d</code> - input dataset</dd><dd><code>x</code> - coordinates</dd>
<dt><span class="strong">Returns:</span></dt><dd>interpolated value</dd></dl>
</li>
</ul>
<a name="interpolate(org.eclipse.january.dataset.Dataset, org.eclipse.january.dataset.Dataset, double...)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>interpolate</h4>
<pre>public static&nbsp;double&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.1788">interpolate</a>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;d,
                 <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;m,
                 double...&nbsp;x)</pre>
<div class="block">Linearly interpolate a value at a point in a n-D dataset with a mask. The dataset is considered to have
 zero support outside its bounds. Thus points just outside are interpolated from the boundary
 value to zero. The number of coordinates must match the rank of the dataset.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>d</code> - input dataset</dd><dd><code>m</code> - mask dataset (can be null)</dd><dd><code>x</code> - coordinates</dd>
<dt><span class="strong">Returns:</span></dt><dd>interpolated value</dd></dl>
</li>
</ul>
<a name="interpolate(double[], org.eclipse.january.dataset.CompoundDataset, double...)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>interpolate</h4>
<pre>public static&nbsp;void&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.1881">interpolate</a>(double[]&nbsp;values,
               <a href="../../../../org/eclipse/january/dataset/CompoundDataset.html" title="interface in org.eclipse.january.dataset">CompoundDataset</a>&nbsp;d,
               double...&nbsp;x)</pre>
<div class="block">Linearly interpolate an array of values at a point in a compound n-D dataset. The dataset is
 considered to have zero support outside its bounds. Thus points just outside are interpolated
 from the boundary value to zero.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>values</code> - linearly interpolated array</dd><dd><code>d</code> - </dd><dd><code>x</code> - </dd></dl>
</li>
</ul>
<a name="getLinear(org.eclipse.january.dataset.IDataset, double)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getLinear</h4>
<pre><a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public static&nbsp;double&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.1968">getLinear</a>(<a href="../../../../org/eclipse/january/dataset/IDataset.html" title="interface in org.eclipse.january.dataset">IDataset</a>&nbsp;d,
                          double&nbsp;x0)</pre>
<div class="block"><span class="strong">Deprecated.</span>&nbsp;<i>Use <a href="../../../../org/eclipse/january/dataset/Maths.html#interpolate(org.eclipse.january.dataset.Dataset,%20double)"><code>interpolate(Dataset, double)</code></a></i></div>
<div class="block">Linearly interpolate a value at a point in a 1D dataset. The dataset is considered to have
 zero support outside its bounds. Thus points just outside are interpolated from the boundary
 value to zero.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>d</code> - input dataset</dd><dd><code>x0</code> - coordinate</dd>
<dt><span class="strong">Returns:</span></dt><dd>interpolated value</dd></dl>
</li>
</ul>
<a name="getLinear(double[], org.eclipse.january.dataset.CompoundDataset, double)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getLinear</h4>
<pre><a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public static&nbsp;void&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.1982">getLinear</a>(double[]&nbsp;values,
                        <a href="../../../../org/eclipse/january/dataset/CompoundDataset.html" title="interface in org.eclipse.january.dataset">CompoundDataset</a>&nbsp;d,
                        double&nbsp;x0)</pre>
<div class="block"><span class="strong">Deprecated.</span>&nbsp;<i>Use <a href="../../../../org/eclipse/january/dataset/Maths.html#interpolate(double[],%20org.eclipse.january.dataset.CompoundDataset,%20double)"><code>interpolate(double[], CompoundDataset, double)</code></a></i></div>
<div class="block">Linearly interpolate a value at a point in a compound 1D dataset. The dataset is considered
 to have zero support outside its bounds. Thus points just outside are interpolated from the
 boundary value to zero.</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>values</code> - interpolated array</dd><dd><code>d</code> - input dataset</dd><dd><code>x0</code> - coordinate</dd></dl>
</li>
</ul>
<a name="getBilinear(org.eclipse.january.dataset.IDataset, double, double)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getBilinear</h4>
<pre><a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public static&nbsp;double&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.1995">getBilinear</a>(<a href="../../../../org/eclipse/january/dataset/IDataset.html" title="interface in org.eclipse.january.dataset">IDataset</a>&nbsp;d,
                            double&nbsp;x0,
                            double&nbsp;x1)</pre>
<div class="block"><span class="strong">Deprecated.</span>&nbsp;<i>Use <a href="../../../../org/eclipse/january/dataset/Maths.html#interpolate(org.eclipse.january.dataset.Dataset,%20double,%20double)"><code>interpolate(Dataset, double, double)</code></a></i></div>
<div class="block">Interpolated a value from 2D dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>d</code> - input dataset</dd><dd><code>x0</code> - coordinate</dd><dd><code>x1</code> - coordinate</dd>
<dt><span class="strong">Returns:</span></dt><dd>bilinear interpolation</dd></dl>
</li>
</ul>
<a name="getBilinear(org.eclipse.january.dataset.IDataset, org.eclipse.january.dataset.IDataset, double, double)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getBilinear</h4>
<pre><a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public static&nbsp;double&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.2009">getBilinear</a>(<a href="../../../../org/eclipse/january/dataset/IDataset.html" title="interface in org.eclipse.january.dataset">IDataset</a>&nbsp;d,
                            <a href="../../../../org/eclipse/january/dataset/IDataset.html" title="interface in org.eclipse.january.dataset">IDataset</a>&nbsp;m,
                            double&nbsp;x0,
                            double&nbsp;x1)</pre>
<div class="block"><span class="strong">Deprecated.</span>&nbsp;<i>Use <a href="../../../../org/eclipse/january/dataset/Maths.html#interpolate(org.eclipse.january.dataset.Dataset,%20org.eclipse.january.dataset.Dataset,%20double,%20double)"><code>interpolate(Dataset, Dataset, double, double)</code></a></i></div>
<div class="block">Interpolated a value from 2D dataset with mask</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>d</code> - input dataset</dd><dd><code>m</code> - mask dataset</dd><dd><code>x0</code> - coordinate</dd><dd><code>x1</code> - coordinate</dd>
<dt><span class="strong">Returns:</span></dt><dd>bilinear interpolation</dd></dl>
</li>
</ul>
<a name="getBilinear(double[], org.eclipse.january.dataset.CompoundDataset, double, double)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>getBilinear</h4>
<pre><a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Deprecated.html?is-external=true" title="class or interface in java.lang">@Deprecated</a>
public static&nbsp;void&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.2022">getBilinear</a>(double[]&nbsp;values,
                          <a href="../../../../org/eclipse/january/dataset/CompoundDataset.html" title="interface in org.eclipse.january.dataset">CompoundDataset</a>&nbsp;d,
                          double&nbsp;x0,
                          double&nbsp;x1)</pre>
<div class="block"><span class="strong">Deprecated.</span>&nbsp;<i>Use <a href="../../../../org/eclipse/january/dataset/Maths.html#interpolate(double[],%20org.eclipse.january.dataset.CompoundDataset,%20double,%20double)"><code>interpolate(double[], CompoundDataset, double, double)</code></a></i></div>
<div class="block">Interpolated a value from 2D compound dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>values</code> - bilinear interpolated array</dd><dd><code>d</code> - </dd><dd><code>x0</code> - </dd><dd><code>x1</code> - </dd></dl>
</li>
</ul>
<a name="difference(org.eclipse.january.dataset.Dataset, int, int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>difference</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.2464">difference</a>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;a,
                 int&nbsp;n,
                 int&nbsp;axis)</pre>
<div class="block">Discrete difference of dataset along axis using finite difference</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>n</code> - order of difference</dd><dd><code>axis</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>difference</dd></dl>
</li>
</ul>
<a name="derivative(org.eclipse.january.dataset.Dataset, org.eclipse.january.dataset.Dataset, int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>derivative</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.2562">derivative</a>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;x,
                 <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;y,
                 int&nbsp;n)</pre>
<div class="block">Calculates the derivative of a line described by two datasets (x,y) given a spread of n either
 side of the point</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>x</code> - The x values of the function to take the derivative of.</dd><dd><code>y</code> - The y values of the function to take the derivative of.</dd><dd><code>n</code> - The spread the derivative is calculated from, i.e. the
            smoothing, the higher the value, the more smoothing occurs.</dd>
<dt><span class="strong">Returns:</span></dt><dd>A dataset which contains all the derivative point for point.</dd></dl>
</li>
</ul>
<a name="centralDifference(org.eclipse.january.dataset.Dataset, int)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>centralDifference</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.2638">centralDifference</a>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;a,
                        int&nbsp;axis)</pre>
<div class="block">Discrete difference of dataset along axis using finite central difference</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>axis</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>difference</dd></dl>
</li>
</ul>
<a name="gradient(org.eclipse.january.dataset.Dataset, org.eclipse.january.dataset.Dataset...)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>gradient</h4>
<pre>public static&nbsp;<a href="https://docs.oracle.com/javase/7/docs/api/java/util/List.html?is-external=true" title="class or interface in java.util">List</a>&lt;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&gt;&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/Maths.html#line.2909">gradient</a>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;y,
                     <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>...&nbsp;x)</pre>
<div class="block">Calculate gradient (or partial derivatives) by central difference</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>y</code> - </dd><dd><code>x</code> - one or more datasets for dependent variables</dd>
<dt><span class="strong">Returns:</span></dt><dd>a list of datasets (one for each dimension in y)</dd></dl>
</li>
</ul>
<a name="addFunctionName(org.eclipse.january.dataset.Dataset, org.eclipse.january.dataset.Dataset, org.eclipse.january.dataset.Dataset, java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>addFunctionName</h4>
<pre>protected static&nbsp;void&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.21">addFunctionName</a>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;a,
                   <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;b,
                   <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;dataset,
                   <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;fname)</pre>
</li>
</ul>
<a name="addFunctionName(org.eclipse.january.dataset.Dataset, java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>addFunctionName</h4>
<pre>protected static&nbsp;void&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.25">addFunctionName</a>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;dataset,
                   <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;fname)</pre>
</li>
</ul>
<a name="addBinaryOperatorName(org.eclipse.january.dataset.Dataset, org.eclipse.january.dataset.Dataset, org.eclipse.january.dataset.Dataset, java.lang.String)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>addBinaryOperatorName</h4>
<pre>protected static&nbsp;void&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.29">addBinaryOperatorName</a>(<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;a,
                         <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;b,
                         <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;dataset,
                         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/String.html?is-external=true" title="class or interface in java.lang">String</a>&nbsp;oname)</pre>
</li>
</ul>
<a name="toLong(double)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>toLong</h4>
<pre>protected static&nbsp;long&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.33">toLong</a>(double&nbsp;d)</pre>
</li>
</ul>
<a name="add(java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>add</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.44">add</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
          <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<div class="block">add operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>a + b, addition of a and b</dd></dl>
</li>
</ul>
<a name="add(java.lang.Object, java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>add</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.55">add</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
          <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
          <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">add operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>a + b, addition of a and b</dd></dl>
</li>
</ul>
<a name="subtract(java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>subtract</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.934">subtract</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<div class="block">subtract operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>a - b, subtraction of a by b</dd></dl>
</li>
</ul>
<a name="subtract(java.lang.Object, java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>subtract</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.945">subtract</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
               <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">subtract operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>a - b, subtraction of a by b</dd></dl>
</li>
</ul>
<a name="multiply(java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>multiply</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.1824">multiply</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<div class="block">multiply operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>a * b, product of a and b</dd></dl>
</li>
</ul>
<a name="multiply(java.lang.Object, java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>multiply</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.1835">multiply</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
               <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
               <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">multiply operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>a * b, product of a and b</dd></dl>
</li>
</ul>
<a name="divide(java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>divide</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.2714">divide</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
             <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<div class="block">divide operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>a / b, division of a by b</dd></dl>
</li>
</ul>
<a name="divide(java.lang.Object, java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>divide</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.2725">divide</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
             <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
             <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">divide operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>a / b, division of a by b</dd></dl>
</li>
</ul>
<a name="dividez(java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>dividez</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.3706">dividez</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<div class="block">dividez operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>a / b, division of a by b</dd></dl>
</li>
</ul>
<a name="dividez(java.lang.Object, java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>dividez</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.3717">dividez</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
              <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">dividez operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>a / b, division of a by b</dd></dl>
</li>
</ul>
<a name="divideTowardsFloor(java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>divideTowardsFloor</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.4680">divideTowardsFloor</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<div class="block">divideTowardsFloor operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>a / b, division of a by b but rounded towards negative infinity</dd></dl>
</li>
</ul>
<a name="divideTowardsFloor(java.lang.Object, java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>divideTowardsFloor</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.4691">divideTowardsFloor</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                         <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">divideTowardsFloor operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>a / b, division of a by b but rounded towards negative infinity</dd></dl>
</li>
</ul>
<a name="power(java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>power</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.6120">power</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
            <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<div class="block">power operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>a ** b, raise a to power of b</dd></dl>
</li>
</ul>
<a name="power(java.lang.Object, java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>power</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.6131">power</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
            <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
            <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">power operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>a ** b, raise a to power of b</dd></dl>
</li>
</ul>
<a name="remainder(java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>remainder</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.7022">remainder</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<div class="block">remainder operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>a % b, remainder of division of a by b</dd></dl>
</li>
</ul>
<a name="remainder(java.lang.Object, java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>remainder</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.7033">remainder</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">remainder operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>a % b, remainder of division of a by b</dd></dl>
</li>
</ul>
<a name="maximum(java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>maximum</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.7826">maximum</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<div class="block">maximum operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>return maximum of a and b</dd></dl>
</li>
</ul>
<a name="maximum(java.lang.Object, java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>maximum</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.7837">maximum</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
              <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">maximum operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>return maximum of a and b</dd></dl>
</li>
</ul>
<a name="minimum(java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>minimum</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.8764">minimum</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<div class="block">minimum operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>return minimum of a and b</dd></dl>
</li>
</ul>
<a name="minimum(java.lang.Object, java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>minimum</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.8775">minimum</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
              <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">minimum operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>return minimum of a and b</dd></dl>
</li>
</ul>
<a name="bitwiseAnd(java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>bitwiseAnd</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.9702">bitwiseAnd</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<div class="block">bitwiseAnd operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>a & b, bitwise AND of a and b</dd></dl>
</li>
</ul>
<a name="bitwiseAnd(java.lang.Object, java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>bitwiseAnd</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.9713">bitwiseAnd</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                 <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">bitwiseAnd operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>a & b, bitwise AND of a and b</dd></dl>
</li>
</ul>
<a name="bitwiseOr(java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>bitwiseOr</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.10027">bitwiseOr</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<div class="block">bitwiseOr operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>a | b, bitwise inclusive OR of a and b</dd></dl>
</li>
</ul>
<a name="bitwiseOr(java.lang.Object, java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>bitwiseOr</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.10038">bitwiseOr</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">bitwiseOr operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>a | b, bitwise inclusive OR of a and b</dd></dl>
</li>
</ul>
<a name="bitwiseXor(java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>bitwiseXor</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.10352">bitwiseXor</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<div class="block">bitwiseXor operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>a ^ b, bitwise exclusive OR of a and b</dd></dl>
</li>
</ul>
<a name="bitwiseXor(java.lang.Object, java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>bitwiseXor</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.10363">bitwiseXor</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                 <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">bitwiseXor operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>a ^ b, bitwise exclusive OR of a and b</dd></dl>
</li>
</ul>
<a name="leftShift(java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>leftShift</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.10677">leftShift</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<div class="block">leftShift operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>a << b, bitwise left shift of a by b</dd></dl>
</li>
</ul>
<a name="leftShift(java.lang.Object, java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>leftShift</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.10688">leftShift</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">leftShift operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>a << b, bitwise left shift of a by b</dd></dl>
</li>
</ul>
<a name="rightShift(java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>rightShift</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.11002">rightShift</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<div class="block">rightShift operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>a >> b, bitwise right shift of a by b</dd></dl>
</li>
</ul>
<a name="rightShift(java.lang.Object, java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>rightShift</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.11013">rightShift</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                 <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                 <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">rightShift operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>a >> b, bitwise right shift of a by b</dd></dl>
</li>
</ul>
<a name="unsignedRightShift(java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>unsignedRightShift</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.11327">unsignedRightShift</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b)</pre>
<div class="block">unsignedRightShift operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>a >>> b, bitwise right shift of a by b with zeros added</dd></dl>
</li>
</ul>
<a name="unsignedRightShift(java.lang.Object, java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>unsignedRightShift</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.11338">unsignedRightShift</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                         <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;b,
                         <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">unsignedRightShift operator</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>b</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>a >>> b, bitwise right shift of a by b with zeros added</dd></dl>
</li>
</ul>
<a name="bitwiseInvert(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>bitwiseInvert</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.11660">bitwiseInvert</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">bitwiseInvert - ~a, bitwise invert (or NOT) each element</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="bitwiseInvert(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>bitwiseInvert</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.11670">bitwiseInvert</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                    <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">bitwiseInvert - ~a, bitwise invert (or NOT) each element</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="sin(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>sin</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.11876">sin</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">sin - evaluate the sine function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="sin(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>sin</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.11886">sin</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
          <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">sin - evaluate the sine function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="cos(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>cos</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.12428">cos</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">cos - evaluate the cosine function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="cos(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>cos</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.12438">cos</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
          <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">cos - evaluate the cosine function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="tan(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>tan</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.12980">tan</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">tan - evaluate the tangent function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="tan(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>tan</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.12990">tan</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
          <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">tan - evaluate the tangent function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="arcsin(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>arcsin</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.13556">arcsin</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">arcsin - evaluate the inverse sine function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="arcsin(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>arcsin</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.13566">arcsin</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
             <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">arcsin - evaluate the inverse sine function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="arccos(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>arccos</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.14116">arccos</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">arccos - evaluate the inverse cosine function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="arccos(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>arccos</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.14126">arccos</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
             <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">arccos - evaluate the inverse cosine function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="arctan(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>arctan</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.14676">arctan</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">arctan - evaluate the inverse tangent function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="arctan(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>arctan</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.14686">arctan</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
             <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">arctan - evaluate the inverse tangent function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="sinh(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>sinh</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.15236">sinh</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">sinh - evaluate the hyperbolic sine function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="sinh(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>sinh</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.15246">sinh</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
           <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">sinh - evaluate the hyperbolic sine function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="cosh(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>cosh</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.15788">cosh</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">cosh - evaluate the hyperbolic cosine function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="cosh(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>cosh</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.15798">cosh</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
           <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">cosh - evaluate the hyperbolic cosine function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="tanh(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>tanh</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.16340">tanh</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">tanh - evaluate the tangent hyperbolic function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="tanh(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>tanh</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.16350">tanh</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
           <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">tanh - evaluate the tangent hyperbolic function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="arcsinh(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>arcsinh</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.16916">arcsinh</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">arcsinh - evaluate the inverse hyperbolic sine function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="arcsinh(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>arcsinh</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.16926">arcsinh</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">arcsinh - evaluate the inverse hyperbolic sine function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="arccosh(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>arccosh</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.17476">arccosh</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">arccosh - evaluate the inverse hyperbolic cosine function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="arccosh(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>arccosh</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.17486">arccosh</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">arccosh - evaluate the inverse hyperbolic cosine function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="arctanh(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>arctanh</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.18036">arctanh</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">arctanh - evaluate the inverse hyperbolic tangent function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="arctanh(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>arctanh</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.18046">arctanh</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
              <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">arctanh - evaluate the inverse hyperbolic tangent function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="log(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>log</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.18596">log</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">log - evaluate the logarithm function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="log(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>log</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.18606">log</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
          <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">log - evaluate the logarithm function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="log2(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>log2</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.19148">log2</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">log2 - evaluate the logarithm function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="log2(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>log2</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.19158">log2</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
           <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">log2 - evaluate the logarithm function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="log10(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>log10</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.19700">log10</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">log10 - evaluate the logarithm function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="log10(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>log10</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.19710">log10</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
            <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">log10 - evaluate the logarithm function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="log1p(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>log1p</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.20252">log1p</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">log1p - evaluate the logarithm function of 1 plus on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="log1p(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>log1p</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.20262">log1p</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
            <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">log1p - evaluate the logarithm function of 1 plus on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="exp(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>exp</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.20804">exp</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">exp - evaluate the exponential function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="exp(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>exp</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.20814">exp</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
          <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">exp - evaluate the exponential function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="expm1(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>expm1</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.21364">expm1</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">expm1 - evaluate the exponential function - 1 on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="expm1(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>expm1</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.21374">expm1</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
            <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">expm1 - evaluate the exponential function - 1 on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="sqrt(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>sqrt</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.21924">sqrt</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">sqrt - evaluate the square root function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="sqrt(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>sqrt</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.21934">sqrt</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
           <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">sqrt - evaluate the square root function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="cbrt(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>cbrt</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.22484">cbrt</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">cbrt - evaluate the cube root function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="cbrt(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>cbrt</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.22494">cbrt</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
           <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">cbrt - evaluate the cube root function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="square(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>square</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.23044">square</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">square - square each element</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="square(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>square</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.23054">square</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
             <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">square - square each element</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="floor(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>floor</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.23596">floor</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">floor - evaluate the floor function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="floor(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>floor</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.23606">floor</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
            <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">floor - evaluate the floor function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="ceil(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ceil</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.24148">ceil</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">ceil - evaluate the ceiling function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="ceil(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>ceil</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.24158">ceil</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
           <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">ceil - evaluate the ceiling function on each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="rint(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>rint</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.24700">rint</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">rint - round each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="rint(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>rint</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.24710">rint</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
           <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">rint - round each element of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="truncate(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>truncate</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.25252">truncate</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">truncate - truncate each element to integers of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="truncate(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>truncate</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.25262">truncate</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
               <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">truncate - truncate each element to integers of the dataset</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="toDegrees(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>toDegrees</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.25804">toDegrees</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">toDegrees - convert to degrees</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="toDegrees(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>toDegrees</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.25814">toDegrees</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">toDegrees - convert to degrees</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="toRadians(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>toRadians</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.26356">toRadians</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">toRadians - convert to radians</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="toRadians(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>toRadians</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.26366">toRadians</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
                <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">toRadians - convert to radians</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="signum(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>signum</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.26908">signum</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">signum - sign of each element</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="signum(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>signum</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.26918">signum</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
             <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">signum - sign of each element</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="negative(java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>negative</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.27460">negative</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a)</pre>
<div class="block">negative - negative value of each element</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="negative(java.lang.Object, org.eclipse.january.dataset.Dataset)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>negative</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.27470">negative</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
               <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o)</pre>
<div class="block">negative - negative value of each element</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="clip(java.lang.Object, java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockList">
<li class="blockList">
<h4>clip</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.28014">clip</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
           <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;pa,
           <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;pb)</pre>
<div class="block">clip - clip elements to limits</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>pa</code> - </dd><dd><code>pb</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
<a name="clip(java.lang.Object, org.eclipse.january.dataset.Dataset, java.lang.Object, java.lang.Object)">
<!--   -->
</a>
<ul class="blockListLast">
<li class="blockList">
<h4>clip</h4>
<pre>public static&nbsp;<a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;<a href="../../../../src-html/org/eclipse/january/dataset/GeneratedMaths.html#line.28026">clip</a>(<a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;a,
           <a href="../../../../org/eclipse/january/dataset/Dataset.html" title="interface in org.eclipse.january.dataset">Dataset</a>&nbsp;o,
           <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;pa,
           <a href="https://docs.oracle.com/javase/7/docs/api/java/lang/Object.html?is-external=true" title="class or interface in java.lang">Object</a>&nbsp;pb)</pre>
<div class="block">clip - clip elements to limits</div>
<dl><dt><span class="strong">Parameters:</span></dt><dd><code>a</code> - </dd><dd><code>o</code> - output can be null - in which case, a new dataset is created</dd><dd><code>pa</code> - </dd><dd><code>pb</code> - </dd>
<dt><span class="strong">Returns:</span></dt><dd>dataset</dd></dl>
</li>
</ul>
</li>
</ul>
</li>
</ul>
</div>
</div>
<!-- ========= END OF CLASS DATA ========= -->
<!-- ======= START OF BOTTOM NAVBAR ====== -->
<div class="bottomNav"><a name="navbar_bottom">
<!--   -->
</a><a href="#skip-navbar_bottom" title="Skip navigation links"></a><a name="navbar_bottom_firstrow">
<!--   -->
</a>
<ul class="navList" title="Navigation">
<li><a href="../../../../overview-summary.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="navBarCell1Rev">Class</li>
<li><a href="class-use/Maths.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">
<li><a href="../../../../org/eclipse/january/dataset/LongDataset.html" title="class in org.eclipse.january.dataset"><span class="strong">Prev Class</span></a></li>
<li><a href="../../../../org/eclipse/january/dataset/NullIterator.html" title="class in org.eclipse.january.dataset"><span class="strong">Next Class</span></a></li>
</ul>
<ul class="navList">
<li><a href="../../../../index.html?org/eclipse/january/dataset/Maths.html" target="_top">Frames</a></li>
<li><a href="Maths.html" target="_top">No Frames</a></li>
</ul>
<ul class="navList" id="allclasses_navbar_bottom">
<li><a href="../../../../allclasses-noframe.html">All 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>
</div>
<div>
<ul class="subNavList">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor_summary">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method_summary">Method</a></li>
</ul>
<ul class="subNavList">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li><a href="#constructor_detail">Constr</a>&nbsp;|&nbsp;</li>
<li><a href="#method_detail">Method</a></li>
</ul>
</div>
<a name="skip-navbar_bottom">
<!--   -->
</a></div>
<!-- ======== END OF BOTTOM NAVBAR ======= -->
<p class="legalCopy"><small>Copyright &#169; 2017. All rights reserved.</small></p>
</body>
</html>
