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啦。