/** * @deprecated very unsafe method without checks */ @Deprecated public static Tensor multiplySumElementsOnFactors(Sum sum) { final Tensor[] newSumData = new Tensor[sum.size()]; for (int i = newSumData.length - 1; i >= 0; --i) newSumData[i] = multiply(CC.generateNewSymbol(), sum.get(i)); return new Sum(newSumData, IndicesFactory.create(newSumData[0].getIndices().getFree())); }
Sum(final Tensor[] data, Indices indices) { super(indices); assert data.length > 1; this.data = data; TensorWrapper[] wrappers = new TensorWrapper[data.length]; int i; for (i = 0; i < data.length; ++i) wrappers[i] = new TensorWrapper(data[i]); ArraysUtils.quickSort(wrappers, data); this.hash = hash0(data, indices); }
private static boolean isSymbolicPoly(final Tensor t) { //indices are already checked if (t instanceof Complex) return true; else if (t instanceof SimpleTensor)//todo if TensorField (when symmetries)? return t.getIndices().size() <= 1; else if (t instanceof Product || t instanceof Power) { for (Tensor m : t) if (!isSymbolicPoly(m)) return false; return true; } return false; }
private static Term[] sum2SplitArray(Sum sum, Int pivotPosition) { Term[] terms = new Term[sum.size()]; int pivotSumsCount = Integer.MAX_VALUE, pivotPosition1 = -1; for (int i = sum.size() - 1; i >= 0; --i) { terms[i] = tensor2term(sum.get(i)); if (terms[i].factors.length < pivotSumsCount) { pivotSumsCount = terms[i].factors.length; pivotPosition1 = i; } } pivotPosition.value = pivotPosition1; return terms; }
@Override public String toString(OutputFormat mode) { StringBuilder sb = new StringBuilder(); String temp; for (int i = 0; ; ++i) { temp = get(i).toString(mode, Sum.class); if ((temp.charAt(0) == '-' || temp.charAt(0) == '+') && sb.length() != 0) sb.deleteCharAt(sb.length() - 1); String str = get(i).toString(mode, Sum.class); if (str.contains("'") && !mode.printMatrixIndices) return toString(mode.printMatrixIndices()); sb.append(str); if (i == size() - 1) return sb.toString(); sb.append('+'); } }
private static Tensor[] reIm(Tensor sum) { IntArrayList im = new IntArrayList(sum.size()); for (int i = sum.size() - 1; i >= 0; --i) { if (sum.get(i) instanceof Complex && !((Complex) sum.get(i)).getImaginary().isZero()) im.add(i); else if (sum.get(i) instanceof Product && !((Product) sum.get(i)).getFactor().getImaginary().isZero()) im.add(i); } Tensor[] parts = new Tensor[2]; int[] positions = im.toArray(); parts[0] = ((Sum) sum).select(positions); parts[1] = ((Sum) sum).remove(positions); return parts; }
@Override public Tensor set(int i, Tensor tensor) { // return super.set(i, tensor); if (i >= data.length || i < 0) throw new IndexOutOfBoundsException(); Tensor old = data[i]; if (old == tensor) return this; if (TensorUtils.equalsExactly(old, tensor)) return this; if (TensorUtils.isIndeterminate(tensor)) return tensor; if (TensorUtils.isZero(tensor)) return remove(i); Tensor[] newData = data.clone(); newData[i] = tensor; if (TensorUtils.equals(old, tensor)) return new Sum(newData, indices); return Tensors.sum(newData); }
it.set(((Sum) current).remove(ps)); continue main;
@Override protected Tensor select1(int[] positions) { Tensor[] newData = new Tensor[positions.length]; int i = -1; for (int position : positions) newData[++i] = data[position]; return new Sum(newData, indices); }
/** * Expands out the product of two sums. * * @param s1 first sum * @param s2 second sum * @param transformations additional transformations to be * consequently applied on each term * in the resulting expression. * @param factors if specified, then each resulting term will be multiplied on this factor * @return the resulting expanded tensor */ public static Tensor expandPairOfSums(Sum s1, Sum s2, Tensor[] factors, Transformation[] transformations) { ExpandPairPort epp = new ExpandPairPort(s1, s2, factors); TensorBuilder sum = new SumBuilder(s1.size() * s2.size()); Tensor t; while ((t = epp.take()) != null) sum.put(apply(transformations, t)); return sum.build(); }
private Tensor factorSymbolicTerms(Tensor tensor) { FromParentToChildIterator iterator = new FromParentToChildIterator(tensor); Tensor c; while ((c = iterator.next()) != null) { if (!(c instanceof Sum)) continue; Tensor remainder = c, temp; IntArrayList symbolicPositions = new IntArrayList(); for (int i = c.size() - 1; i >= 0; --i) { temp = c.get(i); if (isSymbolic(temp)) { symbolicPositions.add(i); if (remainder instanceof Sum) remainder = ((Sum) remainder).remove(i); else remainder = Complex.ZERO; } } Tensor symbolicPart = ((Sum) c).select(symbolicPositions.toArray()); symbolicPart = factorSymbolicTerm(symbolicPart); if (remainder instanceof Sum) { SumBuilder sb = new SumBuilder(remainder.size()); for (Tensor tt : remainder) sb.put(factorSymbolicTerms(tt)); remainder = sb.build(); } else remainder = factorSymbolicTerms(remainder); iterator.set(Tensors.sum(symbolicPart, remainder)); } return iterator.result(); }
assert temp instanceof Sum; sb.put(temp.get(nonProductOfSumsPositions.get(i))); temp = ((Sum) temp).remove(nonProductOfSumsPositions.get(i));
@Override protected Tensor remove1(final int[] positions) { Tensor[] newData = new Tensor[data.length - positions.length]; int pointer = 0, counter = -1; for (int i = 0; i < data.length; ++i) if (pointer < positions.length && i == positions[pointer]) ++pointer; else newData[++counter] = data[i]; if (newData.length == 1) return newData[0]; return new Sum(newData, indices); }
private static Tensor multiplyWithBuilder(Sum sum, Tensor factor, Transformation... transformations) { SumBuilder sb = new SumBuilder(sum.size()); for (Tensor t : sum) sb.put(Transformation.Util.applySequentially(multiply(t, factor), transformations)); return sb.build(); }
private static Tensor multiplyWithFactory(Sum sum, Tensor factor, Transformation... transformations) { final ArrayList<Tensor> newSumData = new ArrayList<>(sum.size()); Tensor temp; boolean reduced = false; for (int i = sum.size() - 1; i >= 0; --i) { temp = Transformation.Util.applySequentially(multiply(factor, sum.get(i)), transformations); if (!TensorUtils.isZero(temp)) { newSumData.add(temp); if (!reduced && isReduced(sum.get(i), factor, temp)) reduced = true; } } if (newSumData.size() == 0) return Complex.ZERO; if (newSumData.size() == 1) return newSumData.get(0); final Tensor[] data = newSumData.toArray(new Tensor[newSumData.size()]); if (reduced) return SumFactory.FACTORY.create(data); return new Sum(data, IndicesFactory.create(newSumData.get(0).getIndices().getFree())); }