/**

* @license

* Copyright 2017 Google LLC. 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.

* =============================================================================

*/

// Workaround for: https://github.com/bazelbuild/rules_nodejs/issues/1265

/// <reference types="@webgpu/types/dist" />

import {getGlobal} from './global_util';

import {tensorToString} from './tensor_format';

import {DataId, TensorInfo} from './tensor_info';

import {ArrayMap, BackendValues, DataType, DataTypeMap, DataValues, NumericDataType, Rank, ShapeMap, SingleValueMap, TypedArray} from './types';

import * as util from './util';

import {computeStrides, toNestedArray} from './util';

export interface TensorData<D extends DataType> {

dataId?: DataId;

values?: DataTypeMap[D];

}

// This interface mimics KernelBackend (in backend.ts), which would create a

// circular dependency if imported.

export interface Backend {}

/**

* A mutable object, similar to `tf.Tensor`, that allows users to set values

* at locations before converting to an immutable `tf.Tensor`.

*

* See `tf.buffer` for creating a tensor buffer.

*

* @doc {heading: 'Tensors', subheading: 'Classes'}

*/

export class TensorBuffer<R extends Rank, D extends DataType = 'float32'> {

}

export interface DataToGPUWebGLOption {

customTexShape?: [number, number];

}

export type DataToGPUOptions = DataToGPUWebGLOption;

export interface GPUData {

}

export interface TensorTracker {

}

/**

* The Tensor class calls into this handler to delegate chaining operations.

*/

export interface OpHandler {

}

// For tracking tensor creation and disposal.

let trackerFn: () => TensorTracker = null;

// Used by chaining methods to call into ops.

let opHandler: OpHandler = null;

// Used to warn about deprecated methods.

let deprecationWarningFn: (msg: string) => void = null;

// This here so that we can use this method on dev branches and keep the

// functionality at master.

// tslint:disable-next-line:no-unused-expression

[deprecationWarningFn];

/**

* An external consumer can register itself as the tensor tracker. This way

* the Tensor class can notify the tracker for every tensor created and

* disposed.

*/

export function setTensorTracker(fn: () => TensorTracker) {

trackerFn = fn;

}

/**

* An external consumer can register itself as the op handler. This way the

* Tensor class can have chaining methods that call into ops via the op

* handler.

*/

export function setOpHandler(handler: OpHandler) {

opHandler = handler;

}

/**

* Sets the deprecation warning function to be used by this file. This way the

* Tensor class can be a leaf but still use the environment.

*/

export function setDeprecationWarningFn(fn: (msg: string) => void) {

deprecationWarningFn = fn;

}

// Declare this namespace to make Tensor class augmentation work in google3.

export declare namespace Tensor {}

/**

* A `tf.Tensor` object represents an immutable, multidimensional array of

* numbers that has a shape and a data type.

*

* For performance reasons, functions that create tensors do not necessarily

* perform a copy of the data passed to them (e.g. if the data is passed as a

* `Float32Array`), and changes to the data will change the tensor. This is not

* a feature and is not supported. To avoid this behavior, use the tensor before

* changing the input data or create a copy with `copy = tf.add(yourTensor, 0)`.

*

* See `tf.tensor` for details on how to create a `tf.Tensor`.

*

* @doc {heading: 'Tensors', subheading: 'Classes'}

*/

export class Tensor<R extends Rank = Rank> implements TensorInfo {

}

Object.defineProperty(Tensor, Symbol.hasInstance, {

value: (instance: Tensor) => {

}

});

export function getGlobalTensorClass() {

}

// Global side effect. Cache global reference to Tensor class

getGlobalTensorClass();

export interface NumericTensor<R extends Rank = Rank> extends Tensor<R> {

}

export interface StringTensor<R extends Rank = Rank> extends Tensor<R> {

}

/** @doclink Tensor */

export type Scalar = Tensor<Rank.R0>;

/** @doclink Tensor */

export type Tensor1D = Tensor<Rank.R1>;

/** @doclink Tensor */

export type Tensor2D = Tensor<Rank.R2>;

/** @doclink Tensor */

export type Tensor3D = Tensor<Rank.R3>;

/** @doclink Tensor */

export type Tensor4D = Tensor<Rank.R4>;

/** @doclink Tensor */

export type Tensor5D = Tensor<Rank.R5>;

/** @doclink Tensor */

export type Tensor6D = Tensor<Rank.R6>;

/**

* A mutable `tf.Tensor`, useful for persisting state, e.g. for training.

*

* @doc {heading: 'Tensors', subheading: 'Classes'}

*/

export class Variable<R extends Rank = Rank> extends Tensor<R> {

}

Object.defineProperty(Variable, Symbol.hasInstance, {

value: (instance: Variable) => {

return instance instanceof Tensor && instance.assign != null &&

instance.assign instanceof Function;

}

});