Provides information about the version of Rmind.

Calculates accuracy score for classification model.

Calculates Auto-correlation.

acf(x)

Add a number of days to a date.

Compute summaries of subsets of data. The result table will also contain the grouped key columns. If the ds and table arguments are not specified a temporary table is created.

Note that the “count” function does not require a data vector. Average is not supported on logical vectors. Average and sum are not supported on bitwise-shared (xor) types.

Note that the order of rows in the output is not deterministic.

aggregate(key.columns, data.columns, functions)

aggregate(key.columns, data.columns, functions, ds=NULL, table=NULL, names=NULL, overwrite=FALSE)

Appends elements to a vector or a list. Note that it mutates the sequence and returns its value, it does not return a new sequence.

append(x, value)

append(x, value, after=NULL)

Bring column vectors of a Sharemind database table into scope. Note that it will reassign if variables with the same names already exist.

Compute the area under the receiver operating characteristic curve.

Perform the Bonferroni correction for multiple testing. Divides the significance level by the number of hypotheses.

Plots a box and whiskers plot of a private vector. If the first argument is a list of private vectors, a plot is produced for each of them.

boxplot(x)

boxplot(x, ylim=NULL, title="", label="", tic.labels=NULL, ratio=4/3)

Attempts to construct a vector of the arguments passed to it. If the arguments are numeric then they are coerced to the same type and concatenated. If the arguments have types that can not be coerced, a list of the arguments is created.

Convert a private vector to another type.

Print out a concatenated string representation of values.

cat(1, 2, 3)

cat(1, 2, 3, sep=" ")

Concatenate tables by columns. If the ds and table arguments are not given, a temporary table is created.

cbind(table1, table2)

cbind(table1, table2, result.ds=NULL, result.table=NULL, result.overwrite=FALSE)

For each element of a private vector, ‘ceiling’ finds the smallest integer greater than the element. The resulting vector will have an integral type.

Perform Pearson’s chi-squared test of independence or goodness of fit test.

The x and y arguments are data vectors. Note that booleans and signed integers will be converted to an unsigned integral type so the data should not contain negative values.

If only the first input is supplied it is handled as a vector of frequencies and a goodness of fit test is performed. You can supply the expected probabilities as the p argument.

If both x and y are supplied they are handled as factors and cross tabulated. Pearson’s test of independence is performed on the contingency table. If the inputs are integers not factors then you must specify the possible levels as public vectors using the xlevels and ylevels arguments.

The test returns TRUE if the null hypothesis is rejected.

chisq.test(x, y=NULL, xlevels=NULL, ylevels=NULL, significance=0.05, p=NULL)

Create a private vector from a public vector.

Close a file handle.

close(handle)

Returns a list with private column vectors of a Sharemind database table.

Calculates the covariance of two private vectors.

Returns [information gain, important feature, its threshold] for each node.

For example, when the max.depth in ctree() is three, this function returns a list with seven elements. The number of elements (nodes) is decided as 2 ^ max.depth - 1 (binary tree). Node number is based on breadth-first search and node1 is the root.

ctree.importance(result)

Fits decision tree classifier.

The function returns a list with six elements. The elements are:

ctree(model)

predict

Convert a string date into a numeric representation. The syntax of the format string is specified in the documentation of the Haskell time package. It’s similar to standard UNIX formatting, so “man strftime” should be helpful. Throws an exception if parsing fails.

Extract months from dates. The result is an int64 private vector.

Compute the difference of dates in days.

Returns the ceiling and floor values for confidence interval based on given z.

The function returns a named list with six elements. The elements are:

Returns the results of Kalman Filter for a DLM which is specified by either dlmModPoly or dlmModJoint.

The function returns a named list.

When mod is the result of dlmModPoly(order=1), the elements are:
s * mod - the updated DLM. A private matrix.

When mod is the result of dlmModPoly(order=2), the elements are:

When mod is the result of dlmModJoint, the elements are:

Returns the expected value and variance of future system states.

The function returns a named list.

When filtered mod is based on dlmModPoly(order=1), the elements are:

When filtered mod is based on the other DLM, the elements are:

Returns the minus log likelihood of a filtered DLM.

The lower the value, the better.

Applying Liu-West filter with Rao-Blackwellzation for a DLM which is specified by dlmModPoly(order=1).

The argument mod needs to be the result of dlmModPoly(order=1), but dV and dW values will be ingored.

The function returns a named list. The elements are:

When it is confirmed that the values V and W converge to a constant values, it is recommended to set those values to dlmModPoly() and apply dlmFilter().

Combines dlmModPoly(order=2) and dlmModSeas (or dlmModTrig). Only order=2 for dlmModPoly is supported.

Returns a Nth order polynomial DLM (Dynamic Linear Model).

The function returns a named list with six elements. The elements are:

Returns a DLM representing a specified seasonal component.

The function returns a named list with six elements. The elements are:

For filtering, use dlmModJoint before dlmFilter.

Returns a DLM representing a specified periodic component.

The function returns a named list with eight elements. The elements are:

For filtering, use dlmModJoint before dlmFilter.

Returns the results of Kalman Smoother using a filtered DLM.

The function returns a named list.

When filtered mod is based on dlmModPoly(order=1), the elements are:

When filtered mod is based on the other DLM, the elements are:

Calls a function on a list of arguments.

Creates a vector of floating point numbers.

Check if each element of a private vector is an element of a set.

Compute the error function of a numeric vector.

Compute the exponential function of a numeric vector.

Calculates f1 score for classification model.

f1(actual, predicted)

f1(actual, predicted, average="macro")

Create a private factor vector from a list of public strings.

The mapping argument specifies how the string levels are mapped to integer codes. This is an optimisation used to speed up computations with factors in Sharemind. An example of the mapping argument would be list(a=1, b=2) when there are two levels (“a” and “b”). The codes must be sequential and start from 1.

You can get the factor mapping of an existing factor using levels. This allows you to create a new factor vector with the same mapping as an existing one like this:

factor(list("a"), levels(x))

factor(x)

factor(x, list(a=1, b=2))

Calculates the Discrete Fourier Transform (DFT) with the Fast Fourier Transform (FFT) algorithm.

This function returns a named list with two elements: real and imag. Both are vectors.

Warning: only a vector with “a power of 2” length is supported. If the input vector length is not a power of 2, this function slices at the index “the largest power of 2” (ex., if the length is 100, the function slices the vector at index 64).

fft(z)

Opens a file handle which can be used to read the file or write to the file.

file(path)

file(path, mode="rw")

Perform Fisher’s exact test to test for association between two binary variables. The numeric values 0 and 1 are always taken as the levels so make sure to convert your inputs to this format. This is performed implicitly when one of the inputs is a factor with two levels. Returns TRUE if the null hypothesis is rejected and FALSE otherwise.

fisher.test(a, b)

fisher.test(a, b, significance=0.05)

For each element of a private vector, floor finds the largest integer less than the element. The resulting vector will have an integral type.

Send unfinished writes to a file handle to the operating system.

flush(handle)

Calculates the frequency table of a private vector.

If the pretty argument is TRUE the frequency table is printed to the output. Otherwise a list of the counts or frequencies is returned which are named according to the factor levels.

freq(x)

freq(x, freq=TRUE, pretty=FALSE)

Plots a histogram of a private factor vector or public a list of bin counts. Unlike hist which calculates frequencies for ranges, freqplot counts the frequency of each distinct value so it’s more useful for discrete data.

freqplot(x)

freqplot(x, title=NULL, xlab=NULL, ylab=NULL, xtics=NULL, freq=TRUE, ratio=4/3)

Fits generalized linear models. Only two types of models are currently supported: regular linear regression (if family is “gaussian”) and logistic regression (if family is “binomial-logit”). The documentation of lm describes the different methods of solving systems of linear equations. The function returns a list with six elements. The elements are:

glm(model)

glm(model, family="gaussian", iterations=10, sole.method=NULL, sole.iterations=10)

predict

