LBFGS.runLBFGS = function (data,gradient,updater,numCorrections,convergenceTol,maxNumIterations,regParam,initialWeights) {
var data_uw = Utils.unwrapObject(data);
var rdd = data_uw.rdd();
var gradient_uw = Utils.unwrapObject(gradient);
var updater_uw = Utils.unwrapObject(updater);
var initialWeights_uw = Utils.unwrapObject(initialWeights);
var javaObject = org.apache.spark.mllib.optimization.LBFGS.runLBFGS(rdd,gradient_uw,updater_uw,numCorrections,convergenceTol,maxNumIterations,regParam,initialWeights_uw);
return Utils.javaToJs(javaObject);
};
Matrix.prototype.toArray = function () {
var res = this.getJavaObject().toArray();
var results = [];
for (var i = 0; i < res.length; i++) {
var value = res[i];
var o = Utils.javaToJs(value);
results.push(o);
}
return results;
};
TwitterUtils.createStream = function (jssc, twitterAuth, filters) {
var jssc_uw = Utils.unwrapObject(jssc);
var twitterAuth_uw = Utils.unwrapObject(twitterAuth);
if (!twitterAuth_uw)
twitterAuth_uw = null;
if (!filters)
filters = null;
var javaObject = JavaTwitterUtils["createStream(JavaStreamingContext,twitter4j.auth.Authorization,String[])"]
(jssc_uw, twitterAuth_uw, filters);
return Utils.javaToJs(javaObject, jssc);
};
Estimator.prototype.fit = function(dataset, paramMap) {
var dataset_uw = Utils.unwrapObject(dataset);
var javaObject;
if (paramMap) {
var paramMap_uw = Utils.unwrapObject(paramMap);
javaObject = this.getJavaObject().fit(dataset_uw, paramMap_uw);
} else {
javaObject = this.getJavaObject().fit(dataset_uw);
}
return Utils.javaToJs(javaObject);
};
StreamingContext.prototype.queueStream = function (queue) {
var jQueue = new JLinkedList();
for (var index in queue)
jQueue.add(Utils.unwrapObject(queue[index]));
var oneAtATime = (arguments.length > 1) ? arguments[1] : true;
var javaObject;
if (arguments.length > 2) {
var defaultRDD_uw = Utils.unwrapObject(arguments[2]);
javaObject = this.getJavaObject().queueStream(jQueue, oneAtATime, defaultRDD_uw);
}
else
javaObject = this.getJavaObject().queueStream(jQueue, oneAtATime);
return Utils.javaToJs(javaObject);
};
SQLContext.prototype.createExternalTable = function (tableName, path, source, options, schema) {
var javaObject;
if (tableName && path && !source && !options && !schema) {
javaObject = this.getJavaObject().createExternalTable(tableName, path);
} else if (tableName && path && source && !options && !schema) {
javaObject = this.getJavaObject().createExternalTable(tableName, path, source);
} else if (tableName && source && options && !schema) {
var options_uw = Utils.createJavaHashMap(options);
javaObject = this.getJavaObject().createExternalTable(tableName, source, options_uw);
} else if (tableName && source && options && schema) {
var options_uw = Utils.createJavaHashMap(options);
var schema_uw = Utils.unwrapObject(schema);
javaObject = this.getJavaObject().createExternalTable(tableName, source, schema_uw, options_uw);
}
return Utils.javaToJs(javaObject);
};
DataFrameReader.prototype.jdbc = function () {
var javaObject;
if (arguments.length == 3) {
// connectionPropertiesMap
var map = Utils.createJavaHashMap(arguments[2], new java.util.Properties());
javaObject = this.getJavaObject().jdbc(arguments[0], arguments[1], map);
} else if (arguments.length == 4) {
// predicates
var map = Utils.createJavaHashMap(arguments[3], new java.util.Properties());
javaObject = this.getJavaObject().jdbc(arguments[0], arguments[1], arguments[2], map);
} else if (arguments.length == 7) {
var map = Utils.createJavaHashMap(arguments[6], new java.util.Properties());
javaObject = this.getJavaObject().jdbc(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5], map);
} else {
throw "DataFrameReader.jdbc() invalid number of arguments.";
}
return Utils.javaToJs(javaObject);
}
GroupedData.prototype.agg = function () {
/*
* First convert any strings to Columns
*/
var args = Utils.createJavaObjectArguments(arguments, Column);
/*
* Create a argument list we can send to Java
*/
var str = "this.getJavaObject().agg("
for (var i = 0; i < args.length; i++) {
var spacer = i < 1 ? "" : ",";
str += spacer + "args[" + i + "]";
}
str += ");";
var javaObject = eval(str);
return Utils.javaToJs(javaObject);
};
ALS.train = function (ratings, rank, iterations, lambda, blocks, seed) {
/*
var ratings_uw = Utils.unwrapObject(ratings);
if (ratings_uw instanceof org.apache.spark.api.java.JavaRDD) {
ratings_uw = ratings_uw.rdd();
}
*/
var ratings_uw = org.apache.spark.api.java.JavaRDD.toRDD(ratings.getJavaObject());
var javaObject;
if (seed) {
javaObject = org.apache.spark.mllib.recommendation.ALS.train(ratings_uw, rank, iterations, lambda, blocks, seed);
} else if (blocks) {
javaObject = org.apache.spark.mllib.recommendation.ALS.train(ratings_uw, rank, iterations, lambda, blocks);
} else if (lambda) {
javaObject = org.apache.spark.mllib.recommendation.ALS.train(ratings_uw, rank, iterations, lambda);
} else {
javaObject = org.apache.spark.mllib.recommendation.ALS.train(ratings_uw, rank, iterations);
}
return Utils.javaToJs(javaObject);
};
RandomForest.trainRegressor = function (input,
categoricalFeaturesInfo,
numTrees,
featureSubsetStrategy,
impurity,
maxDepth,
maxBins,
seed) {
var categoricalFeaturesInfo_uw = Utils.createJavaHashMap(categoricalFeaturesInfo);
var javaObject = org.apache.spark.mllib.tree.RandomForest.trainRegressor(
Utils.unwrapObject(input),
categoricalFeaturesInfo_uw,
numTrees,
featureSubsetStrategy,
impurity,
maxDepth,
maxBins,
seed
);
return Utils.javaToJs(javaObject);
};
SQLContext.prototype.sql = function (sqlText) {
return Utils.javaToJs(this.getJavaObject().sql(sqlText));
};
SQLContext.prototype.createDataFrame = function (rowRDD_or_values, schema) {
function castDataType(x, dt){
/*
Nashorn interprets numbers as java.lang.Double, java.lang.Long, or java.lang.Integer objects,
depending on the computation performed.
JavaScript numbers are not always converted to the correct Java type. So we need to force all the number types in the
row to be matched to the type specified in the schema
*/
if ((x instanceof java.lang.Integer) && (dt.getJavaObject() instanceof org.apache.spark.sql.types.DoubleType)) {
return x.doubleValue();
} else if ((x instanceof java.lang.Integer) && (dt.getJavaObject() instanceof org.apache.spark.sql.types.FloatType)) {
return x.floatValue();
} else if ((x instanceof java.lang.Double) && (dt.getJavaObject() instanceof org.apache.spark.sql.types.IntegerType)) {
return x.intValue();
} else if ((x instanceof java.lang.Double) && (dt.getJavaObject() instanceof org.apache.spark.sql.types.FloatType)) {
return x.floatValue();
} else if (dt.getJavaObject() instanceof org.apache.spark.sql.types.ArrayType) {
var elmDt = dt.elementType();
var elements =[];
x.forEach(function(elem){
elements.push(castDataType(elem, elmDt))
})
return Serialize.jsToJava(elements);
} else {
return Utils.unwrapObject(x);
}
}
var DoubleType = require(EclairJS_Globals.NAMESPACE + '/sql/types/DoubleType');
var rowRDD_uw;
var schema_uw = Utils.unwrapObject(schema);
var fields = schema.fields();
if (Array.isArray(rowRDD_or_values)) {
var rows = new java.util.ArrayList();
rowRDD_or_values.forEach(function (row) {
if (Array.isArray(row)) {
var rowValues = new java.util.ArrayList();;
for (var i = 0; i < row.length; i++) {
var x = row[i];
var dt = fields[i].dataType();
rowValues.add(castDataType(x, dt));
}
rows.add(org.apache.spark.sql.RowFactory.create(rowValues.toArray()));
} else {
var v = [];
for (var i = 0; i < row.length(); i++) {
var x = row.get(i);
var dt = fields[i].dataType();
v.push(castDataType(x, dt));
}
rows.add(org.apache.spark.sql.RowFactory.create(v));
}
});
rowRDD_uw = rows;
} else {
rowRDD_uw = Utils.unwrapObject(rowRDD_or_values);
/*
Nashorn interprets numbers as java.lang.Double, java.lang.Long, or java.lang.Integer objects, depending on the computation performed.
JavaScript numbers are not always converted to the correct Java type. So we will use the Java function with
RDD.map to force them to the correct java type based on the schema provided.
NOTE: so far this seems to have only been an issue with number in RDD<Row> not when passed and Array. If we start seeing
the same issue when passed an Array we may need to do something similar in the if clause.
*/
var rdd_mapped = rowRDD_uw.map(new org.eclairjs.nashorn.sql.SqlContextCreateDataFrameFunction(schema_uw));
rowRDD_uw = rdd_mapped;
}
var x = this.getJavaObject().createDataFrame(Utils.unwrapObject(rowRDD_uw), Utils.unwrapObject(schema));
return Utils.javaToJs(x);
};
SQLContext.prototype.read = function () {
return Utils.javaToJs(this.getJavaObject().read());
};
PrefixSpanFreqSequence.prototype.sequence = function() {
var javaObject = this.getJavaObject().javaSequence();
return Utils.javaToJs(javaObject);
};
ClassificationModel.prototype.predict = function(testData) {
var testData_uw = Utils.unwrapObject(testData);
var javaObject = this.getJavaObject().predict(testData_uw);
return Utils.javaToJs(javaObject);
};
IsotonicRegressionModel.load = function (sc, path) {
var sc_uw = Utils.unwrapObject(sc);
var javaObject = org.apache.spark.mllib.regression.IsotonicRegressionModel.load(sc_uw.sc(), path);
return Utils.javaToJs(javaObject);
};
Predictor.prototype.copy = function(extra) {
var extra_uw = Utils.unwrapObject(extra);
var javaObject = this.getJavaObject().copy(extra_uw);
return Utils.javaToJs(javaObject);
};
VectorIndexer.prototype.transformSchema = function (schema) {
var schema_uw = Utils.unwrapObject(schema);
var javaObject = this.getJavaObject().transformSchema(schema_uw);
return Utils.javaToJs(javaObject);
};
Model.prototype.parent = function() {
var javaObject = this.getJavaObject().parent();
return Utils.javaToJs(javaObject);
};
SQLContext.prototype.udf = function () {
var javaObject = this.getJavaObject().udf();
var udfr = Utils.javaToJs(javaObject);
udfr.sparkContext(this.sparkContext());
return udfr;
};
StreamingContext.prototype.socketTextStream = function (host, port) {
var jDStream = this.getJavaObject().socketTextStream(host, port);
return Utils.javaToJs(jDStream, this);
};
UDFRegistration.prototype.register = function (name, func, returnType, bindArgs) {
var f = func.toString().replace(/ /g, ''); // removes all whitespace
var end = f.indexOf("{");
var f1 = f.substring(0, end - 1);
var f2 = f1.replace(/function\(/g, '');
var args = f2.split(",");
var bindArgsLen = bindArgs ? bindArgs.length : 0;
var udfArgLen = args.length - bindArgsLen;
var udfClass;
switch (udfArgLen) {
case 1:
udfClass = org.eclairjs.nashorn.sql.JSUDF1;
break;
case 2:
udfClass = org.eclairjs.nashorn.sql.JSUDF2;
break;
case 3:
udfClass = org.eclairjs.nashorn.sql.JSUDF3;
break;
case 4:
udfClass = org.eclairjs.nashorn.sql.JSUDF4;
break;
case 5:
udfClass = org.eclairjs.nashorn.sql.JSUDF5;
break;
case 6:
udfClass = org.eclairjs.nashorn.sql.JSUDF6;
break;
case 7:
udfClass = org.eclairjs.nashorn.sql.JSUDF7;
break;
case 8:
udfClass = org.eclairjs.nashorn.sql.JSUDF8;
break;
case 9:
udfClass = org.eclairjs.nashorn.sql.JSUDF9;
break;
case 10:
udfClass = org.eclairjs.nashorn.sql.JSUDF10;
break;
case 11:
udfClass = org.eclairjs.nashorn.sql.JSUDF11;
break;
case 12:
udfClass = org.eclairjs.nashorn.sql.JSUDF12;
break;
case 13:
udfClass = org.eclairjs.nashorn.sql.JSUDF13;
break;
case 14:
udfClass = org.eclairjs.nashorn.sql.JSUDF14;
break;
case 15:
udfClass = org.eclairjs.nashorn.sql.JSUDF15;
break;
case 16:
udfClass = org.eclairjs.nashorn.sql.JSUDF16;
break;
case 17:
udfClass = org.eclairjs.nashorn.sql.JSUDF17;
break;
case 18:
udfClass = org.eclairjs.nashorn.sql.JSUDF18;
break;
case 19:
udfClass = org.eclairjs.nashorn.sql.JSUDF19;
break;
case 20:
udfClass = org.eclairjs.nashorn.sql.JSUDF20;
break;
case 21:
udfClass = org.eclairjs.nashorn.sql.JSUDF21;
break;
case 22:
udfClass = org.eclairjs.nashorn.sql.JSUDF22;
break;
default:
throw "Unsupported number of argument for UDF"
break;
}
var fn = Utils.createLambdaFunction(func, udfClass, this.sparkContext(), bindArgs);
var returnType_uw = Utils.unwrapObject(returnType);
fn.setReturnType(returnType_uw);
var javaObject = this.getJavaObject().register(name, fn, returnType_uw);
return Utils.javaToJs(javaObject);
};
SQLContext.prototype.table = function (tableName) {
return Utils.javaToJs(this.getJavaObject().table(tableName));
};
RFormula.prototype.formula = function () {
var javaObject = this.getJavaObject().formula();
return Utils.javaToJs(javaObject);
};
SQLContext.prototype.sparkContext = function () {
var javaObject;
javaObject = this.getJavaObject().sparkContext();
return Utils.javaToJs(javaObject);
};
Predictor.prototype.setPredictionCol = function(value) {
var javaObject = this.getJavaObject().setPredictionCol(value);
return Utils.javaToJs(javaObject);
};
VectorIndexer.prototype.fit = function (dataset) {
var dataset_uw = Utils.unwrapObject(dataset);
var javaObject = this.getJavaObject().fit(dataset_uw);
return Utils.javaToJs(javaObject);
};
VectorIndexerModel.prototype.transform = function (dataset) {
var dataset_uw = Utils.unwrapObject(dataset);
var javaObject = this.getJavaObject().transform(dataset_uw);
return Utils.javaToJs(javaObject);
};
VectorIndexer.prototype.maxCategories = function () {
var javaObject = this.getJavaObject().maxCategories();
return Utils.javaToJs(javaObject);
};
VectorIndexerModel.prototype.categoryMaps = function () {
var javaObject = this.getJavaObject().javaCategoryMaps();
return Utils.javaToJs(javaObject); // java.util.Map
};