Changeset 156

Timestamp:

12/05/07 14:22:09 (9 months ago)

Author:

Don Clugston

Message:

Fixed constant folding for dot (first attempt)

Files:

• trunk/blade/BladeDemo.d (modified) (1 diff)
• trunk/blade/BladeRank.d (modified) (1 diff)
• trunk/blade/BladeSimplify.d (modified) (4 diffs)

trunk/blade/BladeDemo.d

@@ -51 +51 @@
-
-// Parses, and rank checks OK. Doesn't simplify yet, no codegen.
-// 
+ //
-
-    writefln("a=", a);

trunk/blade/BladeRank.d

@@ -280 +280 @@
-}
-
+
-// Return true if the entire expression contains a multiplication by a scalar
-bool hasScalarMultiply(char [] expr, char [] rank)

trunk/blade/BladeSimplify.d

@@ -150 +150 @@
-}
-
+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;
+}
+
+// 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;
+}
+
-/**
- * Rewrite the expression, taking advantage of distributivity of [] and
@@ -160 +238 @@
-char [] exprSimplify(char [] expr, char [] rank, char [] mulexpr, char [] indexexpr)
-{
-
+
+
-        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);
+            
+//            assert(0, leftmul~"#" ~ rightmul);
-//            if (hasScalarMultiply(left, rank)) {
-//
+
-//            }
-//            if (hasScalarMultiply(right, rank)) {
-//            } // ditto for right.
-
-
+
+
+
+
+
-            assert(indexexpr.length==0, "BLADE ICE: rank mismatch in dot product");
-
-
+
+
+
+
-    }
-    // Deal with ++ and --. Only for scalars
@@ -313 +403 @@
-
-unittest {
+//    assert(0, exprSimplify("d(A,A*d(A,A))", "1", "","")); // == "d(A,A)*d(A,A)");
-    assert(exprSimplify("A+=(B*(C[D,D..$]))","1020","","")=="(A+=(B* {C[D,D..$]} ))");
-    assert(exprSimplify("A+=(((D[E])*B)[E])", "103300","","")=="(A+=(B* {D[E][E]} ))");
@@ -320 +411 @@
-    assert(exprSimplify("A=(((B*E)+(C*E))*D)", "11100","","")=="(A=(( {(D*E)} *B)+( {(D*E)} *C)))");
-    assert(exprSimplify("A=(D*((B*E)+(C*E)))", "11100","","")=="(A=(( {(D*E)} *B)+( {(D*E)} *C)))");
-//    assert(exprSimplify("d(A,A*d(A,A))", "1", "","") == "d(A,A)*d(A,A)
+    assert(exprSimplify("d((A*(B*C)),(B*A))","010","","")== "d(B,B)* {((A*C)*A)}
-
-    RevisedExpression e = simplifyVectorExpression("A+=(((D[B])*C)[B])", "2004");