1371

pending completion

Build # 1371

Build Type

push

travis-ci-com

Committed by

web-flow

Commit Message

primitive_ops: be robust to undefined/null (#348)

A skill can always return undefined/null in a parameter if the
value is not available. In that case, we should return false
in the filter without an error.

Run Details

4439 of 6232 branches covered (71.23%)

Branch coverage included in aggregate %.

3 of 9 new or added lines in 1 file covered. (33.33%)

3 existing lines in 1 file now uncovered.

10172 of 12596 relevant lines covered (80.76%)

47726.59 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

69.15

/lib/runtime/primitive_ops.ts

// -*- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 -*-
//
// This file is part of ThingTalk
//
// Copyright 2018-2020 The Board of Trustees of the Leland Stanford Junior University
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>

import assert from 'assert';

import * as Ast from '../ast';

import {
    LocationLike,
    Location,
    Entity,
    Time,
    Currency,
    RecurrentTimeRule
} from './values';

// Implementations of the ThingTalk operators

function arrayEquals(a : unknown[], b : unknown[]) : boolean {
    if (a.length !== b.length)
        return false;

    for (let i = 0; i < a.length; i++) {
        if (!equality(a[i], b[i]))
            return false;
    }

    return true;
}

function objectEquals<T1, T2>(a : T1, b : T2) : boolean {
    const a_props = Object.getOwnPropertyNames(a) as Array<keyof T1>;
    const b_props = Object.getOwnPropertyNames(b) as Array<keyof T2>;

    if (a_props.length !== b_props.length)
        return false;

    for (let i = 0; i < a_props.length; i ++) {
        if (!equality(a[a_props[i]], b[a_props[i] as unknown as keyof T2]))
            return false;
    }

    return true;
}

export function distance(a : LocationLike, b : LocationLike) : number {
    const R = 6371000; // meters
    const lat1 = a.y;
    const lat2 = b.y;
    const lon1 = a.x;
    const lon2 = a.x;
    function toRadians(deg : number) { return deg * Math.PI / 180.0; }

    // formula courtesy of http://www.movable-type.co.uk/scripts/latlong.html
    const φ1 = toRadians(lat1);
    const φ2 = toRadians(lat2);
    const Δφ = toRadians(lat2-lat1);
    const Δλ = toRadians(lon2-lon1);

    const x = Math.sin(Δφ/2) * Math.sin(Δφ/2) +
            Math.cos(φ1) * Math.cos(φ2) *
            Math.sin(Δλ/2) * Math.sin(Δλ/2);
    const c = 2 * Math.atan2(Math.sqrt(x), Math.sqrt(1-x));

    return R * c;
}

function locationEquals(a : LocationLike, b : LocationLike) : boolean {
    if (a === b)
        return true;
    if (a.x === b.x && a.y === b.y)
        return true;
    //console.log('Comparing locations', [a,b]);
    const d = distance(a, b);
    //console.log('Distance (m): ' + d.toFixed(2));
    return d <= 10000;
}

function hasValueOf(x : unknown) : x is number|Date|Time {
    return typeof x === 'number' || x instanceof Date || x instanceof Time;
}

function editDistance(one : (string|unknown[]), two : (string|unknown[])) : number {
    if (typeof one === 'string' && typeof two === 'string') {
        if (one === two)
            return 0;
        if (one.indexOf(two) >= 0)
            return one.length - two.length;
        if (two.indexOf(one) >= 0)
            return two.length - one.length;
    }

    const R = one.length + 1;
    const C = two.length + 1;
    const matrix = new Array<number>(R * C);

    function set(i : number, j : number, v : number) : void {
        assert(i * C + j < R * C);
        matrix[i * C + j] = v;
    }

    function get(i : number, j : number) : number {
        assert(i * C + j < R * C);
        return matrix[i * C + j];
    }

    for (let j = 0; j < C; j++)
        set(0, j, j);
    for (let i = 1; i < R; i++)
        set(i, 0, i);
    for (let i = 1; i <= one.length; i++) {
        for (let j = 1; j <= two.length; j++) {
            if (one[i - 1] === two[j - 1])
                set(i, j, get(i - 1, j - 1));
            else
                set(i, j, 1 + Math.min(Math.min(get(i - 1, j), get(i, j - 1)), get(i - 1, j - 1)));
        }
    }

    return get(one.length, two.length);
}

export function equality(a : unknown, b : unknown) : boolean {
    if (a === b)
        return true;
    if (a === null || b === null) // they can't be both null because a !== b
        return false;
    if (a === undefined || b === undefined)
        return false;
    if (Number.isNaN(a) && Number.isNaN(b))
        return true;
    if (a instanceof Date && typeof b === 'string')
        return +a === +new Date(b);
    if (typeof a === 'string' && b instanceof Date)
        return +new Date(a) === +b;
    if (hasValueOf(a) && hasValueOf(b))
        return +a === +b;
    if (a instanceof Currency && b instanceof Currency)
        return a.value === b.value && a.code.toLowerCase() === b.code.toLowerCase();
    if (a instanceof Currency && typeof b === 'number')
        return +a === +b;
    if (b instanceof Currency && typeof a === 'number')
        return +a === +b;
    if (Location.isLocation(a) && Location.isLocation(b))
        return locationEquals(a, b);
    if (Entity.isEntity(a) && Entity.isEntity(b))
        return String(a) === String(b);
    if (a instanceof Ast.Example && b instanceof Ast.Example)
        return a.id === b.id;
    if (Array.isArray(a) && Array.isArray(b))
        return arrayEquals(a, b);
    if (typeof a === 'object' && typeof b === 'object') {
        assert(a !== null);
        assert(b !== null);
        return objectEquals(a, b);
    }

    return false;
}

export function like(a_ : unknown, b : string) : boolean {
    if (a_ instanceof Entity && a_.display)
        return like(a_.display, b);

    if (typeof a_ === 'string' && typeof b === 'string') {
        let a = a_.toLowerCase();
        a = a.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
        a = a.replace(/[\p{Mark}\p{Punctuation}\p{Separator}\p{Other}_]/ug, ' ');
        a = a.replace(/\p{White_Space}+/ug, ' ');
        a = a.trim();
        b = b.toLowerCase();
        b = b.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
        b = b.replace(/[\p{Mark}\p{Punctuation}\p{Separator}\p{Other}_]/ug, ' ');
        b = b.replace(/\p{White_Space}+/ug, ' ');
        b = b.trim();
        if (a.indexOf(b) >= 0)
            return true;
        for (const token_b of b.split(' ')) {
            let tokenFound = false;
            for (const token_a of a.split(' ')) {
                if (token_a === token_b || (editDistance(token_a, token_b) <= 1 && token_b.length > 1)) {
                    tokenFound = true;
                    break;
                }
            }
            if (!tokenFound)
                return false;
        }
        return true;
    }
    return false;
}

export function startsWith(a : unknown, b : unknown) : boolean {
    if (typeof a === 'string' && typeof b === 'string')
        return a.toLowerCase().startsWith(b.toLowerCase());
    return false;
}

export function endsWith(a : unknown, b : unknown) : boolean {
    if (typeof a === 'string' && typeof b === 'string')
        return a.toLowerCase().endsWith(b.toLowerCase());
    return false;
}

export function recurrentTimeSpecContains(spec : RecurrentTimeRule[],
                                          timeOrDate : Date|Time) : boolean {
    assert(Array.isArray(spec));

    let contained = false;
    for (const rule of spec) {
        if (rule.contains(timeOrDate)) {
            if (rule.subtract)
                contained = false;
            else
                contained = true;
        }
    }
    return contained;
}

export function contains(a : unknown[]|null|undefined, b : unknown) : boolean {
    if (a === null || a === undefined)
        return false;
    return a.some((x) => equality(x, b));
}

// b is a substring of any element of a
export function containsLike(a : unknown[]|null|undefined, b : string) {
    if (a === null || a === undefined)
        return false;
    return a.some((x) => like(x, b));
}

// any element of b is a substring of a
export function inArrayLike(a : string, b : string[]|null|undefined) {
    if (b === null || b === undefined)
        return false;
    return b.some((x) => like(a, x));
}

export function getTime(d : Date) : Time {
    return new Time(d.getHours(), d.getMinutes(), d.getSeconds());
}

export function getCurrency(d : number) : Currency {
    return new Currency(d, 'usd'); //Assumes that default location is USA
}

// aggregations
export function sum(a : number, b : number) : number {
    return a + b;
}
export function max(a : number, b : number) : number {
    return Math.max(a, b);
}
export function min(a : number, b : number) : number {
    return Math.min(a, b);
}
export function argmax(value : number, previous : number) : boolean {
    return value > previous;
}
export function argmin(value : number, previous : number) : boolean {
    return value < previous;
}

// FIXME: replace with a faster implementation based on binary trees
// if we care
export class EqualitySet {
    store : unknown[];

    constructor() {
        this.store = [];
    }

    has(value : unknown) : boolean {
        for (const candidate of this.store) {
            if (equality(candidate, value))
                return true;
        }
        return false;
    }

    add(value : unknown) : void {
        for (const candidate of this.store) {
            if (equality(candidate, value))
                return;
        }
        this.store.push(value);
    }

    get size() : number {
        return this.store.length;
    }
}

type ArgMinMaxOp = (value : number, previous : number) => number;

export class ArgMinMaxState<T> {
    private _op : ArgMinMaxOp;
    private _field : keyof T;
    private _total : number;
    private _filled : number;
    private _tuples : T[];
    private _outputTypes : string[];
    private _base : number;

    constructor(op : ArgMinMaxOp,
                field : keyof T,
                base : number,
                limit : number) {
        this._op = op;
        this._field = field;

        this._total = Math.max(base + limit - 1, 1);
        this._filled = 0;
        this._tuples = new Array(this._total);
        this._outputTypes = new Array(this._total);

        this._base = Math.max(base-1, 0);
    }

    *[Symbol.iterator]() : Generator<[string, unknown], void> {
        for (let i = this._base; i < this._filled; i++)
            yield [this._outputTypes[i], this._tuples[i]];
    }

    update(tuple : T, outputType : string) : void {
        const value = tuple[this._field] as unknown as number;

        for (let i = 0; i < this._filled; i++) {
            const candidate = this._tuples[i][this._field] as unknown as number;
            if (this._op(value, candidate)) {
                // shift everything by one

                let last;
                if (this._filled < this._total) {
                    last = this._filled;
                    this._filled++;
                } else {
                    last = this._filled-1;
                }
                for (let j = last; j > i; j--) {
                    this._tuples[j] = this._tuples[j-1];
                    this._outputTypes[j] = this._outputTypes[j-1];
                }

                this._tuples[i] = tuple;
                this._outputTypes[i] = outputType;
                return;
            }
        }

        if (this._filled < this._total) {
            this._tuples[this._filled] = tuple;
            this._outputTypes[this._filled] = outputType;
            this._filled ++;
        }
    }
}

export function count(x : unknown[]) : number {
    return x.length;
}

export function aggregateMax(array : number[]) : number {
    let value = -Infinity;
    for (const element of array)
        value = Math.max(element, value);
    return value;
}
export function aggregateMin(array : number[]) : number {
    let value = Infinity;
    for (const element of array)
        value = Math.min(element, value);
    return value;
}
export function aggregateSum(array : number[]) : number {
    let value = 0;
    for (const element of array)
        value += element;
    return value;
}
export function aggregateAvg(array : number[]) : number {
    let sum = 0;
    let count = 0;
    for (const element of array) {
        sum += element;
        count += 1;
    }
    return sum/count;
}
export function dateAdd(date : Date, offset : number) : Date {
    return new Date(date.getTime() + offset);
}
export function dateSub(date : Date, offset : number) : Date {
    return new Date(date.getTime() - offset);
}
export function timeAdd(time : Time, offset : number) : Time {
    return Time.fromSeconds(Number(time) + Math.round(offset/1000));
}
export function timeSub(time : Time, offset : number) : Time {
    return Time.fromSeconds(Number(time) - Math.round(offset/1000));
}

1	// -- mode: typescript; indent-tabs-mode: nil; js-basic-offset: 4 --
2	//
3	// This file is part of ThingTalk
4	//
5	// Copyright 2018-2020 The Board of Trustees of the Leland Stanford Junior University
6	//
7	// Licensed under the Apache License, Version 2.0 (the "License");
8	// you may not use this file except in compliance with the License.
9	// You may obtain a copy of the License at
10	//
11	// http://www.apache.org/licenses/LICENSE-2.0
12	//
13	// Unless required by applicable law or agreed to in writing, software
14	// distributed under the License is distributed on an "AS IS" BASIS,
15	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16	// See the License for the specific language governing permissions and
17	// limitations under the License.
18	//
19	// Author: Giovanni Campagna <gcampagn@cs.stanford.edu>
20
21	import assert from 'assert';	2✔
22
23	import * as Ast from '../ast';	2✔
24
25	import {	2✔
26	LocationLike,
27	Location,
28	Entity,
29	Time,
30	Currency,
31	RecurrentTimeRule
32	} from './values';
33
34	// Implementations of the ThingTalk operators
35
36	function arrayEquals(a : unknown[], b : unknown[]) : boolean {
37	if (a.length !== b.length)	16✔
38	return false;	4✔
39
40	for (let i = 0; i < a.length; i++) {	12✔
41	if (!equality(a[i], b[i]))	16✔
42	return false;	2✔
43	}
44
45	return true;	10✔
46	}
47
48	function objectEquals<T1, T2>(a : T1, b : T2) : boolean {
49	const a_props = Object.getOwnPropertyNames(a) as Array<keyof T1>;	10✔
50	const b_props = Object.getOwnPropertyNames(b) as Array<keyof T2>;	10✔
51
52	if (a_props.length !== b_props.length)	10!
53	return false;	×
54
55	for (let i = 0; i < a_props.length; i ++) {	10✔
56	if (!equality(a[a_props[i]], b[a_props[i] as unknown as keyof T2]))	44✔
57	return false;	2✔
58	}
59
60	return true;	8✔
61	}
62
63	export function distance(a : LocationLike, b : LocationLike) : number {	2✔
64	const R = 6371000; // meters	×
65	const lat1 = a.y;	×
66	const lat2 = b.y;	×
67	const lon1 = a.x;	×
68	const lon2 = a.x;	×
69	function toRadians(deg : number) { return deg * Math.PI / 180.0; }	×
70
71	// formula courtesy of http://www.movable-type.co.uk/scripts/latlong.html
72	const φ1 = toRadians(lat1);	×
73	const φ2 = toRadians(lat2);	×
74	const Δφ = toRadians(lat2-lat1);	×
75	const Δλ = toRadians(lon2-lon1);	×
76
77	const x = Math.sin(Δφ/2) * Math.sin(Δφ/2) +	×
78	Math.cos(φ1) * Math.cos(φ2) *
79	Math.sin(Δλ/2) * Math.sin(Δλ/2);
80	const c = 2 * Math.atan2(Math.sqrt(x), Math.sqrt(1-x));	×
81
82	return R * c;	×
83	}
84
85	function locationEquals(a : LocationLike, b : LocationLike) : boolean {
86	if (a === b)	12!
87	return true;	×
88	if (a.x === b.x && a.y === b.y)	12!
89	return true;	12✔
90	//console.log('Comparing locations', [a,b]);
91	const d = distance(a, b);	×
92	//console.log('Distance (m): ' + d.toFixed(2));
93	return d <= 10000;	×
94	}
95
96	function hasValueOf(x : unknown) : x is number\|Date\|Time {
97	return typeof x === 'number' \|\| x instanceof Date \|\| x instanceof Time;	252✔
98	}
99
100	function editDistance(one : (string\|unknown[]), two : (string\|unknown[])) : number {
101	if (typeof one === 'string' && typeof two === 'string') {	50!
102	if (one === two)	50!
103	return 0;	×
104	if (one.indexOf(two) >= 0)	50!
105	return one.length - two.length;	×
106	if (two.indexOf(one) >= 0)	50✔
107	return two.length - one.length;	10✔
108	}
109
110	const R = one.length + 1;	40✔
111	const C = two.length + 1;	40✔
112	const matrix = new Array<number>(R * C);	40✔
113
114	function set(i : number, j : number, v : number) : void {
115	assert(i * C + j < R * C);	1,776✔
116	matrix[i * C + j] = v;	1,776✔
117	}
118
119	function get(i : number, j : number) : number {
120	assert(i * C + j < R * C);	3,658✔
121	return matrix[i * C + j];	3,658✔
122	}
123
124	for (let j = 0; j < C; j++)	40✔
125	set(0, j, j);	274✔
126	for (let i = 1; i < R; i++)	40✔
127	set(i, 0, i);	220✔
128	for (let i = 1; i <= one.length; i++) {	40✔
129	for (let j = 1; j <= two.length; j++) {	220✔
130	if (one[i - 1] === two[j - 1])	1,282✔
131	set(i, j, get(i - 1, j - 1));	114✔
132	else
133	set(i, j, 1 + Math.min(Math.min(get(i - 1, j), get(i, j - 1)), get(i - 1, j - 1)));	1,168✔
134	}
135	}
136
137	return get(one.length, two.length);	40✔
138	}
139
140	export function equality(a : unknown, b : unknown) : boolean {	2✔
141	if (a === b)	334✔
142	return true;	126✔
143	if (a === null \|\| b === null) // they can't be both null because a !== b	208✔
144	return false;	2✔
145	if (a === undefined \|\| b === undefined)	206!
146	return false;	×
147	if (Number.isNaN(a) && Number.isNaN(b))	206✔
148	return true;	2✔
149	if (a instanceof Date && typeof b === 'string')	204✔
150	return +a === +new Date(b);	2✔
151	if (typeof a === 'string' && b instanceof Date)	202✔
152	return +new Date(a) === +b;	2✔
153	if (hasValueOf(a) && hasValueOf(b))	200✔
154	return +a === +b;	46✔
155	if (a instanceof Currency && b instanceof Currency)	154✔
156	return a.value === b.value && a.code.toLowerCase() === b.code.toLowerCase();	16✔
157	if (a instanceof Currency && typeof b === 'number')	138✔
158	return +a === +b;	4✔
159	if (b instanceof Currency && typeof a === 'number')	134✔
160	return +a === +b;	4✔
161	if (Location.isLocation(a) && Location.isLocation(b))	130✔
162	return locationEquals(a, b);	12✔
163	if (Entity.isEntity(a) && Entity.isEntity(b))	118✔
164	return String(a) === String(b);	86✔
165	if (a instanceof Ast.Example && b instanceof Ast.Example)	32!
166	return a.id === b.id;	×
167	if (Array.isArray(a) && Array.isArray(b))	32✔
168	return arrayEquals(a, b);	16✔
169	if (typeof a === 'object' && typeof b === 'object') {	16✔
170	assert(a !== null);	10✔
171	assert(b !== null);	10✔
172	return objectEquals(a, b);	10✔
173	}
174
175	return false;	6✔
176	}
177
178	export function like(a_ : unknown, b : string) : boolean {	2✔
179	if (a_ instanceof Entity && a_.display)	46!
180	return like(a_.display, b);	×
181
182	if (typeof a_ === 'string' && typeof b === 'string') {	46!
183	let a = a_.toLowerCase();	46✔
184	a = a.normalize("NFD").replace(/[\u0300-\u036f]/g, "");	46✔
185	a = a.replace(/[\p{Mark}\p{Punctuation}\p{Separator}\p{Other}_]/ug, ' ');	46✔
186	a = a.replace(/\p{White_Space}+/ug, ' ');	46✔
187	a = a.trim();	46✔
188	b = b.toLowerCase();	46✔
189	b = b.normalize("NFD").replace(/[\u0300-\u036f]/g, "");	46✔
190	b = b.replace(/[\p{Mark}\p{Punctuation}\p{Separator}\p{Other}_]/ug, ' ');	46✔
191	b = b.replace(/\p{White_Space}+/ug, ' ');	46✔
192	b = b.trim();	46✔
193	if (a.indexOf(b) >= 0)	46✔
194	return true;	24✔
195	for (const token_b of b.split(' ')) {	22✔
196	let tokenFound = false;	30✔
197	for (const token_a of a.split(' ')) {	30✔
198	if (token_a === token_b \|\| (editDistance(token_a, token_b) <= 1 && token_b.length > 1)) {	56✔
199	tokenFound = true;	20✔
200	break;	20✔
201	}
202	}
203	if (!tokenFound)	30✔
204	return false;	10✔
205	}
206	return true;	12✔
207	}
208	return false;	×
209	}
210
211	export function startsWith(a : unknown, b : unknown) : boolean {	2✔
212	if (typeof a === 'string' && typeof b === 'string')	×
213	return a.toLowerCase().startsWith(b.toLowerCase());	×
214	return false;	×
215	}
216
217	export function endsWith(a : unknown, b : unknown) : boolean {	2✔
218	if (typeof a === 'string' && typeof b === 'string')	×
219	return a.toLowerCase().endsWith(b.toLowerCase());	×
220	return false;	×
221	}
222
223	export function recurrentTimeSpecContains(spec : RecurrentTimeRule[],	2✔
224	timeOrDate : Date\|Time) : boolean {
225	assert(Array.isArray(spec));	×
226
227	let contained = false;	×
228	for (const rule of spec) {	×
229	if (rule.contains(timeOrDate)) {	×
230	if (rule.subtract)	×
231	contained = false;	×
232	else
233	contained = true;	×
234	}
235	}
236	return contained;	×
237	}
238
239	export function contains(a : unknown[]\|null\|undefined, b : unknown) : boolean {	2✔
NEW 240	if (a === null \|\| a === undefined)	×
NEW 241	return false;	×
UNCOV 242	return a.some((x) => equality(x, b));	×
243	}
244
245	// b is a substring of any element of a
246	export function containsLike(a : unknown[]\|null\|undefined, b : string) {	2✔
NEW 247	if (a === null \|\| a === undefined)	×
NEW 248	return false;	×
UNCOV 249	return a.some((x) => like(x, b));	×
250	}
251
252	// any element of b is a substring of a
253	export function inArrayLike(a : string, b : string[]\|null\|undefined) {	2✔
NEW 254	if (b === null \|\| b === undefined)	×
NEW 255	return false;	×
UNCOV 256	return b.some((x) => like(a, x));	×
257	}
258
259	export function getTime(d : Date) : Time {	2✔
260	return new Time(d.getHours(), d.getMinutes(), d.getSeconds());	×
261	}
262
263	export function getCurrency(d : number) : Currency {	2✔
264	return new Currency(d, 'usd'); //Assumes that default location is USA	×
265	}
266
267	// aggregations
268	export function sum(a : number, b : number) : number {	2✔
269	return a + b;	×
270	}
271	export function max(a : number, b : number) : number {	2✔
272	return Math.max(a, b);	×
273	}
274	export function min(a : number, b : number) : number {	2✔
275	return Math.min(a, b);	4✔
276	}
277	export function argmax(value : number, previous : number) : boolean {	2✔
278	return value > previous;	×
279	}
280	export function argmin(value : number, previous : number) : boolean {	2✔
281	return value < previous;	28✔
282	}
283
284	// FIXME: replace with a faster implementation based on binary trees
285	// if we care
286	export class EqualitySet {	2✔
287	store : unknown[];
288
289	constructor() {
290	this.store = [];	2✔
291	}
292
293	has(value : unknown) : boolean {
294	for (const candidate of this.store) {	×
295	if (equality(candidate, value))	×
296	return true;	×
297	}
298	return false;	×
299	}
300
301	add(value : unknown) : void {
302	for (const candidate of this.store) {	6✔
303	if (equality(candidate, value))	4✔
304	return;	2✔
305	}
306	this.store.push(value);	4✔
307	}
308
309	get size() : number {
310	return this.store.length;	2✔
311	}
312	}
313
314	type ArgMinMaxOp = (value : number, previous : number) => number;
315
316	export class ArgMinMaxState<T> {	2✔
317	private _op : ArgMinMaxOp;
318	private _field : keyof T;
319	private _total : number;
320	private _filled : number;
321	private _tuples : T[];
322	private _outputTypes : string[];
323	private _base : number;
324
325	constructor(op : ArgMinMaxOp,
326	field : keyof T,
327	base : number,
328	limit : number) {
329	this._op = op;	12✔
330	this._field = field;	12✔
331
332	this._total = Math.max(base + limit - 1, 1);	12✔
333	this._filled = 0;	12✔
334	this._tuples = new Array(this._total);	12✔
335	this._outputTypes = new Array(this._total);	12✔
336
337	this._base = Math.max(base-1, 0);	12✔
338	}
339
340	*[Symbol.iterator]() : Generator<[string, unknown], void> {
341	for (let i = this._base; i < this._filled; i++)	12✔
342	yield [this._outputTypes[i], this._tuples[i]];	18✔
343	}
344
345	update(tuple : T, outputType : string) : void {
346	const value = tuple[this._field] as unknown as number;	36✔
347
348	for (let i = 0; i < this._filled; i++) {	36✔
349	const candidate = this._tuples[i][this._field] as unknown as number;	28✔
350	if (this._op(value, candidate)) {	28✔
351	// shift everything by one
352
353	let last;
354	if (this._filled < this._total) {	18✔
355	last = this._filled;	14✔
356	this._filled++;	14✔
357	} else {
358	last = this._filled-1;	4✔
359	}
360	for (let j = last; j > i; j--) {	18✔
361	this._tuples[j] = this._tuples[j-1];	22✔
362	this._outputTypes[j] = this._outputTypes[j-1];	22✔
363	}
364
365	this._tuples[i] = tuple;	18✔
366	this._outputTypes[i] = outputType;	18✔
367	return;	18✔
368	}
369	}
370
371	if (this._filled < this._total) {	18✔
372	this._tuples[this._filled] = tuple;	14✔
373	this._outputTypes[this._filled] = outputType;	14✔
374	this._filled ++;	14✔
375	}
376	}
377	}
378
379	export function count(x : unknown[]) : number {	2✔
380	return x.length;	×
381	}
382
383	export function aggregateMax(array : number[]) : number {	2✔
384	let value = -Infinity;	×
385	for (const element of array)	×
386	value = Math.max(element, value);	×
387	return value;	×
388	}
389	export function aggregateMin(array : number[]) : number {	2✔
390	let value = Infinity;	×
391	for (const element of array)	×
392	value = Math.min(element, value);	×
393	return value;	×
394	}
395	export function aggregateSum(array : number[]) : number {	2✔
396	let value = 0;	×
397	for (const element of array)	×
398	value += element;	×
399	return value;	×
400	}
401	export function aggregateAvg(array : number[]) : number {	2✔
402	let sum = 0;	×
403	let count = 0;	×
404	for (const element of array) {	×
405	sum += element;	×
406	count += 1;	×
407	}
408	return sum/count;	×
409	}
410	export function dateAdd(date : Date, offset : number) : Date {	2✔
411	return new Date(date.getTime() + offset);	×
412	}
413	export function dateSub(date : Date, offset : number) : Date {	2✔
414	return new Date(date.getTime() - offset);	×
415	}
416	export function timeAdd(time : Time, offset : number) : Time {	2✔
417	return Time.fromSeconds(Number(time) + Math.round(offset/1000));	×
418	}
419	export function timeSub(time : Time, offset : number) : Time {	2✔
420	return Time.fromSeconds(Number(time) - Math.round(offset/1000));	×
421	}

stanford-oval / thingtalk / 1371

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous