Changeset 162

Timestamp:

12/14/07 07:40:53 (9 months ago)

Author:

Don Clugston

Message:

Scalar folding now done by a visitor -- all deprecated code removed.

Files:

• trunk/blade/Blade.d (modified) (1 diff)
• trunk/blade/BladeDemo.d (modified) (2 diffs)
• trunk/blade/BladeSimplify.d (modified) (11 diffs)

trunk/blade/Blade.d

@@ -512 +512 @@
-    int lenvec = findVectorForLength(tree);
-    char [] result = assertAllVectorLengthsEqual(tree);
+    result ~= "// " ~ tree.expression ~ \n;
-    result ~= "for (int blade_index=0; blade_index<" 
-    ~ getDimensionLengthForSymbol(tree.mapping[lenvec], tree, 1) ~

trunk/blade/BladeDemo.d

@@ -33 +33 @@
-                            [5.14, 455, 554, 2.43]];
-    real k=3.4;
-
+
-    mixin(vectorize(` a += (d[2..$-1]*2.01*a[2]-another[][1])["abc".length-3..$]`));
-    mixin(vectorize(" a-= 2.01*(        3.04+k)*r"));    
- 
+
-    mixin(vectorize("q+= q*2.01"));
-   
@@ -44 +44 @@
-    mixin(vectorize("a+=6*another[1]"));
-    mixin(vectorize("a+=6*another[1][]"));
-   
-    mixin(vectorize("another[0..$,1]+=6*a[0..2]"));
-    mixin(vectorize("r-=another[0]"));

trunk/blade/BladeSimplify.d

@@ -114 +114 @@
-}
-
-// DEPRECATED
-/// As for exprSimplify, but allows the whole thing to be wrapped in parentheses.
-char [] subexprSimplify(char [] expr, char [] rank, char [] mulexpr, char [] indexexpr)
-{
-    if (expr.length==1) {
-        int r = subexprRank(expr, rank);
-        char [] e = expr;
-        if(indexexpr.length>0) {
-            assert(r>0, "BLADE BUG: MISMATCHED INDEX " ~ expr ~ " " ~ indexexpr ~ " " ~ mulexpr);
-            e = " {" ~ expr ~ indexexpr ~ "} ";
-        }
-        if (mulexpr.length>1) {
-            // in this case, it's worth creating a new variable
-            return "( {" ~ mulexpr ~ "} *" ~ e ~ ")";
-        }
-        if (mulexpr.length>0) return "(" ~ mulexpr ~ "*" ~ e ~ ")";
-        return e;
-    }
-    // strip off the parentheses before simplifying
-    return exprSimplify(expr[1..$-1], rank, mulexpr, indexexpr);
-}
-
-// DEPRECATED
-// Simplify a scalar*tensor expression.
-char [] simplifyScalarMul(char [] scalar, char [] tensor, char [] mulexpr, char [] rank, char [] indexexpr)
-{
-    char [] m = scalar;
-    if (mulexpr.length>0) m = "(" ~ mulexpr ~ "*" ~ scalar ~ ")";
-    // BUG: It's also worth scalar folding A*(B*U[]-V[]) into (A*B)*U[]+(-A)*V[],
-    if (tensor.length > 1 && hasScalarMultiply(tensor[1..$-1], rank)) {
-        // opportunity for scalar folding
-        return subexprSimplify(tensor, rank, m, indexexpr);
-    } else {
-        if (m.length>1) m = " {" ~ m ~ "} ";
-        return "(" ~ m ~ "*" ~ subexprSimplify(tensor, rank, "", indexexpr) ~ ")";
-    }
-}
-
-// DEPRECATED
-char [] getCommonMultiplucation(char [] expr, char [] rank)
-{
-    if (expr.length>1 && expr[0]=='(') expr = expr[1..$-1];
-    else if (expr.length==1 && expr[0]>='A' && expr[0]<='Z'){
-        return rank[expr[0]-'A']=='0'? expr : "";
-    } else assert(0, "BLADE ICE: " ~ expr);
-    if (expr.length>2 && (expr[0..2]=="++" || expr[0..2]=="--" || expr[$-2..$]=="++" || expr[$-2..$]=="--")) {
-        return "";
-    }
-    if (expr[0]=='+' || expr[0]=='-') return getCommonMultiplucation(expr[1..$], rank);
-    int x = exprLength(expr);
-    int y = x+1;
-    assert(y < expr.length, "BLADE ICE:" ~ expr);
-    // Deal with shifts, op=, and NCEG operators
-    while (expr[y+1]=='<' || expr[y+1]=='>' || expr[y+1]=='=') ++y;
-    char [] op = expr[x+1..y+1];    
-    char [] left = expr[0..x+1];
-    char [] right = expr[y+1..$];
-    if (op=="[") {
-        // (A)[C] can still have a multiply by scalar, if A contains a
-        // multiply.
-        if (left.length==1) return "";
-        return getCommonMultiplucation(left[1..$], rank);
-    }
-    if (op!="*") return "";    
-    int leftrnk = subexprRank(left, rank);
-    int rightrnk = subexprRank(right, rank);
-    char [] leftMul = "";
-    char [] rightMul = "";
-    if (leftrnk == 0 && rightrnk == 0) { return expr; }
-    if (leftrnk == 0) leftMul = left; else leftMul = getCommonMultiplucation(left, rank);
-    if (rightrnk== 0) rightMul = right; else rightMul = getCommonMultiplucation(right, rank);
-    if (leftMul!="" && rightMul!="") return "(" ~ leftMul ~ "*" ~ rightMul ~ ")";
-    if (leftMul!="") return leftMul;
-    return rightMul;
-}
-
-// DEPRECATED
-// Simplify the expression, assuming global scalar multiply has already been removed.
-char [] simplifyWithoutMul(char [] rawExpr, char [] rank)
-{
-    char [] expr = rawExpr;
-    if (expr.length==1 && expr[0]>='A' && expr[0]<='Z') {
-        return rank[expr[0]-'A']=='0'? "":expr;
-    } else if (expr.length>1 && expr[0]=='(') expr = rawExpr[1..$-1];
-
-    if (expr.length>2 && (expr[0..2]=="++" || expr[0..2]=="--" || expr[$-2..$]=="++" || expr[$-2..$]=="--")) {
-        return expr;
-    }
-    int x = exprLength(expr);
-    int y = x+1;
-    assert(y < expr.length, "BLADE ICE:" ~ expr);
-    // Deal with shifts, op=, and NCEG operators
-    while (expr[y+1]=='<' || expr[y+1]=='>' || expr[y+1]=='=') ++y;
-    char [] op = expr[x+1..y+1];    
-    char [] left = expr[0..x+1];
-    char [] right = expr[y+1..$];
-/*    
-    if (op=="[") {
-        // (A)[C] can still have a multiply by scalar, if A contains a
-        // multiply.
-        if (left.length==1) return left;
-        return simplifyWithoutMul(left[1..$], rank);
-    }
-*/
-    if (op!="*") return subexprSimplify(rawExpr, rank, "", "");
-    
-    int leftrnk = subexprRank(left, rank);
-    int rightrnk = subexprRank(right, rank);
-    char [] leftMul = "";
-    char [] rightMul = "";
-    if (leftrnk == 0 && rightrnk == 0) return "";
-    if (leftrnk == 0) leftMul = ""; else leftMul = simplifyWithoutMul(left, rank);
-    if (rightrnk== 0) rightMul = ""; else rightMul = simplifyWithoutMul(right, rank);
-    if (leftMul!="" && rightMul!="") return "(" ~ leftMul ~ "*" ~ rightMul ~ ")";
-    if (leftMul!="") return leftMul;
-    return rightMul;
-}
-
-// DEPRECATED
-/**
- * Rewrite the expression, taking advantage of distributivity of [] and
- * associativity of *. Additionally, we group all scalars together, whenever
- * possible.
- *
- * This process creates compound scalars and vectors, delineated by " {" and "} ".
- * They will be removed in a subsequent step.
- */
-char [] exprSimplify(char [] expr, char [] rank, char [] mulexpr, char [] indexexpr)
-{
-    if (expr.length>3 && expr[0..2]=="d(") { // dot product
-        assert(indexexpr=="", "BLADE ICE");
-        int x = exprLength(expr[2..$-1]);
-            char [] left = expr[2..x+3];
-            char [] right = expr[x+4..$-1];
-            char [] leftmul = "";
-            char [] rightmul = "";            
-            leftmul = getCommonMultiplucation(left, rank);
-            rightmul = getCommonMultiplucation(right, rank);
-            char [] m = leftmul;
-            if (rightmul.length>0) m = m==""? rightmul : "(" ~ m ~ "*" ~rightmul~")";
-            if (mulexpr.length>0) m = m=="" ? mulexpr : "(" ~ m ~ "*" ~mulexpr~")";
-            if (m.length>1) m= "* {" ~ m ~ "} ";
-            else if (m.length==1) m= "*" ~ m;
-            assert(indexexpr.length==0, "BLADE ICE: rank mismatch in dot product");
-            return " {d(" ~ simplifyWithoutMul(left, rank) ~ "," ~
-                          simplifyWithoutMul(right, rank) ~ ")} " ~ m;
-    }
-    // Deal with ++ and --. Only for scalars
-    if (expr.length>2 && (expr[0..2]=="++" || expr[0..2]=="--")) {
-        return expr[0..2] ~ subexprSimplify(expr[2..$], rank, mulexpr, indexexpr);
-    }
-    if (expr.length>2 && (expr[$-2..$]=="++" || expr[$-2..$]=="--")) {
-        return subexprSimplify(expr[0..$-2], rank, mulexpr, indexexpr) ~ expr[$-2..$];
-    }
-    // Deal with unary operators
-    if (expr[0]=='-') {
-        // Fold unary minus into a multiply, if possible.
-        if (mulexpr.length>0) return subexprSimplify(expr[1..$], rank, "-" ~ mulexpr, indexexpr);
-        return "-" ~ subexprSimplify(expr[1..$], rank, mulexpr, indexexpr);
-    }
-    // Just remove unary plus.
-    if (expr[0]=='+') return subexprSimplify(expr[1..$], rank, mulexpr, indexexpr);
-   
-    int x = exprLength(expr);
-    int y = x+1;
-    assert(y < expr.length, expr);
-    // Deal with shifts, op=, and NCEG operators
-    while (expr[y+1]=='<' || expr[y+1]=='>' || expr[y+1]=='=') ++y;    
-
-    char [] op = expr[x+1..y+1];    
-    char [] left = expr[0..x+1];
-    char [] right = expr[y+1..$];
-    if (expr[x+1]=='[') right = expr[y+1..$-1]; // drop off the ']'.
-    if (op=="[") {
-        // accumulate indexing and slicing operations
-        return subexprSimplify(left, rank, mulexpr, "[" ~ right ~ "]" ~ indexexpr);
-    }
-    int lrank = subexprRank(left, rank);
-    int rrank = subexprRank(right, rank);
-    // Fold scalars together
-    if (op=="*") {
-        if (lrank==0)
-            return simplifyScalarMul(left, right, mulexpr, rank, indexexpr);
-        else if (rrank==0) 
-            return simplifyScalarMul(right, left, mulexpr, rank, indexexpr);
-        // else it's matrix * matrix
-    }
-    if (op=="*=") {
-        if (rrank==0) {
-            char [] m = right;
-            if (mulexpr.length>0) m ~= "*" ~ mulexpr;
-            if (m.length>1)  m= " {" ~ m ~ "} ";
-            return "(" ~ subexprSimplify(left, rank, "", indexexpr)~ "*=" ~ m ~ ")";
-        } // else it's matrix *= matrix
-    }
-    return "(" ~ subexprSimplify(left, rank, mulexpr, indexexpr) ~ op ~ subexprSimplify(right, rank, mulexpr, indexexpr) ~ ")";
-}
-
-// Determine rank of a multidimensional index
-int indexRank(char [] s)
@@ -337 +139 @@
-RevisedExpression simplifyVectorExpression(char [] expr, char [] rank, Symbol[] symTable=[])
-{
-
-
-
-
+
-    char [][] comp;
-    char [] used = ""; // which of the old variables are used; gives the new mapping
@@ -353 +152 @@
-            for (k=i+1; s[k]!=' '; ++k) {}
-            char [] newexpr = s[i+2..k-1]; // strip off the {}
+            
+            int newi = k;
+            if (i>0 && k<s.length && s[i-1]=='(' && s[k+1]==')') {
+                e = e[0..$-1]; // remove the last '('
+                newi=k+1; // don't add ')'
+            }
-            // Check for a duplicate
-            int z;
@@ -371 +176 @@
-                }                
-            } else e ~= cast(char)('A'+z+rank.length);
-k
+newi
-        } else {
-            e ~= s[i];
@@ -405 +210 @@
-}
-
-
-
-
-
-
-
-
-
-
-
-
+
-    RevisedExpression e = simplifyVectorExpression("A+=(((D[B])*C)[B])", "2004");
-    assert(e.expression == "A+=(B*C)");
-    assert(e.rank=="202");
-    assert(e.compounds[0]=="D[B,B]");
-    assert(e.mapping=="ACE");
+    assert(e.expression== "A+=(C*B)");
-}
-
@@ -460 +255 @@
-       } else {
-           assert(sym!="$" && this_.rank[sym[0]-'A']>'0', "Rank error " ~ sym);
-TODO: We
+Note: Later, we'll
-           return sym ~ createMultiSlice(this_.slicing);           
-       }
@@ -494 +289 @@
-            //   it might contain a dollar, which we need to replace. 
-            // * If the existing dimension is a slice, the two slices will combine.
- 
+
-            // The items inside the slice are top-level, ie have no slice or dollar.
-            char [] a = wrapInParens(doVisit(IndexFoldingVisitor(this_.rank,"$",[]), slices[$-1][0]));
@@ -625 +420 @@
-struct ScalarFold
-{
-
+       // vector or matrix expression; empty for a pure scalar expression
-    char [] multiplier; // scalar multiply of the entire expression
-}
@@ -662 +457 @@
-        } else {
-            ScalarFold f = doVisit(this_, expr);
-
+
+
-        }
-    }
-    ReturnType onVisitPostfix(This this_, char [] op, char [] expr) {
-        ScalarFold f = doVisit(this_, expr);
-
+
+
-    }
-    ReturnType onVisitIndex(This this_, char [] base, char [][2][] slices) {
-        // Base is always a single symbol.
+        assert(base.length==1);
-        ScalarFold left = doVisit(this_, base);
-
+
+
+
+
+
+
+
+
-        return ScalarFold(" {" ~ left.expr ~ createMultiSlice(slices)~ "} ", left.multiplier);
-    }
@@ -688 +493 @@
-        if (first.expr=="" && second.expr=="") { // both are 100% scalars -- it remains a scalar.
-            return ScalarFold("",
-WithCompound
-WithCompound
+
+
-        }
-        return ScalarFold(wrapInParens(combineMulWithCompound(first.expr, first.multiplier)) ~ op ~
@@ -717 +522 @@
-    if (f.multiplier=="") return f.expr;
-    else if (f.expr=="") return " {" ~ f.multiplier ~ "} ";
-" {" ~ f.multiplier ~ "} *" ~ wrapInParens(f.exp
+combineMulWithCompound(f.expr, f.multiplie
-}
-