org.tensorics.core.lang.DoubleTensorics Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
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.
There is a newer version: 0.0.81
Show newest version
// @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 java.util.Comparator;

import org.tensorics.core.commons.lang.OngoingBinaryOperation;
import org.tensorics.core.commons.operations.Conversion;
import org.tensorics.core.commons.options.ManipulationOption;
import org.tensorics.core.function.DiscreteFunction;
import org.tensorics.core.function.lang.FunctionExpressionSupportWithConversionAndComparator;
import org.tensorics.core.function.lang.OngoingDeferredDiscreteFunctionBinaryOperation;
import org.tensorics.core.iterable.lang.OngoingDeferredIterableBinaryPredicate;
import org.tensorics.core.iterable.lang.OngoingQuantityIterableValueExtraction;
import org.tensorics.core.math.operations.BinaryFunction;
import org.tensorics.core.math.operations.BinaryOperation;
import org.tensorics.core.quantity.QuantifiedValue;
import org.tensorics.core.quantity.lang.OngoingDeferredQuantifiedScalarOperation;
import org.tensorics.core.quantity.lang.OngoingQuantifiedScalarBinaryPredicate;
import org.tensorics.core.quantity.lang.OngoingQuantifiedScalarConversion;
import org.tensorics.core.quantity.lang.OngoingQuantifiedScalarOperation;
import org.tensorics.core.quantity.lang.OngoingQuantityValueExtraction;
import org.tensorics.core.quantity.options.ConfidenceLevel;
import org.tensorics.core.scalar.lang.OngoingDeferredBinaryOperation;
import org.tensorics.core.scalar.lang.OngoingDeferredBinaryPredicate;
import org.tensorics.core.scalar.lang.OngoingScalarBinaryPredicate;
import org.tensorics.core.tensor.Shape;
import org.tensorics.core.tensor.Tensor;
import org.tensorics.core.tensor.lang.OngoingDeferredQuantifiedTensorOperation;
import org.tensorics.core.tensor.lang.OngoingDeferredTensorOperation;
import org.tensorics.core.tensor.lang.OngoingQuantifiedTensorOperation;
import org.tensorics.core.tensor.lang.OngoingTensorOperation;
import org.tensorics.core.tensorbacked.Tensorbacked;
import org.tensorics.core.tensorbacked.lang.OngoingDeferredQuantifiedTensorBackedOperation;
import org.tensorics.core.tensorbacked.lang.OngoingDeferredTensorBackedOperation;
import org.tensorics.core.tensorbacked.lang.OngoingQuantifiedTensorBackedOperation;
import org.tensorics.core.tensorbacked.lang.OngoingTensorBackedOperation;
import org.tensorics.core.tree.domain.Expression;
import org.tensorics.core.units.Unit;

/**
 * Provides delegate methods to a static instance of a TensoricSupport. This is for convenience purposes, so
 * that a simple calculation does not have to inherit from the support class, but can statically import methods from
 * this class.
 * 
 * @author kfuchsbe
 */
public final class DoubleTensorics {

    private static final TensoricDoubleSupport SUPPORT = new TensoricDoubleSupport();
    private static final TensoricsDoubleExpressionSupport EXPRESSION_SUPPORT = new TensoricsDoubleExpressionSupport();

    private DoubleTensorics() {
        /* only static methods */
    }

    public static final OngoingBinaryOperation calculate(Double operand) {
        return SUPPORT.calculate(operand);
    }

    public static final Double avarageOf(Iterable values) {
        return SUPPORT.avarageOf(values);
    }

    public static final Double negativeOf(Double element) {
        return SUPPORT.negativeOf(element);
    }

    public static final Double inverseOf(Double element) {
        return SUPPORT.inverseOf(element);
    }

    public static final Double sizeOf(Iterable values) {
        return SUPPORT.sizeOf(values);
    }

    public static final Double zero() {
        return SUPPORT.zero();
    }

    public static final Double two() {
        return SUPPORT.two();
    }

    public static final Double one() {
        return SUPPORT.one();
    }

    public static final Double countOf(int number) {
        return SUPPORT.countOf(number);
    }

    public static final Double sumOf(Iterable values) {
        return SUPPORT.sumOf(values);
    }

    public static final Double rmsOf(Iterable values) {
        return SUPPORT.rmsOf(values);
    }

    public static final Double squareRootOf(Double value) {
        return SUPPORT.squareRootOf(value);
    }

    public static final Double squareOf(Double value) {
        return SUPPORT.squareOf(value);
    }

    public static final  OngoingTensorOperation calculate(Tensor tensoric) {
        return SUPPORT.calculate(tensoric);
    }

    public static final Double sumOfSquaresOf(Iterable values) {
        return SUPPORT.sumOfSquaresOf(values);
    }

    public static final  Tensor zeros(Shape shape) {
        return SUPPORT.zeros(shape);
    }

    public static final  Tensor ones(Shape shape) {
        return SUPPORT.ones(shape);
    }

    public static final  Tensor elementInverseOf(Tensor tensor) {
        return SUPPORT.elementInverseOf(tensor);
    }

    public static final  Tensor negativeOf(Tensor tensor) {
        return SUPPORT.negativeOf(tensor);
    }

    public static final QuantifiedValue averageOfQ(Iterable> values) {
        return SUPPORT.averageOfQ(values);
    }

    public static final QuantifiedValue rmsOfQ(Iterable> values) {
        return SUPPORT.rmsOfQ(values);
    }

    public static final QuantifiedValue varOfQ(Iterable> values) {
        return SUPPORT.varOfQ(values);
    }

    public static final QuantifiedValue stdOfQ(Iterable> values) {
        return SUPPORT.stdOfQ(values);
    }

    public static final OngoingQuantifiedTensorOperation calculateQ(Tensor> left) {
        return SUPPORT.calculateQ(left);
    }

    public static final QuantifiedValue sizeOfQ(Iterable> values) {
        return SUPPORT.sizeOfQ(values);
    }

    public static final QuantifiedValue valueOf(Double value, Unit unit) {
        return SUPPORT.valueOf(value, unit);
    }

    public static final OngoingQuantifiedScalarOperation calculate(Double value,
            javax.measure.unit.Unit unit) {
        return SUPPORT.calculate(value, unit);
    }

    public static final QuantifiedValue sumOfQ(Iterable> values) {
        return SUPPORT.sumOfQ(values);
    }

    public static final OngoingQuantifiedScalarOperation calculate(QuantifiedValue scalar) {
        return SUPPORT.calculate(scalar);
    }

    public static final QuantifiedValue negativeOf(QuantifiedValue element) {
        return SUPPORT.negativeOf(element);
    }

    public static final QuantifiedValue inverseOf(QuantifiedValue element) {
        return SUPPORT.inverseOf(element);
    }

    public static final > TB negativeOf(TB tensorBacked) {
        return SUPPORT.negativeOf(tensorBacked);
    }

    public static final > OngoingTensorBackedOperation calculate(
            TB tensorBacked) {
        return SUPPORT.calculate(tensorBacked);
    }

    public static final >> TB negativeOfQ(TB tensorBacked) {
        return SUPPORT.negativeOfQ(tensorBacked);
    }

    public static final >> OngoingQuantifiedTensorBackedOperation calculateQ(
            QTB left) {
        return SUPPORT.calculateQ(left);
    }

    public static final OngoingScalarBinaryPredicate testIf(Double left) {
        return SUPPORT.testIf(left);
    }

    public static final OngoingQuantifiedScalarBinaryPredicate testIf(QuantifiedValue left) {
        return SUPPORT.testIf(left);
    }

    public static final Double absoluteValueOf(Double value) {
        return SUPPORT.absoluteValueOf(value);
    }

    public static final  Tensor elementwise(BinaryFunction operation, Tensor left, Tensor right) {
        return SUPPORT.elementwise(operation, left, right);
    }

    public static final Tensor elementwise(BinaryOperation operation, Tensor left,
            Tensor right) {
        return SUPPORT.elementwise(operation, left, right);
    }

    public static final QuantifiedValue valueOf(Double value, javax.measure.unit.Unit unit) {
        return SUPPORT.valueOf(value, unit);
    }

    public static final OngoingQuantityValueExtraction valueOf(QuantifiedValue quantity) {
        return SUPPORT.valueOf(quantity);
    }

    public static final OngoingQuantityIterableValueExtraction valuesOfI(
            Iterable> quantities) {
        return SUPPORT.valuesOfI(quantities);
    }

    public static final ConfidenceLevel confidenceLevelOf(Double confidenceLevel) {
        return SUPPORT.confidenceLevelOf(confidenceLevel);
    }

    public static final TensoricSupport with(ManipulationOption newOption) {
        return SUPPORT.with(newOption);
    }

    public static final OngoingQuantityIterableValueExtraction valuesOf(
            Iterable> quantities) {
        return SUPPORT.valuesOf(quantities);
    }

    public static final OngoingQuantifiedScalarConversion convert(QuantifiedValue value) {
        return SUPPORT.convert(value);
    }

    public static final Expression negativeOf(Expression element) {
        return EXPRESSION_SUPPORT.negativeOf(element);
    }

    public final Expression averageOf(Iterable iterable) {
        return EXPRESSION_SUPPORT.averageOf(iterable);
    }

    public static final Expression inverseOf(Expression element) {
        return EXPRESSION_SUPPORT.inverseOf(element);
    }

    public static final Expression averageOf(Expression> iterableExpression) {
        return EXPRESSION_SUPPORT.averageOf(iterableExpression);
    }

    public static final Expression sizeOf(Expression> iterableExpression) {
        return EXPRESSION_SUPPORT.sizeOf(iterableExpression);
    }

    public Expression squareRootOf(Expression value) {
        return EXPRESSION_SUPPORT.squareRootOf(value);
    }

    public static final Expression sumOf(Expression> iterableExpression) {
        return EXPRESSION_SUPPORT.sumOf(iterableExpression);
    }

    public Expression squareOf(Expression value) {
        return EXPRESSION_SUPPORT.squareOf(value);
    }

    public static final  OngoingDeferredTensorOperation calculateT(Expression> tensoric) {
        return EXPRESSION_SUPPORT.calculateT(tensoric);
    }

    public static final Expression rmsOf(Expression> iterableExpression) {
        return EXPRESSION_SUPPORT.rmsOf(iterableExpression);
    }

    public static final OngoingDeferredBinaryOperation calculate(Expression left) {
        return EXPRESSION_SUPPORT.calculate(left);
    }

    public static final Expression sumOfSquaresOf(Expression> iterableExpression) {
        return EXPRESSION_SUPPORT.sumOfSquaresOf(iterableExpression);
    }

    public static final  Expression> elementInverseOf(Expression> tensor) {
        return EXPRESSION_SUPPORT.elementInverseOf(tensor);
    }

    public static final  Expression> elementNegativeOf(Expression> tensor) {
        return EXPRESSION_SUPPORT.elementNegativeOf(tensor);
    }

    public static final OngoingDeferredQuantifiedTensorOperation calculateQT(
            Tensor> left) {
        return EXPRESSION_SUPPORT.calculate(left);
    }

    public static final OngoingDeferredQuantifiedScalarOperation calculateQ(
            Expression> scalar) {
        return EXPRESSION_SUPPORT.calculateQ(scalar);
    }

    public static final > Expression elementNegativeOfTB(Expression tensor) {
        return EXPRESSION_SUPPORT.elementNegativeOfTB(tensor);
    }

    public static final > OngoingDeferredTensorBackedOperation calculateTB(
            Class resultClass, Expression tensoric) {
        return EXPRESSION_SUPPORT.calculateTB(resultClass, tensoric);
    }

    public static final >> Expression elementNegativeOfQTB(
            Class resultClass, Expression tensor) {
        return EXPRESSION_SUPPORT.elementNegativeOfQTB(resultClass, tensor);
    }

    public static final >> OngoingDeferredQuantifiedTensorBackedOperation calculateQTB(
            Class resultClass, Expression tensor) {
        return EXPRESSION_SUPPORT.calculateQTB(resultClass, tensor);
    }

    public static final OngoingDeferredBinaryPredicate testIf(Expression expression) {
        return EXPRESSION_SUPPORT.testIf(expression);
    }

    public static final OngoingDeferredIterableBinaryPredicate testIfIt(
            Expression> iterableExpression) {
        return EXPRESSION_SUPPORT.testIfIt(iterableExpression);
    }

    public static final Expression rmsOfF(Expression> functionExpresssion) {
        return EXPRESSION_SUPPORT.rmsOfF(functionExpresssion);
    }

    public static final Expression averageOfF(
            Expression> functionExpresssion) {
        return EXPRESSION_SUPPORT.averageOfF(functionExpresssion);
    }

    public static final  OngoingDeferredDiscreteFunctionBinaryOperation calculateF(
            Expression> functionExpresssion) {
        return EXPRESSION_SUPPORT.calculateF(functionExpresssion);
    }

    public static final  FunctionExpressionSupportWithConversionAndComparator withConversionAndComparator(
            Conversion conversion, Comparator comparator) {
        return EXPRESSION_SUPPORT.withConversionAndComparator(conversion, comparator);
    }
}