Source: rdd/FloatRDD.js

  1. /*
  2.  * Copyright 2016 IBM Corp.
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  *
  8.  *      http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */
  16. module.exports = function(kernelP, server) {
  17.   return (function() {
  18.     var Utils = require('../utils.js');
  20.     var gKernelP = kernelP;
  22.     /*
  23.      This is the wrapper class for org.apache.spark.api.java.JavaDoubleRDD
  24.      a Java type Double = JavaScript type float thus the name change from
  25.      DoubleRDD to FloatRDD
  26.      */
  28.     /**
  29.      * @classdesc
  30.      * @param {module:eclairjs/rdd.RDD} srdd
  31.      * @class
  32.      * @memberof module:eclairjs/rdd
  33.      * @extends RDD
  34.      */
  35.     function FloatRDD() {
  36.       Utils.handleConstructor(this, arguments, gKernelP);
  37.     }
  39.     /**
  40.      * @param {module:eclairjs/rdd.RDD} rdd
  41.      * @returns {module:eclairjs/rdd.FloatRDD}
  42.      */
  43.     FloatRDD.prototype.wrapRDD = function (rdd) {
  44.       throw "not implemented by ElairJS";
  45.     };
  47.     /**
  48.      * @returns {module:eclairjs/rdd.FloatRDD}
  49.      */
  50.     FloatRDD.prototype.cache = function () {
  51.       throw "not implemented by ElairJS";
  52.     };
  54.     /**
  55.      * Set this RDD's storage level to persist its values across operations after the first time
  56.      * it is computed. Can only be called once on each RDD.
  57.      * @param {module:eclairjs/storage.StorageLevel} newLevel
  58.      * @returns {module:eclairjs/rdd.FloatRDD}
  59.      */
  60.     FloatRDD.prototype.persist = function (newLevel) {
  61.       throw "not implemented by ElairJS";
  62.     };
  64.     /**
  65.      * Mark the RDD as non-persistent, and remove all blocks for it from memory and disk.
  66.      *
  67.      * @param {boolean} [blocking]  Whether to block until all blocks are deleted.
  68.      * @returns {module:eclairjs/rdd.FloatRDD}
  69.      */
  70.     FloatRDD.prototype.unpersist = function (blocking) {
  71.       throw "not implemented by ElairJS";
  72.     };
  74.     /**
  75.      * @returns {float}
  76.      */
  77.     FloatRDD.prototype.first = function () {
  78.       throw "not implemented by ElairJS";
  79.     };
  81.     /**
  82.      * Return a new RDD containing the distinct elements in this RDD.
  83.      * @param {number} [numPartitions]
  84.      * @returns {module:eclairjs/rdd.FloatRDD}
  85.      */
  86.     FloatRDD.prototype.distinct = function (numPartitions) {
  87.       throw "not implemented by ElairJS";
  88.     };
  90.     /**
  91.      * Return a new RDD containing only the elements that satisfy a predicate.
  92.      * @param {function} func
  93.      * @returns {module:eclairjs/rdd.FloatRDD}
  94.      */
  95.     FloatRDD.prototype.filter = function (func, bindArgs) {
  96.       throw "not implemented by ElairJS";
  97.     };
  99.     /**
  100.      * Return a new RDD that is reduced into `numPartitions` partitions.
  101.      * @param {number} numPartitions
  102.      * @param {boolean} [shuffle]
  103.      * @returns {module:eclairjs/rdd.FloatRDD}
  104.      */
  105.     FloatRDD.prototype.coalesce = function (numPartitions, shuffle) {
  106.       throw "not implemented by ElairJS";
  107.     };
  109.     /**
  110.      * Return a new RDD that has exactly numPartitions partitions.
  111.      *
  112.      * Can increase or decrease the level of parallelism in this RDD. Internally, this uses
  113.      * a shuffle to redistribute data.
  114.      *
  115.      * If you are decreasing the number of partitions in this RDD, consider using `coalesce`,
  116.      * which can avoid performing a shuffle.
  117.      * @param {number} numPartitions
  118.      * @returns {module:eclairjs/rdd.FloatRDD}
  119.      */
  120.     FloatRDD.prototype.repartition = function (numPartitions) {
  121.       throw "not implemented by ElairJS";
  122.     };
  124.     /**
  125.      * Return an RDD with the elements from `this` that are not in `other`.
  126.      *
  127.      * Uses `this` partitioner/partition size, because even if `other` is huge, the resulting
  128.      * RDD will be <= us.
  129.      * @param {module:eclairjs/rdd.FloatRDD} other
  130.      * @returns {module:eclairjs/rdd.FloatRDD}
  131.      */
  132.     FloatRDD.prototype.subtract0 = function (other) {
  133.       throw "not implemented by ElairJS";
  134.     };
  136.     /**
  137.      * Return an RDD with the elements from `this` that are not in `other`.
  138.      * @param {module:eclairjs/rdd.FloatRDD} other
  139.      * @param {number} numPartitions
  140.      * @returns {module:eclairjs/rdd.FloatRDD}
  141.      */
  142.     FloatRDD.prototype.subtract1 = function (other, numPartitions) {
  143.       throw "not implemented by ElairJS";
  144.     };
  146.     /**
  147.      * Return an RDD with the elements from `this` that are not in `other`.
  148.      * @param {module:eclairjs/rdd.FloatRDD} other
  149.      * @param {Partitioner} p
  150.      * @returns {module:eclairjs/rdd.FloatRDD}
  151.      */
  152.     FloatRDD.prototype.subtract2 = function (other, p) {
  153.       throw "not implemented by ElairJS";
  154.     };
  156.     /**
  157.      * Return a sampled subset of this RDD.
  158.      * @param {boolean} withReplacement
  159.      * @param {float} fraction
  160.      * @param {number} [seed]
  161.      * @returns {module:eclairjs/rdd.FloatRDD}
  162.      */
  163.     FloatRDD.prototype.sample = function (withReplacement, fraction, seed) {
  164.       throw "not implemented by ElairJS";
  165.     };
  167.     /**
  168.      * Return the union of this RDD and another one. Any identical elements will appear multiple
  169.      * times (use `.distinct()` to eliminate them).
  170.      * @param {module:eclairjs/rdd.FloatRDD} other
  171.      * @returns {module:eclairjs/rdd.FloatRDD}
  172.      */
  173.     FloatRDD.prototype.union = function (other) {
  174.       throw "not implemented by ElairJS";
  175.     };
  177.     /**
  178.      * Return the intersection of this RDD and another one. The output will not contain any duplicate
  179.      * elements, even if the input RDDs did.
  180.      *
  181.      * Note that this method performs a shuffle internally.
  182.      * @param {module:eclairjs/rdd.FloatRDD} other
  183.      * @returns {module:eclairjs/rdd.FloatRDD}
  184.      */
  185.     FloatRDD.prototype.intersection = function (other) {
  186.       throw "not implemented by ElairJS";
  187.     };
  189.     /**
  190.      * @returns {float}
  191.      */
  192.     FloatRDD.prototype.sum = function () {
  193.       throw "not implemented by ElairJS";
  194.     };
  196.     /**
  197.      * Returns the minimum element from this RDD as defined by
  198.      * the default comparator natural order.
  199.      * @returns {float}  the minimum of the RDD
  200.      */
  201.     FloatRDD.prototype.min = function () {
  202.       throw "not implemented by ElairJS";
  203.     };
  205.     /**
  206.      * Returns the maximum element from this RDD as defined by
  207.      * the default comparator natural order.
  208.      * @returns {float}  the maximum of the RDD
  209.      */
  210.     FloatRDD.prototype.max = function () {
  211.       throw "not implemented by ElairJS";
  212.     };
  214.     /**
  215.      * Return a {@link StatCounter} object that captures the mean, variance and
  216.      * count of the RDD's elements in one operation.
  217.      * @returns {StatCounter}
  218.      */
  219.     FloatRDD.prototype.stats = function () {
  220.       throw "not implemented by ElairJS";
  221.     };
  223.     /**
  224.      * @returns {float}
  225.      */
  226.     FloatRDD.prototype.mean = function () {
  227.       var args = {
  228.         target: this,
  229.         method: 'mean',
  230.         returnType: Number
  231.       };
  233.       return Utils.generate(args);
  234.     };
  236.     /**
  237.      * @returns {float}
  238.      */
  239.     FloatRDD.prototype.variance = function () {
  240.       throw "not implemented by ElairJS";
  241.     };
  243.     /**
  244.      * @returns {float}
  245.      */
  246.     FloatRDD.prototype.stdev = function () {
  247.       throw "not implemented by ElairJS";
  248.     };
  250.     /**
  251.      * Compute the sample standard deviation of this RDD's elements (which corrects for bias in
  252.      * estimating the standard deviation by dividing by N-1 instead of N).
  253.      * @returns {float}
  254.      */
  255.     FloatRDD.prototype.sampleStdev = function () {
  256.       throw "not implemented by ElairJS";
  257.     };
  259.     /**
  260.      * Compute the sample variance of this RDD's elements (which corrects for bias in
  261.      * estimating the standard variance by dividing by N-1 instead of N).
  262.      * @returns {float}
  263.      */
  264.     FloatRDD.prototype.sampleVariance = function () {
  265.       throw "not implemented by ElairJS";
  266.     };
  268.     /**
  269.      * @param {number} timeout
  270.      * @param {float} [confidence]
  271.      * @returns {PartialResult}
  272.      */
  273.     FloatRDD.prototype.meanApprox = function (timeout, confidence) {
  274.       throw "not implemented by ElairJS";
  275.     };
  277.     /**
  278.      * Approximate operation to return the sum within a timeout.
  279.      * @param {number} timeout
  280.      * @param {float} [confidence]
  281.      * @returns {PartialResult}
  282.      */
  283.     FloatRDD.prototype.sumApprox = function (timeout, confidence) {
  284.       throw "not implemented by ElairJS";
  285.     };
  287.     /**
  288.      * Compute a histogram of the data using bucketCount number of buckets evenly
  289.      *  spaced between the minimum and maximum of the RDD. For example if the min
  290.      *  value is 0 and the max is 100 and there are two buckets the resulting
  291.      *  buckets will be [0,50) [50,100]. bucketCount must be at least 1
  292.      * If the RDD contains infinity, NaN throws an exception
  293.      * If the elements in RDD do not vary (max == min) always returns a single bucket.
  294.      * @param {number} bucketCount
  295.      * @returns {Pair}
  296.      */
  297.     FloatRDD.prototype.histogram0 = function (bucketCount) {
  298.       throw "not implemented by ElairJS";
  299.     };
  302.     /**
  303.      * Compute a histogram using the provided buckets. The buckets are all open
  304.      * to the left except for the last which is closed
  305.      *  e.g. for the array
  306.      *  [1,10,20,50] the buckets are [1,10) [10,20) [20,50]
  307.      *  e.g 1<=x<10 , 10<=x<20, 20<=x<50
  308.      *  And on the input of 1 and 50 we would have a histogram of 1,0,0
  309.      *
  310.      * Note: if your histogram is evenly spaced (e.g. [0, 10, 20, 30]) this can be switched
  311.      * from an O(log n) insertion to O(1) per element. (where n = # buckets) if you set evenBuckets
  312.      * to true.
  313.      * buckets must be sorted and not contain any duplicates.
  314.      * buckets array must be at least two elements
  315.      * All NaN entries are treated the same. If you have a NaN bucket it must be
  316.      * the maximum value of the last position and all NaN entries will be counted
  317.      * in that bucket.
  318.      * @param {number[]} buckets
  319.      * @returns {number[]}
  320.      */
  321.     FloatRDD.prototype.histogram1 = function (buckets) {
  322.       throw "not implemented by ElairJS";
  323.     };
  326.     /**
  327.      * @param {float[]} buckets
  328.      * @param {boolean} evenBuckets
  329.      * @returns {number[]}
  330.      */
  331.     FloatRDD.prototype.histogram2 = function (buckets, evenBuckets) {
  332.       throw "not implemented by ElairJS";
  333.     };
  335.     /**
  336.      * Save this FloatRDD as a text file, using string representations of elements.
  337.      * @param {string} path
  338.      * @param {boolean} [overwrite] defaults to false, if true overwrites file if it exists
  339.      * @returns {Promise.<void>}
  340.      */
  341.     FloatRDD.prototype.saveAsTextFile = function(path) {
  342.       var args = {
  343.         target: this,
  344.         method: 'saveAsTextFile',
  345.         args: Utils.wrapArguments(arguments)
  346.       };
  348.       return Utils.generate(args);
  349.     };
  351.     /**
  352.      * Save this FloatRDD as a SequenceFile of serialized objects.
  353.      * @param {string} path
  354.      * @param {boolean} [overwrite] defaults to false, if true overwrites file if it exists
  355.      * @returns {Promise.<void>}
  356.      */
  357.     FloatRDD.prototype.saveAsObjectFile = function(path) {
  358.       var args = {
  359.         target: this,
  360.         method: 'saveAsObjectFile',
  361.         args: Utils.wrapArguments(arguments)
  362.       };
  364.       return Utils.generate(args);
  365.     };
  367.     /**
  368.      * @param {string} name
  369.      * @returns {module:eclairjs/rdd.FloatRDD}
  370.      */
  371.     FloatRDD.prototype.setName = function (name) {
  372.       throw "not implemented by ElairJS";
  373.     };
  375.     FloatRDD.prototype.toString = function() {
  376.       var args = {
  377.         target: this,
  378.         method: 'toString',
  379.         returnType: String
  380.       };
  382.       return Utils.generate(args);
  383.     };
  385. //
  386. // static methods
  387. //
  389.     /**
  390.      * @param {module:eclairjs/rdd.RDD} rdd
  391.      * @returns {module:eclairjs/rdd.FloatRDD}
  392.      */
  393.     FloatRDD.fromRDD = function(rdd) {
  394.       var args = {
  395.         target: FloatRDD,
  396.         method: 'fromRDD',
  397.         args: Utils.wrapArguments(arguments),
  398.         returnType: FloatRDD,
  399.         kernelP: rdd.kernelP,
  400.         static: true
  401.       };
  403.       return Utils.generate(args);
  404.     };
  406.     /**
  407.      * @param {module:eclairjs/rdd.FloatRDD} rdd
  408.      * @returns {module:eclairjs/rdd.RDD}
  409.      */
  410.     FloatRDD.toRDD = function (rdd) {
  411.       throw "not implemented by ElairJS";
  412.     };
  414.     FloatRDD.moduleLocation = '/FloatRDD';
  416.     return FloatRDD;
  417.   })();
  418. };