submatrix.java

JAVA 数学程序库 提供常规的数值计算程序包

                            throwMathLibException("SubMatrix: index exceeds array dimensions");

                    // find position in array (y,x) by index
                    int x = (int)(index/dy); // column of original data
                    int y = index - x*dy;    // row of original data
        
                    // different approach if working on cell arrays
                    // if a={'asdf',[4,5]} then a{1,2} will return a number token [4,5] 
                    if ((operands[0] instanceof CellArrayToken) && leftCellB)
                    {
                        ErrorLogger.debugLine("SubMatrix: cell1");
                        return ((DataToken)operands[0]).getElement(y,x); 
                    }

                    // copy original values to return array
                    retToken.setElement(yi, 
                                        xi,
                                        ((DataToken)operands[0]).getElement(y,x));

                } // end yi
            } // end xi
            return retToken;
            
		} // end two operands
		
        
   		/***********************************************************************/
		// evaluate HORIZONTAL selection (e.g. submatrix(a,3,<...>) )          
        ErrorLogger.debugLine("SubMatrix: "+operands[2].toString());

		if(operands[2] instanceof DoubleNumberToken)
		{
            // e.g. submatrix(a,1,<some array>)
			// e.g. submatrix(a,1,2) 
		}
        else if(operands[2] instanceof LogicalToken)
        {
            // e.g. submatrix(a,b,[true,true,false,true])
            LogicalToken l = (LogicalToken)operands[2];
            
            // find number of elements unequal zero
            int n = 0;
            for (int i=0; i<l.getNumberOfElements(); i++)
            {
                if (l.getValue(i))
                    n++;
            }
            
            // create index array from boolean values
            // eg. a=[true,true,false,true] ->[1,2,4] (use indices with "true")
            double[][] values = new double [1][n];
            int ni =0;
            for (int i=0; i<l.getNumberOfElements(); i++)
            {
                if (l.getValue(i))
                {
                  values[0][ni] = (double)i + 1;
                  ni++;
                }
            }            
            operands[2] = new DoubleNumberToken(values,null);
   
        }
		else if(operands[2] instanceof Expression)
		{
            // e.g.  submatrix(a,:) or submatrix(a,2:end)
            Expression    expr = (Expression)operands[2];
            OperatorToken op   = (OperatorToken)expr.getData();

            // check if expression contains colon, e.g. (:) , (3:end)
            if ((op == null)                         ||
                (!(op instanceof ColonOperatorToken))  )
                throwMathLibException("SubMatrix: colon error");

            OperandToken colonOp = null;

            if (expr.getNumberOfChildren() == 2)
            {
                // submatrix(a,3,4:end)
                OperandToken left  = expr.getChild(0);
                OperandToken right = expr.getChild(1);
                    
                if ( (!(right instanceof DelimiterToken))                   ||
                     (!((DelimiterToken)right).getWordValue().equals("end"))  )
                        throwMathLibException("SubMatrix: wrong delimiter");
                
                // if three arguments: e.g. submatrix(a,3,4:end) -> 4:dx
                right = new DoubleNumberToken(dx);

                // create new ColonOperator and return new indexes
                colonOp = new Expression(new ColonOperatorToken(), left, right);
            }
            else if (expr.getNumberOfChildren() == 3)
            {
                // e.g. (2:3:end)
                OperandToken left   = expr.getChild(0);
                OperandToken middle = expr.getChild(1);
                OperandToken right  = expr.getChild(2);
                    
                if ( (!(right instanceof DelimiterToken))                   ||
                     (!((DelimiterToken)right).getWordValue().equals("end"))  )
                        throwMathLibException("SubMatrix: wrong delimiter");
                
                // if three arguments: e.g. submatrix(a,3,4:2:end) -> 4:2:dx
                right = new DoubleNumberToken(dx);

                // create new ColonOperator and return new indexes
                colonOp = new Expression(new ColonOperatorToken(), left, middle, right);
            }
            else if (expr.getNumberOfChildren() == 0)
            {
                // if three arguments: e.g. submatrix(a,3,:) -> all columns
                colonOp = new Expression(new ColonOperatorToken(),
                                         new DoubleNumberToken(1),
                                         new DoubleNumberToken(dx)    );
            }
            else
                throwMathLibException("SubMatrix: colon wrong number of childs");
    
            // evaluate new colon expression
            colonOp = colonOp.evaluate(null);
            
            if ( !(colonOp instanceof DoubleNumberToken))
                throwMathLibException("SubMatrix: colon error wrong type");
              
            // copy new array of indices to second operand of SubMatrix
            operands[2]= colonOp;
        }
        else
            throwMathLibException("SubMatrix: eval: unknown operand");
		
        x_dy      = ((DoubleNumberToken)operands[2]).getSizeY();
        x_dx      = ((DoubleNumberToken)operands[2]).getSizeX();
        x_indexes = ((DoubleNumberToken)operands[2]).getReValues();

        
        //*********************************************************************
        int sizeY = y_dy*y_dx;  // number of rows    of return array
        int sizeX = x_dy*x_dx;  // number of columns of return array
        int y     = 0;
        int x     = 0;
        ErrorLogger.debugLine("SubMatrix: sizeY="+sizeY+" sizeX="+sizeX);   

        // create return array with size of limits operator
        DataToken retToken = ((DataToken)operands[0]).getElementSized(sizeY,sizeX);
        
        // work through y_indixces
        for (int yxi=0; yxi<y_dx; yxi++)
        {
            for (int yyi=0; yyi<y_dy ; yyi++)
            {
                // check if row-number is valid
                int indexY = (int)y_indexes[yyi][yxi]-1;
                if ((indexY<0) || (indexY>dy-1))
                        throwMathLibException("SubMatrix: index exceeds array dimensions");

                // work through x_indixes
                x=0;
                for (int xxi=0; xxi<x_dx; xxi++)
                {
                    for (int xyi=0; xyi<x_dy; xyi++)
                    {
                        ErrorLogger.debugLine("SubMatrix: y="+y+" x="+x);
                        

                        // different approach if working on cell arrays
                        // if a={'asdf',[4,5]} then a{1,2} will return a number token [4,5] 
                        if ((operands[0] instanceof CellArrayToken) && leftCellB)
                        {
                            ErrorLogger.debugLine("SubMatrix: cell1");
                            return ((DataToken)operands[0]).getElement((int)y_indexes[yyi][yxi]-1,
                                                                       (int)x_indexes[xyi][xxi]-1); 
                        }

                        
                        // copy original values to return array
                        retToken.setElement(y, 
                                            x,
                                            ((DataToken)operands[0]).getElement((int)y_indexes[yyi][yxi]-1,
                                                                                (int)x_indexes[xyi][xxi]-1));
                     x++;   
                        
                    } // end xyi
                } // end xxi
  
                y++;
            } // end yyi
        } // end yxi
        return retToken;
        
	} // end evaluate
}

/*
@GROUP
matrix
@SYNTAX
answer = submatrix(matrix, sizey, sizex)
answer = submatrix(matrix, index)
@DOC
Returns a portion of a matrix.
@NOTES
@EXAMPLES
a=[1,2,3,4,5;6,7,8,9,10;1,2,3,4,5]                                                
submatrix(a,1,2)   = 2                                 
submatrix(a,3,:)   = [3,8,3]'	       					
submatrix(a,2:5,2) = [7,8,9,10]
submatrix(a,1:end,:)
submatrix(a,[2,6,3,2]) 						
@SEE
subassign

*/