Fits generalized linear models with Dai-Liao non-linear conjugate gradient optimization with the strong wolfe conditions. Supported families are “gaussian”, “binomial-logit”, “gamma”, and “poisson”. When family="binomial-logit", the dependent must be either 0 or 1.

The function returns a list with six elements. The elements are:

glmnet(model)

predict

Take the first n elements of a vector.

head(x, n)

head(x, n=6)

Plots a heatmap from private data. This is a replacement for X-Y plots in ordinary statistics software. The function takes two private vectors consisting of the x and y coordinates respectively. Instead of drawing each point separately, the number of points falling in an area is counted and a shade is assigned to the area.

heatmap(x, y)

heatmap(x, y, xlab=NULL, ylab=NULL, regression=FALSE, ratio=4/3)

Plots a histogram of a private vector.

hist(x)

hist(x, title=NULL, xlab=NULL, ylab=NULL, ylim=NULL, freq=TRUE, ratio=4/3)

Hosmer-Lemeshow goodness of fit test for binary classifiers.

hoslem.test(observations, predictions)

hoslem.test(observations, predictions, significance=0.05, groups=10)

Read and evaluate a file containing Rmind code. Unlike the source procedure, the path passed to import is relative to the path of the source code file containing the call to import.

Creates a vector of integers.

Given a private vector, returns a private vector indicating which values are not missing.

Returns a public boolean stating whether all values in a given private vector are binary (zeroes and ones)

Checks if a value is NULL.

is.null(x)

Apply a function to each element of a list or a public vector. If the input is a vector it’s converted into a list. Use sapply if you want the vector to remain a vector. Since the function exists on the client side, it can only be applied to public inputs.

Returns the length of a vector or a list.

Get the list of levels of a private factor vector. The list elements are integer codes of the levels and are labeled with the string representation of the level.

Constructs a list of the arguments passed to it. List elements can be named by giving the name and value pairs as keyword arguments, e.g. name = value.

Perform linear regression. The methods used for solving systems of linear equations are “lu” (LU decomposition), “gauss” (Gaussian elimination), “conjugate-gradient” (Conjugate gradient method), “inversion” (matrix inversion). The conjugate gradient method is fast and accurate but accuracy depends on the number of iterations. Matrix inversion is fast but is only implemented for less than four variables. If the method argument is NULL, either matrix inversion or LU decomposition is chosen depending on the number of variables. The function returns a vector with the estimated coefficients. The first element is the intercept.

lm(model)

lm(model, method=NULL, iterations=10)

Compute the natural logarithm of a numeric vector.

Loads a Sharemind table.

Perform LOESS regression with one explanatory variable and linear local regression.

loess(x, y)

loess(x, y, span=0.75, points=10)

Compute the logarithm of a numeric vector.

log(x, base)

log(x, base=exp(1))

Compute the base 10 logarithm of a numeric vector.

Creates a vector of booleans.

List variables in the current environment.

List database tables in a data source.

Calculates the median absolute deviation of a private vector (median(abs(x - median(x))) * constant).

mad(x)

mad(x, constant=1.4826)

Perform the Mann-Whitney U test.

mann.whitney.test(x, y)

mann.whitney.test(x, y, alternative="two.sided", significance=0.05, correct=TRUE)

Constructs a private matrix.

Returns the largest element of a private vector.

Calculates the arithmetic mean of a private vector.

Calculates the median of a private vector.

Merge two Sharemind database tables. The original tables remain unchanged. If by, by.x and by.y are unspecified the procedure attempts to find a column with a common name. If multiple such pairs exist, use the by argument. If the key column is named differently in each table, use by.x and by.y. To perform a cross join give NULL as the value of by. Use a list of strings to specify a multi-column key.

Note that the order of rows in the output is not deterministic.

merge(x, y)

merge(x, y, by="", by.x=NULL, by.y=NULL, all=FALSE, all.x=FALSE, all.y=FALSE)

Returns the smallest element of a private vector.

Extract months from dates. The result is an int64 private vector.

Calculates mse (mean squared error) score for regression model.

mse(actual, predicted)

