private static Tensor extractNonComplexFactor(Tensor t) { Product p = (Product) t; if (p.getFactor().isMinusOne()) return p.get(1); else return null; }
public PrimitiveProductSubstitution(Tensor from, Tensor to) { super(from, to); Product product = (Product) from; this.fromFactor = product.getFactor(); this.fromIndexless = product.getIndexless(); this.fromContent = product.getContent(); this.fromData = fromContent.getDataCopy(); }
private static Mapping0 buildMapping(Tensor eps, Tensor part) { if (!(part instanceof Product)) return null; Product p = (Product) part; Complex factor = p.getFactor(); Mapping mapping = IndexMappings.getFirst(eps, p.getDataSubProduct()); if (mapping == null) return null; return new Mapping0(factor, mapping); }
@Override public boolean is(Tensor tensor) { if (tensor instanceof Power) { Tensor exponent = tensor.get(1); if (exponent instanceof Complex) return NumberUtils.isRealNegative((Complex) exponent); if (exponent instanceof Product) return ((Product) exponent).getFactor().isMinusOne(); } return false; } };
@Override Tensor newTo_(Tensor currentNode, SubstitutionIterator iterator) { Product product = (Product) currentNode; Complex factor = product.getFactor(); PContent content = new PContent(product.getIndexless(), product.getDataSubProduct()); //TODO getForbidden only if necessary!!!!!!!!!!!!!!!!! ForbiddenContainer forbidden = new ForbiddenContainer(); SubsResult subsResult = atomicSubstitute(content, forbidden, iterator); if (subsResult == null) return currentNode; List<Tensor> newTos = new ArrayList<>(); while (true) { if (subsResult == null) break; factor = factor.divide(fromFactor); newTos.add(subsResult.newTo); content = subsResult.remainder; subsResult = atomicSubstitute(content, forbidden, iterator); } Tensor[] result = new Tensor[newTos.size() + content.indexless.length + 2]; System.arraycopy(newTos.toArray(new Tensor[newTos.size()]), 0, result, 0, newTos.size()); System.arraycopy(content.indexless, 0, result, newTos.size(), content.indexless.length); result[result.length - 2] = content.data; result[result.length - 1] = factor; return Tensors.multiply(result); }
private static boolean testMapping(Mapping0 mapping0, Tensor eps, Tensor part) { if (!(part instanceof Product)) return false; Product p = (Product) part; Complex factor = p.getFactor(); Tensor ds = p.getDataSubProduct(); if (IndexMappings.testMapping(mapping0.mapping, eps, ds)) return factor.equals(mapping0.factor); else if (IndexMappings.testMapping(mapping0.mapping.addSign(true), eps, ds)) return factor.equals(mapping0.factor.negate()); return false; }
if (pfrom.sizeWithoutFactor() != pto.sizeWithoutFactor()) return IndexMappingProvider.Util.EMPTY_PROVIDER; Boolean booluon = compareFactors(pfrom.getFactor(), pto.getFactor()); if (booluon == null) return IndexMappingProvider.Util.EMPTY_PROVIDER; if (pfrom.getFactor().equals(pto.getFactor())) for (int i = 0; i < pfrom.sizeWithoutFactor(); ++i) if (pfrom.getWithoutFactor(i).hashCode() != pto.getWithoutFactor(i).hashCode())
rebuild.put(Tensors.multiply(((Product) t).getFactor(), newCoefficient, ((Product) t).getDataSubProduct()));
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; }
for (Tensor t : tensor) { if (t instanceof Product) containsImageOne = ((Product) t).getFactor().isImaginary(); else if (t instanceof Complex) containsImageOne = ((Complex) t).isImaginary();