如何处理JAVA语言编写的矩阵乘法运算中的符号运算问题

还是那句话，找一本数值分析 Java版看一看就好了

如果矩阵中有多个变量,有多种运算,比如ln(x)之类,那就相当麻烦了.

有人吗?有人吗?有人吗?
help!help!help!
都等了两天了,还是没有人来......
为什么呢?为什么呢?为什么呢?

矩阵中的每一个节点：（Value，Type）用type标记是已知还是未知，用value来计算。。最后综合一下就0K了

谢谢啊，不过能说的细致一些吗？已知和未知在矩阵相乘过程中提前并不知道，我是JAVA新手，需要看哪一部分java知识才能把这个问题吃透啊？是数据结构还是其他啊，数值计算的JAVA书上并没有这一部分知识．
可以的话能用两个２＊２的矩阵相乘给个小例子吗？

有人吗？帮帮忙啊......
就是符号运算问题的java编程。
比如数学软件mathematica或maple就比较擅长符号运算，我现在就是想用java编程来实现它。
期待高手啊......

首先矩阵中的每个元素应该定义成一元多项式类，可以用数组或者list表示
public class Element {
public double[] item;
}如果item[0] = 1.2 item[1] = 3.2 item[2] = 4.5 等同于 4.5x^2 + 3.2x + 1.2，如此类推
然后矩阵相乘时，Element * Element就是一元多项式乘数罢了public Element multiply(Element element) {
Element result = new Element();
result.item = new double[item.length + element.item.length - 1];
for(int i = item.length - 1; i >= 0; i--) {
for(int j = element.item.length - 1; j >= 0; j--)
result.item[i + j] += item[i] * element.item[j];
}
return result;
}

