public Tensor toProduct() { ProductBuilder pb = new ProductBuilder(); for (int i = 0; i < gPositions.size(); i++) pb.put(pc.get(gPositions.get(i))); return pb.build(); }
@Override public Tensor take() { if (currentBuilder == null) return null; if (sumsAndPowers.length == 0) { currentBuilder = null; return tensor; } Tensor t = sumsAndPowers[sumsAndPowers.length - 1].take(); if (t == null) { currentBuilder = nextCombination(); sumsAndPowers[sumsAndPowers.length - 1].reset(); return take(); } ProductBuilder temp = currentBuilder.clone(); temp.put(t); return temp.build(); } }
Product p = (Product) tensor; if (isEmpty()) { initializeData(p.factor, p.indexlessData, p.data); } else { factor = factor.multiply(p.factor); return; for (Tensor t : p.indexlessData) put(t); elements.addAll(Arrays.asList(p.data));
public ProductPort(Tensor tensor, boolean expandSymbolic) { this.tensor = tensor; this.expandSymbolic = expandSymbolic; this.base = new ProductBuilder(); List<ResettablePort> sumOrPowerPorts = new ArrayList<>(); int theLargestSumPosition = 0, theLargestSumSize = 0, productSize = tensor.size(); base.put(m); continue; base.put(m);
@Override public TensorBuilder getBuilder() { return new ProductBuilder(indexlessData.length, data.length); }
@Override public ProductBuilder clone() { return new ProductBuilder(factor, new ArrayList<>(elements), new ArrayList<>(indexLess), symbolicPowers.clone()); } }
OutputPort<Tensor> nextPort() { final int[] tuple = tuplesPort.take(); if (tuple == null) return null; TIntHashSet added = new TIntHashSet(initialForbidden); ProductBuilder builder = new ProductBuilder(); builder.put(base.get(tuple[0])); for (int i = 1; i < tuple.length; ++i) builder.put(ApplyIndexMapping.renameDummy(base.get(tuple[i]), added.toArray(), added)); return createPort(builder.build(), expandSymbolic); }
ProductBuilder pb = new ProductBuilder(baseFactors.size(), baseFactors.size()); for (FactorNode node : baseFactors) { pb.put(node.toTensor()); node.minExponent.value = node.exponent; sb.put(nodesToProduct(term.factors)); return Tensors.multiply(pb.build(), sb.build());
TensorBuilder denominator = new ProductBuilder(), numerator = new ProductBuilder(); for (Tensor power : powers) if (denominatorIndicator.is(power)) return new NumeratorDenominator(tensor, Complex.ONE); ProductBuilder denominators = new ProductBuilder(); Tensor temp = tensor; Tensor t; if (denominatorIndicator.is(t)) { exponent = Tensors.negate(t.get(1)); denominators.put(Tensors.pow(t.get(0), exponent)); if (temp instanceof Product) temp = ((Product) temp).remove(i); return new NumeratorDenominator(temp, denominators.build());
ProductBuilder pb = new ProductBuilder(); pb.put(indexless); pb.put(content.get(i)); return pb.build();
return tensor; ProductBuilder builder = new ProductBuilder(); for (Tensor nonMetric : nonMetrics) builder.put(nonMetric);// builder.put(transform(nonMetric, tempContainer)); for (MetricWrapper mk : tempContainer.container) builder.put(mk.metric); return builder.build(); } else if (tensor instanceof Sum || tensor instanceof Expression) {
ProductBuilder calculatedTraces = new ProductBuilder(); calculatedTraces.put(traceOfProduct(product.select(partition))); positionsOfMatrices.addAll(partition); c = multiply(c, calculatedTraces.build()); iterator.set(simplifications.transform(c));
addAll(varIndices.getInverted().getAllIndices().copy(), allFreeArgIndices)), new int[0]); ProductBuilder builder = new ProductBuilder(0, length); for (i = 0; i < length; ++i) builder.put(createMetricOrKronecker(allFreeArgIndices[i], allFreeVarIndices[i])); derivative = new SubstitutionTransformation(symmetric, builder.build()).transform(derivative); this.derivative = derivative; this.freeVarIndices = var.getIndices().getFree().getInverted().getAllIndices().copy();
ProductBuilder pb = new ProductBuilder(10, productSize); for (Tensor descriptor : descriptors) { Indices free = descriptor.getIndices().getFree(); forbidden.addAll(TensorUtils.getAllIndicesNamesT(descriptor)); pb.put(descriptor); Complex factor = new Complex(1 + nextInt(100)); factor = random.nextBoolean() ? factor : factor.negate(); pb.put(factor); return pb.build();
TensorField varF = (TensorField) rule.var; if (rule.useDeltaFunction) { ProductBuilder pb = new ProductBuilder(); pb.put(differentiateSimpleTensor((SimpleTensor) tensor, rule, transformations)); for (int i = 0; i < varF.size(); i++) pb.put(createDiracDelta(field.get(i), varF.get(i))); return pb.build(); } else if (anyMappingExists(varF, field) || anyMappingExists(field, varF)) return differentiateSimpleTensor((SimpleTensor) tensor, rule, transformations);
ProductBuilder dataRemainder = new ProductBuilder(0, (content.data instanceof Product) ? content.data.size() ++pivot; else dataRemainder.put(currentData[i]); Tensor dataRemainderT = dataRemainder.build();