/**

* @license

* Copyright 2018 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.

*

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

*/

import * as tf from '@tensorflow/tfjs-core';

import {TensorContainer, TensorLike} from '@tensorflow/tfjs-core';

import * as seedrandom from 'seedrandom';

import {iteratorFromConcatenated, iteratorFromFunction, iteratorFromItems, iteratorFromZipped, LazyIterator, ZipMismatchMode} from './iterators/lazy_iterator';

import {Container} from './types';

import {canTensorify, deepMapAndAwaitAll, DeepMapResult, isIterable} from './util/deep_map';

/**

* A nested structure of Datasets, used as the input to zip().

*/

export type DatasetContainer = Container<Dataset<TensorContainer>>;

// TODO(soergel): consider vectorized operations within the pipeline.

/**

* Represents a potentially large list of independent data elements (typically

* 'samples' or 'examples').

*

* A 'data example' may be a primitive, an array, a map from string keys to

* values, or any nested structure of these.

*

* A `Dataset` represents an ordered collection of elements, together with a

* chain of transformations to be performed on those elements. Each

* transformation is a method of `Dataset` that returns another `Dataset`, so

* these may be chained, e.g.

* `const processedDataset = rawDataset.filter(...).map(...).batch(...)`.

*

* Data loading and transformation is done in a lazy, streaming fashion. The

* dataset may be iterated over multiple times; each iteration starts the data

* loading anew and recapitulates the transformations.

*

* A `Dataset` is typically processed as a stream of unbatched examples -- i.e.,

* its transformations are applied one example at a time. Batching produces a

* new `Dataset` where each element is a batch. Batching should usually come

* last in a pipeline, because data transformations are easier to express on a

* per-example basis than on a per-batch basis.

*

* The following code examples are calling `await dataset.forEachAsync(...)` to

* iterate once over the entire dataset in order to print out the data.

*

* @doc {heading: 'Data', subheading: 'Classes', namespace: 'data'}

*/

export abstract class Dataset<T extends tf.TensorContainer> {

}

/**

* Create a `Dataset` defined by a provided iterator() function.

*

* ```js

* let i = -1;

* const func = () =>

* ++i < 5 ? {value: i, done: false} : {value: null, done: true};

* const iter = tf.data.iteratorFromFunction(func);

* const ds = tf.data.datasetFromIteratorFn(iter);

* await ds.forEachAsync(e => console.log(e));

* ```

*/

export function datasetFromIteratorFn<T extends tf.TensorContainer>(

}

/**

* Create a `Dataset` from an array of elements.

*

* Create a Dataset from an array of objects:

* ```js

* const a = tf.data.array([{'item': 1}, {'item': 2}, {'item': 3}]);

* await a.forEachAsync(e => console.log(e));

* ```

*

* Create a Dataset from an array of numbers:

* ```js

* const a = tf.data.array([4, 5, 6]);

* await a.forEachAsync(e => console.log(e));

* ```

* @param items An array of elements that will be parsed as items in a dataset.

*

* @doc {heading: 'Data', subheading: 'Creation', namespace: 'data'}

*/

export function array<T extends tf.TensorContainer>(items: T[]): Dataset<T> {

return datasetFromIteratorFn(

async () => iteratorFromItems(items), items.length);

}

/**

* Create a `Dataset` by zipping together an array, dict, or nested

* structure of `Dataset`s (and perhaps additional constants).

* The underlying datasets must provide elements in a consistent order such that

* they correspond.

*

* The number of elements in the resulting dataset is the same as the size of

* the smallest dataset in datasets.

*

* The nested structure of the `datasets` argument determines the

* structure of elements in the resulting iterator.

*

* Note this means that, given an array of two datasets that produce dict

* elements, the result is a dataset that produces elements that are arrays

* of two dicts:

*

* Zip an array of datasets:

* ```js

* console.log('Zip two datasets of objects:');

* const ds1 = tf.data.array([{a: 1}, {a: 2}, {a: 3}]);

* const ds2 = tf.data.array([{b: 4}, {b: 5}, {b: 6}]);

* const ds3 = tf.data.zip([ds1, ds2]);

* await ds3.forEachAsync(e => console.log(JSON.stringify(e)));

*

* // If the goal is to merge the dicts in order to produce elements like

* // {a: ..., b: ...}, this requires a second step such as:

* console.log('Merge the objects:');

* const ds4 = ds3.map(x => {return {a: x[0].a, b: x[1].b}});

* await ds4.forEachAsync(e => console.log(e));

* ```

*

* Zip a dict of datasets:

* ```js

* const a = tf.data.array([{a: 1}, {a: 2}, {a: 3}]);

* const b = tf.data.array([{b: 4}, {b: 5}, {b: 6}]);

* const c = tf.data.zip({c: a, d: b});

* await c.forEachAsync(e => console.log(JSON.stringify(e)));

* ```

*

* @doc {heading: 'Data', subheading: 'Operations', namespace: 'data'}

*/

export function zip<O extends tf.TensorContainer>(datasets: DatasetContainer):

}

/**

* A zip function for use with deepZip, passed via the columnMajorBatch call.

*

* Accepts an array of identically-structured nested elements and either batches

* them (if they are primitives, numeric arrays, or Tensors) or requests

* recursion (if not).

*/

// tslint:disable-next-line:no-any

function deepBatchConcat(rows: any[]): DeepMapResult {

}

/**

* Assembles a list of same-shaped numbers, number arrays, or Tensors

* into a single new Tensor where axis 0 is the batch dimension.

*/

function batchConcat<T extends(TensorLike | tf.Tensor)>(arrays: T[]):

}