"use strict";
/**
 * @license
 * Copyright 2017 Google Inc. All Rights Reserved.
 * 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.
 * =============================================================================
 */
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
var _this = this;
Object.defineProperty(exports, "__esModule", { value: true });
var tf = require("../index");
var jasmine_util_1 = require("../jasmine_util");
var test_util_1 = require("../test_util");
var util = require("../util");
var selu_util = require("./selu_util");
jasmine_util_1.describeWithFlags('relu', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, -2, 0, 3, -0.1]);
                    result = tf.relu(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 0, 0, 3, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('basic relu6', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, -2, 0, 8, -0.1]);
                    result = tf.relu6(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 0, 0, 6, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('5D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor5d([1, -2, 5, -3], [1, 2, 2, 1, 1]);
                    result = tf.relu(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 0, 5, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('6D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor6d([1, -2, 5, -3, -1, 4, 7, 8], [1, 2, 2, 2, 1, 1]);
                    result = tf.relu(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 0, 5, 0, 0, 4, 7, 8]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('does nothing to positive values', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(1);
                    result = tf.relu(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('sets negative values to 0', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(-1);
                    result = tf.relu(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('preserves zero values', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0);
                    result = tf.relu(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs, float32', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, -2, 0, 3, -0.1, NaN]);
                    result = tf.relu(a);
                    expect(result.dtype).toBe('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 0, 0, 3, 0, NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: positive scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, grad, da, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(3);
                    dy = tf.scalar(5);
                    grad = tf.grad(function (a) { return tf.relu(a); });
                    da = grad(a, dy);
                    expect(da.shape).toEqual(a.shape);
                    expect(da.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [5]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: relu6', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, grad, da, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(8);
                    dy = tf.scalar(5);
                    grad = tf.grad(function (a) { return tf.relu6(a); });
                    da = grad(a, dy);
                    expect(da.shape).toEqual(a.shape);
                    expect(da.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, grad, da, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(3);
                    dy = tf.scalar(5);
                    grad = tf.grad(function (a) { return tf.relu(a.clone()).clone(); });
                    da = grad(a, dy);
                    expect(da.shape).toEqual(a.shape);
                    expect(da.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [5]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: negative scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, grad, da, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(-3);
                    dy = tf.scalar(5);
                    grad = tf.grad(function (a) { return tf.relu(a); });
                    da = grad(a, dy);
                    expect(da.shape).toEqual(a.shape);
                    expect(da.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: array', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, grad, da, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([1, -1, 0, .1], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    grad = tf.grad(function (a) { return tf.relu(a); });
                    da = grad(a, dy);
                    expect(da.shape).toEqual(a.shape);
                    expect(da.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 0, 0, 4]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: relu6 array', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, grad, da, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([8, -1, 0, .1], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    grad = tf.grad(function (a) { return tf.relu6(a); });
                    da = grad(a, dy);
                    expect(da.shape).toEqual(a.shape);
                    expect(da.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 0, 0, 4]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.relu({}); })
            .toThrowError(/Argument 'x' passed to 'relu' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    result = tf.relu([1, -2, 0, 3, -0.1]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 0, 0, 3, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.relu('q'); })
            .toThrowError(/Argument 'x' passed to 'relu' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('abs', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, -2, 0, 3, -0.1]);
                    result = tf.abs(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 2, 0, 3, 0.1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('5D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor5d([1, -2, 0, -3], [1, 2, 2, 1, 1]);
                    result = tf.abs(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 2, 0, 3]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('6D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor6d([1, -2, 5, -3, -1, 4, 7, 8], [1, 2, 2, 2, 1, 1]);
                    result = tf.abs(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 2, 5, 3, 1, 4, 7, 8]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('complex64 rank-1', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.complex([-2, -1, 0, 1, 2], [1, 2, 3, 0, -1]);
                    result = tf.abs(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [
                            Math.sqrt(-2 * -2 + 1 * 1), Math.sqrt(-1 * -1 + 2 * 2),
                            Math.sqrt(0 * 0 + 3 * 3), Math.sqrt(1 * 1 + 0 * 0),
                            Math.sqrt(2 * 2 + -1 * -1)
                        ]]);
                    expect(result.shape).toEqual([5]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('complex64 rank-2', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.complex([[-3, -2, -1], [0, 1, 2]], [[4, 1, 2], [3, 0, -1]]);
                    result = tf.abs(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [
                            Math.sqrt(-3 * -3 + 4 * 4), Math.sqrt(-2 * -2 + 1 * 1),
                            Math.sqrt(-1 * -1 + 2 * 2), Math.sqrt(0 * 0 + 3 * 3),
                            Math.sqrt(1 * 1 + 0 * 0), Math.sqrt(2 * 2 + -1 * -1)
                        ]]);
                    expect(result.shape).toEqual([2, 3]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('complex64 rank-3', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.complex([[[-3, -2], [-1, 0]], [[1, 2], [3, 4]]], [[[4, 1], [2, 3]], [[0, -1], [-3, -4]]]);
                    result = tf.abs(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [
                            Math.sqrt(-3 * -3 + 4 * 4), Math.sqrt(-2 * -2 + 1 * 1),
                            Math.sqrt(-1 * -1 + 2 * 2), Math.sqrt(0 * 0 + 3 * 3),
                            Math.sqrt(1 * 1 + 0 * 0), Math.sqrt(2 * 2 + -1 * -1),
                            Math.sqrt(3 * 3 + -3 * -3), Math.sqrt(4 * 4 + -4 * -4)
                        ]]);
                    expect(result.shape).toEqual([2, 2, 2]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('is underflow-safe for complex64', function () { return __awaiter(_this, void 0, void 0, function () {
        var floatBits, small, a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    floatBits = tf.backend().floatPrecision();
                    switch (floatBits) {
                        case 32:
                            small = 1e-30;
                            break;
                        case 16:
                            small = 1e-4;
                            break;
                        default:
                            throw new Error("Test not implemented for ENV.engine.floatPrecision()=" + floatBits + ".");
                    }
                    a = tf.complex([small, 0, small, 0], [small, small, 0, 0]);
                    result = tf.abs(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(),
                        [
                            Math.hypot(small, small), Math.hypot(0, small), Math.hypot(small, 0),
                            Math.hypot(0, 0)
                        ],
                        /*tolerance=*/ small / 100]);
                    expect(result.shape).toEqual([4]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, -2, 0, 3, -0.1, NaN]);
                    result = tf.abs(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 2, 0, 3, 0.1, NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, da, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(4);
                    dy = tf.scalar(8);
                    da = tf.grad(function (a) { return tf.abs(a); })(a, dy);
                    expect(da.shape).toEqual(a.shape);
                    expect(da.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 * 1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () {
        var a = tf.scalar(4);
        var dy = tf.scalar(8);
        var da = tf.grad(function (a) { return a.clone().abs().clone(); })(a, dy);
        expect(da.shape).toEqual(a.shape);
        expect(da.dtype).toEqual('float32');
    });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, da, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, 2, -3, 5]);
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    da = tf.grad(function (a) { return tf.abs(a); })(a, dy);
                    expect(da.shape).toEqual(a.shape);
                    expect(da.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1 * 1, 2 * 1, 3 * -1, 4 * 1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, da, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([3, -1, -2, 3], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    da = tf.grad(function (a) { return tf.abs(a); })(a, dy);
                    expect(da.shape).toEqual(a.shape);
                    expect(da.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1 * 1, 2 * -1, 3 * -1, 4 * 1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.abs({}); })
            .toThrowError(/Argument 'x' passed to 'abs' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    result = tf.abs([1, -2, 0, 3, -0.1]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 2, 0, 3, 0.1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.abs('q'); })
            .toThrowError(/Argument 'x' passed to 'abs' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('step', jasmine_util_1.ALL_ENVS, function () {
    it('with 1d tensor', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, -2, -.01, 3, -0.1]);
                    result = tf.step(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 0, 0, 1, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('with 1d tensor and alpha', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, -2, -.01, 3, NaN]);
                    result = tf.step(a, 0.1);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 0.1, 0.1, 1, NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('with 2d tensor', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([1, -5, -3, 4], [2, 2]);
                    result = tf.step(a);
                    expect(result.shape).toEqual([2, 2]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 0, 0, 1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, -2, -.01, 3, NaN]);
                    result = tf.step(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 0, 0, 1, NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(-4);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.step(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(-4);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.step(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, 2, -3, 5]);
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    gradients = tf.grad(function (a) { return tf.step(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 0, 0, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([3, -1, -2, 3], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    gradients = tf.grad(function (a) { return tf.step(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 0, 0, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.step({}); })
            .toThrowError(/Argument 'x' passed to 'step' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    result = tf.step([1, -2, -.01, 3, -0.1]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 0, 0, 1, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.step('q'); })
            .toThrowError(/Argument 'x' passed to 'step' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('neg', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, -3, 2, 7, -4]);
                    result = tf.neg(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [-1, 3, -2, -7, 4]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagate NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, expected, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, -3, 2, 7, NaN]);
                    result = tf.neg(a);
                    expected = [-1, 3, -2, -7, NaN];
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, da, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(4);
                    dy = tf.scalar(8);
                    da = tf.grad(function (a) { return tf.neg(a); })(a, dy);
                    expect(da.shape).toEqual(a.shape);
                    expect(da.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 * -1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, da, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(4);
                    dy = tf.scalar(8);
                    da = tf.grad(function (a) { return tf.neg(a.clone()).clone(); })(a, dy);
                    expect(da.shape).toEqual(a.shape);
                    expect(da.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 * -1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, da, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, 2, -3, 5]);
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    da = tf.grad(function (a) { return tf.neg(a); })(a, dy);
                    expect(da.shape).toEqual(a.shape);
                    expect(da.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1 * -1, 2 * -1, 3 * -1, 4 * -1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, da, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([3, -1, -2, 3], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    da = tf.grad(function (a) { return tf.neg(a); })(a, dy);
                    expect(da.shape).toEqual(a.shape);
                    expect(da.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1 * -1, 2 * -1, 3 * -1, 4 * -1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.neg({}); })
            .toThrowError(/Argument 'x' passed to 'neg' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    result = tf.neg([1, -3, 2, 7, -4]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [-1, 3, -2, -7, 4]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.neg('q'); })
            .toThrowError(/Argument 'x' passed to 'neg' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('sigmoid', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, 7, -4];
                    a = tf.tensor1d(values);
                    result = tf.sigmoid(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = 1 / (1 + Math.exp(-values[i]));
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('6D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.ones([2, 2, 2, 2, 2, 2]);
                    result = tf.sigmoid(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = 1 / (1 + Math.exp(-1.0));
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, res, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([3, NaN]);
                    res = tf.sigmoid(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, res.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1 / (1 + Math.exp(-3)), NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, da, aVals, dyVals, expected, i, y, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, 2, -3, 5]);
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    da = tf.grad(function (a) { return tf.sigmoid(a); })(a, dy);
                    return [4 /*yield*/, a.array()];
                case 1:
                    aVals = _b.sent();
                    return [4 /*yield*/, dy.array()];
                case 2:
                    dyVals = _b.sent();
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        y = 1 / (1 + Math.exp(-aVals[i]));
                        expected[i] = dyVals[i] * y * (1 - y);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 3:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, da, aVals, dyVals, expected, i, y, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, 2, -3, 5]);
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    da = tf.grad(function (a) { return tf.sigmoid(a.clone()).clone(); })(a, dy);
                    return [4 /*yield*/, a.array()];
                case 1:
                    aVals = _b.sent();
                    return [4 /*yield*/, dy.array()];
                case 2:
                    dyVals = _b.sent();
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        y = 1 / (1 + Math.exp(-aVals[i]));
                        expected[i] = dyVals[i] * y * (1 - y);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 3:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.sigmoid({}); })
            .toThrowError(/Argument 'x' passed to 'sigmoid' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, 7, -4];
                    result = tf.sigmoid(values);
                    expected = [];
                    for (i = 0; i < values.length; i++) {
                        expected[i] = 1 / (1 + Math.exp(-values[i]));
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.sigmoid('q'); })
            .toThrowError(/Argument 'x' passed to 'sigmoid' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('logSigmoid', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, 7, -4];
                    a = tf.tensor1d(values);
                    result = tf.logSigmoid(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = Math.log(1 / (1 + Math.exp(-values[i])));
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, expected, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(-2);
                    result = tf.logSigmoid(a);
                    expected = [Math.log(1 / (1 + Math.exp(2)))];
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, 2, -3, 5];
                    a = tf.tensor2d(values, [2, 2]);
                    result = tf.logSigmoid(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = Math.log(1 / (1 + Math.exp(-values[i])));
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('larger magnitude negative inputs', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [-100, -200, -3000];
                    a = tf.tensor1d(values);
                    result = tf.logSigmoid(a);
                    expected = [-100, -200, -3000];
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('larger magnitude positive inputs', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [100, 200, 3000, 50000];
                    a = tf.tensor1d(values);
                    result = tf.logSigmoid(a);
                    expected = [0, 0, 0, 0];
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, res, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([3, NaN]);
                    res = tf.logSigmoid(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, res.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.log(1 / (1 + Math.exp(-3))), NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, dyVal, da, aVal, y, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(3);
                    dy = tf.scalar(4);
                    return [4 /*yield*/, dy.array()];
                case 1:
                    dyVal = _b.sent();
                    da = tf.grad(function (a) { return tf.logSigmoid(a); })(a, dy);
                    return [4 /*yield*/, a.array()];
                case 2:
                    aVal = _b.sent();
                    y = 1 / (1 + Math.exp(aVal));
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 3:
                    _a.apply(void 0, [_b.sent(), [dyVal * y]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, aVals, dy, dyVals, da, expected, i, y, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, 2, -3, 5]);
                    return [4 /*yield*/, a.array()];
                case 1:
                    aVals = _b.sent();
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    return [4 /*yield*/, dy.array()];
                case 2:
                    dyVals = _b.sent();
                    da = tf.grad(function (a) { return tf.logSigmoid(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        y = 1 / (1 + Math.exp(aVals[i]));
                        expected[i] = dyVals[i] * y;
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 3:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, aVals, dy, dyVals, da, expected, i, y, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, 2, -3, 5]);
                    return [4 /*yield*/, a.array()];
                case 1:
                    aVals = _b.sent();
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    return [4 /*yield*/, dy.array()];
                case 2:
                    dyVals = _b.sent();
                    da = tf.grad(function (a) { return tf.logSigmoid(a.clone()).clone(); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        y = 1 / (1 + Math.exp(aVals[i]));
                        expected[i] = dyVals[i] * y;
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 3:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, da, expected, aVals, dyVals, i, y, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([1, 2, -3, 5], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    da = tf.grad(function (a) { return tf.logSigmoid(a); })(a, dy);
                    expected = [];
                    return [4 /*yield*/, a.data()];
                case 1:
                    aVals = _b.sent();
                    return [4 /*yield*/, dy.data()];
                case 2:
                    dyVals = _b.sent();
                    for (i = 0; i < a.size; i++) {
                        y = 1 / (1 + Math.exp(aVals[i]));
                        expected[i] = dyVals[i] * y;
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 3:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.logSigmoid({}); })
            .toThrowError(/Argument 'x' passed to 'logSigmoid' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var result, expected, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    result = tf.logSigmoid(-2);
                    expected = [Math.log(1 / (1 + Math.exp(2)))];
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.logSigmoid('q'); })
            .toThrowError(/Argument 'x' passed to 'logSigmoid' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('softplus', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, 7, -4];
                    a = tf.tensor1d(values);
                    result = tf.softplus(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = Math.log((1 + Math.exp(values[i])));
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, expected, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(-2);
                    result = tf.softplus(a);
                    expected = [Math.log((1 + Math.exp(-2)))];
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, 2, -3, 5];
                    a = tf.tensor2d(values, [2, 2]);
                    result = tf.softplus(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = Math.log((1 + Math.exp(values[i])));
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('larger magnitude negative inputs', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [-100, -200, -3000, -50000];
                    a = tf.tensor1d(values);
                    result = tf.softplus(a);
                    expected = [0, 0, 0, 0];
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('larger magnitude positive inputs', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [100, 200, 3000];
                    a = tf.tensor1d(values);
                    result = tf.softplus(a);
                    expected = [100, 200, 3000];
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, res, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([3, NaN]);
                    res = tf.softplus(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, res.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.log((1 + Math.exp(3))), NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, aVal, dyVal, da, y, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(3);
                    dy = tf.scalar(4);
                    return [4 /*yield*/, a.array()];
                case 1:
                    aVal = _b.sent();
                    return [4 /*yield*/, dy.array()];
                case 2:
                    dyVal = _b.sent();
                    da = tf.grad(function (a) { return tf.softplus(a); })(a, dy);
                    y = 1 / (1 + Math.exp(-aVal));
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 3:
                    _a.apply(void 0, [_b.sent(), [dyVal * y]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, aVal, dyVal, da, y, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(3);
                    dy = tf.scalar(4);
                    return [4 /*yield*/, a.array()];
                case 1:
                    aVal = _b.sent();
                    return [4 /*yield*/, dy.array()];
                case 2:
                    dyVal = _b.sent();
                    da = tf.grad(function (a) { return tf.softplus(a.clone()).clone(); })(a, dy);
                    y = 1 / (1 + Math.exp(-aVal));
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 3:
                    _a.apply(void 0, [_b.sent(), [dyVal * y]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, aVals, dy, dyVals, da, expected, i, y, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, 2, -3, 5]);
                    return [4 /*yield*/, a.array()];
                case 1:
                    aVals = _b.sent();
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    return [4 /*yield*/, dy.array()];
                case 2:
                    dyVals = _b.sent();
                    da = tf.grad(function (a) { return tf.softplus(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        y = 1 / (1 + Math.exp(-aVals[i]));
                        expected[i] = dyVals[i] * y;
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 3:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, da, expected, aVals, dyVals, i, y, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([1, 2, -3, 5], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    da = tf.grad(function (a) { return tf.softplus(a); })(a, dy);
                    expected = [];
                    return [4 /*yield*/, a.data()];
                case 1:
                    aVals = _b.sent();
                    return [4 /*yield*/, dy.data()];
                case 2:
                    dyVals = _b.sent();
                    for (i = 0; i < a.size; i++) {
                        y = 1 / (1 + Math.exp(-aVals[i]));
                        expected[i] = dyVals[i] * y;
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 3:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.softplus({}); })
            .toThrowError(/Argument 'x' passed to 'softplus' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var result, expected, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    result = tf.softplus(-2);
                    expected = [Math.log((1 + Math.exp(-2)))];
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.softplus('q'); })
            .toThrowError(/Argument 'x' passed to 'softplus' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('sqrt', jasmine_util_1.ALL_ENVS, function () {
    it('sqrt', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([2, 4]);
                    r = tf.sqrt(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.sqrt(2), Math.sqrt(4)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('sqrt propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, NaN]);
                    r = tf.sqrt(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.sqrt(1), NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, da, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(4);
                    dy = tf.scalar(8);
                    da = tf.grad(function (a) { return tf.sqrt(a); })(a, dy);
                    expect(da.shape).toEqual(a.shape);
                    expect(da.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 / (2 * Math.sqrt(4))]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, da, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(4);
                    dy = tf.scalar(8);
                    da = tf.grad(function (a) { return tf.sqrt(a.clone()).clone(); })(a, dy);
                    expect(da.shape).toEqual(a.shape);
                    expect(da.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 / (2 * Math.sqrt(4))]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, 2, 3, 5]);
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    gradients = tf.grad(function (a) { return tf.sqrt(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(),
                        [
                            1 / (2 * Math.sqrt(1)), 2 / (2 * Math.sqrt(2)),
                            3 / (2 * Math.sqrt(3)), 4 / (2 * Math.sqrt(5))
                        ],
                        1e-1]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([3, 1, 2, 3], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    gradients = tf.grad(function (a) { return tf.sqrt(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(),
                        [
                            1 / (2 * Math.sqrt(3)), 2 / (2 * Math.sqrt(1)),
                            3 / (2 * Math.sqrt(2)), 4 / (2 * Math.sqrt(3))
                        ],
                        1e-1]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.sqrt({}); })
            .toThrowError(/Argument 'x' passed to 'sqrt' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    r = tf.sqrt([2, 4]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.sqrt(2), Math.sqrt(4)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.sqrt('q'); })
            .toThrowError(/Argument 'x' passed to 'sqrt' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('rsqrt', jasmine_util_1.ALL_ENVS, function () {
    it('rsqrt', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([2, 4]);
                    r = tf.rsqrt(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1 / Math.sqrt(2), 1 / Math.sqrt(4)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('rsqrt propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, NaN]);
                    r = tf.rsqrt(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1 / Math.sqrt(1), NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, da, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(4);
                    dy = tf.scalar(8);
                    da = tf.grad(function (a) { return tf.rsqrt(a); })(a, dy);
                    expect(da.shape).toEqual(a.shape);
                    expect(da.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [(-1 * 8) / (2 * Math.pow(4, 1.5))]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, da, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(4);
                    dy = tf.scalar(8);
                    da = tf.grad(function (a) { return tf.rsqrt(a.clone()).clone(); })(a, dy);
                    expect(da.shape).toEqual(a.shape);
                    expect(da.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, da.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [(-1 * 8) / (2 * Math.pow(4, 1.5))]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, 2, 3, 5]);
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    gradients = tf.grad(function (a) { return tf.rsqrt(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(),
                        [
                            -1 * 1 / (2 * Math.pow(1, 1.5)), -1 * 2 / (2 * Math.pow(2, 1.5)),
                            -1 * 3 / (2 * Math.pow(3, 1.5)), -1 * 4 / (2 * Math.pow(5, 1.5))
                        ],
                        1e-1]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([3, 1, 2, 3], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    gradients = tf.grad(function (a) { return tf.rsqrt(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(),
                        [
                            -1 * 1 / (2 * Math.pow(3, 1.5)), -1 * 2 / (2 * Math.pow(1, 1.5)),
                            -1 * 3 / (2 * Math.pow(2, 1.5)), -1 * 4 / (2 * Math.pow(3, 1.5))
                        ],
                        1e-1]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.rsqrt({}); })
            .toThrowError(/Argument 'x' passed to 'rsqrt' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    r = tf.rsqrt([2, 4]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1 / Math.sqrt(2), 1 / Math.sqrt(4)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.rsqrt('q'); })
            .toThrowError(/Argument 'x' passed to 'rsqrt' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('square', jasmine_util_1.ALL_ENVS, function () {
    it('1D array', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([2, 4, Math.sqrt(2)]);
                    r = tf.square(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [4, 16, 2]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('2D array', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([1, 2, Math.sqrt(2), Math.sqrt(3)], [2, 2]);
                    r = tf.square(a);
                    expect(r.shape).toEqual([2, 2]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 4, 2, 3]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('5D array', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor5d([1, 2, Math.sqrt(2), Math.sqrt(3)], [1, 1, 2, 2, 1]);
                    r = tf.square(a);
                    expect(r.shape).toEqual([1, 1, 2, 2, 1]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 4, 2, 3]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('6D array', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor6d([1, 2, Math.sqrt(2), Math.sqrt(3), 3, 4, Math.sqrt(7), Math.sqrt(13)], [1, 1, 2, 2, 2, 1]);
                    r = tf.square(a);
                    expect(r.shape).toEqual(a.shape);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 4, 2, 3, 9, 16, 7, 13]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('square propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1.5, NaN]);
                    r = tf.square(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [2.25, NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.square(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [2 * 5 * 8]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.square(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [2 * 5 * 8]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([-1, 2, 3, -5]);
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    gradients = tf.grad(function (a) { return tf.square(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [-2, 4 * 2, 6 * 3, -10 * 4]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([-3, 1, 2, 3], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    gradients = tf.grad(function (a) { return tf.square(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [-6 * 1, 2 * 2, 4 * 3, 6 * 4]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor5D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor5d([-3, 1, 2, 3], [1, 1, 1, 2, 2]);
                    dy = tf.tensor5d([1, 2, 3, 4], [1, 1, 1, 2, 2]);
                    gradients = tf.grad(function (a) { return tf.square(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [-6 * 1, 2 * 2, 4 * 3, 6 * 4]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor6D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor6d([-3, 1, 2, 3, -4, 5, 12, 3], [1, 1, 1, 2, 2, 2]);
                    dy = tf.tensor6d([1, 2, 3, 4, 5, 6, 7, 8], [1, 1, 1, 2, 2, 2]);
                    gradients = tf.grad(function (a) { return tf.square(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(),
                        [-6 * 1, 2 * 2, 4 * 3, 6 * 4, -8 * 5, 10 * 6, 24 * 7, 6 * 8]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.square({}); })
            .toThrowError(/Argument 'x' passed to 'square' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    r = tf.square([2, 4, Math.sqrt(2)]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [4, 16, 2]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.square('q'); })
            .toThrowError(/Argument 'x' passed to 'square' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('reciprocal', jasmine_util_1.ALL_ENVS, function () {
    it('1D array', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([2, 3, 0, NaN]);
                    r = tf.reciprocal(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1 / 2, 1 / 3, Infinity, NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('2D array', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([1, Infinity, 0, NaN], [2, 2]);
                    r = tf.reciprocal(a);
                    expect(r.shape).toEqual([2, 2]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1 / 1, 0, Infinity, NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('reciprocal propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1.5, NaN]);
                    r = tf.reciprocal(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1 / 1.5, NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.reciprocal(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [-1 * 8 * (1 / (5 * 5))]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.reciprocal(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [-1 * 8 * (1 / (5 * 5))]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([-1, 2, 3, -5]);
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    gradients = tf.grad(function (a) { return tf.reciprocal(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [
                            -1 * 1 * (1 / (-1 * -1)), -1 * 2 * (1 / (2 * 2)), -1 * 3 * (1 / (3 * 3)),
                            -1 * 4 * (1 / (-5 * -5))
                        ]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([-1, 2, 3, -5], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    gradients = tf.grad(function (a) { return tf.reciprocal(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [
                            -1 * 1 * (1 / (-1 * -1)), -1 * 2 * (1 / (2 * 2)), -1 * 3 * (1 / (3 * 3)),
                            -1 * 4 * (1 / (-5 * -5))
                        ]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.reciprocal({}); })
            .toThrowError(/Argument 'x' passed to 'reciprocal' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    r = tf.reciprocal([2, 3, 0, NaN]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1 / 2, 1 / 3, Infinity, NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.reciprocal('q'); })
            .toThrowError(/Argument 'x' passed to 'reciprocal' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('log', jasmine_util_1.ALL_ENVS, function () {
    it('log', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, 2]);
                    r = tf.log(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.log(1), Math.log(2)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('log 6D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, expectedResult, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.range(1, 65).reshape([2, 2, 2, 2, 2, 2]);
                    r = tf.log(a);
                    expectedResult = [];
                    for (i = 1; i < 65; i++) {
                        expectedResult[i - 1] = Math.log(i);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expectedResult]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('log propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, NaN]);
                    r = tf.log(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.log(1), NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(5);
                    dy = tf.scalar(3);
                    gradients = tf.grad(function (a) { return tf.log(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [3 / 5]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(5);
                    dy = tf.scalar(3);
                    gradients = tf.grad(function (a) { return tf.log(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [3 / 5]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([-1, 2, 3, -5]);
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    gradients = tf.grad(function (a) { return tf.log(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1 / -1, 2 / 2, 3 / 3, 4 / -5]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([-3, 1, 2, 3], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    gradients = tf.grad(function (a) { return tf.log(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1 / -3, 2 / 1, 3 / 2, 4 / 3]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.log({}); })
            .toThrowError(/Argument 'x' passed to 'log' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    r = tf.log([1, 2]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.log(1), Math.log(2)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.log('q'); })
            .toThrowError(/Argument 'x' passed to 'log' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('log1p', jasmine_util_1.ALL_ENVS, function () {
    it('log1p', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, 2]);
                    r = tf.log1p(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.log1p(1), Math.log1p(2)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('log1p propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, NaN]);
                    r = tf.log1p(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.log1p(1), NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(5);
                    dy = tf.scalar(3);
                    gradients = tf.grad(function (a) { return tf.log1p(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [3 / (1 + 5)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () {
        var a = tf.scalar(5);
        var gradients = tf.grad(function (a) { return a.clone().log1p().clone(); })(a);
        expect(gradients.shape).toEqual(a.shape);
        expect(gradients.dtype).toEqual('float32');
    });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([-1, 2, 3, -5]);
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    gradients = tf.grad(function (a) { return tf.log1p(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(),
                        [Infinity, 2 / (1 + 2), 3 / (1 + 3), 4 / (1 + -5)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([-3, 1, 2, 3], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    gradients = tf.grad(function (a) { return tf.log1p(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(),
                        [1 / (1 + -3), 2 / (1 + 1), 3 / (1 + 2), 4 / (1 + 3)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.log1p({}); })
            .toThrowError(/Argument 'x' passed to 'log1p' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    r = tf.log1p([1, 2]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.log1p(1), Math.log1p(2)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.log1p('q'); })
            .toThrowError(/Argument 'x' passed to 'log1p' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('ceil', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1.5, 2.1, -1.4]);
                    r = tf.ceil(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [2, 3, -1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1.5, NaN, -1.4]);
                    r = tf.ceil(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [2, NaN, -1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(5.2);
                    dy = tf.scalar(3);
                    gradients = tf.grad(function (a) { return tf.ceil(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(5.2);
                    dy = tf.scalar(3);
                    gradients = tf.grad(function (a) { return tf.ceil(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([-1.1, 2.6, 3, -5.9]);
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    gradients = tf.grad(function (a) { return tf.ceil(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 0, 0, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([-3, 1, 2.2, 3], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    gradients = tf.grad(function (a) { return tf.ceil(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 0, 0, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.ceil({}); })
            .toThrowError(/Argument 'x' passed to 'ceil' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    r = tf.ceil([1.5, 2.1, -1.4]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [2, 3, -1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.ceil('q'); })
            .toThrowError(/Argument 'x' passed to 'ceil' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('floor', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1.5, 2.1, -1.4]);
                    r = tf.floor(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 2, -2]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1.5, NaN, -1.4]);
                    r = tf.floor(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, NaN, -2]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(5.2);
                    dy = tf.scalar(3);
                    gradients = tf.grad(function (a) { return tf.floor(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(5.2);
                    dy = tf.scalar(3);
                    gradients = tf.grad(function (a) { return tf.floor(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([-1.1, 2.6, 3, -5.9]);
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    gradients = tf.grad(function (a) { return tf.floor(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 0, 0, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([-3, 1, 2.2, 3], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    gradients = tf.grad(function (a) { return tf.floor(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 0, 0, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.floor({}); })
            .toThrowError(/Argument 'x' passed to 'floor' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    r = tf.floor([1.5, 2.1, -1.4]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 2, -2]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.floor('q'); })
            .toThrowError(/Argument 'x' passed to 'floor' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('sign', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1.5, 0, NaN, -1.4]);
                    r = tf.sign(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 0, 0, -1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('does not propagate NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1.5, NaN, -1.4]);
                    r = tf.sign(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 0, -1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(5.2);
                    dy = tf.scalar(3);
                    gradients = tf.grad(function (a) { return tf.sign(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(5.2);
                    dy = tf.scalar(3);
                    gradients = tf.grad(function (a) { return tf.sign(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([-1.1, 2.6, 3, -5.9]);
                    dy = tf.tensor1d([-1, 1, 1, -1]);
                    gradients = tf.grad(function (a) { return tf.sign(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 0, 0, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([-3, 1, 2.2, 3], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    gradients = tf.grad(function (a) { return tf.sign(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 0, 0, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.sign({}); })
            .toThrowError(/Argument 'x' passed to 'sign' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    r = tf.sign([1.5, 0, NaN, -1.4]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 0, 0, -1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.sign('q'); })
            .toThrowError(/Argument 'x' passed to 'sign' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('isNaN', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([NaN, Infinity, -Infinity, 0, 1]);
                    r = tf.isNaN(a);
                    expect(r.dtype).toEqual('bool');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 0, 0, 0, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(NaN);
                    dy = tf.scalar(3);
                    gradients = tf.grad(function (a) { return tf.isNaN(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([NaN, Infinity, -Infinity, 0, 1]);
                    dy = tf.tensor1d([1, 1, 1, 1, 1]);
                    gradients = tf.grad(function (a) { return tf.isNaN(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 0, 0, 0, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([NaN, Infinity, -Infinity, 0], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    gradients = tf.grad(function (a) { return tf.isNaN(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 0, 0, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.isNaN({}); })
            .toThrowError(/Argument 'x' passed to 'isNaN' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    r = tf.isNaN([NaN, Infinity, -Infinity, 0, 1]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 0, 0, 0, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.isNaN('q'); })
            .toThrowError(/Argument 'x' passed to 'isNaN' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('isInf', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([NaN, Infinity, -Infinity, 0, 1]);
                    r = tf.isInf(a);
                    expect(r.dtype).toEqual('bool');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 1, 1, 0, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(NaN);
                    dy = tf.scalar(3);
                    gradients = tf.grad(function (a) { return tf.isInf(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([NaN, Infinity, -Infinity, 0, 1]);
                    dy = tf.tensor1d([1, 1, 1, 1, 1]);
                    gradients = tf.grad(function (a) { return tf.isInf(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 0, 0, 0, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([NaN, Infinity, -Infinity, 0], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    gradients = tf.grad(function (a) { return tf.isInf(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 0, 0, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.isInf({}); })
            .toThrowError(/Argument 'x' passed to 'isInf' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    r = tf.isInf([NaN, Infinity, -Infinity, 0, 1]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 1, 1, 0, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.isInf('q'); })
            .toThrowError(/Argument 'x' passed to 'isInf' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('isFinite', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([NaN, Infinity, -Infinity, 0, 1]);
                    r = tf.isFinite(a);
                    expect(r.dtype).toEqual('bool');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 0, 0, 1, 1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(NaN);
                    dy = tf.scalar(3);
                    gradients = tf.grad(function (a) { return tf.isFinite(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([NaN, Infinity, -Infinity, 0, 1]);
                    dy = tf.tensor1d([1, 1, 1, 1, 1]);
                    gradients = tf.grad(function (a) { return tf.isFinite(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 0, 0, 0, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([NaN, Infinity, -Infinity, 0], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    gradients = tf.grad(function (a) { return tf.isFinite(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 0, 0, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.isFinite({}); })
            .toThrowError(/Argument 'x' passed to 'isFinite' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    r = tf.isFinite([NaN, Infinity, -Infinity, 0, 1]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 0, 0, 1, 1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.isFinite('q'); })
            .toThrowError(/Argument 'x' passed to 'isFinite' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('exp', jasmine_util_1.ALL_ENVS, function () {
    it('exp', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, 2, 0]);
                    r = tf.exp(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.exp(1), Math.exp(2), 1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('exp propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, NaN, 0]);
                    r = tf.exp(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.exp(1), NaN, 1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(3);
                    gradients = tf.grad(function (a) { return tf.exp(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [3 * Math.exp(0.5)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(3);
                    gradients = tf.grad(function (a) { return tf.exp(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [3 * Math.exp(0.5)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([-1, 2, 3, -5]);
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    gradients = tf.grad(function (a) { return tf.exp(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(),
                        [1 * Math.exp(-1), 2 * Math.exp(2), 3 * Math.exp(3), 4 * Math.exp(-5)],
                        1e-1]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([-3, 1, 2, 3], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    gradients = tf.grad(function (a) { return tf.exp(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(),
                        [1 * Math.exp(-3), 2 * Math.exp(1), 3 * Math.exp(2), 4 * Math.exp(3)],
                        1e-1]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.exp({}); })
            .toThrowError(/Argument 'x' passed to 'exp' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    r = tf.exp([1, 2, 0]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.exp(1), Math.exp(2), 1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.exp('q'); })
            .toThrowError(/Argument 'x' passed to 'exp' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('expm1', jasmine_util_1.ALL_ENVS, function () {
    it('expm1', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, 2, 0]);
                    r = tf.expm1(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.expm1(1), Math.expm1(2), Math.expm1(0)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('expm1 propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, NaN, 0]);
                    r = tf.expm1(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.expm1(1), NaN, Math.expm1(0)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(3);
                    gradients = tf.grad(function (a) { return tf.expm1(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [3 * Math.exp(0.5)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(3);
                    gradients = tf.grad(function (a) { return tf.expm1(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [3 * Math.exp(0.5)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([-1, 2, 3, -5]);
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    gradients = tf.grad(function (a) { return tf.expm1(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(),
                        [1 * Math.exp(-1), 2 * Math.exp(2), 3 * Math.exp(3), 4 * Math.exp(-5)],
                        1e-1]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([-3, 1, 2, 3], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    gradients = tf.grad(function (a) { return tf.expm1(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(),
                        [1 * Math.exp(-3), 2 * Math.exp(1), 3 * Math.exp(2), 4 * Math.exp(3)],
                        1e-1]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.expm1({}); })
            .toThrowError(/Argument 'x' passed to 'expm1' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    r = tf.expm1([1, 2, 0]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.expm1(1), Math.expm1(2), Math.expm1(0)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.expm1('q'); })
            .toThrowError(/Argument 'x' passed to 'expm1' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('sin', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, 7, -4];
                    a = tf.tensor1d(values);
                    result = tf.sin(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = Math.sin(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, res, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([4, NaN, 0]);
                    res = tf.sin(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, res.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.sin(4), NaN, Math.sin(0)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.sin(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 * Math.cos(5)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.sin(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 * Math.cos(5)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([-1, 2, 3, -5]);
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    gradients = tf.grad(function (a) { return tf.sin(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(),
                        [1 * Math.cos(-1), 2 * Math.cos(2), 3 * Math.cos(3), 4 * Math.cos(-5)],
                        1e-1]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([-3, 1, 2, 3], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    gradients = tf.grad(function (a) { return tf.sin(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(),
                        [1 * Math.cos(-3), 2 * Math.cos(1), 3 * Math.cos(2), 4 * Math.cos(3)],
                        1e-1]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.sin({}); })
            .toThrowError(/Argument 'x' passed to 'sin' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, 7, -4];
                    result = tf.sin(values);
                    expected = [];
                    for (i = 0; i < values.length; i++) {
                        expected[i] = Math.sin(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.sin('q'); })
            .toThrowError(/Argument 'x' passed to 'sin' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('cos', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, 7, -4];
                    a = tf.tensor1d(values);
                    result = tf.cos(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = Math.cos(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, res, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([4, NaN, 0]);
                    res = tf.cos(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, res.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.cos(4), NaN, Math.cos(0)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.cos(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 * Math.sin(5) * -1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.cos(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 * Math.sin(5) * -1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([-1, 2, 3, -5]);
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    gradients = tf.grad(function (a) { return tf.cos(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(),
                        [
                            1 * Math.sin(-1) * -1, 2 * Math.sin(2) * -1, 3 * Math.sin(3) * -1,
                            4 * Math.sin(-5) * -1
                        ],
                        1e-1]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([-3, 1, 2, 3], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    gradients = tf.grad(function (a) { return tf.cos(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(),
                        [
                            1 * Math.sin(-3) * -1, 2 * Math.sin(1) * -1, 3 * Math.sin(2) * -1,
                            4 * Math.sin(3) * -1
                        ],
                        1e-1]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.cos({}); })
            .toThrowError(/Argument 'x' passed to 'cos' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, 7, -4];
                    result = tf.cos(values);
                    expected = [];
                    for (i = 0; i < values.length; i++) {
                        expected[i] = Math.cos(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.cos('q'); })
            .toThrowError(/Argument 'x' passed to 'cos' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('tan', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, 7, -4];
                    a = tf.tensor1d(values);
                    result = tf.tan(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = Math.tan(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, res, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([4, NaN, 0]);
                    res = tf.tan(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, res.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.tan(4), NaN, Math.tan(0)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.tan(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 / (Math.cos(0.5) * Math.cos(0.5))]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.tan(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 / (Math.cos(0.5) * Math.cos(0.5))]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [-1, 2, 3, -5];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor1d(aValues);
                    dy = tf.tensor1d(dyValues);
                    gradients = tf.grad(function (a) { return tf.tan(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = dyValues[i] / (Math.cos(aValues[i]) * Math.cos(aValues[i]));
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    // The grad(tan(x)) which relies on 1/cos(x) is less precise on Windows.
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    // The grad(tan(x)) which relies on 1/cos(x) is less precise on Windows.
                    _a.apply(void 0, [_b.sent(), expected, test_util_1.TEST_EPSILON_FLOAT16]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [-3, 1, 2, 3];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor2d(aValues, [2, 2]);
                    dy = tf.tensor2d(dyValues, [2, 2]);
                    gradients = tf.grad(function (a) { return tf.tan(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = dyValues[i] / (Math.cos(aValues[i]) * Math.cos(aValues[i]));
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.tan({}); })
            .toThrowError(/Argument 'x' passed to 'tan' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, 7, -4];
                    result = tf.tan(values);
                    expected = [];
                    for (i = 0; i < values.length; i++) {
                        expected[i] = Math.tan(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.tan('q'); })
            .toThrowError(/Argument 'x' passed to 'tan' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('asin', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [.1, -3, 2, 7, -4];
                    a = tf.tensor1d(values);
                    result = tf.asin(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = Math.asin(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, res, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([4, NaN, 0]);
                    res = tf.asin(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, res.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.asin(4), NaN, Math.asin(0)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.asin(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 / Math.sqrt(1 - (0.5 * 0.5))]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.asin(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 / Math.sqrt(1 - (0.5 * 0.5))]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [-0.1, 0.2, 0.3, -0.5];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor1d(aValues);
                    dy = tf.tensor1d(dyValues);
                    gradients = tf.grad(function (a) { return tf.asin(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = dyValues[i] / Math.sqrt(1 - (aValues[i] * aValues[i]));
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [-0.3, 0.1, 0.2, 0.3];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor2d(aValues, [2, 2]);
                    dy = tf.tensor2d(dyValues, [2, 2]);
                    gradients = tf.grad(function (a) { return tf.asin(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = dyValues[i] / Math.sqrt(1 - (aValues[i] * aValues[i]));
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.asin({}); })
            .toThrowError(/Argument 'x' passed to 'asin' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [.1, -3, 2, 7, -4];
                    result = tf.asin(values);
                    expected = [];
                    for (i = 0; i < values.length; i++) {
                        expected[i] = Math.asin(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.asin('q'); })
            .toThrowError(/Argument 'x' passed to 'asin' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('acos', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [.1, -3, 2, 7, -4];
                    a = tf.tensor1d(values);
                    result = tf.acos(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = Math.acos(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, res, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([4, NaN, 0]);
                    res = tf.acos(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, res.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.acos(4), NaN, Math.acos(0)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.acos(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [(-1 * 8) / Math.sqrt(1 - (0.5 * 0.5))]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.acos(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [(-1 * 8) / Math.sqrt(1 - (0.5 * 0.5))]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [-0.1, 0.2, 0.3, -0.5];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor1d(aValues);
                    dy = tf.tensor1d(dyValues);
                    gradients = tf.grad(function (a) { return tf.acos(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] =
                            (-1 * dyValues[i]) / Math.sqrt(1 - (aValues[i] * aValues[i]));
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [-0.3, 0.1, 0.2, 0.3];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor2d(aValues, [2, 2]);
                    dy = tf.tensor2d(dyValues, [2, 2]);
                    gradients = tf.grad(function (a) { return tf.acos(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] =
                            (-1 * dyValues[i]) / Math.sqrt(1 - (aValues[i] * aValues[i]));
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.acos({}); })
            .toThrowError(/Argument 'x' passed to 'acos' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [.1, -3, 2, 7, -4];
                    result = tf.acos(values);
                    expected = [];
                    for (i = 0; i < values.length; i++) {
                        expected[i] = Math.acos(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.acos('q'); })
            .toThrowError(/Argument 'x' passed to 'acos' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('atan', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, 7, -4];
                    a = tf.tensor1d(values);
                    result = tf.atan(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = Math.atan(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('6D atan', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.range(1, 65).reshape([2, 2, 2, 2, 2, 2]);
                    result = tf.atan(a);
                    expected = [];
                    for (i = 1; i < 65; ++i) {
                        expected[i - 1] = Math.atan(i);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, res, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([4, NaN, 0]);
                    res = tf.atan(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, res.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.atan(4), NaN, Math.atan(0)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.atan(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 / (1 + (0.5 * 0.5))]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.atan(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 / (1 + (0.5 * 0.5))]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [-0.1, 0.2, 0.3, -0.5];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor1d(aValues);
                    dy = tf.tensor1d(dyValues);
                    gradients = tf.grad(function (a) { return tf.atan(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = dyValues[i] / (1 + (aValues[i] * aValues[i]));
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [-0.3, 0.1, 0.2, 0.3];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor2d(aValues, [2, 2]);
                    dy = tf.tensor2d(dyValues, [2, 2]);
                    gradients = tf.grad(function (a) { return tf.atan(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = dyValues[i] / (1 + (aValues[i] * aValues[i]));
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.atan({}); })
            .toThrowError(/Argument 'x' passed to 'atan' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, 7, -4];
                    result = tf.atan(values);
                    expected = [];
                    for (i = 0; i < values.length; i++) {
                        expected[i] = Math.atan(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.atan('q'); })
            .toThrowError(/Argument 'x' passed to 'atan' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('sinh', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, -1, -4];
                    a = tf.tensor1d(values);
                    result = tf.sinh(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = Math.sinh(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, res, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([4, NaN, 0]);
                    res = tf.sinh(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, res.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.sinh(4), NaN, Math.sinh(0)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.sinh(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 * Math.cosh(0.5)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.sinh(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 * Math.cosh(0.5)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [-1, 2, 3, -5];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor1d(aValues);
                    dy = tf.tensor1d(dyValues);
                    gradients = tf.grad(function (a) { return tf.sinh(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = dyValues[i] * Math.cosh(aValues[i]);
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [-3, 1, 2, 3];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor2d(aValues, [2, 2]);
                    dy = tf.tensor2d(dyValues, [2, 2]);
                    gradients = tf.grad(function (a) { return tf.sinh(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = dyValues[i] * Math.cosh(aValues[i]);
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.sinh({}); })
            .toThrowError(/Argument 'x' passed to 'sinh' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, -1, -4];
                    result = tf.sinh(values);
                    expected = [];
                    for (i = 0; i < values.length; i++) {
                        expected[i] = Math.sinh(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.sinh('q'); })
            .toThrowError(/Argument 'x' passed to 'sinh' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('cosh', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, -1, -4];
                    a = tf.tensor1d(values);
                    result = tf.cosh(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = Math.cosh(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, res, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([4, NaN, 0]);
                    res = tf.cosh(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, res.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.cosh(4), NaN, Math.cosh(0)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.cosh(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 * Math.sinh(0.5)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.cosh(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 * Math.sinh(0.5)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [-1, 2, 3, -5];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor1d(aValues);
                    dy = tf.tensor1d(dyValues);
                    gradients = tf.grad(function (a) { return tf.cosh(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = dyValues[i] * Math.sinh(aValues[i]);
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [-3, 1, 2, 3];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor2d(aValues, [2, 2]);
                    dy = tf.tensor2d(dyValues, [2, 2]);
                    gradients = tf.grad(function (a) { return tf.cosh(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = dyValues[i] * Math.sinh(aValues[i]);
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.cosh({}); })
            .toThrowError(/Argument 'x' passed to 'cosh' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, -1, -4];
                    result = tf.cosh(values);
                    expected = [];
                    for (i = 0; i < values.length; i++) {
                        expected[i] = Math.cosh(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.cosh('q'); })
            .toThrowError(/Argument 'x' passed to 'cosh' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('tanh', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, 7, -4];
                    a = tf.tensor1d(values);
                    result = tf.tanh(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = util.tanh(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, res, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([4, NaN, 0]);
                    res = tf.tanh(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, res.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [util.tanh(4), NaN, util.tanh(0)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.tanh(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 * (1 - (Math.tanh(0.5) * Math.tanh(0.5)))]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.tanh(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 * (1 - (Math.tanh(0.5) * Math.tanh(0.5)))]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [-1, 2, 3, -5];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor1d(aValues);
                    dy = tf.tensor1d(dyValues);
                    gradients = tf.grad(function (a) { return tf.tanh(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] =
                            dyValues[i] * (1 - (Math.tanh(aValues[i]) * Math.tanh(aValues[i])));
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [-3, 1, 2, 3];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor2d(aValues, [2, 2]);
                    dy = tf.tensor2d(dyValues, [2, 2]);
                    gradients = tf.grad(function (a) { return tf.tanh(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] =
                            dyValues[i] * (1 - (Math.tanh(aValues[i]) * Math.tanh(aValues[i])));
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.tanh({}); })
            .toThrowError(/Argument 'x' passed to 'tanh' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, 7, -4];
                    result = tf.tanh(values);
                    expected = [];
                    for (i = 0; i < values.length; i++) {
                        expected[i] = util.tanh(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.tanh('q'); })
            .toThrowError(/Argument 'x' passed to 'tanh' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('leakyRelu', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([0, 1, -2]);
                    result = tf.leakyRelu(a);
                    expect(result.shape).toEqual(a.shape);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 1, -0.4]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaN', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([0, 1, NaN]);
                    result = tf.leakyRelu(a);
                    expect(result.shape).toEqual(a.shape);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 1, NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, alpha, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(-4);
                    dy = tf.scalar(8);
                    alpha = 0.1;
                    gradients = tf.grad(function (a) { return tf.leakyRelu(a, alpha); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 * alpha]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, alpha, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(-4);
                    dy = tf.scalar(8);
                    alpha = 0.1;
                    gradients = tf.grad(function (a) { return tf.leakyRelu(a.clone(), alpha).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 * alpha]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, alpha, a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [1, -1, 0.1];
                    dyValues = [1, 2, 3];
                    alpha = 0.1;
                    a = tf.tensor1d(aValues);
                    dy = tf.tensor1d(dyValues);
                    gradients = tf.grad(function (a) { return tf.leakyRelu(a, alpha); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 2 * alpha, 3]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, alpha, a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [1, -1, 0.1, 0.5];
                    dyValues = [1, 2, 3, 4];
                    alpha = 0.1;
                    a = tf.tensor2d(aValues, [2, 2]);
                    dy = tf.tensor2d(dyValues, [2, 2]);
                    gradients = tf.grad(function (a) { return tf.leakyRelu(a, alpha); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 2 * alpha, 3, 4]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.leakyRelu({}); })
            .toThrowError(/Argument 'x' passed to 'leakyRelu' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    result = tf.leakyRelu([0, 1, -2]);
                    expect(result.shape).toEqual([3]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 1, -0.4]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.leakyRelu('q'); })
            .toThrowError(/Argument 'x' passed to 'leakyRelu' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('elu', jasmine_util_1.ALL_ENVS, function () {
    it('calculate elu', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, -1, 0]);
                    result = tf.elu(a);
                    expect(result.shape).toEqual(a.shape);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, -0.6321, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('elu propagates NaN', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, NaN]);
                    result = tf.elu(a);
                    expect(result.shape).toEqual(a.shape);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('derivative', function () { return __awaiter(_this, void 0, void 0, function () {
        var x, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    x = tf.tensor1d([1, 3, -2]);
                    dy = tf.tensor1d([5, 50, 500]);
                    gradients = tf.grad(function (a) { return tf.elu(a); })(x, dy);
                    expect(gradients.shape).toEqual(x.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [5, 50, 500 * Math.exp(-2)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var x, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    x = tf.tensor1d([1, 3, -2]);
                    dy = tf.tensor1d([5, 50, 500]);
                    gradients = tf.grad(function (a) { return tf.elu(a.clone()).clone(); })(x, dy);
                    expect(gradients.shape).toEqual(x.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [5, 50, 500 * Math.exp(-2)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.elu({}); })
            .toThrowError(/Argument 'x' passed to 'elu' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    result = tf.elu([1, -1, 0]);
                    expect(result.shape).toEqual(result.shape);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, -0.6321, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.elu('q'); })
            .toThrowError(/Argument 'x' passed to 'elu' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('selu', jasmine_util_1.ALL_ENVS, function () {
    var scaleAlpha = selu_util.SELU_SCALEALPHA;
    var scale = selu_util.SELU_SCALE;
    it('calculate selu', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, -1, 0]);
                    result = tf.selu(a);
                    expect(result.shape).toEqual(a.shape);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1.0507, -1.1113, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('selu propagates NaN', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1, NaN]);
                    result = tf.selu(a);
                    expect(result.shape).toEqual(a.shape);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1.0507, NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValue, dyValue, a, dy, gradients, _a, _b;
        return __generator(this, function (_c) {
            switch (_c.label) {
                case 0:
                    aValue = 1;
                    dyValue = 1;
                    a = tf.scalar(aValue);
                    dy = tf.scalar(dyValue);
                    gradients = tf.grad(function (a) { return tf.selu(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_c.sent(), [dyValue * scale]]);
                    aValue = -1;
                    dyValue = 2;
                    a = tf.scalar(aValue);
                    dy = tf.scalar(dyValue);
                    gradients = tf.grad(function (a) { return tf.selu(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _b = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 2:
                    _b.apply(void 0, [_c.sent(), [dyValue * scaleAlpha * Math.exp(aValue)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValue, dyValue, a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValue = 1;
                    dyValue = 1;
                    a = tf.scalar(aValue);
                    dy = tf.scalar(dyValue);
                    gradients = tf.grad(function (a) { return tf.selu(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [dyValue * scale]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [1, -1, 0];
                    dyValues = [1, 2, 3];
                    a = tf.tensor1d(aValues);
                    dy = tf.tensor1d(dyValues);
                    gradients = tf.grad(function (a) { return tf.selu(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        if (aValues[i] > 0) {
                            expected[i] = dyValues[i] * scale;
                        }
                        else {
                            expected[i] = dyValues[i] * scaleAlpha * Math.exp(aValues[i]);
                        }
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [1, -1, 0, 0.5];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor2d(aValues, [2, 2]);
                    dy = tf.tensor2d(dyValues, [2, 2]);
                    gradients = tf.grad(function (a) { return tf.selu(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        if (aValues[i] > 0) {
                            expected[i] = dyValues[i] * scale;
                        }
                        else {
                            expected[i] = dyValues[i] * scaleAlpha * Math.exp(aValues[i]);
                        }
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.selu({}); })
            .toThrowError(/Argument 'x' passed to 'selu' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    result = tf.selu([1, -1, 0]);
                    expect(result.shape).toEqual([3]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1.0507, -1.1113, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.selu('q'); })
            .toThrowError(/Argument 'x' passed to 'selu' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('clip', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, min, max, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([3, -1, 0, 100, -7, 2]);
                    min = -1;
                    max = 50;
                    result = tf.clipByValue(a, min, max);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [3, -1, 0, 50, -1, 2]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, min, max, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([3, -1, 0, 100, -7, 2, NaN]);
                    min = -1;
                    max = 50;
                    result = tf.clipByValue(a, min, max);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [3, -1, 0, 50, -1, 2, NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('min greater than max', function () {
        var a = tf.tensor1d([3, -1, 0, 100, -7, 2]);
        var min = 1;
        var max = -1;
        var f = function () {
            tf.clipByValue(a, min, max);
        };
        expect(f).toThrowError();
    });
    it('gradient: 1D tensor', function () { return __awaiter(_this, void 0, void 0, function () {
        var min, max, x, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    min = -1;
                    max = 2;
                    x = tf.tensor1d([3, -2, 1]);
                    dy = tf.tensor1d([5, 50, 500]);
                    gradients = tf.grad(function (x) { return x.clipByValue(min, max); })(x, dy);
                    expect(gradients.shape).toEqual(x.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 0, 500]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient: 1D tensor with max or min value', function () { return __awaiter(_this, void 0, void 0, function () {
        var min, max, x, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    min = -1;
                    max = 2;
                    x = tf.tensor1d([-1, 1, 2, 3]);
                    dy = tf.tensor1d([1, 10, 100, 1000]);
                    gradients = tf.grad(function (x) { return x.clipByValue(min, max); })(x, dy);
                    expect(gradients.shape).toEqual(x.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 10, 100, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient: scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var min, max, x, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    min = -1;
                    max = 2;
                    x = tf.scalar(-10);
                    dy = tf.scalar(5);
                    gradients = tf.grad(function (x) { return x.clipByValue(min, max); })(x, dy);
                    expect(gradients.shape).toEqual(x.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var min, max, x, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    min = -1;
                    max = 2;
                    x = tf.scalar(-10);
                    dy = tf.scalar(5);
                    gradients = tf.grad(function (x) { return x.clone().clipByValue(min, max).clone(); })(x, dy);
                    expect(gradients.shape).toEqual(x.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with primitive as input', function () { return __awaiter(_this, void 0, void 0, function () {
        var min, max, x, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    min = -1;
                    max = 2;
                    x = -10;
                    dy = tf.scalar(5);
                    gradients = tf.grad(function (x) { return x.clipByValue(min, max); })(x, dy);
                    expect(gradients.shape).toEqual([]);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.clipByValue({}, 0, 1); })
            .toThrowError(/Argument 'x' passed to 'clipByValue' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var min, max, result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    min = -1;
                    max = 50;
                    result = tf.clipByValue([3, -1, 0, 100, -7, 2], min, max);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [3, -1, 0, 50, -1, 2]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('clip(x, eps, 1-eps) never returns 0 or 1', function () { return __awaiter(_this, void 0, void 0, function () {
        var min, max, res;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    min = tf.backend().epsilon();
                    max = 0.5;
                    return [4 /*yield*/, tf.clipByValue([0, 1], min, max).data()];
                case 1:
                    res = _a.sent();
                    expect(res[0]).toBeGreaterThan(0);
                    expect(res[1]).toBeCloseTo(max);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.clipByValue('q', 0, 1); })
            .toThrowError(/Argument 'x' passed to 'clipByValue' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('round', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([0.9, 2.5, 2.3, 1.5, -4.5]);
                    r = a.round();
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 2, 2, 2, -4]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([1.5, NaN, -1.4]);
                    r = tf.round(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [2, NaN, -1]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(5.2);
                    dy = tf.scalar(3);
                    gradients = tf.grad(function (a) { return tf.round(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(5.2);
                    dy = tf.scalar(3);
                    gradients = tf.grad(function (a) { return tf.round(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([-1.1, 2.6, 3, -5.9]);
                    dy = tf.tensor1d([1, 2, 3, 4]);
                    gradients = tf.grad(function (a) { return tf.round(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 0, 0, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor2d([-3, 1, 2.2, 3], [2, 2]);
                    dy = tf.tensor2d([1, 2, 3, 4], [2, 2]);
                    gradients = tf.grad(function (a) { return tf.round(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0, 0, 0, 0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.round({}); })
            .toThrowError(/Argument 'x' passed to 'round' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var r, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    r = tf.round([0.9, 2.5, 2.3, 1.5, -4.5]);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, r.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [1, 2, 2, 2, -4]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.round('q'); })
            .toThrowError(/Argument 'x' passed to 'round' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('asinh', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, 7, -4];
                    a = tf.tensor1d(values);
                    result = tf.asinh(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = Math.asinh(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, expected, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(1);
                    result = tf.asinh(a);
                    expected = [Math.asinh(1)];
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, 7];
                    a = tf.tensor2d(values, [2, 2]);
                    result = tf.asinh(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = Math.asinh(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, res, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([4, NaN, 0]);
                    res = tf.asinh(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, res.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.asinh(4), NaN, Math.asinh(0)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.asinh(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 / Math.sqrt(1.0 + 0.5 * 0.5)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.asinh(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 / Math.sqrt(1.0 + 0.5 * 0.5)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [-1, 2, 3, -5];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor1d(aValues);
                    dy = tf.tensor1d(dyValues);
                    gradients = tf.grad(function (a) { return tf.asinh(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = dyValues[i] / Math.sqrt(1 + aValues[i] * aValues[i]);
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [-3, 1, 2, 3];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor2d(aValues, [2, 2]);
                    dy = tf.tensor2d(dyValues, [2, 2]);
                    gradients = tf.grad(function (a) { return tf.asinh(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = dyValues[i] / Math.sqrt(1 + aValues[i] * aValues[i]);
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.asinh({}); })
            .toThrowError(/Argument 'x' passed to 'asinh' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [1, -3, 2, 7, -4];
                    result = tf.asinh(values);
                    expected = [];
                    for (i = 0; i < values.length; i++) {
                        expected[i] = Math.asinh(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.asinh('q'); })
            .toThrowError(/Argument 'x' passed to 'asinh' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('acosh', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [2, 3, 4, 5, 6];
                    a = tf.tensor1d(values);
                    result = tf.acosh(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = Math.acosh(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var value, a, result, expected, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    value = 2;
                    a = tf.scalar(value);
                    result = tf.acosh(a);
                    expected = [Math.acosh(value)];
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('tensor2d', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [2, 3, 4, 5];
                    a = tf.tensor2d(values, [2, 2]);
                    result = tf.acosh(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = Math.acosh(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, res, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([4, NaN, 2]);
                    res = tf.acosh(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, res.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.acosh(4), NaN, Math.acosh(2)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('NaN outside function domain', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, res, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([4, -1, 2]);
                    res = tf.acosh(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, res.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.acosh(4), NaN, Math.acosh(2)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(1.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.acosh(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8.0 / Math.sqrt(1.5 * 1.5 - 1.0)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(1.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.acosh(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8.0 / Math.sqrt(1.5 * 1.5 - 1.0)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [2, 3, 5, 10];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor1d(aValues);
                    dy = tf.tensor1d(dyValues);
                    gradients = tf.grad(function (a) { return tf.acosh(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = dyValues[i] / Math.sqrt(Math.pow(aValues[i], 2) - 1.0);
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [2, 3, 5, 7];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor2d(aValues, [2, 2]);
                    dy = tf.tensor2d(dyValues, [2, 2]);
                    gradients = tf.grad(function (a) { return tf.acosh(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = dyValues[i] / Math.sqrt(Math.pow(aValues[i], 2) - 1.0);
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.acosh({}); })
            .toThrowError(/Argument 'x' passed to 'acosh' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [2, 3, 4, 5, 6];
                    result = tf.acosh(values);
                    expected = [];
                    for (i = 0; i < values.length; i++) {
                        expected[i] = Math.acosh(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.acosh('q'); })
            .toThrowError(/Argument 'x' passed to 'acosh' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('atanh', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [-0.25, 0.25, 0.5, .75, -0.4];
                    a = tf.tensor1d(values);
                    result = tf.atanh(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = Math.atanh(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var value, a, result, expected, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    value = 0.2;
                    a = tf.scalar(value);
                    result = tf.atanh(a);
                    expected = [Math.atanh(value)];
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('tensor2d', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [0.2, 0.3, 0.4, 0.5];
                    a = tf.tensor2d(values, [2, 2]);
                    result = tf.atanh(a);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = Math.atanh(values[i]);
                    }
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, res, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([0.5, NaN, 0]);
                    res = tf.atanh(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, res.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.atanh(0.5), NaN, Math.atanh(0)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('NaN outside function domain', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, res, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([-2, 0, 2]);
                    res = tf.atanh(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, res.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [NaN, Math.atanh(0), NaN]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.atanh(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 / (1 - 0.5 * 0.5)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.atanh(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [8 / (1 - 0.5 * 0.5)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [-0.1, 0.2, 0.3, -0.5];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor1d(aValues);
                    dy = tf.tensor1d(dyValues);
                    gradients = tf.grad(function (a) { return tf.atanh(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = dyValues[i] / (1 - Math.pow(aValues[i], 2));
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [-0.3, 0.1, 0.2, 0.3];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor2d(aValues, [2, 2]);
                    dy = tf.tensor2d(dyValues, [2, 2]);
                    gradients = tf.grad(function (a) { return tf.atanh(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = dyValues[i] / (1 - Math.pow(aValues[i], 2));
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.atanh({}); })
            .toThrowError(/Argument 'x' passed to 'atanh' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    result = tf.atanh(0.2);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [Math.atanh(0.2)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.atanh('q'); })
            .toThrowError(/Argument 'x' passed to 'atanh' must be numeric/);
    });
});
jasmine_util_1.describeWithFlags('erf', jasmine_util_1.ALL_ENVS, function () {
    it('basic', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [-0.25, 0.25, 0.5, .75, -0.4];
                    a = tf.tensor1d(values);
                    result = tf.erf(a);
                    expected = [-0.2763264, 0.2763264, 0.5204999, 0.7111556, -0.4283924];
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('blowup', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [-1.4, -2.5, -3.1, -4.4];
                    a = tf.tensor1d(values);
                    result = tf.erf(a);
                    expected = [-0.9522852, -0.999593, -0.9999883, -1];
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, expected, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(1);
                    result = tf.erf(a);
                    expected = [0.8427008];
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('scalar in int32', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, result, expected, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(1, 'int32');
                    result = tf.erf(a);
                    expected = [0.8427008];
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('tensor2d', function () { return __awaiter(_this, void 0, void 0, function () {
        var values, a, result, expected, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    values = [0.2, 0.3, 0.4, 0.5];
                    a = tf.tensor2d(values, [2, 2]);
                    result = tf.erf(a);
                    expected = [0.2227026, 0.32862678, 0.42839235, 0.5204999];
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('propagates NaNs', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, res, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.tensor1d([0.5, NaN, 0]);
                    res = tf.erf(a);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, res.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0.5204999, NaN, 0.0]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Scalar', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.erf(a); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(),
                        [8 * 2 * Math.exp(-0.5 * 0.5) / Math.sqrt(Math.PI)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradient with clones', function () { return __awaiter(_this, void 0, void 0, function () {
        var a, dy, gradients, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    a = tf.scalar(0.5);
                    dy = tf.scalar(8);
                    gradients = tf.grad(function (a) { return tf.erf(a.clone()).clone(); })(a, dy);
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(),
                        [8 * 2 * Math.exp(-0.5 * 0.5) / Math.sqrt(Math.PI)]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor1D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [-0.1, 0.2, 0.3, -0.5];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor1d(aValues);
                    dy = tf.tensor1d(dyValues);
                    gradients = tf.grad(function (a) { return tf.erf(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = dyValues[i] * 2 * Math.exp(-aValues[i] * aValues[i]) /
                            Math.sqrt(Math.PI);
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('gradients: Tensor2D', function () { return __awaiter(_this, void 0, void 0, function () {
        var aValues, dyValues, a, dy, gradients, expected, i, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    aValues = [-0.3, 0.1, 0.2, 0.3];
                    dyValues = [1, 2, 3, 4];
                    a = tf.tensor2d(aValues, [2, 2]);
                    dy = tf.tensor2d(dyValues, [2, 2]);
                    gradients = tf.grad(function (a) { return tf.erf(a); })(a, dy);
                    expected = [];
                    for (i = 0; i < a.size; i++) {
                        expected[i] = dyValues[i] * 2 * Math.exp(-aValues[i] * aValues[i]) /
                            Math.sqrt(Math.PI);
                    }
                    expect(gradients.shape).toEqual(a.shape);
                    expect(gradients.dtype).toEqual('float32');
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, gradients.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), expected]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws when passed a non-tensor', function () {
        expect(function () { return tf.erf({}); })
            .toThrowError(/Argument 'x' passed to 'erf' must be a Tensor/);
    });
    it('accepts a tensor-like object', function () { return __awaiter(_this, void 0, void 0, function () {
        var result, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    result = tf.erf(1);
                    _a = test_util_1.expectArraysClose;
                    return [4 /*yield*/, result.data()];
                case 1:
                    _a.apply(void 0, [_b.sent(), [0.8427008]]);
                    return [2 /*return*/];
            }
        });
    }); });
    it('throws for string tensor', function () {
        expect(function () { return tf.erf('q'); })
            .toThrowError(/Argument 'x' passed to 'erf' must be numeric/);
    });
});
//# sourceMappingURL=unary_ops_test.js.map