java数学公式自动编译

㈠ java 公式编辑器是如何实现的

1 词法分析
2 只实现简单的公式 如(2*3+6/2 *12*(12-1+6/(2+3))) 类似这样的公式的话 可以考虑通过java调用javascript语法来完成。具体能否实现，没搞过，不知道。

㈡ 请问用Java编写一个 数学表达式计算程序

System.out.println("\t" + n + "! = " + compute(n));//调用compute方法,传入参数n
}

// 计算n!的方法
static long compute(int n) {

// 1!=1; 2!=2*1=2; 3!=3*2*1; 4!=4*3! ... n!=n*(n-1)!
// 递归: 方法本身含有对自己的调用
if (n == 1) {
return 1;
} else {
return n*compute(n-1);//20*compute(20-1)
}
}

㈢ java 数学公式

这个公式不复杂啊，统共就会用到Math里面的求次方的pow函数了。

因为这个属于java.lang包下的，调用方法就是Math.pow(a,b)，相当于a^b了。

当然是一步一步算了，Java不是matlab，还不支持符号运算。double的精度应该够你用了，

如果要用任意精度的运算，才考虑用java.math包下的BigDecimal,BigInteger那些类，一般不需要。

你的公式用java写，如下：

doubleloanamount,monthlyInterestRate;
intnumOfYears;
//上述变量的赋值（略）
doubleresult=(loanamount*monthlyInterestRate)/(1-1/Math.pow(1+monthlyInterestRate,numOfYears*12));

㈣ java计算简单的数学公式.

publicclassDemo2{
	publicstaticvoidmain(String[]args){
		doubleprice=100.0;//单价
		intnums=200;//数量
		doubletotal;//总价
		total=price*nums;//计算总价
		
		doubleprofit;//利润
		doublecost=12000;//成本
		doubletax=0.17;//税率
		profit=(total-cost)*(1-tax);//计算利润
		System.out.println("利润:"+profit+"元");//输出利润
	}
}

运行测试

利润:6640.0元

㈤ Java中求平方以及立方的函数式什么

Math.pow(x,2)就是平方。Math.pow(x,3)就是立方。

Math.pow(底数,几次方)，如：double a=2.0，double b=3.0，double c=Math.pow(a,b)，就是2的三次方是多少；c最终为8。

(5)java数学公式自动编译扩展阅读：

Math.pow()函数返回基数（base）的指数（exponent）次幂，即base的exponent次幂。Java是一种简单的，跨平台的，面向对象的，分布式的，解释的，健壮的安全的，结构的中立的，可移植的，性能很优异的多线程的，动态的语言。

Java编程工具如下：

1、Eclipse：一个开放源代码的、基于Java的可扩展开发平台 。

2、NetBeans：开放源码的Java集成开发环境，适用于各种客户机和Web应用。

3、IntelliJ IDEA：在代码自动提示、代码分析等方面的具有很好的功能。

4、MyEclipse：由Genuitec公司开发的一款商业化软件，是应用比较广泛的Java应用程序集成开发环境 。

5、EditPlus：如果正确配置Java的编译器“Javac”以及解释器“Java”后，可直接使用EditPlus编译执行Java程序 。

㈥ java如何实现一个数学公式求解

简单的数学公式一般只要逻辑加上简单的运算，但是如果涉及到微分 什么的 就比较麻烦了，可能会用到数据结构。

㈦ JAVA 文本表达式解析成数学公式,计算出结果

