292 lines
11 KiB
JavaScript
292 lines
11 KiB
JavaScript
import * as Blockly from 'blockly/core';
|
|
|
|
export const tuple_create_with = function (_, generator) {
|
|
// Create a list with any number of elements of any type.
|
|
var varName = generator.variableDB_.getName(this.getFieldValue('VAR'),
|
|
Blockly.Variables.NAME_TYPE);
|
|
//var size=window.parseFloat(this.getFieldValue('SIZE'));
|
|
var code = new Array(this.itemCount_);
|
|
var default_value = '0';
|
|
for (var n = 0; n < this.itemCount_; n++) {
|
|
|
|
code[n] = generator.valueToCode(this, 'ADD' + n,
|
|
generator.ORDER_NONE) || default_value;
|
|
}
|
|
// if (this.itemCount_!=1){
|
|
// generator.definitions_['var_declare'+varName] = varName+'= '+ '(' + code.join(', ') + ')\n';}
|
|
// else {
|
|
// generator.definitions_['var_declare'+varName] = varName+'= '+ '(' + code.join(', ') + ',)\n';}
|
|
if (this.itemCount_ != 1) {
|
|
var code = varName + '= ' + '(' + code.join(', ') + ')\n';
|
|
}
|
|
else {
|
|
var code = varName + '= ' + '(' + code.join(', ') + ',)\n';
|
|
}
|
|
return code;
|
|
}
|
|
|
|
export const tuple_create_with_text2 = function (_, generator) {
|
|
var varName = generator.variableDB_.getName(this.getFieldValue('VAR'),
|
|
Blockly.Variables.NAME_TYPE);
|
|
//var size=window.parseFloat(this.getFieldValue('SIZE'));
|
|
var text = this.getFieldValue('TEXT');
|
|
//generator.definitions_['var_declare'+varName] = varName+'= '+ '(' + text + ')\n';
|
|
var code = varName + '= ' + '(' + text + ')\n';
|
|
return code;
|
|
}
|
|
|
|
export const tuple_create_with_text_return = function (_, generator) {
|
|
var text = this.getFieldValue('TEXT');
|
|
var code = '(' + text + ')';
|
|
return [code, generator.ORDER_ATOMIC];
|
|
}
|
|
|
|
export const tuple_getIndex = function (_, generator) {
|
|
// Indexing into a list is the same as indexing into a string.
|
|
var varName = generator.valueToCode(this, 'TUP', generator.ORDER_ASSIGNMENT) || '0';
|
|
var argument0 = generator.valueToCode(this, 'AT',
|
|
generator.ORDER_ADDITIVE) || '1';
|
|
if (argument0.match(/^\d+$/)) {
|
|
// If the index is a naked number, decrement it right now.
|
|
argument0 = parseInt(argument0, 10);
|
|
}
|
|
// else {
|
|
// If the index is dynamic, decrement it in code.
|
|
// argument0;
|
|
// }
|
|
var code = varName + '[' + argument0 + ']';
|
|
return [code, generator.ORDER_ATOMIC];
|
|
}
|
|
|
|
export const tuple_length = function (_, generator) {
|
|
var varName = generator.valueToCode(this, 'TUP', generator.ORDER_ASSIGNMENT) || '0';
|
|
var code = 'len(' + varName + ')';
|
|
return [code, generator.ORDER_ATOMIC];
|
|
}
|
|
|
|
export const tuple_del = function (_, generator) {
|
|
var varName = generator.valueToCode(this, 'TUP', generator.ORDER_ASSIGNMENT) || '0';
|
|
var code = 'del ' + varName + '\n';
|
|
return code;
|
|
}
|
|
|
|
export const tuple_join = function (_, generator) {
|
|
var varName1 = generator.valueToCode(this, 'TUP1', generator.ORDER_ASSIGNMENT) || '0';
|
|
var varName2 = generator.valueToCode(this, 'TUP2', generator.ORDER_ASSIGNMENT) || '0';
|
|
var code = varName1 + " + " + varName2;
|
|
return [code, generator.ORDER_ATOMIC];
|
|
}
|
|
|
|
export const tuple_max = function (_, generator) {
|
|
var varname = generator.valueToCode(this, 'TUP', generator.ORDER_ASSIGNMENT) || '0';
|
|
var maxmin = this.getFieldValue('DIR');
|
|
var code = maxmin + "(" + varname + ')';
|
|
return [code, generator.ORDER_ATOMIC];
|
|
}
|
|
|
|
export const tuple_change_to = function (_, generator) {
|
|
var op = this.getFieldValue('OP');
|
|
var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ASSIGNMENT) || '0';
|
|
var code = op + '(' + varName + ')\n';
|
|
return [code, generator.ORDER_ATOMIC];
|
|
}
|
|
|
|
export const tuple_find = function (_, generator) {
|
|
var op = this.getFieldValue('OP');
|
|
var varName = generator.valueToCode(this, 'VAR', generator.ORDER_ASSIGNMENT) || '0';
|
|
var argument = generator.valueToCode(this, 'data', generator.ORDER_ASSIGNMENT) || '0';
|
|
if (op == 'INDEX')
|
|
var code = varName + '.index(' + argument + ')';
|
|
else if (op == 'COUNT')
|
|
var code = varName + '.count(' + argument + ')';
|
|
return [code, generator.ORDER_ATOMIC];
|
|
}
|
|
|
|
export const tuple_trig = function (a, generator) {
|
|
var b = a.getFieldValue("OP"), c;
|
|
generator.definitions_['import_math'] = "import math";
|
|
a = generator.valueToCode(a, 'data', generator.ORDER_NONE)
|
|
switch (b) {
|
|
case "LEN":
|
|
c = "len(" + a + ")";
|
|
break;
|
|
case "SUM":
|
|
c = "sum(" + a + ")";
|
|
break;
|
|
case "MIN":
|
|
c = "min(" + a + ")";
|
|
break;
|
|
case "MAX":
|
|
c = "max(" + a + ")";
|
|
break;
|
|
case 'AVERAGE':
|
|
// generator.definitions_['from_numbers_import_Number'] =
|
|
// 'from numbers import Number';
|
|
var functionName = generator.provideFunction_(
|
|
'math_mean',
|
|
// This operation excludes null and values that aren't int or float:',
|
|
// math_mean([null, null, "aString", 1, 9]) == 5.0.',
|
|
['def ' + generator.FUNCTION_NAME_PLACEHOLDER_ + '(myList):',
|
|
' localList = [e for e in myList if type(e) == int or type(e) == float]',
|
|
' if not localList: return',
|
|
' return float(sum(localList)) / len(localList)']);
|
|
c = functionName + '(' + a + ')';
|
|
break;
|
|
case 'MEDIAN':
|
|
// generator.definitions_['from_numbers_import_Number'] =
|
|
// 'from numbers import Numberd';
|
|
var functionName = generator.provideFunction_(
|
|
'math_median',
|
|
// This operation excludes null values:
|
|
// math_median([null, null, 1, 3]) == 2.0.
|
|
['def ' + generator.FUNCTION_NAME_PLACEHOLDER_ + '(myList):',
|
|
' localList = sorted([e for e in myList if type(e) == int or type(e) == float])',
|
|
' if not localList: return',
|
|
' if len(localList) % 2 == 0:',
|
|
' return (localList[len(localList) // 2 - 1] + ' +
|
|
'localList[len(localList) // 2]) / 2.0',
|
|
' else:',
|
|
' return localList[(len(localList) - 1) // 2]']);
|
|
c = functionName + '(' + a + ')';
|
|
break;
|
|
case 'MODE':
|
|
var functionName = generator.provideFunction_(
|
|
'math_modes',
|
|
// As a list of numbers can contain more than one mode,
|
|
// the returned result is provided as an array.
|
|
// Mode of [3, 'x', 'x', 1, 1, 2, '3'] -> ['x', 1].
|
|
['def ' + generator.FUNCTION_NAME_PLACEHOLDER_ + '(some_list):',
|
|
' modes = []',
|
|
' # Using a lists of [item, count] to keep count rather than dict',
|
|
' # to avoid "unhashable" errors when the counted item is ' +
|
|
'itself a list or dict.',
|
|
' counts = []',
|
|
' maxCount = 1',
|
|
' for item in some_list:',
|
|
' found = False',
|
|
' for count in counts:',
|
|
' if count[0] == item:',
|
|
' count[1] += 1',
|
|
' maxCount = max(maxCount, count[1])',
|
|
' found = True',
|
|
' if not found:',
|
|
' counts.append([item, 1])',
|
|
' for counted_item, item_count in counts:',
|
|
' if item_count == maxCount:',
|
|
' modes.append(counted_item)',
|
|
' return modes']);
|
|
c = functionName + '(' + a + ')';
|
|
break;
|
|
case 'STD_DEV':
|
|
generator.definitions_['import_math'] = 'import math';
|
|
var functionName = generator.provideFunction_(
|
|
'math_standard_deviation',
|
|
['def ' + generator.FUNCTION_NAME_PLACEHOLDER_ + '(numbers):',
|
|
' n = len(numbers)',
|
|
' if n == 0: return',
|
|
' mean = float(sum(numbers)) / n',
|
|
' variance = sum((x - mean) ** 2 for x in numbers) / n',
|
|
' return math.sqrt(variance)']);
|
|
c = functionName + '(' + a + ')';
|
|
break;
|
|
default:
|
|
throw 'Unknown operator: ' + b;
|
|
}
|
|
if (c)
|
|
return [c, generator.ORDER_FUNCTION_CALL];
|
|
|
|
}
|
|
|
|
export const tuple_getSublist = function (block, generator) {
|
|
// Get sublist.
|
|
var list = generator.valueToCode(block, 'LIST',
|
|
generator.ORDER_MEMBER) || '[]';
|
|
var where1 = block.getFieldValue('WHERE1');
|
|
var where2 = block.getFieldValue('WHERE2');
|
|
switch (where1) {
|
|
case 'FROM_START':
|
|
var at1 = generator.getAdjustedInt(block, 'AT1');
|
|
if (at1 == '0') {
|
|
at1 = '';
|
|
}
|
|
break;
|
|
case 'FROM_END':
|
|
var at1 = generator.getAdjustedInt(block, 'AT1', 1, true);
|
|
break;
|
|
case 'FIRST':
|
|
var at1 = '0';
|
|
break;
|
|
default:
|
|
throw 'Unhandled option (lists_getSublist)';
|
|
}
|
|
switch (where2) {
|
|
case 'FROM_START':
|
|
var at2 = generator.getAdjustedInt(block, 'AT2', 1);
|
|
at2 = at2 - 1;
|
|
break;
|
|
case 'FROM_END':
|
|
var at2 = generator.getAdjustedInt(block, 'AT2', 1, true);
|
|
// Ensure that if the result calculated is 0 that sub-sequence will
|
|
// include all elements as expected.
|
|
if (!Blockly.isNumber(String(at2))) {
|
|
generator.definitions_['import_sys'] = 'import sys';
|
|
at2 += ' or sys.maxsize';
|
|
} else if (at2 == '0') {
|
|
at2 = '';
|
|
}
|
|
break;
|
|
case 'LAST':
|
|
var at2 = '-1';
|
|
break;
|
|
default:
|
|
throw 'Unhandled option (lists_getSublist)';
|
|
}
|
|
var code = list + '[' + at1 + ' : ' + at2 + ']';
|
|
return [code, generator.ORDER_MEMBER];
|
|
}
|
|
|
|
export const tuple_create_with_noreturn = function (_, generator) {
|
|
// Create a list with any number of elements of any type.
|
|
var code = new Array(this.itemCount_);
|
|
var default_value = '0';
|
|
|
|
|
|
for (var n = 0; n < this.itemCount_; n++) {
|
|
|
|
code[n] = generator.valueToCode(this, 'ADD' + n,
|
|
generator.ORDER_NONE) || default_value;
|
|
}
|
|
// if (this.itemCount_!=1){
|
|
// generator.definitions_['var_declare'+varName] = varName+'= '+ '(' + code.join(', ') + ')\n';}
|
|
// else {
|
|
// generator.definitions_['var_declare'+varName] = varName+'= '+ '(' + code.join(', ') + ',)\n';}
|
|
if (this.itemCount_ != 1) {
|
|
var code = '(' + code.join(', ') + ')';
|
|
}
|
|
else {
|
|
var code = '(' + code.join(', ') + ',)';
|
|
}
|
|
|
|
return [code, generator.ORDER_ATOMIC];
|
|
}
|
|
|
|
export const tuple_get_sublist = function (_, generator) {
|
|
// Get sublist.
|
|
var list = generator.valueToCode(this, 'LIST', generator.ORDER_ADDITIVE) || '0';
|
|
var at1 = generator.valueToCode(this, 'AT1', generator.ORDER_ADDITIVE) || '0';
|
|
var at2 = generator.valueToCode(this, 'AT2', generator.ORDER_ADDITIVE) || '0';
|
|
var code = list + '[' + at1 + ' : ' + at2 + ']';
|
|
return [code, generator.ORDER_ATOMIC];
|
|
}
|
|
|
|
export const tuple_get_random_item = function (_, generator) {
|
|
generator.definitions_['import_random'] = 'import random';
|
|
var varName = generator.valueToCode(this, 'TUP', generator.ORDER_ADDITIVE) || 'mytup';
|
|
var code = 'random.choice(' + varName + ')';
|
|
return [code, generator.ORDER_ATOMIC];
|
|
}
|
|
|
|
export const tuple_totuple = function (_, generator) {
|
|
var str = generator.valueToCode(this, 'VAR', generator.ORDER_ATOMIC) || '0'
|
|
return ['tuple(' + str + ')', generator.ORDER_ATOMIC];
|
|
} |