khiva 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d46c3d7ed62e5adf119b172084d7a7bf6f6a77d49eae2cb3039cca6ce4a9b9a3
-  data.tar.gz: '09b7f85b1c1ddd51f2a78c732b24350d4e43c2471ebccbe5e37f501213a4cf65'
+  metadata.gz: b7e270535ccb0436961b438ccf0d6effd1976933e1c5a2f98920d207816d6c21
+  data.tar.gz: 8fa258b1c954a3cdd5ad02c0b1da57f6d175fc844e0fdabe2ae82f902a18d431
 SHA512:
-  metadata.gz: 7e5ef4486b11cd7333fd819381150f854a62b2c744c31014950f1e5e7ca8b17ede6e87e1277751c58211e029edb990a605e7d2f428c8374ec7c1cc63ec8c3c7d
-  data.tar.gz: a96c1716abec95ddef7caa6e389e8fa796c4ef03a584c0204508ab37a0096fce5b356040c2d1770e422803285a7a3aa2d7a27e4573e35d0faf89857b588f7100
+  metadata.gz: a54ff69b81b37c7e206a46babc733ed1987e16ae84dd40a19eae0fb688b08e245a8df1b212debc5342f1e7da1a934aa972b8a936faf58b1300aa3cdecb519a70
+  data.tar.gz: aac9b7764789f171d5f7b33834148117a7423b2182303b4d45bd1307d9a57c187fa492499810692846f25b6f13e20f3243b8cba4b28c82a0faa4b3ce949fb478

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.1.1 (2020-12-18)
+
+- Added many more methods
+
 ## 0.1.0 (2020-12-17)
 
 - First release

data/README.md

