博客园_编程　＆　生活

从管理职能中寻找项目管理的秘诀之一

2011-09-09T01:49:00Z

要做好一个项目，无疑是很不容易的。可以说，一个项目要真正取得成功，项目经理不掉一层皮，是不可能的。项目经理忙，是可以理解的，但项目经理应该忙什么事情呢？

以下是经常出现的场景：

高级经理：说项目已经过去一个多了，你赶快把计划提交上来。

项目经理：太忙了，没有时间做计划。

高级经理：某某同志开发不太熟炼，你要把怎么做先帮他分析清楚，然后每天要检查他做得怎么样，以免出现偏差。

项目经理：很多事情要做啊，没时间搞这么细。

高级经理：那你每天在忙什么呢？

项目经理：……

项目经理没时间做计划、没时间去检查和辅导项目组成员的工作，出现这种情况，不管项目经理在忙什么，都是本末倒置，因为这些才是项目经理最需要去做的事情。这些事情没做，项目经理很忙，是瞎忙，典型的“盲茫忙”。

那么项目经理究竟应该做什么工作呢？按照PMBok知识体系，项目管理有五大过程组、九大领域，无疑可以作为项目经理的行动指南，但对于经验不足的项目经理，就好比狗咬刺猬，无处下口。其实项目管理的秘诀，可以从管理的基本职能中去找。

未完待续

本文链接

项目管理中的目标管理与承诺管理

2011-09-08T01:17:00Z

目标管理体现了以终为始的思想。项目是最佳的实施目标管理的环境，因为项目的本质就是在一定的时间、成本、资源等约束时下，完成预期的目标。对项目的进行WBS分解时，最下面一级的工作包是面向可交付成果的，目标性非常明确，以工作包为基础，将整个项目的大目标分解为一个个的小目标，按照SMART的原则分配给项目组成员，并进行跟踪、辅导、检查、评估。通过这种方式，将项目管理的过程，转变目标管理的过程，项目受控性会更佳。

如果将项目组成员分为管理人员（主要是项目经理）和执行人员的话，目标管理会更多的从管理人员的口中说出来。对于执行人员而言，当他接受一个目标（即任务）时，他实际上是做出了一个承诺：我接受这项目任务，并承诺达到目标。从这个层面讲，目标管理与承诺管理可以很好的结合起来，成为一个硬币的两个面。

承诺管理是一种基于诚信的管理，既然做出了承诺，就要想方设法达到，否则你便失去了诚信，所谓一诺千金，“人而无谓，不知其可”。如果一个人长期失信，他的价值自然也会大打折扣。

承诺管理也是自我管理的基础。软件项目与传统项目的主要不同之处，在于软件的完成依赖于每个人的大脑，看不见、摸不着，但潜力巨大、弹性也大。同一件工作，可以天天工作8小时一个月完成，也可能会想方设法一周就能完成。承诺管理本质上也就是通过承诺这种庄重的形式，给执行人员加压，促使其发挥潜能，确保工作及时保质保量的完成。

本文链接

程序员基本素质要求

2011-09-07T09:42:00Z

1 具备严密的逻辑思维能力

计算机中最讲逻辑的，程序员逻辑不严密，计算机是不会自动帮你处理的，最后的结果就是不经意间跳出几个臭虫。不讲逻辑的程序员是最可怕的。比如，当系统需要处理证件号码信息，如果程序员在代码中直接当作身份证号码来处理，这就是不讲逻辑的表现。显然，除了身份证号码之外，还有学生证、军官证、驾驶证，甚于包括组织机构代码证等。再例如，同一套系统有多个客户在使用，对于同一个功能，不同客户要求处理的方式存在出入，有的程序员直接在代码里面用if...else处理:

if (district="guangzhou")

{

...

}

else if (district=="foshan")

...

当程序员准备写出这样的代码的时候，难道就没有考虑过假如再多了几个客户，又当如何处理呢？这种代码的出现，要么是不负责任，要么是程序员不具备基本的逻辑思维能力，两种情况都很可怕。

2 沟通协作精神

程序员往往比较有个性，这本身并不是问题，并没一点个性程序员，往往很难在技术上修炼到顶尖水平。但现实中，许多程序员的个性，却严重影响了与团队的沟通协作，这就不应该了。软件行业个人英雄主义时代，已经渐渐远去，一个软件项目的成功，是团队共同努力的结果，团队成员之间良好的协作是项目成功的基础。

沟通协作方面应当注意以下问题：

（1）团队成员应服从项目经理安排，求同存异。

有个性的程序员，当发生分歧时，往往过份坚持自己的看法，争论到吵架的地步，这对团队协作是非常有害的。柳传志说:“成功需要妥协”，不会妥协的人往往会四处碰壁，特别是与上级发生分歧时，若仍不妥协，那就更不应该了。当程序员不能说服项目经理时，就应当服从项目经理的安排，这是基本的职业素养。

（2）对可疑的问题应及时沟通反馈

程序员在编码的过程中，对于存在的问题或风险，应及时与相关人员沟通，而不是擅自主张，按自己觉得理所当然的去做。有一位项目经理在抱怨时说，程序员没有按照设计去做，导致系统出现在很多问题。这当然一方面是项目经理失职，检查不到位，但对于程序员而言，显示也是由于没有主动沟通反馈所导致。

（3）尊重他人劳动成果

程序员往往害怕修改别人的代码，特别是注释少、文档资料不齐或情况，这个是可以理解的。但不能轻易否定前人的工作成果，动不动就要将前人的成果推倒重来，最后的结果往往仍然是问题丛生。

（4）正视“个性”

第一，有个性不等于孤癖；第二，成功首先要心智成熟，个性不是借口。

（5）有意识锻炼自己的表达和写作能力

3 追求卓越的精神

不断追求卓越的人，才能真正走向卓越。应当说大部分程序员是有追求的，他们追求更高的工资、更高的职位，这没错，但这不等同于追求卓越。追求卓越，首先是工作将工作做到最好，在允许的范围内精益求精。

追求卓越最基本的要求，就是不能容忍你的代码中的BUG。有些程序员把代码编译通过了，自己也不完整运行一次，就自以为工作完成了，然后交给测试员去测试，这是不负责任的表现，不负责任的人是不可能走向卓越的。我很反对程序员或项目经理抱怨测试人员水平不行，项目的质量问题都赖在测试人员身上。真正优秀的程序员，不会过分依赖于测试人员，没有专职测试人员，同样可以开发出高质量软件，因为程序员自己应当测试自己的代码。

追求卓越的程序员还应当经常重构自己的代码，使代码更高效、更易懂、更灵活、更易于维护。

4 学习精神并具有较强学习能力

软件行业新技术、新理念、新工具层出不穷，程序员应当热爱学习、善于学习，既然选择了软件行业，就应当“认命”，不断学习，成为技术专家、业务专家。

5 注重代码规范

代码规范是程序员走向成熟的表现。代码规范化对于分析代码、理解代码、代码重构、软件调试、系统维护等有着重要的作用。

本文链接

采用浮点数编码的遗传算法的问题

2010-10-13T06:59:00Z

最近学习了一下遗传算法，于是参考了一篇论文，采用浮点数编码写了一个算法，运行了一下，发布收敛很慢，遗传了几百代与几十代相比，只是略显稳定，随机性比较强。而且容易限入局部极值中。例如，我以求函数xsin(10PI*x)+2.0为例，最大值大约在x=1.85附近，在x=1.65附近有一个局部极值。我写的算法大约70%的机会取得1.85附近的值，30%机会取得1.65附近的值。总之效果不理想。不知有没有朋友有兴趣帮我看一下。

初始化种群

        public List<PopUnit> InitPop()
        {
            if (CalculateFitnessHanler == null)
                throw new Exception("未设置计算表达式的事件CalculateHanler");
            if (m_Parameters.PopSize<=10)
                throw new Exception("种群数太小");

            List<PopUnit> pool = new List<PopUnit>();

            for (int i = 0; i <= m_Parameters.PopSize-1; i++)
            {
                double d = m_Random.NextDouble();
                d = m_Parameters.L + (m_Parameters.R - m_Parameters.L) * d;
                double val= CalculateFitnessHanler(new double[] { d });
                PopUnit unit = new PopUnit(d, val);
                pool.Add(unit);
            }
            return pool;
        }

选择操作

public List<PopUnit> Select(List<PopUnit> data)
        {
            int dropoutCount = (int)(m_Parameters.DropoutRate * data.Count);

            List<PopUnit> newpool = new List<PopUnit>();
            for (int i = 0; i <= dropoutCount - 1; i++)
            {
                newpool.Add(data[i].Clone() as PopUnit);
                newpool.Add(data[i].Clone() as PopUnit);
            }
            int tmpCount = data.Count - newpool.Count;
            for (int i = dropoutCount; i <= dropoutCount + tmpCount - 1; i++)
            {
                newpool.Add(data[i].Clone() as PopUnit);
            }
            return newpool;
        }

交叉操作：

public void CrossOver(double a,double b,out double a1,out double b1)
        {
            if (m_Random.NextDouble() > m_Parameters.CrossOverRate)
            {
                a1 = a;
                b1 = b;
                return;
            }


            double r = 0.1;
            double a2 = m_Random.NextDouble() * r;
            double b2 = m_Random.NextDouble() * r;

            a1 = (1 - a2) * a + b2 * b;
            b1 = (1 - b2) * b + a2 * a;


            if (a1 < m_Parameters.L)
                a1 = m_Parameters.L;
            if (b1 < m_Parameters.L)
                b1 = m_Parameters.L;
            if (a1 > m_Parameters.R)
                a1 = m_Parameters.R;
            if (b1 > m_Parameters.R)
                b1 = m_Parameters.R;
            //Console.WriteLine("crossover a1={0},b1={1}  ->  a2={2},b2={3}", a, b, a1, b1);
        }

变异操作：

public double Mutation(double c)
        {
            double tmpd = m_Random.NextDouble();
            if (tmpd > m_Parameters.MutateRate)
            {
                return c;
            }

            double k = 0.2;
            //k = (m_Parameters.MaxGenerations-T)/ (m_Parameters.MaxGenerations + 2D) * 0.4D;
            double res;
            if (m_Random.Next(2) == 1)
            {
                res = c + k * (m_Parameters.R - c) *m_Random.NextDouble();
            }
            else
            {
                res = c - k * (c - m_Parameters.L) *m_Random.NextDouble();
            }
            //Console.WriteLine("mutation: {0} -> {1}", c, res);

            return res;
        }

种群大小=100，交叉概率=0.7，变异概率=0.1

本文链接

.net表达式计算器（中缀表达式转后缀表达式，支持20多个数学函数，支持函数嵌套,免费共享～）

2010-10-13T06:24:00Z

最近在网上查了一下表达工计算器的类库，发现Java版本的有一个比较成熟的叫W3EVal，好像是一个IBM工程师写的，.net就很少了（可能是我了解不够多），但投机取巧的实现思路有很多，比如：
　　（1）将Javasript中代码编译成.net类库，利用Javascript中的eval函数来实现;
　　（2）利用ScriptControl执行JavaScript脚本实现;
　　（3）利用DataTable的计算功能实现简单计算;
　　（4）利用.net动态编译功能来实现等
　　这些方法在csdn的坛里有讨论，请见：http://topic.csdn.net/u/20070301/13/c8c33bd1-f146-4b44-9882-aab6d430f724.html

　　心想既然还没有成熟的.net类库，何不自己做一个呢，其实并不难，只要稍有点耐心调试一下就好了。于是参考一编中缀表达式转后缀表达式的论文，很快写了一个，发现效果不错，所以发出来跟大家共享，希望对大家有用。

