05c08-1.php

来自「介绍PHP5的给类型函数应用」· PHP 代码 · 共 248 行

<?php
// A Library of Matrix Math functions.
// All assume a Matrix defined by a 2 dimensional array, where the first 
//  index (array[x]) are the rows and the second index (array[x][y]) 
//  are the columns

// First create a few helper functions

// A function to determine if a matrix is well formed.  That is to say that 
//  it is perfectly rectangular with no missing values:
function _matrix_well_formed($matrix) {
    // If this is not an array, it is badly formed, return false.
    if (!(is_array($matrix))) {
        return false;
    } else {
        // Count the number of rows.
        $rows = count($matrix);
        
        // Now loop through each row:
        for ($r = 0; $r < $rows; $r++) {
            // Make sure that this row is set, and an array.  Checking to 
            //  see if it is set is ensuring that this is a 0 based 
            //  numerically indexed array.
            if (!(isset($matrix[$r]) && is_array($matrix[$r]))) {
                return false;
            } else {
                // If this is row 0, calculate the columns in it:
                if ($r == 0) {
                    $cols = count($matrix[$r]);
                // Ensure that the number of columns is identical else exit
                } elseif (count($matrix[$r]) != $cols) {
                    return false;
                }
                
                // Now, loop through all the columns for this row
                for ($c = 0; $c < $cols; $c++) {
                    // Ensure this entry is set, and a number
                    if (!(isset($matrix[$r][$c]) && 
                            is_numeric($matrix[$r][$c]))) {
                        return false;
                    }
                }
            }
        }
    }
    
    // Ok, if we actually made it this far, then we have not found 
    //  anything wrong with the matrix.
    return true;                    
}

// A function to return the rows in a matrix - 
//   Does not check for validity, it assumes the matrix is well formed.
function _matrix_rows($matrix) {
    return count($matrix);
}

// A function to return the columns in a matrix - 
//   Does not check for validity, it assumes the matrix is well formed.
function _matrix_columns($matrix) {
    return count($matrix[0]);
}

// This function performs operations on matrix elements, such as addition 
//  or subtraction. To use it, pass it 2 matrices, and the operation you 
//  wish to perform, as a string: '+', '-'
function matrix_element_operation($a, $b, $operation) {
    // Verify both matrices are well formed
    $valid = false;
    if (_matrix_well_formed($a) && _matrix_well_formed($b)) {
        // Make sure they have the same number of columns & rows
        $rows = _matrix_rows($a);
        $columns = _matrix_columns($a);
        
        if (($rows == _matrix_rows($b)) && 
                ($columns == _matrix_columns($b))) {
            // We have a valid setup for continuing with element math
            $valid = true;
        }
    }
    
    // If invalid, return false
    if (!($valid)) { return false; }
    
    // For each element in the matrices perform the operatoin on the
    //  corresponding element in the other array to it:
    for ($r = 0; $r < $rows; $r++) {
        for ($c = 0; $c < $columns; $c++) {
            eval('$a[$r][$c] '.$operation.'= $b[$r][$c];');
        }
    }
    
    // Return the finished matrix:
    return $a;    
}

// This function performs full matrix operations, such as matrix addition 
//  or matrix multiplication.  As above, pass it to matrices and the 
//  operation: '*', '-', '+'
function matrix_operation($a, $b, $operation) {
    // Verify both matrices are well formed
    $valid = false;
    if (_matrix_well_formed($a) && _matrix_well_formed($b)) {
        // Make sure they have complementary numbers of rows and columns.
        // The number of rows in A should be the number of columns in B
        $rows = _matrix_rows($a);
        $columns = _matrix_columns($a);
        
        if (($columns == _matrix_rows($b)) && 
                ($rows == _matrix_columns($b))) {
            // We have a valid setup for continuing
            $valid = true;
        }
    }
    
    // If invalid, return false
    if (!($valid)) { return false; }
    
    // Create a blank matrix the appropriate size, initialized to 0
    $new = array_fill(0, $rows, array_fill(0, $rows, 0));
    
    // For each row in a ...
    for ($r = 0; $r < $rows; $r++) {
        // For each column in b ...
        for ($c = 0; $c < $rows; $c++) {
            // Take each member of column b, with each member of row a
            // and add the results, storing this in the new table:
            // Loop over each column in A ...
            for ($ac = 0; $ac < $columns; $ac++) {
                // Evaluate the operation
                eval('$new[$r][$c] += $a[$r][$ac] '.
                    $operation.' $b[$ac][$c];');
            }
        }
    } 

    // Return the finished matrix:
    return $new;
}

// A function to perform scalar operations.  This means that you take the scalar value,
//  and the operation provided, and apply it to every element.
function matrix_scalar_operation($matrix, $scalar, $operation) {
    // Verify it is well formed
    if (_matrix_well_formed($matrix)) {
        $rows = _matrix_rows($matrix);
        $columns = _matrix_columns($matrix);

        // For each element in the matrix, multiply by the scalar
        for ($r = 0; $r < $rows; $r++) {
            for ($c = 0; $c < $columns; $c++) {
                eval('$matrix[$r][$c] '.$operation.'= $scalar;');
            }
        }
    
        // Return the finished matrix:
        return $matrix;    
    } else {
        // It wasn't well formed:
        return false;
    }
}

// A handy function for printing matrices (As an HTML table)
function matrix_print($matrix) {
    // Verify it is well formed
    if (_matrix_well_formed($matrix)) {
        $rows = _matrix_rows($matrix);
        $columns = _matrix_columns($matrix);

        // Start the table
        echo '<table>';
        
        // For each row in the matrix:
        for ($r = 0; $r < $rows; $r++) {
            // Begin the row:
            echo '<tr>';

            // For each column in this row
            for ($c = 0; $c < $columns; $c++) {
                // Echo the element:
                echo "<td>{$matrix[$r][$c]}</td>";
            }

            // End the row.
            echo '</tr>';
        }

        // End the table.
        echo "</table>\n";
    } else {
        // It wasn't well formed:
        return false;
    }
}

// Let's do some testing.  First prepare some formatting:
echo "<style>table { border: 1px solid black; margin: 20px; } 
td { text-align: center; }</style>\n";

// Now let's test element operations.  We need identical sized matrices:
$m1 = array(
    array(5, 3, 2),
    array(3, 0, 4),
    array(1, 5, 2),
    );
$m2 = array(
    array(4, 9, 5),
    array(7, 5, 0),
    array(2, 2, 8),
    );
    
// Element addition should give us:  9    12     7
//                                  10     5     4
//                                   3     7    10
matrix_print(matrix_element_operation($m1, $m2, '+'));

// Element subtraction should give us:     1    -6    -3
//                                        -4    -5     4
//                                        -1     3    -6
matrix_print(matrix_element_operation($m1, $m2, '-'));

// Do a scalar multiplication on the 2nd matrix:   8  18  10
//                                                14  10   0
//                                                 4   4  16
matrix_print(matrix_scalar_operation($m2, 2, '*'));

// Define some matrices for full matrix operations. 
// Need to be complements of each other:
$m3 = array(
    array(1, 3, 5),
    array(-2, 5, 1),
    );
$m4 = array(
    array(1, 2),
    array(-2, 8),
    array(1, 1),
    );

// Matrix multiplication gives:  0    31
//                                -11    37
matrix_print(matrix_operation($m3, $m4, '*'));

// Matrix addition gives:     9  20
//                            4  15
matrix_print(matrix_operation($m3, $m4, '+'));
?>