Question

我最近一直在尝试使用遗传算法，现在我想从基因组中建立数学表达式（为了便于讨论，找到一个与某个结果匹配的表达式）。

我的基因组由基因组成，这些基因用字节表示，一个基因组看起来像这样：{12,127,82,35,95,223,85,4,213,228}。长度是预定义的（尽管它必须落在一定范围内），它所采用的形式也不是。也就是说，任何条目都可以采用任何字节值。

现在的诀窍是将其转化为数学表达式。确定基本表达式相当容易，例如：选择前2个值并将它们视为产品，选择第3个值并选择它作为运算符（+， - ，*，/，^，mod），选择第4个值作为产品并选择第5个值作为运营商再次对第3个运营商的结果进行前2个产品的处理。（或者只是将其作为后缀表达式处理）

当您开始允许优先级规则时，复杂性会上升。现在，例如索引2下的条目代表一个'（'，你的边界有一个'）'在某个地方，除了条目3，但不一定是条目4

当然，对于很多事情来说也是如此，你不能最终得到一个操作员，你不能得到一个松散的数字等。

现在我可以使用一个巨大的switch语句（例如）接受所有可能的可能性，但这会使代码不可读。我希望有人在那里知道如何采取这个的好策略。

提前致谢！

**编辑**

根据要求：我想要实现的目标是创建一个可以解析一组数字函数的应用程序。至于我在下面的评论中给出的例子：{4,11,30}，它可能会出现函数（X ^ 3）+ X

Answer 1

Belisarius在评论中提供了相同主题的链接：Algorithm for permutations of operators and operands

我的代码：

    private static double ResolveExpression(byte[] genes, double valueForX)
    {
        // folowing: https://stackoverflow.com/questions/3947937/algorithm-for-permutations-of-operators-and-operands/3948113#3948113
        Stack<double> operandStack = new Stack<double>();

        for (int index = 0; index < genes.Length; index++)
        {
            int genesLeft = genes.Length - index;
            byte gene = genes[index];

            bool createOperand;
            // only when there are enough possbile operators left, possibly add operands
            if (genesLeft > operandStack.Count)
            {
                // only when there are at least 2 operands on the stack
                if (operandStack.Count >= 2)
                {
                    // randomly determine wether to create an operand by threating everything below 127 as an operand and the rest as an operator (better then / 2 due to 0 values)
                    createOperand = gene < byte.MaxValue / 2;
                }
                else
                {
                    // else we need an operand for sure since an operator is illigal
                    createOperand = true;
                }
            }
            else
            {
                // false for sure since there are 2 many operands to complete otherwise
                createOperand = false;
            }

            if (createOperand)
            {
                operandStack.Push(GeneToOperand(gene, valueForX));
            }
            else
            {
                double left = operandStack.Pop();
                double right = operandStack.Pop();

                double result = PerformOperator(gene, left, right);

                operandStack.Push(result);
            }
        }

        // should be 1 operand left on the stack which is the ending result
        return operandStack.Pop();
    }


    private static double PerformOperator(byte gene, double left, double right)
    {
        // There are 5 options currently supported, namely: +, -, *, /, ^ and log (math)
        int code = gene % 6;

        switch (code)
        {
            case 0:
                return left + right;
            case 1:
                return left - right;
            case 2:
                return left * right;
            case 3:
                return left / right;
            case 4:
                return Math.Pow(left, right);
            case 5:
                return Math.Log(left, right);
            default:
                throw new InvalidOperationException("Impossible state");
        }
    }

    private static double GeneToOperand(byte gene, double valueForX)
    {
        // We only support numbers 0 - 9 and X
        int code = gene % 11; // Get a value between 0 and 10
        if (code == 10)
        {
            // 10 is a placeholder for x
            return valueForX;
        }
        else
        {
            return code;
        }
    }

    #endregion // Helpers
}

Answer 2

使用“post-fix”表示法。这很好地处理了优先事项。

修复后符号处理“分组”或“优先级规则”。

例如，在修复后的表达式b ** 2-4 * a * c是

b，2，**，4，a，*，c，*， -

要评估修复后的表达式，只需将值推送到堆栈并执行操作。

所以上面的内容大致如下。

stack.push( b )
stack.push( 2 )
x, y = stack.pop(), stack.pop(); stack.push( y ** x ) 
stack.push( 4 )
stack.push( a )
x, y = stack.pop(), stack.pop(); stack.push( y * x ) 
stack.push( c )
x, y = stack.pop(), stack.pop(); stack.push( y * x ) 
x, y = stack.pop(), stack.pop(); stack.push( y - x )

要使其工作，您需要将字符串字符串分为值和运算符。您还需要检查所有运算符的“arity”，以确保运算符的数量和操作数的数量是平衡的。在这种情况下，二元运算符的数量+ 1是操作数的数量。一元运算符不需要额外的操作数。

Answer 3

与GA一样，解决方案的很大一部分是选择一个好的表示。已经提出了RPN（或后修复）。您仍然存在的一个问题是，您的GA可能会抛出以运算符开头的表达式（或其他地方不匹配的运算符和操作数），例如：

+,-,3,*,4,2,5,+,-

解决方案的一个（小）部分将是为无操作数的运算符定义评估。例如，可以决定序列：

计算结果为0，这是添加的标识元素。自然

将评估为1.数学可能没有弄清楚除法的标识元素是什么，但是APL有。

现在你有了一种方法的基础，如果你得到正确的运算符和操作数序列就不关心了，但是当你有太多操作数的操作符时你仍然会遇到问题。也就是说，（postfix follow）的解释是什么？

2,4,5,+,3,4,-

（可能）评估为

2,9,-1

好吧，如果你想把它减少到一个值，你现在必须发明自己的约定。但是你可以采用GA创建了一个向量值函数的约定。

编辑：对OP评论的回应......

如果一个字节可以表示操作符或操作数，并且如果您的程序对基因组可以分割以进行繁殖的位置没有限制，则总是存在后代表示操作符和操作数无效序列的风险。考虑一下，不是让每个字节都编码一个运算符或一个操作数，而是一个字节可以编码一个运算符+操作数对（你可能会快速地用完字节，所以也许你需要使用两个字节）。然后，一系列字节可能会转换为：

(plus 1)(plus x)(power 2)(times 3)

可以按照从左到右的规则对第一个词进行有意义的解释来评估3((x+1)^2)

将二进制字符串转换为数学表达式

3 个答案: