FormulaParser公式解析类

最新推荐文章于 2024-09-08 15:12:17 发布
最新推荐文章于 2024-09-08 15:12:17 发布
阅读量1.5k 收藏
点赞数
分类专栏： 快速代码 文章标签： 算法 Flash J#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hxzon/article/details/83369014
版权 
FormulaParser公式解析类
使用新的计算函数，新的算法.速度更快，使用更方便.

算法简介:

format函数:
根据格式化的原则,用一系列的if判断,过滤掉不符合的字符,并分割成数组.再利用括号的一一对应,补全

不匹配的括号.

calculate函数:
根据运算法则,给不同运算符赋予不同权值,再通过权值比较便可以确定运算顺序.

类代码:

/* 
* FormulaPareser 公式解析类 
* Version 1.0 
* 2006.8.11 
* Copyright CYJB 
*/ 
// 
/* 
* 公式解析类,可以计算包含加号(+),减号(-),乘号(*),除号(/),乘方(^),取模(%)以及括号的公式. 
* format()格式化公式.格式化遵循以下原则: 
* 1."+","-"号前是非数字时,将被认为是正、负号. 
* 2.当两个运算符连用(例如"^*"),将使用后面的运算符("+""-"除外).若前面的运算符是"+","-",将被 

认为是+1,-1. 
* 3.括号前后直接加数字,将被认为是乘以该数字. 
* 4.当"("与")"不匹配时,将认为是缺少最外层括号. 
* 5.自动去除公式的非法字符(除了".0123456789+-/*%^()"). 
* 6.自动去除"(数字)"中的括号 
* calculate()计算公式.可以传入字符串(会自动调用format函数格式化字符串),也可以直接传入数组 
* (不会调用format函数).直接传入数组需要注意格式，但是计算会更快速. 
* 注意:请注意输入数据的大小,否则可能会计算错误(超过flash计算能力). 
*/ 
// 
class FormulaParser { 
        public static function format(s:String):Array { 
                //格式化公式 
                var data:Array = []; 
                var backets:Array = []; 
                //括号个数记录 
                var n = 0; 
                var s1 = s.charAt(n); 
                while (s1.length == 1) { 
                        var k = s1.charCodeAt(0); 
                        var l = data.length-1; 
                        var s2 = data[l]; 
                        var k2 = (s2.charCodeAt(s2.length-1) == undefined) ? 0 :  

s2.charCodeAt(s2.length-1); 
                        if (k>=48 && k<=57) { 
                                //trace("这个是数字"); 
                                if (k2 == 46 || (k2>=48 && k2<=57)) { 
                                        //trace("前面是数字或."); 
                                        data[l] += s1; 
                                } else if (s2 == "--") { 
                                        //trace("前面是负号"); 
                                        data[l] = "-"+s1; 
                                } else if (s2 == ")") { 
                                        //trace("前面是)"); 
                                        data.push("*"); 
                                        data.push(s1); 
                                } else { 
                                        //trace("前面是开头或+-*/%^或("); 
                                        data.push(s1); 
                                } 
                        } else if (k == 46) { 
                                //trace("这个是."); 
                                if (k2>=48 && k2<=57) { 
                                        //trace("前面是数字"); 
                                        if (s2.indexOf(".") == -1) { 
                                                //只能有一个小数点 
                                                data[l] += s1; 
                                        } 
                                } else if (s2 == "--") { 
                                        //trace("前面是负号"); 
                                        data[l] = "-0."; 
                                } else if (s2 == ")") { 
                                        //trace("前面是)"); 
                                        data.push("*"); 
                                        data.push("0."); 
                                } else if (k2 != 46) { 
                                        //trace("前面是开头或+-*/%^或("); 
                                        data.push("0."); 
                                } 
                        } else if (k == 43 || k == 45) { 
                                //trace("这个是+-"); 
                                if (k2 == 41 || (k2>=48 && k2<=57)) { 
                                        //trace("前面是数字或)"); 
                                        data.push(s1); 
                                } else if (k2 == 46) { 
                                        //trace("前面是."); 
                                        data[l] = data[l].slice(0, -1); 
                                        data.push(s1); 
                                } else if (k == 45) { 
                                        //trace("这个是-"); 
                                        if (s2 == "--") { 
                                                //trace("前面是负号"); 
                                                data.pop(); 
                                        } else if (k2 == 45) { 
                                                //trace("前面是-"); 
                                                data[l] = "+"; 
                                        } else if (k2 == 43) { 
                                                //trace("前面是+"); 
                                                data[l] = "-"; 
                                        } else { 
                                                //trace("前面是开头或+-*/%^或("); 
                                                data.push("--"); 
                                        } 
                                } 
                        } else if (k == 37 || k == 42 || k == 47 || k == 94) { 
                                //trace("这个是*/%^"); 
                                if (k2 == 41 || (k2>=48 && k2<=57)) { 
                                        //trace("前面是数字或)"); 
                                        data.push(s1); 
                                } else if (k2 == 46) { 
                                        //trace("前面是."); 
                                        data[l] = data[l].slice(0, -1); 
                                        data.push(s1); 
                                } else if (s2 == "--") { 
                                        //trace("前面是负号"); 
                                        data[l] = "-1"; 
                                        data.push(s1); 
                                } else if (k2 == 45 || k2 == 43) { 
                                        //trace("前面是+-"); 
                                        data.push("1"); 
                                        data.push(s1); 
                                } else if (s2 != undefined && k2 != 40) { 
                                        //trace("前面是*/%^"); 
                                        data[l] = s1; 
                                } 
                        } else if (s1 == "(") { 
                                //trace("这个是("); 
                                backets.push("("); 
                                if (k2 == 41 || (k2>=48 && k2<=57)) { 
                                        //trace("前面是数字或)"); 
                                        data.push("*"); 
                                        data.push("("); 
                                } else if (k2 == 46) { 
                                        //trace("前面是."); 
                                        data[l] = data[l].slice(0, -1); 
                                        data.push("*"); 
                                        data.push("("); 
                                } else if (s2 == "--") { 
                                        //trace("前面是负号"); 
                                        data[l] = "-1"; 
                                        data.push("*"); 
                                        data.push("("); 
                                } else { 
                                        //trace("前面是开头或+-*/%^或("); 
                                        data.push("("); 
                                } 
                        } else if (s1 == ")") { 
                                //trace("这个是)"); 
                                if (s2 != undefined) { 
                                        if (backets[backets.length-1] == "(") { 
                                                backets.pop(); 
                                        } else { 
                                                backets.push(")"); 
                                        } 
                                } 
                                if (k2 == 41 || (k2>=48 && k2<=57)) { 
                                        //trace("前面是数字或)"); 
                                        data.push(")"); 
                                } else if (s2 == "--") { 
                                        //trace("前面是负号"); 
                                        data[l] = "-1"; 
                                        data.push(")"); 
                                } else if (k2 == 46) { 
                                        //trace("前面是."); 
                                        data[l] = data[l].slice(0, -1); 
                                        data.push(")"); 
                                } else if (k2 == 40) { 
                                        //trace("前面是("); 
                                        data.pop(); 
                                } else if (s2 != undefined) { 
                                        //trace("前面是+-*/%^"); 
                                        data[l] = ")"; 
                                } 
                        } 
                        n++; 
                        s1 = s.charAt(n); 
                } 
                //防止最后一位不合理 
                while (data[data.length-1] == "(") { 
                        data.pop(); 
                        backets.pop(); 
                } 
                var m = data[data.length-1]; 
                if (m == "+" || m == "-" || m == "*" || m == "/" || m == "%" || m == "^") { 
                        data.pop(); 
                } else if (m == "--") { 
                        data.pop(); 
                        data.pop(); 
                } else if (m.substr(-1) == ".") { 
                        data[data.length-1] = m.slice(0, -1); 
                } 
                //防止括号不匹配 
                var bs = backets.join(""); 
                var n1 = bs.split("(").length; 
                var n2 = bs.split(")").length; 
                if (n1 != 0) { 
                        n1--; 
                } 
                if (n2 != 0) { 
                        n2--; 
                } 
                while (n1--) { 
                        data.push(")"); 
                } 
                while (n2--) { 
                        data.splice(0, 0, "("); 
                } 
                //去除"(数字)"中的括号 
                var i = 1; 
                //第一、二位不可能是")" 
                while (i++<data.length) { 
                        if (data == ")") { 
                                if (data[i-2] == "(") { 
                                        data.splice(i, 1); 
                                        data.splice(i-2, 1); 
                                        i -= 2; 
                                } 
                        } 
                } 
                return data; 
        } 
        public static function calculate(s):Number { 
                //计算公式 
                var data:Array = []; 
                //参数的类型检察 
                if (s instanceof Array) { 
                        data = s; 
                } else if (typeof (s) == "string") { 
                        data = format(s); 
                } 
                var m:Array = []; 
                //括号数据存储 
                var num:String = "0"; 
                var l = data.length; 
                var sign:String = "+"; 
                var n:Number = 0; 
                var i = 0; 
                while (i<l) { 
                        if (data == "(") { 
                                m.push([num, sign, n, false]); 
                                if (data[i+1] == "(") { 
                                        i++; 
                                        num = "0"; 
                                        sign = "+"; 
                                        n = 0; 
                                } else { 
                                        num = data[i+1]; 
                                        sign = data[i+2]; 
                          ,              n = getPriority(sign); 
                                        i += 3; 
                                } 
                        } else { 
                                var sign2 = data[i+1]; 
                                if (sign2 == ")") { 
                                        num = evals(num, sign, data); 
                                        while (m[m.length-1][3]) { 
                                                var arr = m.pop(); 
                                                num = evals(arr[0], arr[1], num); 
                                        } 
                                        m[m.length-1][3] = true; 
                                        while (data[i+2] == ")") { 
                                                while (m[m.length-1][3]) { 
                                                        var arr = m.pop(); 
                                                        num = evals(arr[0], arr[1], num); 
                                                } 
                                                m[m.length-1][3] = true; 
                                                i++; 
                                        } 
                                        sign = data[i+2]; 
                                        n = getPriority(sign); 
                                        while (m[m.length-1][2]>=n && m[m.length-1][3]) { 
                                                var arr = m.pop(); 
                                                num = evals(arr[0], arr[1], num); 
                                        } 
                                        i += 3; 
                                        if (i>=l) { 
                                                for (var j in m) { 
                                                        num = evals(m[j][0], m[j][1], num); 
                                                } 
                                        } 
                                } else { 
                                        var n2 = getPriority(sign2); 
                                        if (n>=n2) { 
                                                num = evals(num, sign, data); 
                                                while (m[m.length-1][2]>=n2 && m[m.length- 

1][3]) { 
                                                        var arr = m.pop(); 
                                                        num = evals(arr[0], arr[1], num); 
                                                } 
                                        } else { 
                                                m.push([num, sign, n, true]); 
                                                num = data; 
                                        } 
                                        sign = sign2; 
                                        n = n2; 
                                        i += 2; 
                                } 
                        } 
                } 
                return Number(num); 
        } 
        private static function getPriority(s:String):Number { 
                //计算权值 
                if (s == "+" || s == "-") { 
                        return 1; 
                } else if (s == "*" || s == "/" || s == "%") { 
                        return 2; 
                } else if (s == "^") { 
                        return 3; 
                } else { 
                        return 0; 
                } 
        } 
        private static function evals(n1:String, s:String, n2:String):String { 
                //计算数据 
                switch (s) { 
                case "+" : 
                        return String(Number(n1)+Number(n2)); 
                case "-" : 
                        return String(Number(n1)-Number(n2)); 
                case "*" : 
                        return String(Number(n1)*Number(n2)); 
                case "/" : 
                        return String(Number(n1)/Number(n2)); 
                case "%" : 
                        return String(Number(n1)%Number(n2)); 
                case "^" : 
                        return String(Math.pow(Number(n1), Number(n2))); 
                } 
        } 
}
hxzon
关注
专栏目录
文本公式解析组件
11-29
使用运算树进行解释,大大提高了公式的解析效率 支持 + - * / ^ %三角函数: 比较运算: FormulaParser fp = new FormulaParser(); fp.AddParameter ("a","100"); fp.AddParameter("b", "20"); fp.AddParameter("c", ...
formula-parser:Javascript库解析Excel公式等
05-27
公式解析器 库提供了一个Parser类，用于评估excel和数学公式。 安装 建议的安装公式分析器的方法是使用以下命令通过 ： $ npm install hot-formula-parser --save Node.js： var FormulaParser = require ( 'hot-formula-parser' ) . Parser ; var parser = new FormulaParser ( ) ; parser . parse ( 'SUM(1, 6, 7)' ) ; // It returns `Object {error: null, result: 14}` 浏览器： < script src =" /node_modules/hot-formula-parser/dist/formula-parser.min.js " > </ scrip
Formula Parser
MichaelAn的博客
02-13 384
Formula Parser Library provides a Parser class that evaluates excel and mathematical formulas. hot-formula-parser 可以处理Excel和数学公式 Install A recommended way to i...
探索Handsontable Formula Parser：一款强大的公式解析器
gitblog_00095的博客
04-14 500
探索Handsontable Formula Parser：一款强大的公式解析器 formula-parserJavascript Library parsing Excel Formulas and more项目地址:https://gitcode.com/gh_mirrors/fo/formula-parser 是一个开源项目，专门为处理电子表格和计算引擎中的公式解析任务而设计。它基于Jav...
打造高效数据计算力：深入探索公式解析器（Formula Parser）
gitblog_00509的博客
08-26 291
打造高效数据计算力：深入探索公式解析器（Formula Parser） formula-parserJavascript Library parsing Excel Formulas and more项目地址:https://gitcode.com/gh_mirrors/fo/formula-parser 在数据处理和电子表格应用的领域中，精确而强大的公式计算引擎至关重要。虽然当前项目已标记为废...
使用java处理字符串公式运算的方法
09-05
在实际编程中，我们可以创建一个解析器类 `FormulaParser`，该类包含一个正则表达式来匹配公式中的变量占位符（如 `#{dddd}`）。`parse` 方法接收公式字符串、中间公式映射（`formulas`）和基础数据映射（`values`）...
用BeanShell实现公式管理
12-14
- **FormulaParser**：负责解析用户定义的公式，将其转换为系统可识别的格式，并保存到公式库中。 - **Calculator**：执行计算任务，包含各种运算符，可以根据需求扩展。 - **Formula**：表示单个公式，封装了...
公式解析器：解析和评估以字符串形式给出的数学公式
02-04
公式解析器 Formula Parser是用于解析和评估以字符串形式给出的数学公式的库。 支持： 运算符：+，-，*，/，^ 变量：x，y，z，a，b 小数点为“。”的数字 E表示法中的数字 常数：pi，e，Inf 功能：sqrt，abs，sin，cos，tan，log，exp 无限嵌套括号 NaN（非数字） 安装 需要。 要使用安装： composer require denissimon/formula-parser 用法 require_once __DIR__ . '/vendor/autoload.php' ; use FormulaParser \ Formula
fast-formula-parser:解析并评估JavaScript中的MS Excel公式
05-06
使用JavaScript的快速可靠的Excel公式解析器。 使用LL（1）解析器。 支持280个公式 ABS, ACOS, ACOSH, ACOT, ACOTH, ADDRESS, AND, ARABIC, AREAS, ASC, ASIN, ASINH, ATAN, ATAN2, ATANH, AVEDEV, AVERAGE, AVERAGEA, AVERAGEIF, BAHTTEXT, BASE, BESSELI, BESSELJ, BESSELK, BESSELY, BETA.DIST, BETA.INV, BIN2DEC, BIN2HEX, BIN2OCT, BINOM.DIST, BINOM.DIST.RANGE, BINOM.INV, BITAND, BITLSHIFT, BITOR, BITRSHIFT, BITXOR, CEILING, CEILING.MATH, CEIL
JavaMethodFlow:使用 javaparser 对给定方法执行 java 方法的静态分析和生成调用图的示例项目
06-03
Java方法流 使用 javaparser 对给定方法执行 java 方法的静态分析和生成调用图的示例项目 MethodPrinter 主方法接受源目录列表并打印调用树
a parser for formula
10-25
implement a routine that takes an infix notation expression, converts it to postfix through an expression tree, and then evaluates the postfix notation.
XLParser, 一种 99.9 % 兼容率的Microsoft Excel公式的C# 解析器.zip
10-10
XLParser, 一种 99.9 % 兼容率的Microsoft Excel公式的C# 解析器 XLParser具有以下属性的C# Excel公式分析器：高XLParser已经在a 个真实世界公式上进行了测试，并拥有 99.9 % 成功解析率。compact 解析树XLParser被设计为在Excel电子表格和重构中进行
探索Fast Formula Parser：高效、灵活的公式解析库
gitblog_00038的博客
04-19 406
探索Fast Formula Parser：高效、灵活的公式解析库 项目地址:https://gitcode.com/LesterLyu/fast-formula-parser 在处理复杂的数据计算或科学工程应用时，我们经常会遇到需要解析和执行数学公式的场景。Fast Formula Parser是一个强大的JavaScript库，为开发者提供了一个快速且准确地解析和执行数学表达式的方式。本文将带...
表达式解析（公式）
qq_35530330的博客
02-20 4592
公式解析器 Library提供了一个Parser评估excel和数学公式的类。 安装 安装Formula Parser的推荐方法是使用以下命令通过NPM： $ npm install hot-formula-parser Node.js中使用： // 此处以es6规范为例子 import { Parser, ERROR_REF, error as isFormulaError } from 'h...
js （函数）表达式计算npm包 hot-formula-parser
hzxOnlineOk的博客
08-27 1835
博主使用React + Antd +hot-formula-parser 实现以下功能 hot-formula-parser插件可以帮我们实现表达式的计算，表达式的格式判断等，如下图： https://www.npmjs.com/package/hot-formula-parser 图一 图二 图三 概览图 使用方式： import React, { Co...
开源项目教程：公式解析器 formula-parser
gitblog_00751的博客
08-23 382
开源项目教程：公式解析器 formula-parser formula-parserJavascript Library parsing Excel Formulas and more项目地址:https://gitcode.com/gh_mirrors/fo/formula-parser 本教程旨在指导您了解并快速上手formula-parser这一开源项目。此项目提供了强大的公式解析功能，特...
一个用Java编写的公式解析类
TTS2Game的专栏
08-04 1269
<br /> 初学Java，在工作中需要一个进行公式解析的类。从网上搜到一个相关代码，功能略有欠缺，现修改后能够实现四则运算。为了表示对网友leasion的感谢，并希望能帮助遇到同样问题人，现公开源码如下：<br /><br />/**<br />  * <p>Title: 公式解析类</p><br />  * <p>Description: 实现对包含“()”的表达式进行简单的四则运算。</p><br />  * <p>Copyright: Copyright (c) 2004</p><br />
dp算法练习【7】
最新发布
MADAO的博客
09-08 1414
给你一个按排序的整数数组nums，返回组成的新数组，要求也按排序。平方后，数组变为 [16,1,0,9,100]排序后，数组变为 [0,1,9,16,100]非常简单，思路平方后排序。优化：插入法。
Java FormulaParser类：解析字符串公式的关键操作与函数映射
在"FormulaParser公式解析类(字符串公式)"中，这个Java类主要用于解析和处理数学或逻辑运算的字符串表达式。它主要包含以下几个部分： 1. **常量定义**： - `lc`（List）列表存储算术运算符，如加号("+"), 反引号...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值