R (SuanShuExtension API)

java.lang.Object
- com.numericalmethod.suanshu.misc.R

```
public class R
extends java.lang.Object
```
These are some R-equivalent utility functions. In general, for a R-equivalent function that correspond to a mathematical concept, SuanShu implements it as a class, e.g., Rank. Otherwise, SuanShu implements it as a static utility function. SuanShu uses the same (or similar) names and syntax whenever possible as in R to allow easy conversion from R code.

See Also:

The R Project for Statistical Computing

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`R.ifelse` Return a value with the same shape as `test` which is filled with elements selected from either `yes` or `no` depending on whether the element of test is `true` or `false`.
`static interface`	`R.which` Decide whether x satisfies the `boolean` test.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static double[]`	`cumsum(double[] arr)` Get the cumulative sums of the elements in an array.
`static int[]`	`cumsum(int[] arr)` Get the cumulative sums of the elements in an array.
`static double[]`	`diff(double[] arr)` Get the first differences of an array.
`static double[][]`	`diff(double[][] arr)` Get the first differences of an array of vectors.
`static double[][]`	`diff(double[][] arr, int lag, int order)` Get the lagged and iterated differences of vectors.
`static double[]`	`diff(double[] arr, int lag, int order)` Get the lagged and iterated differences.
`static double[]`	`ifelse(double[] arr, R.ifelse selection)` Return a value with the same shape as `test` which is filled with elements selected from either `yes` or `no` depending on whether the element of test is `true` or `false`.
`static int[]`	`order(double[] arr)` Sort an array in ascending order.
`static int[]`	`order(double[] arr, boolean ascending)` Sort an array either in ascending or descending order.
`static java.lang.String`	`paste(java.util.Collection<java.lang.String> collection, java.lang.String delimiter)` Concatenate `String`s into one `String`.
`static double[]`	`rep(double value, int times)` Generate an array of `double`s of repeated values.
`static int[]`	`rep(int value, int times)` Generate an array of `int`s of repeated values.
`static double[]`	`select(double[] arr, R.which test)` Select the array elements which satisfy the `boolean` test.
`static int[]`	`select(int[] arr, R.which test)` Select the array elements which satisfy the `boolean` test.
`static double[]`	`seq(double from, double to, double inc)` Generate a sequence of `double`s from `from` up to `to` with increments `inc`.
`static int[]`	`seq(int from, int to)` Generate a sequence of `int`s from `from` up to `to` with increments 1.
`static int[]`	`seq(int from, int to, int inc)` Generate a sequence of `int`s from `from` up to `to` with increments `inc`.
`static double[]`	`subarray(double[] arr, int[] indices)` Get a sub-array of the original array with the given indices.
`static int[]`	`subarray(int[] arr, int[] indices)` Get a sub-array of the original array with the given indices.
`static int[]`	`which(double[] arr, R.which test)` Get the indices of the array elements which satisfy the `boolean` test.
`static int[]`	`which(int[] arr, R.which test)` Get the indices of the array elements which satisfy the `boolean` test.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - rep
```
public static double[] rep(double value,
                           int times)
```
    Generate an array of doubles of repeated values.
    
    Parameters:
    
    value - the repeated value
    
    times - the length of the array
    
    Returns:
    
    an array of repetitions of value
  - rep
```
public static int[] rep(int value,
                        int times)
```
    Generate an array of ints of repeated values.
    
    Parameters:
    
    value - the repeated value
    
    times - the length of the array
    
    Returns:
    
    an array of repetitions of value
  - seq
```
public static double[] seq(double from,
                           double to,
                           double inc)
```
    Generate a sequence of doubles from from up to to with increments inc. The last number in the sequence is smaller than or equal to to for positive inc. The last number in the sequence is bigger than or equal to to for negative inc.
    
    Parameters:
    
    from - the first number in the sequence
    
    to - the bound of the sequence
    
    inc - the increment
    
    Returns:
    
    a sequence of doubles
  - seq
```
public static int[] seq(int from,
                        int to,
                        int inc)
```
    Generate a sequence of ints from from up to to with increments inc. The last number in the sequence is smaller than or equal to to for positive inc. The last number in the sequence is bigger than or equal to to for negative inc.
    
    Parameters:
    
    from - the first number in the sequence
    
    to - the bound of the sequence
    
    inc - the increment
    
    Returns:
    
    a sequence of ints
  - seq
```
public static int[] seq(int from,
                        int to)
```
    Generate a sequence of ints from from up to to with increments 1. That is, [from, to], inclusively.
    
    Parameters:
    
    from - the first number in the sequence
    
    to - the bound of the sequence
    
    Returns:
    
    a sequence of ints
  - diff
```
public static double[] diff(double[] arr,
                            int lag,
                            int order)
```
    Get the lagged and iterated differences.
    
    Parameters:
    
    arr - an array, double[]
    
    lag - an integer indicating which lag to use
    
    order - an integer indicating the order of the difference. This is the number of times diff is applied to the data. E.g., diff(x, 1, 2) = diff(diff(x, 1, 1), 1, 1).
    
    Returns:
    
    the lagged and iterated differences
  - diff
```
public static double[] diff(double[] arr)
```
    Get the first differences of an array.
    
    Parameters:
    
    arr - an array, double[]
    
    Returns:
    
    the first differences
  - diff
```
public static double[][] diff(double[][] arr,
                              int lag,
                              int order)
```
    Get the lagged and iterated differences of vectors.
    
    Parameters:
    
    arr - a double[][]; row view; must not be jagged
    
    lag - an integer indicating which lag to use
    
    order - an integer indicating the order of the difference. This is the number of times diff is applied to the data. E.g., diff(x, 1, 2) = diff(diff(x, 1, 1), 1, 1).
    
    Returns:
    
    the lagged and iterated differences
  - diff
```
public static double[][] diff(double[][] arr)
```
    Get the first differences of an array of vectors.
    
    Parameters:
    
    arr - a double[][]; row view; must not be jagged
    
    Returns:
    
    the first differences
  - cumsum
```
public static double[] cumsum(double[] arr)
```
    Get the cumulative sums of the elements in an array.
    
    Parameters:
    
    arr - an array, double[]
    
    Returns:
    
    cumsum
  - cumsum
```
public static int[] cumsum(int[] arr)
```
    Get the cumulative sums of the elements in an array.
    
    Parameters:
    
    arr - an array, int[]
    
    Returns:
    
    cumsum
  - ifelse
```
public static double[] ifelse(double[] arr,
                              R.ifelse selection)
```
    Return a value with the same shape as test which is filled with elements selected from either yes or no depending on whether the element of test is true or false.
    
    Parameters:
    
    arr - an array
    
    selection - the boolean test to decide true or false and return values
    
    Returns:
    
    "yes" or "no" return values
  - which
```
public static int[] which(double[] arr,
                          R.which test)
```
    Get the indices of the array elements which satisfy the boolean test.
    
    Parameters:
    
    arr - an array. double[]
    
    test - the boolean test to decide true or false (which to select)
    
    Returns:
    
    the indices of the satisfying elements
  - which
```
public static int[] which(int[] arr,
                          R.which test)
```
    Get the indices of the array elements which satisfy the boolean test.
    
    Parameters:
    
    arr - an array. int[]
    
    test - the boolean test to decide true or false (which to select)
    
    Returns:
    
    the indices of the satisfying elements
  - select
```
public static double[] select(double[] arr,
                              R.which test)
```
    Select the array elements which satisfy the boolean test. R does not have a 'select' function. The R-equivalent is arr[which(...]}.
    
    Parameters:
    
    arr - an array, double[]
    
    test - the boolean test to determine which elements to be selected
    
    Returns:
    
    the satisfying elements
  - select
```
public static int[] select(int[] arr,
                           R.which test)
```
    Select the array elements which satisfy the boolean test. R does not have a 'select' function. The R-equivalent is arr[which(...]}.
    
    Parameters:
    
    arr - an array, int[]
    
    test - the boolean test to determine which elements to be selected
    
    Returns:
    
    the satisfying elements
  - subarray
```
public static double[] subarray(double[] arr,
                                int[] indices)
```
    Get a sub-array of the original array with the given indices. The R-equivalent is arr[indices].
    
    Parameters:
    
    arr - an array, double[]
    
    indices - an array of indices to select
    
    Returns:
    
    arr[indices].
  - subarray
```
public static int[] subarray(int[] arr,
                             int[] indices)
```
    Get a sub-array of the original array with the given indices. The R-equivalent is arr[indices].
    
    Parameters:
    
    arr - an array, int[]
    
    indices - an array of indices to select
    
    Returns:
    
    arr[indices].
  - order
```
public static int[] order(double[] arr,
                          boolean ascending)
```
    Sort an array either in ascending or descending order.
    
    Parameters:
    
    arr - an array, int[]
    
    ascending - true if arranging elements in ascending order; false if descending order
    
    Returns:
    
    a sorted array
  - order
```
public static int[] order(double[] arr)
```
    Sort an array in ascending order.
    
    Parameters:
    
    arr - an array, int[]
    
    Returns:
    
    a sorted array in ascending order
  - paste
```
public static java.lang.String paste(java.util.Collection<java.lang.String> collection,
                                     java.lang.String delimiter)
```
    Concatenate Strings into one String.
    
    Parameters:
    
    collection - the collection of strings to be concatenated
    
    delimiter - the separation symbol for the strings
    
    Returns:
    
    the concatenated string

Class R

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Detail

rep

rep

seq

seq

seq

diff

diff

diff

diff

cumsum

cumsum

ifelse

which

which

select

select

subarray

subarray

order

order

paste