2004/12/11 | 草稿——自由曲线
类别(Flash进修) | 评论(1) | 阅读(328) | 发表于 20:44
var dot = [];
var count = 0;
var mycase = 0;
var mycase2 = 1;
var ctlDown = false;
onMouseDown = function () {
    if (mycase<3) {
        mycase++;
    } else {
        mycase = 1;
    }
    getdot();
};
onMouseUp = function () {
    mycase++;
    getdot();
};
onMouseMove = function () {
    getdot();
};
var myListener = new Object();
Key.addListener(myListener);
myListener.onKeyDown = function() {
    if (Key.isDown(Key.CONTROL)&&!ctlDown) {
        ctlDown = true;
    }
};
myListener.onKeyUp = function() {
    ctlDown = false;
};
//
var update = setInterval(updateAfterEvent, 10);
//
function getdot() {
    switch (mycase) {
    case 1 :
        if (mycase2 == 1) {
            dot[count] = {};
            dot[count].s = {};
            dot[count].s.x = _xmouse;
            dot[count].s.y = _ymouse;
            dot[count].e = {};
            mycase2 = 2;
        } else {
            dot[count].e.x = _xmouse;
            dot[count].e.y = _ymouse;
        }
        break;
    case 2 :
        if (mycase2 == 2) {
            dot[count].p = {};
            mycase2 = 3;
        } else {
            dot[count].p.x = _xmouse;
            dot[count].p.y = _ymouse;
        }
        break;
    case 3 :
        count++;
        mycase2 = 1;
        break;
    }
    drawline(this, dot);
}
//由点集数据画线
function drawline(mc, dot) {
    mc.clear();
    mc.lineStyle(1);
    for (var i in dot) {
        if (dot[i].e.x != null) {
            mc.moveTo(dot[i].s.x, dot[i].s.y);
            if (dot[i].p.x != null) {
                mc.curveTo(dot[i].p.x, dot[i].p.y, dot[i].e.x, dot[i].e.y);
            } else {
                mc.lineTo(dot[i].e.x, dot[i].e.y);
            }
        }
    }
}

Selection.setFocus("instanceName")
——————————————————————————
Expression & Postfix() //将中缀表达式转变为后缀表达式

{

First();

if (Get()->type == POSTFIX) return *this;

Stack<char> s; s.Push('=');

Expression temp;

ExpNode<Type> *p = Next();

while (p != NULL)

{

switch (p->type)

{

case OPND:

temp.LastInsert(*p); p = Next(); break;

case OPTR:

while (isp(s.GetTop()) > icp(p->optr) )

{

ExpNode<Type> newoptr(s.Pop());

temp.LastInsert(newoptr);

}

if (isp(s.GetTop()) == icp(p->optr) )

{

s.Pop(); p =Next(); break;

}

s.Push(p->optr); p = Next(); break;

default: break;

}

}

*this = temp;

pGetFirst()->data.type = POSTFIX;

return *this;

}



Type Calculate()

{

Expression temp = *this;

if (pGetFirst()->data.type != POSTFIX) temp.Postfix();

Stack<Type> s; Type left, right;

for (ExpNode<Type> *p = temp.Next(); p != NULL; p = temp.Next())

{

switch (p->type)

{

case OPND:

s.Push(p->opnd); break;

case OPTR:

right = s.Pop(); left = s.Pop();

switch (p->optr)

{

case '+': s.Push(left + right); break;

case '-': s.Push(left - right); break;

case '*': s.Push(left * right); break;

case '/': if (right != 0) s.Push(left/right); else return 0; break;

// case '%': if (right != 0) s.Push(left%right); else return 0; break;

// case '^': s.Push(Power(left, right)); break;

default: break;

}

default: break;

}

}

return s.Pop();

}

-----------------------------------------------
//运算符的定义：txt-运算符符号；isp-栈外优先级；icp-栈内优先级
function setupOptrs() {
    var optrs = "+,-,*,/,%,^,(,),=,sin";
    optrs = optrs.split(",");
    for (var i in optrs) {
        var temp = optrs[i];
        optrs[i] = {};
        optrs[i].txt = temp;
        switch (temp) {
        case "=" :
            optrs[i].isp = 0;
            optrs[i].icp = 0;
            break;
        case "(" :
            optrs[i].isp = 1;
            optrs[i].icp = 8;
            break;
        case "^" :
            optrs[i].isp = 7;
            optrs[i].icp = 6;
            break;
        case "*" :
        case "/" :
        case "%" :
            optrs[i].isp = 5;
            optrs[i].icp = 4;
            break;
        case "+" :
        case "-" :
            optrs[i].isp = 3;
            optrs[i].icp = 2;
            break;
        case ")" :
            optrs[i].isp = 8;
            optrs[i].icp = 1;
            break;
        default :
            optrs[i].isp = 0;
            optrs[i].icp = 0;
            break;
        }
    }
    return optrs;
}
//排序时使用的比较函数
function compareFunction(A:Object, B:Object) {
    if (A.ind<B.ind) {
        return -1;
    } else if (A.ind>B.ind) {
        return 1;
    } else {
        return 0;
    }
}
function Postfix(txt:String, optrs:Array) {
    //将表达式标准化：前面添"(",后面添")=",如果"-"左端为"("或",",则在"-"左端添加"0"将其变为减号
    txt = "("+txt+")=";
    var startIndex = -1;
    while ((startIndex=txt.indexOf("-", startIndex+1)) != -1) {
        var ch = txt.substr(startIndex-1, 1);
        if (ch == "(" || ch == ",") {
            txt = txt.slice(0, startIndex)+"0"+txt.slice(startIndex);
        }
    }
    //-----标准化完成-------
    //取得所有运算符在表达式字串中的位置
    var a = [];
    for (var i in optrs) {
        var s = optrs[i].txt;
        var startIndex = -1;
        while ((startIndex=txt.indexOf(s, startIndex+1)) != -1) {
            //a.push(startIndex);
            var L = a.length;
            a[L] = {};
            a[L].len = s.length;
            a[L].ind = startIndex;
        }
    }
    a.sort(compareFunction);
    //将字串转换为数组
    var exp = [];
    for (var i = 0; i<a.length; i++) {
        var L = exp.length;
        exp[L] = {};
        exp[L].txt = (txt.substr(a[i].ind, a[i].len));
        exp[L].typ = 0;
        //typ表示类型：0-运算符，1-数字常量，2-变量(变量名不能以数字开头，而且不能包含运算符)
        var str = txt.substring(a[i].ind+a[i].len, a[i+1].ind);
        if (str != "") {
            var L = exp.length;
            exp[L] = {};
            exp[L].txt = str;
            str = str.substr(0, 1);
            exp[L].typ = (str>="0" && str<="9") ? 1 : 2;
        }
    }
    return exp;
}
//--------主程序段----------
var optrs = setupOptrs();
var txt = "sin(-1+2)-sshh/sin(-4.5-6kk)";
var exp = Postfix(txt, optrs);
//for (var i=0;i<optrs.length;i++)trace(optrs[i].txt+" "+optrs[i].isp+" "+optrs[i].icp)
//for (var i=0;i<exp.length;i++)trace(exp[i].txt+" "+exp[i].typ);
//
-----------------------------------------------------
//运算符的定义：txt-运算符符号；isp-栈外优先级；icp-栈内优先级
function setupOptrs() {
    var optrs = "=,+,-,*,/,%,^,(,),sin";
    optrs = optrs.split(",");
    for (var i in optrs) {
        var temp = optrs[i];
        optrs[i] = {};
        optrs[i].txt = temp;
        switch (temp) {
        case "=" :
            optrs[i].isp = 0;
            optrs[i].icp = 0;
            break;
        case "(" :
            optrs[i].isp = 1;
            optrs[i].icp = 8;
            break;
        case "^" :
            optrs[i].isp = 7;
            optrs[i].icp = 6;
            break;
        case "*" :
        case "/" :
        case "%" :
            optrs[i].isp = 5;
            optrs[i].icp = 4;
            break;
        case "+" :
        case "-" :
            optrs[i].isp = 3;
            optrs[i].icp = 2;
            break;
        case ")" :
            optrs[i].isp = 8;
            optrs[i].icp = 1;
            break;
        default :
            optrs[i].isp = 0;
            optrs[i].icp = 0;
            break;
        }
    }
    return optrs;
}
//排序(运算符出现的先后顺序)时使用的比较函数
function compareFunction(A:Object, B:Object) {
    if (A.ind<B.ind) {
        return -1;
    } else if (A.ind>B.ind) {
        return 1;
    } else {
        return 0;
    }
}
//建立中缀表达式：分离出表达式字串中的元素，按顺序存入数组，并标记其类型：typ>=0:运算符；typ=-1:数字常量；typ=-2:变量(变量名不能以数字开头，而且不能包含运算符)
function setupIFX(txt:String, optrs:Array) {
    //将表达式标准化：前面添"(",后面添")=",如果"-"左端为"("或",",则在"-"左端添加"0"将其变为减号
    txt = "("+txt+")";
    var startIndex = -1;
    while ((startIndex=txt.indexOf("-", startIndex+1)) != -1) {
        var ch = txt.substr(startIndex-1, 1);
        if (ch == "(" || ch == ",") {
            txt = txt.slice(0, startIndex)+"0"+txt.slice(startIndex);
        }
    }
    //-----标准化完成-------
    //取得所有运算符在表达式字串中的位置
    var a = [];
    for (var i in optrs) {
        var s = optrs[i].txt;
        var startIndex = -1;
        while ((startIndex=txt.indexOf(s, startIndex+1)) != -1) {
            //a.push(startIndex);
            var L = a.length;
            a[L] = {};
            a[L].optrNum = i;
            a[L].len = s.length;
            a[L].ind = startIndex;
        }
    }
    a.sort(compareFunction);
    //将字串转换为数组
    var exp = [];
    for (var i = 0; i<a.length; i++) {
        var L = exp.length;
        exp[L] = {};
        exp[L].txt = optrs[a[i].optrNum].txt;
        //typ表示类型：typ>=0:运算符；typ=-1:数字常量；typ=-2:变量(变量名不能以数字开头，而且不能包含运算符)
        exp[L].typ = a[i].optrNum;
        var str = txt.substring(a[i].ind+a[i].len, a[i+1].ind);
        if (str != "") {
            var L = exp.length;
            exp[L] = {};
            exp[L].txt = str;
            str = str.substr(0, 1);
            exp[L].typ = (str>="0" && str<="9") ? -1 : -2;
        }
    }
    return exp;
}
//中缀表达式转为后缀表达式
function ifxToPFX(ifx:Array, optrs:Array) {
    var pfx = [], s = [];
    s[0] = {};
    //s[0].txt = "=";
    //s[0].typ = 0;
    for (var i = 0; i<ifx.length; i++) {
        //typ<0表示当前元素是“操作数”,直接送入pfx
        if (ifx[i].typ<0) {
            pfx.push(ifx[i]);
            //typ>=0表示当前元素是“运算符”
        } else if (ifx[i].txt == "(") {
            s.push(ifx[i]);
        } else if (ifx[i].txt == ")") {
            while (true) {
                var temp=s.pop();
                if(temp.txt=="(")break;
                pfx.push(temp);
            }
            //s栈为空OR当前>s栈顶
        } else if (s.length==0||optrs[ifx[i].typ].isp>optrs[s[s.length].typ].icp) {
            s.pop();
        } else {
            //当前<=s栈顶
            while (optrs[ifx[i].typ].isp<=optrs[s[s.length].typ].icp) {
                pfx.push(s.pop());
            }
        }
    }
    return pfx;
}
//--------主程序段----------
var optrs = setupOptrs();
var txt = "(-1+2*90)-ss/(-4.5-kk)";
var ifx = setupIFX(txt, optrs);
var pfx = ifxToPFX(ifx, optrs);
//for (var i=0;i<optrs.length;i++)trace(optrs[i].txt+" "+optrs[i].isp+" "+optrs[i].icp);
//for (var i=0;i<ifx.length;i++)trace(ifx[i].txt+" "+ifx[i].typ);
for (var i = 0; i<pfx.length; i++) {
    trace(pfx[i].txt+" "+pfx[i].typ);
}
-----------------------------------------------------------
//运算符的定义：txt-运算符符号；isp-栈外优先级；icp-栈内优先级
function setupOptrs() {
    var optrs = "=,+,-,*,/,%,^,(,),sin";
    optrs = optrs.split(",");
    for (var i in optrs) {
        var temp = optrs[i];
        optrs[i] = {};
        optrs[i].txt = temp;
        switch (temp) {
        case "=" :
            optrs[i].isp = 0;
            optrs[i].icp = 0;
            break;
        case "(" :
            optrs[i].isp = 1;
            optrs[i].icp = 8;
            break;
        case "^" :
            optrs[i].isp = 7;
            optrs[i].icp = 6;
            break;
        case "*" :
        case "/" :
        case "%" :
            optrs[i].isp = 5;
            optrs[i].icp = 4;
            break;
        case "+" :
        case "-" :
            optrs[i].isp = 3;
            optrs[i].icp = 2;
            break;
        case ")" :
            optrs[i].isp = 8;
            optrs[i].icp = 1;
            break;
        default :
            optrs[i].isp = 0;
            optrs[i].icp = 0;
            break;
        }
    }
    return optrs;
}
//排序(运算符出现的先后顺序)时使用的比较函数
function compareFunction(A:Object, B:Object) {
    if (A.ind<B.ind) {
        return -1;
    } else if (A.ind>B.ind) {
        return 1;
    } else {
        return 0;
    }
}
//建立中缀表达式：分离出表达式字串中的元素，按顺序存入数组，并标记其类型：typ>=0:运算符；typ=-1:数字常量；typ=-2:变量(变量名不能以数字开头，而且不能包含运算符)
function setupIFX(txt:String, optrs:Array) {
    //将表达式标准化：前面添"(",后面添")=",如果"-"左端为"("或",",则在"-"左端添加"0"将其变为减号
    txt = "("+txt+")=";
    var startIndex = -1;
    while ((startIndex=txt.indexOf("-", startIndex+1)) != -1) {
        var ch = txt.substr(startIndex-1, 1);
        if (ch == "(" || ch == ",") {
            txt = txt.slice(0, startIndex)+"0"+txt.slice(startIndex);
        }
    }
    //-----标准化完成-------
    //取得所有运算符在表达式字串中的位置
    var a = [];
    for (var i in optrs) {
        var s = optrs[i].txt;
        var startIndex = -1;
        while ((startIndex=txt.indexOf(s, startIndex+1)) != -1) {
            //a.push(startIndex);
            var L = a.length;
            a[L] = {};
            a[L].optrNum = i;
            a[L].len = s.length;
            a[L].ind = startIndex;
        }
    }
    a.sort(compareFunction);
    //将字串转换为数组
    var exp = [];
    for (var i = 0; i<a.length; i++) {
        var L = exp.length;
        exp[L] = {};
        exp[L].txt = optrs[a[i].optrNum].txt;
        //typ表示类型：typ>=0:运算符；typ=-1:数字常量；typ=-2:变量(变量名不能以数字开头，而且不能包含运算符)
        exp[L].typ = a[i].optrNum;
        var str = txt.substring(a[i].ind+a[i].len, a[i+1].ind);
        if (str != "") {
            var L = exp.length;
            exp[L] = {};
            exp[L].txt = str;
            str = str.substr(0, 1);
            exp[L].typ = (str>="0" && str<="9") ? -1 : -2;
        }
    }
    return exp;
}
//中缀表达式转为后缀表达式
function ifxToPFX(ifx:Array, optrs:Array) {
    var pfx = [], s = [];
    s[0] = {};
    //s[0].txt = "=";
    //s[0].typ = 0;
    for (var i = 0; i<ifx.length; i++) {
        //typ<0表示当前元素是“操作数”,直接送入pfx
        if (ifx[i].typ<0) {
            pfx.push(ifx[i]);
            //typ>=0表示当前元素是“运算符”
        } else if (ifx[i].txt == "(") {
            s.push(ifx[i]);
        } else if (ifx[i].txt == ")") {
            while (true) {
                var temp = s.pop();
                if (temp.txt == "(") {
                    break;
                }
                pfx.push(temp);
            }
            //s栈为空OR当前>s栈顶
        } else if (s.length == 0 || optrs[ifx[i].typ].isp>optrs[s[s.length].typ].icp) {
            s.push(ifx[i]);
            //遇到表达式结束符"="
        } else if (ifx[i].txt == "=") {
            while (s.length>0) {
                pfx.push(s.pop());
            }
        } else {
            //当前<=s栈顶
            while (optrs[ifx[i].typ].isp<=optrs[s[s.length].typ].icp) {
                pfx.push(s.pop());
            }
        }
    }
    return pfx;
}
//--------主程序段----------
var optrs = setupOptrs();
var txt = "(-1+2*90)-ss/(-4.5-kk)";
var ifx = setupIFX(txt, optrs);
var pfx = ifxToPFX(ifx, optrs);
//for (var i=0;i<optrs.length;i++)trace(optrs[i].txt+" "+optrs[i].isp+" "+optrs[i].icp);
//for (var i=0;i<ifx.length;i++)trace(ifx[i].txt+" "+ifx[i].typ);
for (var i = 0; i<pfx.length; i++) {
    trace(pfx[i].txt+" "+pfx[i].typ);
}
0

评论Comments

日志分类
首页[163]
Flash习作[85]
Flash进修[33]
Flash推荐[16]
Flash涂鸦[4]
听~音乐[9]
我滴地盘er[16]