org.tensorics.core.lang.Tensorics Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of tensorics-core Show documentation
Show all versions of tensorics-core Show documentation
Tensorics is a java framework which uses a tensor as a central object. A tensor represents a set of values placed in an N-dimensional space. Wherever you are tempted to use maps of maps, a tensor might be a good choice ;-) Tensorics provides methods to create, transform and performing calculations with those tensors.
// @formatter:off
/*******************************************************************************
*
* This file is part of tensorics.
*
* Copyright (c) 2008-2011, CERN. 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.
*
******************************************************************************/
// @formatter:on
package org.tensorics.core.lang;
import static org.tensorics.core.tensor.operations.PositionFunctions.forSupplier;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.function.Function;
import java.util.function.Supplier;
import org.tensorics.core.math.ExtendedField;
import org.tensorics.core.quantity.ImmutableQuantifiedValue;
import org.tensorics.core.quantity.QuantifiedValue;
import org.tensorics.core.tensor.Context;
import org.tensorics.core.tensor.ImmutableTensor;
import org.tensorics.core.tensor.Position;
import org.tensorics.core.tensor.Shape;
import org.tensorics.core.tensor.Tensor;
import org.tensorics.core.tensor.TensorBuilder;
import org.tensorics.core.tensor.lang.OngoingCompletion;
import org.tensorics.core.tensor.lang.OngoingFlattening;
import org.tensorics.core.tensor.lang.OngoingTensorFiltering;
import org.tensorics.core.tensor.lang.OngoingTensorManipulation;
import org.tensorics.core.tensor.lang.QuantityTensors;
import org.tensorics.core.tensor.lang.TensorStructurals;
import org.tensorics.core.tensor.operations.FunctionTensorCreationOperation;
import org.tensorics.core.tensor.operations.SingleValueTensorCreationOperation;
import org.tensorics.core.tensorbacked.Tensorbacked;
import org.tensorics.core.tensorbacked.TensorbackedBuilder;
import org.tensorics.core.tensorbacked.Tensorbackeds;
import org.tensorics.core.tensorbacked.lang.OngoingTensorbackedConstruction;
import org.tensorics.core.tensorbacked.lang.OngoingTensorbackedFiltering;
import org.tensorics.core.units.JScienceUnit;
import org.tensorics.core.units.Unit;
import com.google.common.base.Optional;
/**
* The main entry point for constructing and structural manipulation of tensorics. If mathematical operations are
* required, then you should either inherit from {@link TensoricSupport} (or one of its convenience implementations) or
* use the {@link #using(ExtendedField)} method (only recommended for one-liners).
*
* Additional utilities for supporting classes can be found in the corresponding utility classes. E.g.
*
* - {@link org.tensorics.core.tensor.Positions}
*
- {@link org.tensorics.core.tensor.Shapes}
*
- {@link QuantityTensors}
*
- {@link Tensorbackeds}
*
*
* @author kfuchsbe, agorzaws, mihostet
*/
@SuppressWarnings("PMD.TooManyMethods")
public final class Tensorics {
/**
* private constructor to avoid instantiation
*/
private Tensorics() {
/* only static methods */
}
/**
* Creates an instance of a 'support' type class, which provides methods as starting points for the 'fluent' API for
* tensor manipulation.
*
* @param field the (mathematical construct) field which defines the operations for the tensor elements.
* @return a tensoric support, which provides the starting methods for the tensoric fluent API.
* @param the types of values in the field
*/
public static TensoricSupport using(ExtendedField field) {
return new TensoricSupport<>(EnvironmentImpl.of(field, ManipulationOptions.defaultOptions(field)));
}
/**
* @see TensorStructurals#merge(Set)
*/
public static Tensor merge(Iterable> tensors) {
return TensorStructurals.merge(tensors);
}
/**
* @see TensorStructurals#mergeContextIntoShape(Tensor)
*/
public static Tensor mergeContextIntoShape(Tensor tensor) {
return TensorStructurals.mergeContextIntoShape(tensor);
}
/**
* @see Tensorbackeds#mergeTo(Set, Class)
*/
public static , TBOUT extends Tensorbacked, E> TBOUT mergeTo(Set toBeMerged,
Class classToReturn) {
return Tensorbackeds.mergeTo(toBeMerged, classToReturn);
}
/**
* @see ImmutableTensor#builder(Set)
*/
public static TensorBuilder builder(Set> dimensions) {
return ImmutableTensor.builder(dimensions);
}
/**
* @see ImmutableTensor#builder(Class...)
*/
public static TensorBuilder builder(Class... dimensions) {
return ImmutableTensor.builder(dimensions);
}
/**
* @see ImmutableTensor#fromMap(Set, Map)
*/
public static Tensor fromMap(Set> dimensions, Map map) {
return ImmutableTensor.fromMap(dimensions, map);
}
/**
* @see ImmutableTensor#copyOf(Tensor)
*/
public static Tensor copyOf(Tensor tensor) {
return ImmutableTensor.copyOf(tensor);
}
/**
* @see ImmutableTensor#builderFrom(Tensor)
*/
public static TensorBuilder builderFrom(Tensor tensor) {
return ImmutableTensor.builderFrom(tensor);
}
/**
* @see ImmutableTensor#zeroDimensionalOf(Object)
*/
public static Tensor zeroDimensionalOf(T value) {
return ImmutableTensor.zeroDimensionalOf(value);
}
/**
* @see ImmutableQuantifiedValue#of(Object, Unit)
*/
public static ImmutableQuantifiedValue quantityOf(V value, Unit unit) {
return ImmutableQuantifiedValue.of(value, unit);
}
/**
* Convenience method to create a quantity directly from a jscience unit.
*
* @param value the of the quantity
* @param unit the unit of the quantity
* @return a new instance of the quantity
* @see Tensorics#quantityOf(Object, Unit)
*/
public static ImmutableQuantifiedValue quantityOf(V value, javax.measure.unit.Unit unit) {
return quantityOf(value, JScienceUnit.of(unit));
}
/**
* @see Tensorbackeds#builderFor(Class)
*/
public static > TensorbackedBuilder builderFor(Class tensorbackedClass) {
return Tensorbackeds.builderFor(tensorbackedClass);
}
/**
* @see Tensorbackeds#sizeOf(Tensorbacked)
*/
public static > int sizeOf(TB tensorbacked) {
return Tensorbackeds.sizeOf(tensorbacked);
}
/**
* @see Tensorbackeds#dimensionalityOf(Tensorbacked)
*/
public static > int dimensionalityOf(TB tensorbacked) {
return Tensorbackeds.dimensionalityOf(tensorbacked);
}
/**
* @see Tensorbackeds#empty(Class)
*/
public static > TB empty(Class tensorbackedClass) {
return Tensorbackeds.empty(tensorbackedClass);
}
/**
* @see Tensorbackeds#validitiesOf(Tensorbacked)
*/
public static Tensor validitiesOf(Tensorbacked> tensorbacked) {
return Tensorbackeds.validitiesOf(tensorbacked);
}
/**
* @see Tensorbackeds#valuesOf(Tensorbacked)
*/
public static Tensor valuesOf(Tensorbacked> tensorbacked) {
return Tensorbackeds.valuesOf(tensorbacked);
}
/**
* @see Tensorbackeds#errorsOf(Tensorbacked)
*/
public static Tensor> errorsOf(Tensorbacked> tensorbacked) {
return Tensorbackeds.errorsOf(tensorbacked);
}
/**
* @see Tensorbackeds#positionsOf(Tensorbacked)
*/
public static Set positionsOf(Tensorbacked tensorbacked) {
return Tensorbackeds.positionsOf(tensorbacked);
}
/**
* @deprecated use renamed method {@link #quantityTensorOf(Tensor, Unit)}
*/
@Deprecated
public static Tensor> convertToQuantified(Tensor tensor, Unit unit) {
return QuantityTensors.quantityTensorOf(tensor, unit);
}
/**
* @see QuantityTensors#quantityTensorOf(Tensor, Unit)
*/
public static Tensor> quantityTensorOf(Tensor tensor, Unit unit) {
return QuantityTensors.quantityTensorOf(tensor, unit);
}
/**
* @see QuantityTensors#unitOf(Tensor)
*/
public static Unit unitOf(Tensor> tensor) {
return QuantityTensors.unitOf(tensor);
}
/**
* @see Tensorbackeds#unitOf(Tensorbacked)
*/
public static Unit unitOf(Tensorbacked> tensorbacked) {
return Tensorbackeds.unitOf(tensorbacked);
}
/**
* @see Tensorbackeds#shapeOf(Tensorbacked)
*/
public static Shape shapeOf(Tensorbacked tensorbacked) {
return Tensorbackeds.shapeOf(tensorbacked);
}
/**
* @see TensorStructurals#from(Tensor)
*/
public static OngoingTensorManipulation from(Tensor tensor) {
return TensorStructurals.from(tensor);
}
public static Set> dimensionsOf(Tensor tensor) {
return tensor.shape().dimensionSet();
}
public static Set positionsOf(Tensor tensor) {
return tensor.shape().positionSet();
}
public static Tensor validitiesOf(Tensor> tensor) {
return QuantityTensors.validitiesOf(tensor);
}
public static Tensor valuesOf(Tensor> tensor) {
return QuantityTensors.valuesOf(tensor);
}
public static Tensor> errorsOf(Tensor> tensor) {
return QuantityTensors.errorsOf(tensor);
}
public static Tensor errorsOfOr(Tensor> tensor, S defaultValue) {
return QuantityTensors.errorsOfOr(tensor, defaultValue);
}
public static OngoingFlattening flatten(Tensor tensor) {
return TensorStructurals.flatten(tensor);
}
public static OngoingFlattening flatten(Tensorbacked tensorbacked) {
return Tensorbackeds.flatten(tensorbacked);
}
public static Tensor sameValues(Shape shape, S value) {
return new SingleValueTensorCreationOperation(shape, value).perform();
}
public static Tensor createFrom(Shape shape, Supplier supplier) {
return new FunctionTensorCreationOperation<>(shape, forSupplier(supplier)).perform();
}
public static Tensor createFrom(Shape shape, Function function) {
return new FunctionTensorCreationOperation<>(shape, function).perform();
}
public static OngoingCompletion complete(Tensor tensor) {
return TensorStructurals.complete(tensor);
}
public static Tensor transformEntries(Tensor tensor, Function, T> function) {
return TensorStructurals.transformEntries(tensor, function);
}
public static Tensor map(Tensor tensor, Function function) {
return TensorStructurals.transformScalars(tensor, function);
}
public static final Tensor> zeroDimensionalOf(double value, javax.measure.unit.Unit unit) {
QuantifiedValue quantity = quantityOf(value, unit);
return zeroDimensionalOf(quantity);
}
public static final Tensor> zeroDimensionalOf(double value, Unit unit) {
QuantifiedValue quantity = quantityOf(value, unit);
return zeroDimensionalOf(quantity);
}
/**
* @see Tensorbackeds#tensorsOf(Iterable)
*/
public static Iterable> tensorsOf(Iterable> tensorbackeds) {
return Tensorbackeds.tensorsOf(tensorbackeds);
}
/**
* @see Tensorbackeds#construct(Class)
*/
public static > OngoingTensorbackedConstruction construct(
Class tensorbackedClass) {
return Tensorbackeds.construct(tensorbackedClass);
}
/**
* @see Tensorbackeds#stripContext(Tensorbacked)
*/
public static > TB stripContext(TB tensorbacked) {
return Tensorbackeds.stripContext(tensorbacked);
}
/**
* @see TensorStructurals#stripContext(Tensor)
*/
public static Tensor stripContext(Tensor tensor) {
return TensorStructurals.stripContext(tensor);
}
/**
* @see TensorStructurals#filter(Tensor)
*/
public static OngoingTensorFiltering filter(Tensor tensor) {
return TensorStructurals.filter(tensor);
}
/**
* @see Tensorbackeds#filter(Tensorbacked)
*/
public static > OngoingTensorbackedFiltering filter(TB tensorbacked) {
return Tensorbackeds.filter(tensorbacked);
}
/**
* @see TensorStructurals#setContext(Tensor, Context)
*/
public static Tensor setContext(Tensor tensor, Context context) {
return TensorStructurals.setContext(tensor, context);
}
/**
* @see Tensorbackeds#setContext(Tensorbacked, Context)
*/
public static > TB setContext(TB tensorbacked, Context context) {
return Tensorbackeds.setContext(tensorbacked, context);
}
}