　　中缀表达式转后缀表达式的步骤为：
　　1.新建一个Stack栈，用来存放运算符
　　2.新建一个post栈，用来存放最后的后缀表达式
　　3．从左到右扫描中缀表达式：
　　　　（1）若读到的是操作数，直接存入post栈，以#作为数字的结束
　　　　（2）若读到的是(,则直接存入stack栈
　　　　（3）若读到的是），则将stack栈中(前的所有运算符出栈，存入post栈
　　　　（4）若读到的是其它运算符，则将该运算符和stack栈顶运算符作比较：若高于或等于栈顶运算符，则直接存入stack栈，否则将栈顶运算符（所有优先级高于读到的运算符的，不包括括号）出栈，存入post栈。最后将读到的运算符入栈。
　　4.当扫描完后，stack栈中还在运算符时，则将所有的运算符出栈，存入post栈

　　计算后缀表达式的值的步骤为：
　　1.初始化一个空堆栈
　　2.从左到右读入后缀表达式
　　3.如果字符是一个操作数，把它压入堆栈。
　　4.如果字符是个操作符，弹出两个操作数，执行恰当操作，然后把结果压入堆栈。如果您不能够弹出两个操作数，后缀表达式的语法就不正确。
　　5.到后缀表达式末尾，从堆栈中弹出结果。若后缀表达式格式正确，那么堆栈应该为空。

类库的名称就名为NEval ，感觉还比较健壮，速度很快，支持20个数学函数，很容易扩充。目前还没有表达式合法性检查的功能，有兴趣的朋友可以扩充一下，先谢谢。

代码如下：

/// <summary>
    /// 表达式计算类。支持数学函数，支持函数嵌套
    /// 作者watsonyin
    /// 开发日期：2010年10月版本1.0
    /// </summary>
    public class NEval
    {
        public NEval()
        {

        }

        public double Eval(string expr)
        {
            try
            {
                string tmpexpr = expr.ToLower().Trim().Replace(" ", string.Empty);
                return Calc_Internal(tmpexpr);
            }
            catch (ExpressionException eex)
            {
                throw eex;
            }
            catch
            {
                throw new Exception("表达式错误");
            }
        }

        private Random m_Random = null;
        private double Calc_Internal(string expr)
        {
            /*
             * 1.    初始化一个空堆栈
             * 2.    从左到右读入后缀表达式
             * 3.    如果字符是一个操作数，把它压入堆栈。
             * 4.    如果字符是个操作符，弹出两个操作数，执行恰当操作，然后把结果压入堆栈。如果您不能够弹出两个操作数，后缀表达式的语法就不正确。
             * 5.    到后缀表达式末尾，从堆栈中弹出结果。若后缀表达式格式正确，那么堆栈应该为空。
            */

            Stack post2 = ConvertExprBack(expr);
            Stack post = new Stack();
            while (post2.Count > 0)
                post.Push(post2.Pop());

            Stack stack = new Stack();
            while (post.Count > 0)
            {
                string tmpstr = post.Pop().ToString();
                char c = tmpstr[0];
                LetterType lt = JudgeLetterType(tmpstr);
                if (lt == LetterType.Number)
                {
                    stack.Push(tmpstr);
                }
                else if (lt == LetterType.SimpleOperator)
                {
                    double d1 = double.Parse(stack.Pop().ToString());
                    double d2 = double.Parse(stack.Pop().ToString());
                    double r = 0;
                    if (c == '+')
                        r = d2 + d1;
                    else if (c == '-')
                        r = d2 - d1;
                    else if (c == '*')
                        r = d2 * d1;
                    else if (c == '/')
                        r = d2 / d1;
                    else if (c == '^')
                        r = Math.Pow(d2, d1);
                    else
                        throw new Exception("不支持操作符:" + c.ToString());
                    stack.Push(r);
                }
                else if (lt == LetterType.Function)  //如果是函数
                {
                    string[] p;
                    double d = 0;
                    double d1 = 0;
                    double d2 = 0;
                    int tmpos = tmpstr.IndexOf('(');
                    string funcName = tmpstr.Substring(0, tmpos);
                    switch (funcName)
                    {
                        case "asin":
                            SplitFuncStr(tmpstr, 1, out p);
                            d = double.Parse(p[0]);
                            stack.Push(Math.Asin(d).ToString());
                            break;
                        case "acos":
                            SplitFuncStr(tmpstr, 1, out p);
                            d = double.Parse(p[0]);
                            stack.Push(Math.Acos(d).ToString());
                            break;
                        case "atan":
                            SplitFuncStr(tmpstr, 1, out p);
                            d = double.Parse(p[0]);
                            stack.Push(Math.Atan(d).ToString());
                            break;
                        case "acot":
                            SplitFuncStr(tmpstr, 1, out p);
                            d = double.Parse(p[0]);
                            stack.Push((1 / Math.Atan(d)).ToString());
                            break;
                        case "sin":
                            SplitFuncStr(tmpstr, 1, out p);
                            d = double.Parse(p[0]);
                            stack.Push(Math.Sin(d).ToString());
                            break;
                        case "cos":
                            SplitFuncStr(tmpstr, 1, out p);
                            d = double.Parse(p[0]);
                            stack.Push(Math.Cos(d).ToString());
                            break;
                        case "tan":
                            SplitFuncStr(tmpstr, 1, out p);
                            d = double.Parse(p[0]);
                            stack.Push(Math.Tan(d).ToString());
                            break;
                        case "cot":
                            SplitFuncStr(tmpstr, 1, out p);
                            d = double.Parse(p[0]);
                            stack.Push((1 / Math.Tan(d)).ToString());
                            break;
                        case "log":
                            SplitFuncStr(tmpstr, 2, out p);
                            d1 = double.Parse(p[0]);
                            d2 = double.Parse(p[1]);
                            stack.Push(Math.Log(d1, d2).ToString());
                            break;
                        case "ln":
                            SplitFuncStr(tmpstr, 1, out p);
                            d = double.Parse(p[0]);
                            stack.Push(Math.Log(d, Math.E).ToString());
                            break;
                        case "abs":
                            SplitFuncStr(tmpstr, 1, out p);
                            d = double.Parse(p[0]);
                            stack.Push(Math.Abs(d).ToString());
                            break;
                        case "round":
                            SplitFuncStr(tmpstr, 2, out p);
                            d1 = double.Parse(p[0]);
                            d2 = double.Parse(p[1]);
                            stack.Push(Math.Round(d1, (int)d2).ToString());
                            break;
                        case "int":
                            SplitFuncStr(tmpstr, 1, out p);
                            d = double.Parse(p[0]);
                            stack.Push((int)d);
                            break;
                        case "trunc":
                            SplitFuncStr(tmpstr, 1, out p);
                            d = double.Parse(p[0]);
                            stack.Push(Math.Truncate(d).ToString());
                            break;
                        case "floor":
                            SplitFuncStr(tmpstr, 1, out p);
                            d = double.Parse(p[0]);
                            stack.Push(Math.Floor(d).ToString());
                            break;
                        case "ceil":
                            SplitFuncStr(tmpstr, 1, out p);
                            d = double.Parse(p[0]);
                            stack.Push(Math.Ceiling(d).ToString());
                            break;
                        case "random":
                            if (m_Random == null)
                                m_Random = new Random();
                            d = m_Random.NextDouble();
                            stack.Push(d.ToString());
                            break;
                        case "exp":
                            SplitFuncStr(tmpstr, 1, out p);
                            d = double.Parse(p[0]);
                            stack.Push(Math.Exp(d).ToString());
                            break;
                        case "pow":
                            SplitFuncStr(tmpstr, 2, out p);
                            d1 = double.Parse(p[0]);
                            d2 = double.Parse(p[1]);
                            stack.Push(Math.Pow(d1, d2).ToString());
                            break;
                        case "sqrt":
                            SplitFuncStr(tmpstr, 1, out p);
                            d = double.Parse(p[0]);
                            stack.Push(Math.Sqrt(d).ToString());
                            break;
                        default:
                            throw new Exception("未定义的函数：" + funcName);

                    }

                }
            }
            object obj = stack.Pop();
            return double.Parse(obj.ToString());
        }

        /// <summary>
        /// 将函数括号内的字符串进行分割，获得参数列表，如果参数是嵌套的函数，用递归法计算得到它的值
        /// </summary>
        /// <param name="funcstr"></param>
        /// <param name="paramCount"></param>
        /// <param name="parameters"></param>
        private void SplitFuncStr(string funcstr, int paramCount, out string[] parameters)
        {
            parameters = new string[paramCount];
            int tmpPos = funcstr.IndexOf('(', 0);
            string str = funcstr.Substring(tmpPos + 1, funcstr.Length - tmpPos - 2);
            if (paramCount == 1)
            {
                parameters[0] = str;
            }
            else
            {
                int cpnum = 0;
                int startPos = 0;
                int paramIndex = 0;
                for (int i = 0; i <= str.Length - 1; i++)
                {
                    if (str[i] == '(')
                        cpnum++;
                    else if (str[i] == ')')
                        cpnum--;
                    else if (str[i] == ',')
                    {
                        if (cpnum == 0)
                        {
                            string tmpstr = str.Substring(startPos, i - startPos);
                            parameters[paramIndex] = tmpstr;
                            paramIndex++;
                            startPos = i + 1;
                        }
                    }
                }
                if (startPos < str.Length)
                {
                    string tmpstr = str.Substring(startPos);
                    parameters[paramIndex] = tmpstr;
                }
            }

            //如果参数是函数，进一步采用递归的方法生成函数值
            for (int i = 0; i <= paramCount - 1; i++)
            {
                double d;
                if (!double.TryParse(parameters[i], out d))
                {
                    NEval calc = new NEval();
                    d = calc.Eval(parameters[i]);
                    parameters[i] = d.ToString();
                }
            }
        }

        /// <summary>
        /// 将中缀表达式转为后缀表达式
        /// </summary>
        /// <param name="expr"></param>
        /// <returns></returns>
        private Stack ConvertExprBack(string expr)
        {
            /*
             * 新建一个Stack栈，用来存放运算符
             * 新建一个post栈，用来存放最后的后缀表达式
             * 从左到右扫描中缀表达式：
             * 1.若读到的是操作数，直接存入post栈，以#作为数字的结束
             * 2、若读到的是(,则直接存入stack栈
             * 3.若读到的是），则将stack栈中(前的所有运算符出栈，存入post栈
             * 4 若读到的是其它运算符，则将该运算符和stack栈顶运算符作比较：若高于或等于栈顶运算符，则直接存入stack栈，
             * 否则将栈顶运算符（所有优先级高于读到的运算符的，不包括括号）出栈，存入post栈。最后将读到的运算符入栈
             * 当扫描完后，stack栈中还在运算符时，则将所有的运算符出栈，存入post栈
             * */

            Stack post = new Stack();
            Stack stack = new Stack();
            string tmpstr;
            int pos;
            for (int i = 0; i <= expr.Length - 1; i++)
            {
                char c = expr[i];
                LetterType lt = JudgeLetterType(c, expr, i);

                if (lt == LetterType.Number)  //操作数
                {
                    GetCompleteNumber(expr, i, out tmpstr, out pos);
                    post.Push(tmpstr);
                    i = pos;// +1;
                }
                else if (lt == LetterType.OpeningParenthesis) //左括号(
                {
                    stack.Push(c);
                }
                else if (lt == LetterType.ClosingParenthesis) //右括号)
                {
                    while (stack.Count > 0)
                    {
                        if (stack.Peek().ToString() == "(")
                        {
                            stack.Pop();
                            break;
                        }
                        else
                            post.Push(stack.Pop());
                    }
                }
                else if (lt == LetterType.SimpleOperator)  //其它运算符
                {
                    if (stack.Count == 0)
                        stack.Push(c);
                    else
                    {

                        char tmpop = (char)stack.Peek();
                        if (tmpop == '(')
                        {
                            stack.Push(c);
                        }
                        else
                        {
                            if (GetPriority(c) >= GetPriority(tmpop))
                            {
                                stack.Push(c);
                            }
                            else
                            {
                                while (stack.Count > 0)
                                {
                                    object tmpobj = stack.Peek();
                                    if (GetPriority((char)tmpobj) > GetPriority(c))
                                    {
                                        if (tmpobj.ToString() != "(")
                                            post.Push(stack.Pop());
                                        else
                                            break;
                                    }
                                    else
                                        break;
                                }
                                stack.Push(c);
                            }
                        }

                    }
                }
                else if (lt == LetterType.Function)  //如果是一个函数，则完整取取出函数，当作一个操作数处理
                {
                    GetCompleteFunction(expr, i, out tmpstr, out pos);
                    post.Push(tmpstr);
                    i = pos;// +1;
                }

            }
            while (stack.Count > 0)
            {
                post.Push(stack.Pop());
            }

            return post;
        }

        private LetterType JudgeLetterType(char c, string expr, int pos)
        {
            string op = "*/^";
            if ((c <= '9' && c >= '0') || (c == '.'))  //操作数
            {
                return LetterType.Number;
            }
            else if (c == '(')
            {
                return LetterType.OpeningParenthesis;
            }
            else if (c == ')')
            {
                return LetterType.ClosingParenthesis;
            }
            else if (op.IndexOf(c) >= 0)
            {
                return LetterType.SimpleOperator;
            }
            else if ((c == '-') || (c == '+'))//要判断是减号还是负数
            {
                if (pos == 0)
                    return LetterType.Number;
                else
                {
                    char tmpc = expr[pos - 1];
                    if (tmpc <= '9' && tmpc >= '0')  //如果前面一位是操作数
                        return LetterType.SimpleOperator;
                    else if (tmpc == ')')
                        return LetterType.SimpleOperator;
                    else
                        return LetterType.Number;
                }
            }
            else
                return LetterType.Function;
        }

        private LetterType JudgeLetterType(char c)
        {
            string op = "+-*/^";
            if ((c <= '9' && c >= '0') || (c == '.'))  //操作数
            {
                return LetterType.Number;
            }
            else if (c == '(')
            {
                return LetterType.OpeningParenthesis;
            }
            else if (c == ')')
            {
                return LetterType.ClosingParenthesis;
            }
            else if (op.IndexOf(c) >= 0)
            {
                return LetterType.SimpleOperator;
            }
            else
                return LetterType.Function;
        }

        private LetterType JudgeLetterType(string s)
        {
            char c = s[0];
            if ((c == '-') || (c == '+'))
            {
                if (s.Length > 1)
                    return LetterType.Number;
                else
                    return LetterType.SimpleOperator;
            }

            string op = "+-*/^";
            if ((c <= '9' && c >= '0') || (c == '.'))  //操作数
            {
                return LetterType.Number;
            }
            else if (c == '(')
            {
                return LetterType.OpeningParenthesis;
            }
            else if (c == ')')
            {
                return LetterType.ClosingParenthesis;
            }
            else if (op.IndexOf(c) >= 0)
            {
                return LetterType.SimpleOperator;
            }
            else
                return LetterType.Function;
        }

        /// <summary>
        /// 计算操作符的优先级
        /// </summary>
        /// <param name="c"></param>
        /// <returns></returns>
        private int GetPriority(char c)
        {
            if (c == '+' || c == '-')
                return 0;
            else if (c == '*')
                return 1;
            else if (c == '/')  //除号优先级要设得比乘号高，否则分母可能会被先运算掉
                return 2;
            else
                return 2;
        }

        /// <summary>
        /// 获取完整的函数表达式
        /// </summary>
        /// <param name="expr"></param>
        /// <param name="startPos"></param>
        /// <param name="funcStr"></param>
        /// <param name="endPos"></param>
        private void GetCompleteFunction(string expr, int startPos, out string funcStr, out int endPos)
        {
            int cpnum = 0;
            for (int i = startPos; i <= expr.Length - 1; i++)
            {
                char c = expr[i];
                LetterType lt = JudgeLetterType(c);
                if (lt == LetterType.OpeningParenthesis)
                    cpnum++;
                else if (lt == LetterType.ClosingParenthesis)
                {
                    cpnum--;//考虑到函数嵌套的情况，消除掉内部括号
                    if (cpnum == 0)
                    {
                        endPos = i;
                        funcStr = expr.Substring(startPos, endPos - startPos + 1);
                        return;
                    }

                }

            }
            funcStr = "";
            endPos = -1;
        }

        /// <summary>
        /// 获取到完整的数字
        /// </summary>
        /// <param name="expr"></param>
        /// <param name="startPos"></param>
        /// <param name="numberStr"></param>
        /// <param name="endPos"></param>
        private void GetCompleteNumber(string expr, int startPos, out string numberStr, out int endPos)
        {
            char c = expr[startPos];
            for (int i = startPos + 1; i <= expr.Length - 1; i++)
            {
                char tmpc = expr[i];
                if (JudgeLetterType(tmpc) != LetterType.Number)
                {
                    endPos = i - 1;
                    numberStr = expr.Substring(startPos, endPos - startPos + 1);
                    return;
                }
            }
            numberStr = expr.Substring(startPos);
            endPos = expr.Length - 1;
        }
    }

    /// <summary>
    /// 可以检测到的表达式错误的Exception
    /// </summary>
    public class ExpressionException : Exception
    {
        public override string Message
        {
            get
            {
                return base.Message;
            }
        }
    }

    /// <summary>
    /// 字符类别
    /// </summary>
    public enum LetterType
    {
        Number,
        SimpleOperator,
        Function,
        OpeningParenthesis,
        ClosingParenthesis
    }

调用代码如下：

string expr = txtExpression.Text;

NEval neval = new NEval();
return neval.Eval(expr);

本文链接

信息系统项目管理师考试准备要点

2009-07-13T05:56:00Z

考试准备要点：1、熟记9大知识领域，5大过程组，44个过程。2、案例分析要紧扣44个过程中所包含的知识点来做答。3、论文要提前准备，不要在考试时临场发挥。

9月份的PMP成绩出来了

2007-12-06T09:30:00Z

居然这么久才出来成绩，电脑阅卷怎么会这么慢，真奇怪！好在通过了，但不痛快，好险，只有120分，本来以为能到160分以上的。而看看同期同学的成绩，很多没过！要知道这个班以前的通过率都在90%以上。网上查了一下，原来同样的情况广泛存在，以致有些人认为是PMI在捣鬼，企图榨取钱财！面对如此惨象，我不由得暗自庆幸了一下，一把年纪了，我可不想重考啊，不管怎么说，过了就好，小小庆祝一下~

怎样将GIS图形复制到Windows剪贴板，粘贴到Word中

2007-11-22T07:17:00Z

很久没写随笔了，有点想关了这个博客，不再更新，但还是没有下定决心。趁这些天比较闲，发一个以前写着玩的功能吧。复制、粘贴功能是一件很简单的事情，但怎样将GIS图形粘贴到word中呢？最简单的思路还是将GIS图形保存为Image形式，发送到剪贴板，再粘贴到Word。但如果Image格式采用栅格的格式，如BMP或JPEG，则粘贴后在Word中拉伸时，效果会受到影响，比较合适的格式是采用WMF或EMF这种...

为什么人照镜子时，左右是反过来的，而上下并没有反过来

2007-10-19T02:57:00Z

这是有《世界500强面试题》书上的一个题目，我初看到这个题目，大吃一惊，为什么这样一个司空见惯的问题，我从来没有仔细思考过呢。因此我不得不说，提出这个问题的人是个天才。我马上把书抛到一边，思考这个问题。下面是我思考的结果，先折叠起来，要不你先思考一下，然后比对一下？呵呵。我的答案Code highlighting produced by Actipro CodeHighlighter (freew...

软件设计点滴

2007-06-26T07:40:00Z

曾经看过一本书叫《道法自然》，内容略记得一二，但我最欣赏的是它的书名。软件设计没什么太神秘有东西，只要用心体会，其实一切都很自然。软件的设计之“道”，也不在于设计有多么的华丽、精巧，而在于其朴实、自然，最终达到“以无招胜有招”，进入一个全新的境界。一、软件设计理论的层次

博客园_编程 ＆ 生活

从管理职能中寻找项目管理的秘诀 之一

项目管理中的目标管理与承诺管理

程序员基本素质要求

采用浮点数编码的遗传算法的问题

.net表达式计算器（中缀表达式转后缀表达式，支持20多个数学函数，支持函数嵌套,免费共享～）

信息系统项目管理师考试准备要点

9月份的PMP成绩出来了

怎样将GIS图形复制到Windows剪贴板，粘贴到Word中

为什么人照镜子时，左右是反过来的，而上下并没有反过来

软件设计点滴

博客园_编程　＆　生活

从管理职能中寻找项目管理的秘诀之一