正则表达分解字符串
然后运算
给你个例子。以前写的，现在忙没空给你写你这个了，public class CalStr { private String src;

/**
* constructor
*
* @param srcthe string(expression) to calculate
*/
public CalStr(String src) {
this.src = src;
}

/**
* calculate to get the result
*
* @return(double)result
*/
public double getResult() {
String postfix = getPostfix();
Stack stk = new Stack();
// System.out.println(postfix);
String parts[] = postfix.split( " + ");
double result = 0;
for (int i = 0; i < parts.length; i++) {
char tmp = parts[i].charAt(0);
if (!isOperator(tmp)) {
stk.push(parts[i]);
} else {
double a = Double.parseDouble((String) stk.pop());
double b = Double.parseDouble((String) stk.pop());
// b is followed by a in the orignal expression
result = calculate(b, a, tmp);
stk.push(String.valueOf(result));
}
}
return result;
}

/**
* test if the character is an operator,such +,-,*,/
*
* @param opthe character to test
* @returntrue if op is an operator otherwise false
*/
private boolean isOperator(char op) {
return (op == '+ ' || op == '- ' || op == '* ' || op == '/ ');
}

/**
* calculate an expression such (a op b)
*
* @param anumber 1
* @param bnumber 2
* @param opthe operator
* @return(double)(a op b)
*/
public double calculate(double a, double b, char op) {
switch (op) {
case '+ ':
return a + b;
case '- ':
return a - b;
case '* ':
return a * b;
case '/ ':
return a / b;
}
return -1;
}

/**
* convert the suffix to postfix
*
* @returnthe postfix as a string
*/
private String getPostfix() {
Stack stk = new Stack();
String postfix = new String();
char op;
int i = 0;
while (i < src.length()) {
if (Character.isDigit(src.charAt(i)) || src.charAt(i) == '. ') {
postfix += " ";
do {
postfix += src.charAt(i++);
} while ((i < src.length())
&& (Character.isDigit(src.charAt(i))));
postfix += " ";
}

else {
switch (op = src.charAt(i++)) {
case '( ':
stk.push( "( ");
break;

case ') ':
while (stk.peek() != "( ") {
String tmp = (String) stk.pop();
postfix += tmp;
if (tmp.length() == 1 && isOperator(tmp.charAt(0)))
postfix += " ";
}
stk.pop();
postfix += " ";
break;

case '+ ':
case '- ':
while ((!stk.empty()) && (stk.peek() != "( ")) {
postfix += stk.pop() + " ";
}
stk.push(String.valueOf(new Character(op)));
break;

case '* ':
case '/ ':
while ((!stk.empty())
&& ((stk.peek() == "* ") || (stk.peek() == "/ "))) {
postfix += stk.pop() + " ";
}
stk.push(String.valueOf(new Character(op)));
break;
}
}
}
ListIterator it = stk.listIterator(stk.size());
while (it.hasPrevious())
postfix += it.previous() + " ";
return postfix.trim().replaceAll( " +\\. ", ". ");
}

/**
* main function
*
* @param args
*/
public static void main(String args[]) {
System.out.println(new CalStr( "((1.5+6.000)*9+9.36)*(8+9-8*8+8*7) ")
.getResult());
}
}

㈧ 输入运算公式 得到结果 java

通过栈实现,先用栈将中缀表达式转化为后缀表达式，然后再用栈计算后缀表达式的值的
package com.saturday;

import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class MyParse {
static Map<String,Integer> optrOrder;
static {
optrOrder=new HashMap<String,Integer>();
optrOrder.put("(", 0);
optrOrder.put("*", 1);
optrOrder.put("/", 1);
optrOrder.put("%", 1);
optrOrder.put("+",2);
optrOrder.put("-",2);
optrOrder.put("^",3);
optrOrder.put("#",3);
}

public static void main(String[] args){
List<String> tokens;
try{
//词法分析
tokens=lex("+2* (-2+3*4)+-5");

//中缀转后缀
tokens=toRpn(tokens);

//计算结果
System.out.println(calcRpn(tokens));

}catch(Exception ex){
ex.printStackTrace();
}
}

/**
* 将输入串转换为操作符串
* @param sExpres
* @return
*/
public static List<String> lex(String sExpres){
List<String> tokens=new ArrayList<String>();

//将表达式分割成符号序列
String sRegExp="(((?<=^|\\(|\\+|-|\\*|/|%)(\\+|-))?\\d+(\\.\\d+)?)"
+"|\\(|\\)|\\*|/|\\+|-";
Pattern p=Pattern.compile(sRegExp);
Matcher m=p.matcher(sExpres.replaceAll("\\s+",""));
while(m.find()){
tokens.add(m.group());
}

tokens.add("#");

return tokens;
}

/**
* 将中缀表单时转化为后缀表达式
* @param tokens
* @return
*/
public static List<String> toRpn(List<String> tokens)
throws Exception{
List<String> rpnList=new ArrayList<String>();
Stack<String> optrStack=new Stack<String>();

optrStack.add("^");
for(String token:tokens){
if(token.matches("^(\\+|-)?\\d+(\\.\\d+)?$")){
rpnList.add(token);
}else{
outputOptr(token,optrStack,rpnList);
}
}

if(!optrStack.isEmpty()
&&optrStack.lastElement().equals("#")){
return rpnList;
}else{
throw new Exception("后缀表达式转化错误!");
}
}

/**
* 计算后缀表达式的值
* @param rpnTokens
* @return
* @throws Exception
*/
public static double calcRpn(List<String> rpnTokens)
throws Exception{
NumberFormat nf=NumberFormat.getInstance();
Stack<Double> numStack=new Stack<Double>();

for (String token : rpnTokens) {
if (token.matches("^(\\+|-)?\\d+(.\\d+)?$")) {
token=token.indexOf('+')==0
?token.substring(1)
:token;
numStack.add(nf.parse(token).doubleValue());
} else {
doCalcByOptr(token, numStack);
}
}

if (!numStack.isEmpty() && numStack.size() == 1) {
return numStack.lastElement();
} else {
throw new Exception("计算错误！");
}
}

/**
* 将运算符输出到后缀表达式序列.
* @param optr
* @param optrStack
* @param rpnList
* @throws Exception
*/
public static void outputOptr(String optr,
Stack<String> optrStack,
List<String> rpnList)
throws Exception{
String preOptr;

if(optr.equals("(")){//处理左括号
optrStack.push(optr);
return;
}

if(optr.equals(")")){//处理右括号
while(!optrStack.isEmpty()){
preOptr=optrStack.pop();
if(!preOptr.equals("(")){
rpnList.add(preOptr);
}else{
break;
}
}

if(optrStack.isEmpty()){
throw new Exception("括号未闭合!");
}

return;
}

/*按优先级处理其他运算符，若当前运算符优先级较高
* 直接入栈，否则将栈中运算符出战直至栈顶运算符
* 低于当前运算符
*/
preOptr=optrStack.lastElement();
if(optrCmp(optr,preOptr)<0){
optrStack.push(optr);
}else{
while(!preOptr.equals("(")
&&!optrStack.isEmpty()
&&optrCmp(optr,preOptr)>=0){

preOptr=optrStack.pop();
if(!preOptr.equals("^")){
rpnList.add(preOptr);
}
}
optrStack.push(optr);
}
}

/**
* 运算符优先级比较函数,optr1优先级大于optr2返回小于0值,
* 优先级相等返回0,optr1小于optr2返回大于0值.
* @param optr1
* @param optr2
* @return
*/
public static int optrCmp(String optr1,String optr2){
int order1=optrOrder.get(optr1);
int order2=optrOrder.get(optr2);
return order1-order2;
}

/**
* 根据运算符对数据栈中的内容进行操作.
* @param optr
* @param numStack
*/
public static void doCalcByOptr(String optr,
Stack<Double> numStack){
double n1,n2;
n2=numStack.pop();
n1=numStack.pop();

if(optr.equals("+")){
numStack.push(n1+n2);
}else if(optr.equals("-")){
numStack.push(n1-n2);
}else if(optr.equals("*")){
numStack.push(n1*n2);
}else if(optr.equals("/")){
numStack.push(n1/n2);
}else if(optr.equals("%")){
numStack.push(n1%n2);
}
}
}

㈨ 如何用Java实现数学公式的编辑并生成word文档

打开word点击菜单里的插入→对象，在对象类型对话框中选公式3.0，出现一个数学模型，选择符合你要求的模型，在哪里输入编辑就OK啦。