Perform simultaneous chi-squared tests. Note that the data will be converted to an unsigned integral type so it should not contain negative values. The codebook is a list of two vectors. The first contains the values expected in the input and the second contains values that they are assigned to. This can be used to turn multiple categories into one. If you do not wish to change categories, pass list(a:b, a:b) as the codebook argument, where a is the minimum and b the maximum expected value. The Benjamini-Hochberg correction is less conservative but slower. Returns a list with indices of the data sets for which the null hypothesis was rejected.

multiple.chisq.test(dataList, filter, codebook)

multiple.chisq.test(dataList, filter, codebook, significance=0.05, method="benjamini-hochberg")

Perform simultaneous t-tests. The tests are two-sided (the alternative hypothesis is that the means of the groups are different). The variance of the two groups are assumed to be equal. There’s no paired version. The Benjamini-Hochberg correction is less conservative but slower. Returns a list with indices of the data sets for which the null hypothesis was rejected.

multiple.t.test(dataList, filter)

multiple.t.test(dataList, filter, significance=0.05, method="benjamini-hochberg")

Combine multiple plots. The layout can be controlled with the rows and cols arguments. Either one can be specified and the other will be calculated. If neither is specified, the plots are stacked vertically.

multiplot(plotList)

multiplot(plotList, rows=NULL, cols=NULL, ratio=NULL)

Returns a list with the names of columns of a Sharemind database table or names of list elements.

Returns the number of columns in a Sharemind database table.

Returns the number of rows in a Sharemind database table.

Produce an X-Y plot of public values.

The legend position consists of four components - vertical position (top, bottom or center), horizontal position (left, right or center), position in relation to the frame (inside or outside) and position of elements inside the legend (vertical or horizontal).

plot(x, y)

plot(x, y, title="", xlab="", ylab="", ylim=NULL, type=NULL, label.points=FALSE, data.labels=NULL, legend.pos="top right inside vertical", ratio=4/3)

Perform principal component analysis. A list with three values is returned:

prcomp(matrix)

prcomp(matrix, components=1, iterations=10)

Calculates precision score for classification model.

precision(actual, predicted)

precision(actual, predicted, average="macro")

Predict values based on the result of a modeling function such as glm

predict(result, data)

Prints and returns its argument.

Quits the application.

Compute sample quantiles.

quantile(x)

quantile(x, probs=c(0, 0.25, 0.5, 0.75, 1))

Fits random forest classifier.

The function returns a list with seven elements. The elements are:

randomForest(model)

predict

Concatenate tables by row. If the ds and table arguments are not given, a temporary table is created.

rbind(table1, table2)

rbind(table1, table2, result.ds=NULL, result.table=NULL, result.overwrite=FALSE, result.names=NULL)

Calculates recall score for classification model.

recall(actual, predicted)

recall(actual, predicted, average="macro")

Replace level to code mapping of a factor.

Return a list or a vector with multiple copies of a value. If the input is a vector, a vector with count copies is returned. If the input is not a vector, a list with count copies is returned.

Remove variables from the current environment.

rm(x)

rm(x, list=NULL)

Remove missing values.

rm.missing(vector, value)

rm.missing(vector, value=NULL)

Remove outliers of a private vector. The length of the vector will remain the same. Outliers will be marked as not available. There are two methods - “quantiles” and “mad”. If the constant argument is x, “quantiles” will remove values below the (x * 100%) quantile and over the ((1 - x) * 100%) quantile. The default constant is 0.05. If the method is “mad”, the median absolute deviation method of outlier detection is used and the constant will be the lambda of the MAD formula. The default value is 3.

rm.outliers(x)

rm.outliers(x, method="quantiles", constant=NULL)

Remove a database table.

rm.table(ds, table)

Calculates rmse (root mean squared error) score for regression model.

rmse(actual, predicted)

Plot the receiver operating characteristic curve of a binary classifier.

Note that the current implementation leaks the true positive rate and false positive rate computed for each observation. This procedure can be disabled on the server side.

Rounds all elements of a private vector. The resulting vector will have an integral type.