终于把这个问题搞出一点眉目了。
import java.util.*;/**一元多项式类，用一个内部类来表示项，多顶式用链表形式实现.
*/
class Polynomial implements Cloneable{
/**内部类，一元多项式的项类,实现Comparable是为了排序和比较两项时方便.
*/
class Entry implements Comparable<Entry>{
private double coef;   //系数coefficient
private int    expn;   //指数exponent
private Entry  next;   //下一项.

Entry(double c,int e){
coef=c;
expn=e;
next=null;
}
Entry(Entry entry){
coef=entry.getCoef();
expn=entry.getExpn();
next=null;
}
void setNext(Entry e){
next=e;
}
void setCoef(double c){
coef=c;
}
void setExpn(int i){
expn=i;
}
Entry getNext(){
return next;
}
double getCoef(){
return coef;
}

int getExpn(){
return expn;
}

public int compareTo(Entry e){
return expn-e.getExpn();
}

public String toString(){
return String.valueOf(coef)+"#"+String.valueOf(expn);
}
}

private char varChar;          //变量字符.
private Entry polynomial;      //一元多项式.
//private int leng;              //一元多项式的项数.

Polynomial(char c){
polynomial=new Entry(1,1);
varChar=c;

}

/**一元多项式的构造方法.
*  @polyString 一元多项式,用字符串的形式表示,每一项可以形如:符号+实数+变量+指数的形式表示.如5x3-x^2-4x+5,其中5x3中的3是指数.-x^2中2是指数。
*  @variableChar 一元多项式中的变量字符串.
*/
Polynomial(String polyString,char variableChar){
String[] entrysStr=polyString.split("(?<!\\^)(\\+|(?=\\-))");            //把每一项分出来.
Entry[] entrys=new Entry[entrysStr.length];
String regex=variableChar+"\\^|"+variableChar;                           //把系数和指数分出来的正则表达式. for(int i=0;i<entrysStr.length;i++){
String str=entrysStr[i];
str=str.replaceAll(" ","");                                           //把每一项中的空格去掉.
str=str.replaceAll("(^|\\-)"+variableChar,"$11"+variableChar);        //把每一项中无系数的变量之前插入1.
str=str.replaceAll(variableChar+"$",variableChar+"1");                //把每一项中无指数的变量之后插入1.
str=str.replaceAll("^([^"+variableChar+"]+)$","$1"+variableChar+"0"); //给常数项加上变量.
String[] coefExpn=str.split(regex);                                   //把系数和指数分出来.
entrys[i]=new Entry(Double.parseDouble(coefExpn[0]),Integer.parseInt(coefExpn[1]));
}
Arrays.sort(entrys);
polynomial=new Entry(1,1);                                                //建一个带头结点的链表.
Entry p=polynomial;
for(int i=0;i<entrys.length;i++){                                         //依次把每一项加入到链表中.
p.setNext(entrys[i]);
p=entrys[i];
}

varChar=variableChar;
//leng=entrys.length; }
Entry getHead(){
return polynomial;
}
//求一元多项式的项数.
public int leng(){
int counter=0;
Entry p=polynomial;
while(p.getNext()!=null){
counter++;
p=p.getNext();
}

return counter;
}
//复制一个一元多项式.
public Polynomial clone(){
Polynomial result=new Polynomial(varChar);
Entry p=result.getHead();
Entry q=polynomial;
while(q.getNext()!=null){
q=q.getNext();
Entry temp=new Entry(q);
p.setNext(temp);
p=temp;
}
return  result;
}
/**把another多项式合并到当前的一元多项式中，也就是实现了两个一元多项式的加法.
* @param another 另一个一元多项式.
* @return 返回当前的合并了another之后的一元多项式.
*/
public Polynomial add(Polynomial another){
Polynomial result=clone();
Polynomial temp=another.clone();
Entry ha=result.getHead();              //ha指向当前一元多项式的当前项的前一项.
Entry hb=temp.getHead();                //hb指向another的当前项的前一项，这两个引用是为了删除和插入项设的.
Entry pa=ha.getNext();                  //pa指向当前一元多项式的当前项.
Entry pb=hb.getNext();                  //pb指向another的当前项.

while(pa!=null&&pb!=null){
if(pa.compareTo(pb)>0){             //这时要把pb从another中摘下来，加到当前一元多项式中.
ha.setNext(pb);
ha=pb;
pb=pb.getNext();
ha.setNext(pa);
hb.setNext(pb);
}else if(pa.compareTo(pb)<0){       //这时只要移动当前一元多项式的引用就可以了.
ha=pa;
pa=pa.getNext();
}else{                              //这时要合并同类项.
double sum=pa.getCoef()+pb.getCoef();
if(sum!=0){
pa.setCoef(sum);
ha=pa;
}else{
ha.setNext(pa.getNext());    //这两步是把pa从链表中删除.
pa.setNext(null);
}
pa=ha.getNext();

hb.setNext(pb.getNext());        //下面的几步是把pb从another链表中删除.
pb.setNext(null);
pb=hb.getNext();
}
}
if(pb!=null){                             //another中有剩余的项,一定都是比当前多项式幂次高的项，直接加到当前多项式的尾部.
ha.setNext(pb);
}
return result;
}
/**一元多项式乘某一项,是为多项式乘法准备的，担心误用，所以设为private.
*/
private Polynomial multiEntry(Entry e){
Polynomial result=clone();
Entry p=result.getHead();
if(e.getCoef()==0){
return new Polynomial(varChar);
}
while(p.getNext()!=null){
p=p.getNext();
p.setCoef(p.getCoef()*e.getCoef());
p.setExpn(p.getExpn()+e.getExpn());
}
return result;
}
/**一元多项乘法，在加法的基础上完成.
*/
public Polynomial multiply(Polynomial another){
Polynomial result=new Polynomial(varChar);
Entry q=another.getHead().getNext();
while(q!=null){
result=result.add(multiEntry(q));
q=q.getNext();
}
return result;
}

/**用了打印和转换为字符串方便.算法的逻辑比较烦，全是为了使结果符合日常写法.
*/
public String toString(){
StringBuilder result=new StringBuilder();
Entry p=polynomial;
if(p.getNext()!=null){
p=p.getNext();

if(p.getExpn()!=0){
if(p.getCoef()!=1&&p.getCoef()!=-1){
result.append((""+p.getCoef()).replaceAll("\\.0+$",""));  //把系数尾部的.0去掉.
}else if(p.getCoef()==-1){
result.append("-");
}
result.append(varChar);
if(p.getExpn()!=1){
result.append("^");
result.append(p.getExpn());
}
}else{
result.append((""+p.getCoef()).replaceAll("\\.0+$",""));
}
}
while(p.getNext()!=null){
p=p.getNext();
if(p.getCoef()>0){
result.append("+");
}
if(p.getExpn()!=0){
if(p.getCoef()!=1&&p.getCoef()!=-1){
result.append((""+p.getCoef()).replaceAll("\\.0$",""));
}else if(p.getCoef()==-1){
result.append("-");
}
result.append(varChar);
if(p.getExpn()!=1){
result.append("^");
result.append(p.getExpn());
}
}else{
result.append((""+p.getCoef()).replaceAll("\\.0+$",""));
}
}
return result.toString();
}
}public class PolynomialMatrix{
public static void main(String[] args){
String[][] polyMatrix1={{"2"   , "2x3" ,"4"},
                    {"2x-5", "-8"  ,"x"}
                   };
String[][] polyMatrix2={{"0"  ,"5"},
                    {"-x" ,"2"},
                    {"3"  ,"2x^2+4x-1"}
                   };
Polynomial[][] pMatrix1=new Polynomial[polyMatrix1.length][polyMatrix1[0].length];
Polynomial[][] pMatrix2=new Polynomial[polyMatrix2.length][polyMatrix2[0].length];
Polynomial[][] pMatrix3=new Polynomial[pMatrix1.length][pMatrix2[0].length];

//把字符矩阵转为一元多项式矩阵并打印输出.
System.out.println("矩阵1：");
for(int i=0;i<pMatrix1.length;i++){
for(int j=0;j<pMatrix1[i].length;j++){
pMatrix1[i][j]=new Polynomial(polyMatrix1[i][j],'x');
System.out.print(pMatrix1[i][j]+"\t");
}
System.out.println();
}
//把字符矩阵转为一元多项式矩阵并打印输出.
System.out.println("矩阵2：");
for(int i=0;i<pMatrix2.length;i++){
for(int j=0;j<pMatrix2[i].length;j++){
pMatrix2[i][j]=new Polynomial(polyMatrix2[i][j],'x');
System.out.print(pMatrix2[i][j]+"\t");
}
System.out.println();
}

//求两个矩阵的乘积.

for(int i=0;i<pMatrix3.length;i++){
for(int j=0;j<pMatrix3[i].length;j++){
pMatrix3[i][j]=new Polynomial('x');
for(int k=0;k<pMatrix2.length;k++){
pMatrix3[i][j]=pMatrix3[i][j].add(pMatrix1[i][k].multiply(pMatrix2[k][j]));
}
}
}
//输出结果.
System.out.println("两个矩阵的相乘的结果是:");
for(int i=0;i<pMatrix3.length;i++){
for(int j=0;j<pMatrix3[i].length;j++){
System.out.printf("%-20s",""+pMatrix3[i][j]);
}
System.out.println();
}

}
}

F:\java>java PolynomialMatrix
矩阵1：
2       2x^3    4
-5+2x   -8      x
矩阵2：
0       5
-x      2
3       -1+4x+2x^2
两个矩阵的相乘的结果是:
12-2x^4             6+16x+8x^2+4x^3
11x                 -41+9x+4x^2+2x^3

PolynomialMatrix这个类,可以好好写一写下,把一元多项式矩阵的转置,加法,乘法等封装进去.
前面的Polynomial类把我搞的焦头烂额，后面PolynomialMatrix没有心情再写下去了。

调试易

如何处理JAVA语言编写的矩阵乘法运算中的符号运算问题

解决方案 »