@@ -2,11 +2,13 @@
 
 [Khiva](https://github.com/shapelets/khiva) - high-performance time series algorithms - for Ruby
 
+:fire: Runs on GPUs and CPUs
+
 [![Build Status](https://github.com/ankane/khiva-ruby/workflows/build/badge.svg?branch=master)](https://github.com/ankane/khiva-ruby/actions)
 
 ## Installation
 
-First, [install Khiva](#khiva-installation). For Homebrew use:
+First, [install Khiva](#khiva-installation). For Homebrew, use:
 
 ```sh
 brew install khiva
@@ -31,10 +33,32 @@ profile, index = Khiva::Matrix.stomp(a, b, 3)
 Find discords
 
 ```ruby
-discords, discords_indices, subsequence_indices = Khiva::Matrix.find_best_n_discords(profile, index, 2, 2)
+distances, indices, subsequences = Khiva::Matrix.find_best_n_discords(profile, index, 2, 2)
+```
+
+Find motifs
+
+```ruby
+distances, indices, subsequences = Khiva::Matrix.find_best_n_motifs(profile, index, 2, 2)
 ```
 
-## Arrays
+## Modules
+
+- [Array](#array)
+- [Clustering](#clustering)
+- [Dimensionality](#dimensionality)
+- [Distances](#distances)
+- [Features](#features)
+- [Library](#library)
+- [Linalg](#linalg)
+- [Matrix](#matrix)
+- [Normalization](#normalization)
+- [Polynomial](#polynomial)
+- [Regression](#regression)
+- [Regularization](#regularization)
+- [Statistics](#statistics)
+
+## Array
 
 Create an array from a Ruby array
 
@@ -42,7 +66,7 @@ Create an array from a Ruby array
 Khiva::Array.new([1, 2, 3])
 ```
 
-Specify the type
+Specify the type - `:b8`, `:f32`, `:f64`, `:s16`, `:s32`, `:s64`, `:u8`, `:u16`, `:u32`, `:u64`
 
 ```ruby
 Khiva::Array.new([1, 2, 3], type: :s64)
@@ -77,6 +101,28 @@ a.le(b)
 a.ge(b)
 ```
 
+## Clustering
+
+k-means algorithm
+
+```ruby
+centroids, labels = Khiva::Clustering.k_means(tss, k)
+```
+
+k-Shape algorithm
+
+```ruby
+centroids, labels = Khiva::Clustering.k_shape(tss, k)
+```
+
+## Dimensionality
+
+Piecewise aggregate approximate (PAA)
+
+```ruby
+Khiva::Dimensionality.paa(a, bins)
+```
+
 ## Distances
 
 Dynamic time warping (DTW) distance
@@ -115,34 +161,314 @@ Squared Euclidean distance
 Khiva::Distances.squared_euclidean(tss)
 ```
 
+## Features
+
+Sum of square values
+
+```ruby
+Khiva::Features.abs_energy(tss)
+```
+
+Absolute sum of changes
+
+```ruby
+Khiva::Features.absolute_sum_of_changes(tss)
+```
+
+Number of values above the mean
+
+```ruby
+Khiva::Features.count_above_mean(tss)
+```
+
+Number of values below the mean
+
+```ruby
+Khiva::Features.count_below_mean(tss)
+```
+
+The spectral centroid (mean), variance, skew, and kurtosis of the absolute fourier transform spectrum
+
+```ruby
+Khiva::Features.fft_aggregated(tss)
+```
+
+First location of the maximum value
+
+```ruby
+Khiva::Features.first_location_of_maximum(tss)
+```
+
+First location of the minimum value
+
+```ruby
+Khiva::Features.first_location_of_minimum(tss)
+```
+
+Last location of the maximum value
+
+```ruby
+Khiva::Features.last_location_of_maximum(tss)
+```
+
+Last location of the minimum value
+
+```ruby
+Khiva::Features.last_location_of_minimum(tss)
+```
+
+Length of the series
+
+```ruby
+Khiva::Features.length(tss)
+```
+
+Local maximals
+
+```ruby
+Khiva::Features.local_maximals(tss)
+```
+
+Length of the longest consecutive subsequence above the mean
+
+```ruby
+Khiva::Features.longest_strike_above_mean(tss)
+```
+
+Length of the longest consecutive subsequence below the mean
+
+```ruby
+Khiva::Features.longest_strike_below_mean(tss)
+```
+
+Maximum
+
+```ruby
+Khiva::Features.maximum(tss)
+```
+
+Mean
+
+```ruby
+Khiva::Features.mean(tss)
+```
+
+Mean absolute change
+
+```ruby
+Khiva::Features.mean_absolute_change(tss)
+```
+
+Mean change
+
+```ruby
+Khiva::Features.mean_change(tss)
+```
+
+Mean of a central approximation of the second derivative
+
+```ruby
+Khiva::Features.mean_second_derivative_central(tss)
+```
+
+Median
+
+```ruby
+Khiva::Features.median(tss)
+```
+
+Minimum
+
+```ruby
+Khiva::Features.minimum(tss)
+```
+
+Ratio of unique values
+
+```ruby
+Khiva::Features.ratio_value_number_to_time_series_length(tss)
+```
+
+Sample entropy
+
+```ruby
+Khiva::Features.sample_entropy(tss)
+```
+
+Skewness
+
+```ruby
+Khiva::Features.skewness(tss)
+```
+
+Standard deviation
+
+```ruby
+Khiva::Features.standard_deviation(tss)
+```
+
+Sum of values
+
+```ruby
+Khiva::Features.sum_values(tss)
+```
+
+Number of occurrences of a value
+
+```ruby
+Khiva::Features.value_count(tss, v)
+```
+
+Variance
+
+```ruby
+Khiva::Features.variance(tss)
+```
+
+If variance is larger than one
+
+```ruby
+Khiva::Features.variance_larger_than_standard_deviation(tss)
+```
+
+## Library
+
+Get backend info
+
+```ruby
+Khiva::Library.backend_info
+```
+
+Get current backend
+
+```ruby
+Khiva::Library.backend
+```
+
+Get available backends
+
+```ruby
+Khiva::Library.backends
+```
+
+Set backend - `:default`, `:cpu`, `:cuda`, `:opencl`
+
+```ruby
+Khiva::Library.set_backend(:cpu)
+```
+
+Set device
+
+```ruby
+Khiva::Library.set_device(device_id)
+```
+
+Get device id
+
+```ruby
+Khiva::Library.device_id
+```
+
+Get device count
+
+```ruby
+Khiva::Library.device_count
+```
+
+Set device memory in GB
+
+```ruby
+Khiva::Library.set_device_memory_in_gb(1.5)
+```
+
+Get version
+
+```ruby
+Khiva::Library.version
+```
+
+## Linalg
+
+```ruby
+Khiva::Linalg.lls(a, b)
+```
+
+## Matrix
+
+Calculate the matrix profile between `ta` and `tb` using a subsequence length of `m` with the STOMP algorithm
+
+```ruby
+profile, index = Khiva::Matrix.stomp(ta, tb, m)
+```
+
+Calculate the matrix profile between `t` and itself using a subsequence length of `m` with the STOMP algorithm
+
+```ruby
+profile, index = Khiva::Matrix.stomp_self_join(t, m)
+```
+
+Calculate the matrix profile between `ta` and `tb` using a subsequence length of `m`
+
+```ruby
+profile, index = Khiva::Matrix.matrix_profile(ta, tb, m)
+```
+
+Calculate the matrix profile between `t` and itself using a subsequence length of `m`
+
+```ruby
+profile, index = Khiva::Matrix.matrix_profile_self_join(t, m)
+```
+
 ## Normalization
 
 Decimal scaling
 
 ```ruby
-Khiva::Distances.decimal_scaling_norm(tss)
-Khiva::Distances.decimal_scaling_norm!(tss)
+Khiva::Normalization.decimal_scaling_norm(tss)
+Khiva::Normalization.decimal_scaling_norm!(tss)
 ```
 
 Max min
 
 ```ruby
-Khiva::Distances.max_min_norm(tss)
-Khiva::Distances.max_min_norm!(tss)
+Khiva::Normalization.max_min_norm(tss)
+Khiva::Normalization.max_min_norm!(tss)
 ```
 
 Mean
 
 ```ruby
-Khiva::Distances.mean_norm(tss)
-Khiva::Distances.mean_norm!(tss)
+Khiva::Normalization.mean_norm(tss)
+Khiva::Normalization.mean_norm!(tss)
 ```
 
 Znorm
 
 ```ruby
-Khiva::Distances.znorm(tss)
-Khiva::Distances.znorm!(tss)
+Khiva::Normalization.znorm(tss)
+Khiva::Normalization.znorm!(tss)
+```
+
+## Polynomial
+
+Least squares polynomial fit
+
+```ruby
+Khiva::Polynomial.polyfit(x, y, deg)
+```
+
+## Regression
+
+Linear least squares regression
+
+```ruby
+slope, intercept, rvalue, pvalue, stderrest = Khiva::Regression.linear(xss, yss)
+```
+
+## Regularization
+
+```ruby
+Khiva::Regularization.group_by(tss, aggregation_function, columns_key: 1, n_columns_value: 1)
 ```
 
 ## Statistics
@@ -153,14 +479,78 @@ Covariance
 Khiva::Statistics.covariance(tss, unbiased: false)
 ```
 
+Kurtosis
+
+```ruby
+Khiva::Statistics.kurtosis(tss)
+```
+
+Ljung-Box
+
+```ruby
+Khiva::Statistics.ljung_box(tss, lags)
+```
+
+Moment
+
+```ruby
+Khiva::Statistics.moment(tss, k)
+```
+
+Quantile
+
+```ruby
+Khiva::Statistics.quantile(tss, q, precision: 1e-8)
+```
+
+Quantiles cut
+
+```ruby
+Khiva::Statistics.quantiles_cut(tss, quantiles, precision: 1e-8)
+```
+
+Standard deviation
+
+```ruby
+Khiva::Statistics.sample_stdev(tss)
+```
+
+Skewness
+
+```ruby
+Khiva::Statistics.skewness(tss)
+```
+
 ## Khiva Installation
 
 ### Linux
 
-Run:
+Install Boost and Eigen. On Ubuntu, use:
+
+```sh
+sudo apt-get install libboost-all-dev libeigen3-dev
+```
+
+Install ArrayFire:
+
+```sh
+wget -q https://arrayfire.s3.amazonaws.com/3.7.3/ArrayFire-v3.7.3_Linux_x86_64.sh
+chmod +x ./ArrayFire-v3.7.3_Linux_x86_64.sh
+./ArrayFire-v3.7.3_Linux_x86_64.sh --include-subdir --prefix=/opt
+echo /opt/arrayfire/lib64 | sudo tee /etc/ld.so.conf.d/arrayfire.conf
+sudo ldconfig
+```
+
+And install Khiva:
 
 ```sh
-# todo
+git clone --recursive --branch v0.5.0 https://github.com/shapelets/khiva
+cd khiva
+mkdir build
+cd build
+cmake .. -DKHIVA_USE_CONAN=OFF -DKHIVA_BUILD_TESTS=OFF -DKHIVA_BUILD_BENCHMARKS=OFF -DKHIVA_BUILD_JNI_BINDINGS=OFF
+make -j4
+sudo make install
 ```
 
 ### Mac

data/lib/khiva.rb

@@ -3,10 +3,17 @@ require "fiddle/import"
 
 # modules
 require "khiva/array"
+require "khiva/clustering"
+require "khiva/dimensionality"
 require "khiva/distances"
+require "khiva/features"
 require "khiva/library"
+require "khiva/linalg"
 require "khiva/matrix"
 require "khiva/normalization"
+require "khiva/polynomial"
+require "khiva/regression"
+require "khiva/regularization"
 require "khiva/statistics"
 require "khiva/utils"
 require "khiva/version"
@@ -30,8 +37,6 @@ module Khiva
   autoload :FFI, "khiva/ffi"
 
   def self.lib_version
-    v = Fiddle::Pointer.malloc(20)
-    FFI.call(:version, v.ref)
-    v.to_s
+    Library.version
   end
 end

data/lib/khiva/array.rb

@@ -82,6 +82,7 @@ module Khiva
     def to_a
       d = dims
       d.pop while d.last == 1 && d.size > 1
+      d.reverse!
 
       elements = dims.inject(1, &:*)
       data = Fiddle::Pointer.malloc(elements * element_size)

data/lib/khiva/clustering.rb

@@ -0,0 +1,19 @@
+module Khiva
+  module Clustering
+    class << self
+      def k_means(tss, k, tolerance: 1e-10, max_iterations: 100)
+        centroids = Utils.create_ptr
+        labels = Utils.create_ptr
+        FFI.call(:k_means, tss, Utils.int_ptr(k), centroids, labels, Utils.float_ptr(tolerance), Utils.int_ptr(max_iterations))
+        [Array.new(centroids), Array.new(labels)]
+      end
+
+      def k_shape(tss, k, tolerance: 1e-10, max_iterations: 100)
+        centroids = Utils.create_ptr
+        labels = Utils.create_ptr
+        FFI.call(:k_shape, tss, Utils.int_ptr(k), centroids, labels, Utils.float_ptr(tolerance), Utils.int_ptr(max_iterations))
+        [Array.new(centroids), Array.new(labels)]
+      end
+    end
+  end
+end

data/lib/khiva/dimensionality.rb

@@ -0,0 +1,11 @@
+module Khiva
+  module Dimensionality
+    class << self
+      def paa(a, bins)
+        result = Utils.create_ptr
+        FFI.call(:paa, a, Utils.int_ptr(bins), result)
+        Array.new(result)
+      end
+    end
+  end
+end

data/lib/khiva/features.rb

@@ -0,0 +1,173 @@
+module Khiva
+  module Features
+    class << self
+      def abs_energy(arr)
+        result = Utils.create_ptr
+        FFI.call(:abs_energy, arr, result)
+        Array.new(result)
+      end
+
+      def absolute_sum_of_changes(arr)
+        result = Utils.create_ptr
+        FFI.call(:absolute_sum_of_changes, arr, result)
+        Array.new(result)
+      end
+
+      def count_above_mean(arr)
+        result = Utils.create_ptr
+        FFI.call(:count_above_mean, arr, result)
+        Array.new(result)
+      end
+
+      def count_below_mean(arr)
+        result = Utils.create_ptr
+        FFI.call(:count_below_mean, arr, result)
+        Array.new(result)
+      end
+
+      def fft_aggregated(arr)
+        result = Utils.create_ptr
+        FFI.call(:fft_aggregated, arr, result)
+        Array.new(result)
+      end
+
+      def first_location_of_maximum(arr)
+        result = Utils.create_ptr
+        FFI.call(:first_location_of_maximum, arr, result)
+        Array.new(result)
+      end
+
+      def first_location_of_minimum(arr)
+        result = Utils.create_ptr
+        FFI.call(:first_location_of_minimum, arr, result)
+        Array.new(result)
+      end
+
+      def last_location_of_maximum(arr)
+        result = Utils.create_ptr
+        FFI.call(:last_location_of_maximum, arr, result)
+        Array.new(result)
+      end
+
+      def last_location_of_minimum(arr)
+        result = Utils.create_ptr
+        FFI.call(:last_location_of_minimum, arr, result)
+        Array.new(result)
+      end
+
+      def length(arr)
+        result = Utils.create_ptr
+        FFI.call(:length, arr, result)
+        Array.new(result)
+      end
+
+      def local_maximals(arr)
+        result = Utils.create_ptr
+        FFI.call(:local_maximals, arr, result)
+        Array.new(result)
+      end
+
+      def longest_strike_above_mean(arr)
+        result = Utils.create_ptr
+        FFI.call(:longest_strike_above_mean, arr, result)
+        Array.new(result)
+      end
+
+      def longest_strike_below_mean(arr)
+        result = Utils.create_ptr
+        FFI.call(:longest_strike_below_mean, arr, result)
+        Array.new(result)
+      end
+
+      def maximum(arr)
+        result = Utils.create_ptr
+        FFI.call(:maximum, arr, result)
+        Array.new(result)
+      end
+
+      def mean(arr)
+        result = Utils.create_ptr
+        FFI.call(:mean, arr, result)
+        Array.new(result)
+      end
+
+      def mean_absolute_change(arr)
+        result = Utils.create_ptr
+        FFI.call(:mean_absolute_change, arr, result)
+        Array.new(result)
+      end
+
+      def mean_change(arr)
+        result = Utils.create_ptr
+        FFI.call(:mean_change, arr, result)
+        Array.new(result)
+      end
+
+      def mean_second_derivative_central(arr)
+        result = Utils.create_ptr
+        FFI.call(:mean_second_derivative_central, arr, result)
+        Array.new(result)
+      end
+
+      def median(arr)
+        result = Utils.create_ptr
+        FFI.call(:median, arr, result)
+        Array.new(result)
+      end
+
+      def minimum(arr)
+        result = Utils.create_ptr
+        FFI.call(:minimum, arr, result)
+        Array.new(result)
+      end
+
+      def ratio_value_number_to_time_series_length(arr)
+        result = Utils.create_ptr
+        FFI.call(:ratio_value_number_to_time_series_length, arr, result)
+        Array.new(result)
+      end
+
+      def sample_entropy(arr)
+        result = Utils.create_ptr
+        FFI.call(:sample_entropy, arr, result)
+        Array.new(result)
+      end
+
+      def skewness(arr)
+        result = Utils.create_ptr
+        FFI.call(:skewness, arr, result)
+        Array.new(result)
+      end
+
+      def standard_deviation(arr)
+        result = Utils.create_ptr
+        FFI.call(:standard_deviation, arr, result)
+        Array.new(result)
+      end
+
+      def sum_values(arr)
+        result = Utils.create_ptr
+        FFI.call(:sum_values, arr, result)
+        Array.new(result)
+      end
+
+      def value_count(arr, v)
+        result = Utils.create_ptr
+        FFI.call(:value_count, arr, Utils.float_ptr(v), result)
+        Array.new(result)
+      end
+
+      def variance(arr)
+        result = Utils.create_ptr
+        FFI.call(:variance, arr, result)
+        Array.new(result)
+      end
+
+      def variance_larger_than_standard_deviation(arr)
+        result = Utils.create_ptr
+        FFI.call(:variance_larger_than_standard_deviation, arr, result)
+        Array.new(result)
+      end
+    end
+  end
+end

data/lib/khiva/ffi.rb

@@ -41,12 +41,99 @@ module Khiva
     extern "void khiva_not(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
     extern "void copy(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
 
+    # clustering.h
+    extern "void k_means(const khiva_array *tss, const int *k, khiva_array *centroids, khiva_array *labels, const float *tolerance, const int *max_iterations, int *error_code, char *error_message)"
+    extern "void k_shape(const khiva_array *tss, const int *k, khiva_array *centroids, khiva_array *labels, const float *tolerance, const int *max_iterations, int *error_code, char *error_message)"
+
+    # dimensionality.h
+    extern "void paa(const khiva_array *a, const int *bins, khiva_array *result, int *error_code, char *error_message)"
+    extern "void pip(const khiva_array *a, const int *number_ips, khiva_array *result, int *error_code, char *error_message)"
+    extern "void pla_bottom_up(const khiva_array *ts, const float *max_error, khiva_array *result, int *error_code, char *error_message)"
+    extern "void pla_sliding_window(const khiva_array *ts, const float *max_error, khiva_array *result, int *error_code, char *error_message)"
+    extern "void ramer_douglas_peucker(const khiva_array *points, const double *epsilon, khiva_array *res_points, int *error_code, char *error_message)"
+    extern "void sax(const khiva_array *a, const int *alphabet_size, khiva_array *result, int *error_code, char *error_message)"
+    extern "void visvalingam(const khiva_array *points, const int *num_points, khiva_array *res_points, int *error_code, char *error_message)"
+
+    # features.h
+    extern "void abs_energy(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void absolute_sum_of_changes(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void aggregated_autocorrelation(const khiva_array *array, const int *aggregation_function, khiva_array *result, int *error_code, char *error_message)"
+    extern "void aggregated_linear_trend(const khiva_array *array, const long *chunkSize, const int *aggregation_function, khiva_array *slope, khiva_array *intercept, khiva_array *rvalue, khiva_array *pvalue, khiva_array *stderrest, int *error_code, char *error_message)"
+    extern "void approximate_entropy(const khiva_array *array, const int *m, const float *r, khiva_array *result, int *error_code, char *error_message)"
+    extern "void cross_covariance(const khiva_array *xss, const khiva_array *yss, const bool *unbiased, khiva_array *result, int *error_code, char *error_message)"
+    extern "void auto_covariance(const khiva_array *array, const bool *unbiased, khiva_array *result, int *error_code, char *error_message)"
+    extern "void cross_correlation(const khiva_array *xss, const khiva_array *yss, const bool *unbiased, khiva_array *result, int *error_code, char *error_message)"
+    extern "void auto_correlation(const khiva_array *array, const long *max_lag, const bool *unbiased, khiva_array *result, int *error_code, char *error_message)"
+    extern "void binned_entropy(const khiva_array *array, const int *max_bins, khiva_array *result, int *error_code, char *error_message)"
+    extern "void c3(const khiva_array *array, const long *lag, khiva_array *result, int *error_code, char *error_message)"
+    extern "void cid_ce(const khiva_array *array, const bool *zNormalize, khiva_array *result, int *error_code, char *error_message)"
+    extern "void count_above_mean(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void count_below_mean(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void cwt_coefficients(const khiva_array *array, const khiva_array *width, const int *coeff, const int *w, khiva_array *result, int *error_code, char *error_message)"
+    extern "void energy_ratio_by_chunks(const khiva_array *array, const long *num_segments, const long *segment_focus, khiva_array *result, int *error_code, char *error_message)"
+    extern "void fft_aggregated(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void fft_coefficient(const khiva_array *array, const long *coefficient, khiva_array *real, khiva_array *imag, khiva_array *absolute, khiva_array *angle, int *error_code, char *error_message)"
+    extern "void first_location_of_maximum(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void first_location_of_minimum(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void friedrich_coefficients(const khiva_array *array, const int *m, const float *r, khiva_array *result, int *error_code, char *error_message)"
+    extern "void has_duplicates(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void has_duplicate_max(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void has_duplicate_min(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void index_mass_quantile(const khiva_array *array, const float *q, khiva_array *result, int *error_code, char *error_message)"
+    extern "void kurtosis(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void large_standard_deviation(const khiva_array *array, const float *r, khiva_array *result, int *error_code, char *error_message)"
+    extern "void last_location_of_maximum(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void last_location_of_minimum(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void length(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void linear_trend(const khiva_array *array, khiva_array *pvalue, khiva_array *rvalue, khiva_array *intercept, khiva_array *slope, khiva_array *stdrr, int *error_code, char *error_message)"
+    extern "void local_maximals(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void longest_strike_above_mean(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void longest_strike_below_mean(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void max_langevin_fixed_point(const khiva_array *array, const int *m, const float *r, khiva_array *result, int *error_code, char *error_message)"
+    extern "void maximum(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void mean(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void mean_absolute_change(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void mean_change(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void mean_second_derivative_central(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void median(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void minimum(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void number_crossing_m(const khiva_array *array, const int *m, khiva_array *result, int *error_code, char *error_message)"
+    extern "void number_cwt_peaks(const khiva_array *array, const int *max_w, khiva_array *result, int *error_code, char *error_message)"
+    extern "void number_peaks(const khiva_array *array, const int *n, khiva_array *result, int *error_code, char *error_message)"
+    extern "void partial_autocorrelation(const khiva_array *array, const khiva_array *lags, khiva_array *result, int *error_code, char *error_message)"
+    extern "void percentage_of_reoccurring_datapoints_to_all_datapoints(const khiva_array *array, const bool *is_sorted, khiva_array *result, int *error_code, char *error_message)"
+    extern "void percentage_of_reoccurring_values_to_all_values(const khiva_array *array, const bool *is_sorted, khiva_array *result, int *error_code, char *error_message)"
+    extern "void quantile(const khiva_array *array, const khiva_array *q, const float *precision, khiva_array *result, int *error_code, char *error_message)"
+    extern "void range_count(const khiva_array *array, const float *min, const float *max, khiva_array *result, int *error_code, char *error_message)"
+    extern "void ratio_beyond_r_sigma(const khiva_array *array, const float *r, khiva_array *result, int *error_code,vchar *error_message)"
+    extern "void ratio_value_number_to_time_series_length(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void sample_entropy(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void skewness(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void spkt_welch_density(const khiva_array *array, const int *coeff, khiva_array *result, int *error_code, char *error_message)"
+    extern "void standard_deviation(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void sum_of_reoccurring_datapoints(const khiva_array *array, const bool *is_sorted, khiva_array *result, int *error_code, char *error_message)"
+    extern "void sum_of_reoccurring_values(const khiva_array *array, const bool *is_sorted, khiva_array *result, int *error_code, char *error_message)"
+    extern "void sum_values(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void symmetry_looking(const khiva_array *array, const float *r, khiva_array *result, int *error_code, char *error_message)"
+    extern "void time_reversal_asymmetry_statistic(const khiva_array *array, const int *lag, khiva_array *result, int *error_code, char *error_message)"
+    extern "void value_count(const khiva_array *array, const float *v, khiva_array *result, int *error_code, char *error_message)"
+    extern "void variance(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+    extern "void variance_larger_than_standard_deviation(const khiva_array *array, khiva_array *result, int *error_code, char *error_message)"
+
     # library.h
     extern "void backend_info(char **info, int *error_code, char *error_message)"
     extern "void set_backend(const int *backend, int *error_code, char *error_message)"
+    extern "void get_backend(int *backend, int *error_code, char *error_message)"
+    extern "void get_backends(int *backends, int *error_code, char *error_message)"
     extern "void set_device(const int *device, int *error_code, char *error_message)"
+    extern "void get_device_id(int *device_id, int *error_code, char *error_message)"
+    extern "void get_device_count(int *device_count, int *error_code, char *error_message)"
+    extern "void set_device_memory_in_gb(const double *memory, int *error_code, char *error_message)"
     extern "void version(char **v, int *error_code, char *error_message)"
 
+    # linalg.h
+    extern "void lls(const khiva_array *a, const khiva_array *b, khiva_array *result, int *error_code, char *error_message)"
+
     # distances.h
     extern "void dtw(const khiva_array *tss, khiva_array *result, int *error_code, char *error_message)"
     extern "void euclidean(const khiva_array *tss, khiva_array *result, int *error_code, char *error_message)"
@@ -57,7 +144,15 @@ module Khiva
 
     # matrix.h
     extern "void find_best_n_discords(const khiva_array *profile, const khiva_array *index, long m, long n, khiva_array *discord_distances, khiva_array *discord_indices, khiva_array *subsequence_indices, bool self_join, int *error_code, char *error_message)"
+    extern "void find_best_n_motifs(const khiva_array *profile, const khiva_array *index, long m, long n, khiva_array *motif_distances, khiva_array *motif_indices, khiva_array *subsequence_indices, bool self_join, int *error_code, char *error_message)"
+    extern "void find_best_n_occurrences(const khiva_array *q, const khiva_array *t, long n, khiva_array *distances, khiva_array *indexes, int *error_code, char *error_message)"
+    extern "void mass(const khiva_array *q, const khiva_array *t, khiva_array *distances, int *error_code, char *error_message)"
     extern "void stomp(const khiva_array *tssa, const khiva_array *tssb, long m, khiva_array *p, khiva_array *i, int *error_code, char *error_message)"
+    extern "void stomp_self_join(const khiva_array *tss, long m, khiva_array *p, khiva_array *i, int *error_code, char *error_message)"
+    extern "void matrix_profile(const khiva_array *tssa, const khiva_array *tssb, long m, khiva_array *p, khiva_array *i, int *error_code, char *error_message)"
+    extern "void matrix_profile_self_join(const khiva_array *tss, long m, khiva_array *p, khiva_array *i, int *error_code, char *error_message)"
+    extern "void matrix_profile_lr(const khiva_array *tss, long m, khiva_array *pleft, khiva_array *ileft, khiva_array *pright, khiva_array *iright, int *error_code, char *error_message)"
+    extern "void get_chains(const khiva_array *tss, long m, khiva_array *chains, int *error_code, char *error_message)"
 
     # normalization.h
     extern "void decimal_scaling_norm(const khiva_array *tss, khiva_array *result, int *error_code, char *error_message)"
@@ -69,6 +164,16 @@ module Khiva
     extern "void znorm(const khiva_array *tss, const double *epsilon, khiva_array *result, int *error_code, char *error_message)"
     extern "void znorm_in_place(khiva_array *tss, const double *epsilon, int *error_code, char *error_message)"
 
+    # polynomial.h
+    extern "void polyfit(const khiva_array *x, const khiva_array *y, const int *deg, khiva_array *result, int *error_code, char *error_message)"
+    extern "void roots(const khiva_array *p, khiva_array *result, int *error_code, char *error_message)"
+
+    # regression.h
+    extern "void linear(const khiva_array *xss, const khiva_array *yss, khiva_array *slope, khiva_array *intercept, khiva_array *rvalue, khiva_array *pvalue, khiva_array *stderrest, int *error_code, char *error_message)"
+
+    # regularization.h
+    extern "void group_by(const khiva_array *array, const int *aggregation_function, const int *n_columns_key, const int *n_columns_value, khiva_array *result, int *error_code, char *error_message)"
+
     # statistics.h
     extern "void covariance_statistics(const khiva_array *tss, const bool *unbiased, khiva_array *result, int *error_code, char *error_message)"
     extern "void kurtosis_statistics(const khiva_array *tss, khiva_array *result, int *error_code, char *error_message)"

data/lib/khiva/library.rb

@@ -14,6 +14,19 @@ module Khiva
         info.to_s
       end
 
+      def backend
+        backend = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
+        FFI.call(:get_backend, backend)
+        BACKENDS.map(&:reverse).to_h[backend.to_s(backend.size).unpack1("i")]
+      end
+
+      def backends
+        backends = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
+        FFI.call(:get_backends, backends)
+        mask = backends.to_s(backends.size).unpack1("i")
+        BACKENDS.select { |_, v| mask & v != 0 }.map(&:first)
+      end
+
       def set_backend(backend)
         b = BACKENDS[backend]
         raise Error, "Invalid backend: #{backend}" unless b
@@ -23,6 +36,28 @@ module Khiva
       def set_device(device)
         FFI.call(:set_device, Utils.int_ptr(device))
       end
+
+      def device_id
+        device_id = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
+        FFI.call(:get_device_id, device_id)
+        device_id.to_s(device_id.size).unpack1("i")
+      end
+
+      def device_count
+        device_count = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT)
+        FFI.call(:get_device_count, device_count)
+        device_count.to_s(device_count.size).unpack1("i")
+      end
+
+      def set_device_memory_in_gb(memory)
+        FFI.call(:set_device_memory_in_gb, Utils.double_ptr(memory))
+      end
+
+      def version
+        v = Fiddle::Pointer.malloc(20)
+        FFI.call(:version, v.ref)
+        v.to_s
+      end
     end
   end
 end

data/lib/khiva/linalg.rb

@@ -0,0 +1,11 @@
+module Khiva
+  module Linalg
+    class << self
+      def lls(a, b)
+        result = Utils.create_ptr
+        FFI.call(:lls, a, b, result)
+        Array.new(result)
+      end
+    end
+  end
+end

data/lib/khiva/matrix.rb

@@ -9,12 +9,41 @@ module Khiva
         [Array.new(discord_distances), Array.new(discord_indices), Array.new(subsequence_indices)]
       end
 
+      def find_best_n_motifs(profile, index, m, n, self_join: false)
+        motif_distances = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+        motif_indices = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+        subsequence_indices = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+        FFI.call(:find_best_n_motifs, profile, index, m, n, motif_distances, motif_indices, subsequence_indices, self_join ? 1 : 0)
+        [Array.new(motif_distances), Array.new(motif_indices), Array.new(subsequence_indices)]
+      end
+
       def stomp(tssa, tssb, m)
         profile = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
         index = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
         FFI.call(:stomp, tssa, tssb, m, profile, index)
         [Array.new(profile), Array.new(index)]
       end
+
+      def stomp_self_join(tss, m)
+        profile = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+        index = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+        FFI.call(:stomp_self_join, tss, m, profile, index)
+        [Array.new(profile), Array.new(index)]
+      end
+
+      def matrix_profile(tssa, tssb, m)
+        profile = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+        index = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+        FFI.call(:matrix_profile, tssa, tssb, m, profile, index)
+        [Array.new(profile), Array.new(index)]
+      end
+
+      def matrix_profile_self_join(tss, m)
+        profile = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+        index = Fiddle::Pointer.malloc(Fiddle::SIZEOF_VOIDP)
+        FFI.call(:matrix_profile_self_join, tss, m, profile, index)
+        [Array.new(profile), Array.new(index)]
+      end
     end
   end
 end

data/lib/khiva/polynomial.rb

@@ -0,0 +1,11 @@
+module Khiva
+  module Polynomial
+    class << self
+      def polyfit(x, y, deg)
+        result = Utils.create_ptr
+        FFI.call(:polyfit, x, y, Utils.int_ptr(deg), result)
+        Array.new(result)
+      end
+    end
+  end
+end

data/lib/khiva/regression.rb

@@ -0,0 +1,15 @@
+module Khiva
+  module Regression
+    class << self
+      def linear(xss, yss)
+        slope = Utils.create_ptr
+        intercept = Utils.create_ptr
+        rvalue = Utils.create_ptr
+        pvalue = Utils.create_ptr
+        stderrest = Utils.create_ptr
+        FFI.call(:linear, xss, yss, slope, intercept, rvalue, pvalue, stderrest)
+        [Array.new(slope), Array.new(intercept), Array.new(rvalue), Array.new(pvalue), Array.new(stderrest)]
+      end
+    end
+  end
+end

data/lib/khiva/regularization.rb

@@ -0,0 +1,11 @@
+module Khiva
+  module Regularization
+    class << self
+      def group_by(tss, aggregation_function, n_columns_key: 1, n_columns_value: 1)
+        result = Utils.create_ptr
+        FFI.call(:group_by, tss, Utils.int_ptr(aggregation_function), Utils.int_ptr(n_columns_key), Utils.int_ptr(n_columns_value), result)
+        Array.new(result)
+      end
+    end
+  end
+end

data/lib/khiva/statistics.rb

@@ -6,6 +6,48 @@ module Khiva
         FFI.call(:covariance_statistics, tss, Utils.bool_ptr(unbiased), result)
         Array.new(result)
       end
+
+      def kurtosis(tss)
+        result = Utils.create_ptr
+        FFI.call(:kurtosis_statistics, tss, result)
+        Array.new(result)
+      end
+
+      def ljung_box(tss, lags)
+        result = Utils.create_ptr
+        FFI.call(:ljung_box, tss, Utils.long_ptr(lags), result)
+        Array.new(result)
+      end
+
+      def moment(tss, k)
+        result = Utils.create_ptr
+        FFI.call(:moment_statistics, tss, Utils.int_ptr(k), result)
+        Array.new(result)
+      end
+
+      def quantile(tss, q, precision: 1e-8)
+        result = Utils.create_ptr
+        FFI.call(:quantile_statistics, tss, q, Utils.float_ptr(precision), result)
+        Array.new(result)
+      end
+
+      def quantiles_cut(tss, quantiles, precision: 1e-8)
+        result = Utils.create_ptr
+        FFI.call(:quantiles_cut_statistics, tss, Utils.float_ptr(quantiles), Utils.float_ptr(precision), result)
+        Array.new(result)
+      end
+
+      def sample_stdev(tss)
+        result = Utils.create_ptr
+        FFI.call(:sample_stdev_statistics, tss, result)
+        Array.new(result)
+      end
+
+      def skewness(tss)
+        result = Utils.create_ptr
+        FFI.call(:skewness_statistics, tss, result)
+        Array.new(result)
+      end
     end
   end
 end

data/lib/khiva/utils.rb

@@ -6,7 +6,15 @@ module Khiva
       end
 
       def int_ptr(v)
-        Fiddle::Pointer[[v].pack("i*")]
+        Fiddle::Pointer[[v].pack("i")]
+      end
+
+      def long_ptr(v)
+        Fiddle::Pointer[[v].pack("L!")]
+      end
+
+      def float_ptr(v)
+        Fiddle::Pointer[[v].pack("f")]
       end
 
       def double_ptr(v)

data/lib/khiva/version.rb

@@ -1,3 +1,3 @@
 module Khiva
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: khiva
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-17 00:00:00.000000000 Z
+date: 2020-12-18 00:00:00.000000000 Z
 dependencies: []
 description:
 email: andrew@chartkick.com
@@ -21,11 +21,18 @@ files:
 - README.md
 - lib/khiva.rb
 - lib/khiva/array.rb
+- lib/khiva/clustering.rb
+- lib/khiva/dimensionality.rb
 - lib/khiva/distances.rb
+- lib/khiva/features.rb
 - lib/khiva/ffi.rb
 - lib/khiva/library.rb
+- lib/khiva/linalg.rb
 - lib/khiva/matrix.rb
 - lib/khiva/normalization.rb
+- lib/khiva/polynomial.rb
+- lib/khiva/regression.rb
+- lib/khiva/regularization.rb
 - lib/khiva/statistics.rb
 - lib/khiva/utils.rb
 - lib/khiva/version.rb