Reduces each row of a matrix to a scalar value. A reduction of x1, x2, …, xn with the associative and commutative operator * is the value x1 * x2 * … * xn.

Apply a function to each element of a list or a public vector. If the input is a vector or a list where all elements are vectors, the result will be a vector, otherwise it will be a list. Since the function exists on the client side, it can only be applied to public inputs.

Save a plot to a file. If the width or height is specified but not both of them, the aspect ratio of the plot is used to calculate the other one. The format of the image is inferred from the path. The supported formats are PNG and SVG.

Returns the centered (mean 0) and scaled (standard deviation 1) Sharemind table or matrix.

scale(x, center=TRUE, scale=TRUE)

Transform Sharemind table or matrix by scaling each feature to a given range.

scale.minmax(x, min=0, max=1)

Plot the variance (or cumulative proportion of total variance) of each principal component computed by prcomp.

screeplot(x)

screeplot(x, npcs=NULL, cumulative=FALSE)

Calculates the standard deviation of a private vector.

Left-shift elements of each row of a table. When an element of the shift vector is missing, the whole row is marked missing in the result.

Show a plot in a window. If the width or height is specified but not both of them, the aspect ratio of the plot is used to calculate the other one. In the REPL, just evaluating a plot will also show it.

show(plot)

show(plot, width=NULL, height=NULL)

Compute the sine function of a numeric vector.

Sorts a Sharemind database table. A new table is created and the original data remains unchanged.

Read and evaluate a file containing Rmind code.

Compute the square root of a numeric vector.

Stores private vectors into a permanent database table.

store.table(dsName, tableName, columnNamesList, columnsList)

store.table(dsName, tableName, columnNamesList, columnsList, overwrite=FALSE)

Returns a filtered subset of a Sharemind database table.

Note that the order of rows in the output is not deterministic.

subset(x, filter)

subset(x, filter, column=NULL)

Calculates the sum of a vector.

Compute the Akaike information criterion, standard errors and p-values of coefficients of generalized linear models. See the documentation for the glm procedure. A list with three values is returned:

Calculates the minimum, lower quantile, median, mean, upper quantile and maximum of a private vector (in that order).

Display the standard deviation, proportion of total variance and cumulative proportion of principal components computed by prcomp.

Performs Student’s or Welch’s t-test. If var.equal is FALSE, the Welch-Satterthwaite equation is used to find the degrees of freedom. Returns TRUE if the null hypothesis is rejected and FALSE otherwise.

t.test(x, y)

t.test(x, y, paired=FALSE, var.equal=TRUE, significance=0.05, alternative="two.sided", mu=0)

Take the last n elements of a vector.

tail(x, n)

tail(x, n=6)

Returns a string representation of a value.

Splits datasets into train and test.

This functions returns a named list with two new Shremind tables (train and test).

Evaluate an expression and handle errors. The function passed as the error parameter will be executed when expr throws an exception. The error message will be passed to the error function. There is also a finally argument which will be evaluated after evaluation and error handling.

tryCatch(expr, error.handler, finally.expr)

Returns a string representation of the type of the first argument.

Computes a public unique ID from columns of input table. Does not modify the input table but returns a new table that contains the original columns and extra UID column. The rows of the resulting table are shuffled.

Unique ID column can be later used to sort and aggregate.

unique.id(table, "column")

unique.id(table, "column", name="UID")

Remove duplicate elements from a private vector.

Calculates the variance of a private vector.

Perform Wilcoxon rank sum or Wilcoxon signed rank tests. If paired is TRUE then the Wilcoxon signed rank test is performed, otherwise the Wilcoxon rank sum test is performed. Returns TRUE if the null hypothesis is rejected and FALSE otherwise.

wilcoxon.test(x, y)

wilcoxon.test(x, y, paired=FALSE, alternative="two.sided", significance=0.05, correct=TRUE)

Write a string to a file.

write(string, handle)

Fits XGBoost.

The function returns a list with 14 elements. The elements are:

xgboost(model)

predict

Extract years from dates. The result is an int64 private vector.