/** * Returns {@code a} divided by {@code b}. * * @param a tensor * @param b scalar tensor * @return {@code a} divided by {@code b}. * @throws IllegalArgumentException if b is not scalar */ public static Tensor divide(Tensor a, Tensor b) { return multiply(a, reciprocal(b)); }
/** * Returns {@code a} divided by {@code b}. This method takes care about * all conflicting dummy indices in factors. Einstein notation assumed. * * @param a tensor * @param b scalar tensor * @return {@code a} divided by {@code b}. * @throws IllegalArgumentException if b is not scalar */ public static Tensor divideAndRenameConflictingDummies(Tensor a, Tensor b) { return multiplyAndRenameConflictingDummies(a, reciprocal(b)); }
@Override protected Tensor expandProduct(Tensor product) { NumeratorDenominator numDen = NumeratorDenominator.getNumeratorAndDenominator(product, NumeratorDenominator.integerDenominatorIndicator); Tensor numerator = ExpandTransformation.expand(numDen.numerator, transformations); if (numDen.numerator == numerator) return product; return Tensors.multiply(numerator, Tensors.reciprocal(numDen.denominator)); }
@Override protected Tensor expandProduct(Tensor product) { NumeratorDenominator numDen = NumeratorDenominator.getNumeratorAndDenominator(product, NumeratorDenominator.integerDenominatorIndicator); Tensor denominator = ExpandTransformation.expand(numDen.denominator, transformations); if (numDen.denominator == denominator) return product; return Tensors.multiply(numDen.numerator, Tensors.reciprocal(denominator)); }
@Override protected Tensor expandProduct(Product product, Transformation[] transformations) { NumeratorDenominator numDen = NumeratorDenominator.getNumeratorAndDenominator(product, NumeratorDenominator.integerDenominatorIndicator); Tensor denominator = numDen.denominator; // assert !isPositiveIntegerPower(denominator); if (denominator instanceof Product) denominator = ExpandUtils.expandProductOfSums((Product) numDen.denominator, transformations); boolean denExpanded = denominator != numDen.denominator; denominator = reciprocal(denominator); Tensor numerator = numDen.numerator; Tensor res = Tensors.multiply(denominator, numerator), temp = res; if (res instanceof Product) res = ExpandUtils.expandProductOfSums((Product) temp, transformations); if (denExpanded || res != temp) return res; return product; }
/** * Gives inverse matrix. * * @param matrix matrix * @return inverse matrix */ public static Tensor[][] inverse(Tensor[][] matrix) { checkMatrix(matrix); if (matrix.length == 1) return new Tensor[][]{{reciprocal(matrix[0][0])}}; Tensor det = det(matrix); int length = matrix.length; Tensor[][] inverse = new Tensor[length][length]; for (int i = 0; i < length; ++i) { for (int j = 0; j < length; ++j) { inverse[j][i] = divideAndRenameConflictingDummies(det(deleteFromMatrix(matrix, i, j)), det); if ((i + j) % 2 != 0) inverse[j][i] = negate(inverse[j][i]); } } return inverse; }
@Override public Tensor transform(Tensor tensor) { SubstitutionIterator iterator = new SubstitutionIterator(tensor, traverseGuide); Tensor current; while ((current = iterator.next()) != null) { if (current instanceof Product) iterator.unsafeSet(expandProduct((Product) current, transformations)); else if (ExpandUtils.isExpandablePower(current)) { Sum sum = (Sum) current.get(0); int exponent = ((Complex) current.get(1)).intValue(); if (exponent == -1) continue; boolean symbolic = TensorUtils.isSymbolic(sum), reciprocal = exponent < 0; exponent = Math.abs(exponent); Tensor temp; if (symbolic) temp = ExpandUtils.expandSymbolicPower(sum, exponent, transformations); else temp = ExpandUtils.expandPower(sum, exponent, iterator.getForbidden(), transformations); if (reciprocal) temp = reciprocal(temp); if (symbolic) iterator.unsafeSet(temp); else iterator.set(temp); } } return iterator.result(); }
public static NumeratorDenominator getNumeratorAndDenominator(Tensor tensor, Indicator<Tensor> denominatorIndicator) { if (denominatorIndicator.is(tensor)) return new NumeratorDenominator(Complex.ONE, Tensors.reciprocal(tensor)); for (Tensor power : powers) if (denominatorIndicator.is(power)) denominator.put(Tensors.reciprocal(power)); else numerator.put(power);