OngoingOperation.plusV(), OngoingOperation.minusV()

Author: kaifox

src/java/org/tensorics/core/commons/lang/OngoingOperation.java

@@ -33,8 +33,12 @@
 public interface OngoingOperation<T, V> {
 
     T plus(T right);
+    
+    T plusV(V right);
 
     T minus(T right);
+    
+    T minusV(V right);
 
     T elementTimes(T right);
 

src/java/org/tensorics/core/tensor/lang/OngoingDeferredQuantifiedTensorOperation.java

@@ -28,6 +28,7 @@
 import org.tensorics.core.math.operations.BinaryOperation;
 import org.tensorics.core.quantity.QuantifiedValue;
 import org.tensorics.core.quantity.operations.QuantityOperationRepository;
+import org.tensorics.core.tensor.ImmutableScalar;
 import org.tensorics.core.tensor.Tensor;
 import org.tensorics.core.tensor.operations.ElementBinaryOperation;
 import org.tensorics.core.tree.domain.Expression;
@@ -61,6 +62,11 @@ public Expression<Tensor<QuantifiedValue<S>>> plus(Expression<Tensor<QuantifiedV
         return evaluate(right, pseudoField.addition());
     }
 
+    @Override
+    public Expression<Tensor<QuantifiedValue<S>>> plusV(QuantifiedValue<S> right) {
+        return plus(ResolvedExpression.of(ImmutableScalar.of(right)));
+    }
+
     public Expression<Tensor<QuantifiedValue<S>>> minus(Tensor<QuantifiedValue<S>> right) {
         return minus(ResolvedExpression.of(right));
     }
@@ -70,6 +76,11 @@ public Expression<Tensor<QuantifiedValue<S>>> minus(Expression<Tensor<Quantified
         return evaluate(right, pseudoField.subtraction());
     }
 
+    @Override
+    public Expression<Tensor<QuantifiedValue<S>>> minusV(QuantifiedValue<S> right) {
+        return minus(ResolvedExpression.of(ImmutableScalar.of(right)));
+    }
+
     @Override
     public Expression<Tensor<QuantifiedValue<S>>> elementTimes(Expression<Tensor<QuantifiedValue<S>>> right) {
         return evaluate(right, pseudoField.multiplication());

src/java/org/tensorics/core/tensor/lang/OngoingDeferredTensorOperation.java

@@ -29,6 +29,7 @@
 import org.tensorics.core.lang.Tensorics;
 import org.tensorics.core.math.ExplicitField;
 import org.tensorics.core.math.operations.BinaryOperation;
+import org.tensorics.core.tensor.ImmutableScalar;
 import org.tensorics.core.tensor.Tensor;
 import org.tensorics.core.tensor.operations.ElementBinaryOperation;
 import org.tensorics.core.tree.domain.Expression;
@@ -72,11 +73,21 @@ public Expression<Tensor<V>> plus(Expression<Tensor<V>> right) {
         return evaluate(right, field.addition());
     }
 
+    @Override
+    public Expression<Tensor<V>> plusV(V right) {
+        return plus(ResolvedExpression.of(ImmutableScalar.of(right)));
+    }
+
     @Override
     public Expression<Tensor<V>> minus(Expression<Tensor<V>> right) {
         return evaluate(right, field.subtraction());
     }
 
+    @Override
+    public Expression<Tensor<V>> minusV(V right) {
+        return minus(ResolvedExpression.of(ImmutableScalar.of(right)));
+    }
+
     @Override
     public Expression<Tensor<V>> elementDividedByV(V value) {
         Tensor<V> right = Tensorics.scalarOf(value);
@@ -90,40 +101,14 @@ public Expression<Tensor<V>> elementTimes(Expression<Tensor<V>> right) {
 
     @Override
     public Expression<Tensor<V>> elementTimesV(V value) {
-        Tensor<V> right = Tensorics.scalarOf(value);
-        return elementTimes(ResolvedExpression.of(right));
+        return elementTimes(ResolvedExpression.of(ImmutableScalar.of(value)));
     }
 
     @Override
     public Expression<Tensor<V>> elementDividedBy(Expression<Tensor<V>> right) {
         return evaluate(right, field.division());
     }
 
-    // /**
-    // * Calls multiplication operation with question for outupt's {@link
-    // ShapingStrategy}
-    // *
-    // * @param right second tensoric to use
-    // * @return Possibility to choose {@link ShapingStrategy}s
-    // */
-    // public Expression<Tensor<V>> elementTimes(Expression<Tensor<V>> right) {
-    //
-    // }
-
-    // public Expression<Tensor<V>> elementDividedBy(Expression<Tensor<V>>
-    // right) {
-    //
-    // }
-    // /**
-    // * Calls multiplication for single value operation.
-    // *
-    // * @param value to be multiplied in first Tensoric
-    // * @return multiplied tensoric result.
-    // */
-    // public Expression<Tensor<V>> elementTimes(V value) {
-    //
-    // }
-
     private Expression<Tensor<V>> evaluate(Expression<Tensor<V>> right, BinaryOperation<V> operation) {
         return new BinaryOperationExpression<>(new ElementBinaryOperation<V>(operation, optionRegistry), left, right);
     }

src/java/org/tensorics/core/tensor/lang/OngoingQuantifiedTensorOperation.java

@@ -27,6 +27,7 @@
 import org.tensorics.core.math.operations.BinaryOperation;
 import org.tensorics.core.quantity.QuantifiedValue;
 import org.tensorics.core.quantity.operations.QuantityOperationRepository;
+import org.tensorics.core.tensor.ImmutableScalar;
 import org.tensorics.core.tensor.Tensor;
 import org.tensorics.core.tensor.operations.ElementBinaryOperation;
 
@@ -55,11 +56,23 @@ public Tensor<QuantifiedValue<S>> plus(Tensor<QuantifiedValue<S>> right) {
         return evaluate(right, operationRepository.addition());
     }
 
+    @Override
+    public Tensor<QuantifiedValue<S>> plusV(QuantifiedValue<S> right) {
+        return plus(ImmutableScalar.of(right));
+    }
+
+    
     @Override
     public Tensor<QuantifiedValue<S>> minus(Tensor<QuantifiedValue<S>> right) {
         return evaluate(right, operationRepository.subtraction());
     }
 
+    @Override
+    public Tensor<QuantifiedValue<S>> minusV(QuantifiedValue<S> right) {
+        return minus(ImmutableScalar.of(right));
+    }
+    
+    
     @Override
     public Tensor<QuantifiedValue<S>> elementTimes(Tensor<QuantifiedValue<S>> right) {
         return evaluate(right, operationRepository.multiplication());
@@ -86,4 +99,6 @@ private Tensor<QuantifiedValue<S>> evaluate(Tensor<QuantifiedValue<S>> right,
         return new ElementBinaryOperation<>(operation, operationRepository.environment().options()).perform(left,
                 right);
     }
+
+   
 }

src/java/org/tensorics/core/tensor/lang/OngoingTensorOperation.java

@@ -64,7 +64,8 @@ public Tensor<V> plus(Tensor<V> right) {
         return evaluate(right, environment.field().addition());
     }
 
-    public Tensor<V> plus(V right) {
+    @Override
+    public Tensor<V> plusV(V right) {
         return plus(ImmutableScalar.of(right));
     }
 
@@ -73,7 +74,8 @@ public Tensor<V> minus(Tensor<V> right) {
         return evaluate(right, environment.field().subtraction());
     }
 
-    public Tensor<V> minus(V right) {
+    @Override
+    public Tensor<V> minusV(V right) {
         return minus(ImmutableScalar.of(right));
     }
 

src/java/org/tensorics/core/tensorbacked/lang/OngoingQuantifiedTensorBackedOperation.java

@@ -29,6 +29,7 @@
 import org.tensorics.core.math.operations.BinaryOperation;
 import org.tensorics.core.quantity.QuantifiedValue;
 import org.tensorics.core.quantity.operations.QuantityOperationRepository;
+import org.tensorics.core.tensor.ImmutableScalar;
 import org.tensorics.core.tensor.Tensor;
 import org.tensorics.core.tensor.operations.ElementBinaryOperation;
 import org.tensorics.core.tensorbacked.Tensorbacked;
@@ -55,12 +56,30 @@ public OngoingQuantifiedTensorBackedOperation(QuantityOperationRepository<S> pse
 
     @Override
     public QTB plus(QTB right) {
-        return evaluate(right.tensor(), pseudoField.addition());
+        return plusQT(right.tensor());
+    }
+
+    public QTB plusQT(Tensor<QuantifiedValue<S>> tensor) {
+        return evaluate(tensor, pseudoField.addition());
+    }
+
+    @Override
+    public QTB plusV(QuantifiedValue<S> right) {
+        return plusQT(ImmutableScalar.of(right));
     }
 
     @Override
     public QTB minus(QTB right) {
-        return evaluate(right.tensor(), pseudoField.subtraction());
+        return minusQT(right.tensor());
+    }
+
+    public QTB minusQT(Tensor<QuantifiedValue<S>> tensor) {
+        return evaluate(tensor, pseudoField.subtraction());
+    }
+
+    @Override
+    public QTB minusV(QuantifiedValue<S> right) {
+        return minusQT(ImmutableScalar.of(right));
     }
 
     @Override

src/java/org/tensorics/core/tensorbacked/lang/OngoingTensorBackedOperation.java

@@ -28,6 +28,7 @@
 import org.tensorics.core.commons.options.Environment;
 import org.tensorics.core.lang.Tensorics;
 import org.tensorics.core.math.operations.BinaryOperation;
+import org.tensorics.core.tensor.ImmutableScalar;
 import org.tensorics.core.tensor.Tensor;
 import org.tensorics.core.tensor.operations.ElementBinaryOperation;
 import org.tensorics.core.tensorbacked.Tensorbacked;
@@ -63,12 +64,20 @@ public OngoingTensorBackedOperation(Environment<V> environment, TB left) {
 
     @Override
     public TB plus(TB right) {
-        return evaluate(right.tensor(), environment.field().addition());
+        return plusT(right.tensor());
+    }
+
+    public TB plusT(Tensor<V> tensor) {
+        return evaluate(tensor, environment.field().addition());
     }
 
     @Override
     public TB minus(TB right) {
-        return evaluate(right.tensor(), environment.field().subtraction());
+        return minusT(right.tensor());
+    }
+
+    public TB minusT(Tensor<V> tensor) {
+        return evaluate(tensor, environment.field().subtraction());
     }
 
     /**
@@ -127,4 +136,14 @@ private TB evaluate(Tensor<V> right, BinaryOperation<V> operation) {
         return createBackedByTensor(TensorbackedInternals.classOf(left), result);
     }
 
+    @Override
+    public TB plusV(V right) {
+        return plusT(ImmutableScalar.of(right));
+    }
+
+    @Override
+    public TB minusV(V right) {
+        return minusT(ImmutableScalar.of(right));
+    }
+
 }