<?php
/**
 * SeekQuarry/Yioop --
 * Open Source Pure PHP Search Engine, Crawler, and Indexer
 *
 * Copyright (C) 2009 - 2015  Chris Pollett chris@pollett.org
 *
 * LICENSE:
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * END LICENSE
 *
 * @author Chris Pollett (chris@pollett.org)
 * @license http://www.gnu.org/licenses/ GPL3
 * @link http://www.seekquarry.com/
 * @copyright 2009 - 2015
 * @filesource
 */
namespace seekquarry\yioop\library\summarizers;

use seekquarry\yioop\configs as C;
use seekquarry\yioop\library as L;
use seekquarry\yioop\library\CrawlConstants;
use seekquarry\yioop\library\PhraseParser;
use seekquarry\yioop\library\processors\PageProcessor;

/**
 * Class which may be used by the processors to get a summary for a text
 * document that may later be used for indexing. Generate a summary based
 * the Lanczos algorithm.
 * @author Charles Bocage (charles.bocage@sjsu.edu)
 */
class LanczosSummarizer extends Summarizer
{
    /**
     * Number of bytes in a sentence before it is considered long
     * We use strlen rather than mbstrlen. This might actually be
     * a better metric of the potential of a sentence to have info.
     */
    const LONG_SENTENCE_LEN = 50;
    /**
     * Number of sentences in a document before only consider longer
     * sentences in centroid
     */
    const LONG_SENTENCE_THRESHOLD = 100;
    /**
     * Number of distinct terms to use in generating summary
     */
    const MAX_DISTINCT_TERMS = 1000;
    /**
     * Number of words in word cloud
     */
    const WORD_CLOUD_LEN = 5;
    /**
     * Number of nonzero centroid components
     */
    const CENTROID_COMPONENTS = 50;
    /**
     * whether to output the results to the disk or not
     */
    const OUTPUT_TO_FILE = false;
    /**
     * The full disk location to save the result to
     */
    const OUTPUT_FILE_PATH = "/temp/centroid_weighted_summarizer_result.txt";
    /**
     * Generate a summary based on it closeness to the average sentence.
     * It also weights sentences based on the CMS that produced it.
     * @param string $doc complete raw page to generate the summary from.
     * @param string $lang language of the page to decide which stop words to
     *     call proper tokenizer.php of the specified language.
     *
     * @return array array of summary and word cloud
     */
    public static function getLanczosSummary($doc, $lang)
    {
        $raw_doc = $doc;
        $doc = self::pageProcessing($doc);
        /* Format the document to remove characters other than periods and
           alphanumerics.
        */
        $formatted_doc = self::formatDoc($doc);
        $stop_obj = PhraseParser::getTokenizer($lang);
        /* Splitting into sentences */
        $out_sentences = self::getSentences($doc);
        $sentences = self::removeStopWords($out_sentences, $stop_obj);
        $sentence_array = self::splitSentences($sentences, $lang, $raw_doc);
        $terms = $sentence_array[0];
        $tf_per_sentence = $sentence_array[1];
        $tf_per_sentence_normalized = $sentence_array[2];
        $tf_average_sentence =
            self::getAverageSentence($tf_per_sentence_normalized);
        $tf_dot_product_per_sentence =
            self::getDotProduct($tf_per_sentence_normalized,
            $tf_average_sentence);
        usort($tf_dot_product_per_sentence, 'self::sortInAscendingOrder');
        $summary = self::getSummary($tf_dot_product_per_sentence,
            $out_sentences);
        $n = count($out_sentences);
        $terms = array_filter($terms);
        $terms_counts = array_count_values($terms);
        arsort($terms_counts);
        $terms_counts = array_slice($terms_counts, 0,
            self::MAX_DISTINCT_TERMS);
        $terms = array_unique(array_keys($terms_counts));
        $t = count($terms);
        if ($t == 0) {
            return ["", ""];
        }
        /* Initialize Nk [Number of sentences the term occurs] */
        $nk = [];
        $nk = array_fill(0, $t, 0);
        $nt = [];
        /* Count TF for each word */
        for ($i = 0; $i < $n; $i++) {
            for ($j = 0; $j < $t; $j++) {
                if (strpos($sentences[$i], $terms[$j]) !== false) {
                    $nk[$j]++;
                }
            }
        }
        /* Calculate weights of each term for every sentence */
        $w = [];
        $idf = [];
        $idf_temp = 0;
        for ($k = 0; $k < $t; $k++) {
            if ($nk[$k] == 0) {
                $idf_temp = 0;
                $tmp = 0;
            } else {
                $idf_temp = $n / $nk[$k];
                $tmp = log($idf_temp);
            }
            $idf[$k] = $tmp;
        }
        /* Count TF for finding centroid */
        $wc = [];
        $max_nt = -1;
        $b = "\b";
        if (in_array($lang, ["zh-CN", "ja", "ko"])) {
            $b = "";
        }
        for ($j = 0; $j < $t; $j++) {
            $nt = @preg_match_all("/$b{$terms[$j]}$b/", $formatted_doc,
                $matches); //$matches included for backwards compatibility
            $wc[$j] = $nt * $idf[$j];
            if (is_nan($wc[$j]) || is_infinite($wc[$j])) {
                $wc[$j] = 0;
            }
        }
        /* Calculate centroid */
        arsort($wc);
        $centroid = array_slice($wc, 0, self::CENTROID_COMPONENTS, true);
        /* Initializing centroid weight array by 0 */
        $wc = array_fill(0, $t, 0);
        /* Word cloud */
        $i = 0;
        $word_cloud = [];
        foreach ($centroid as $key => $value) {
            $wc[$key] = $value;
            if ($i < self::WORD_CLOUD_LEN) {
                $word_cloud[$i] = $terms[$key];
            }
            $i++;
        }
        //should not need anything below this line
//        if (strlen($formatted_doc) < PageProcessor::$max_description_len
//            || $n == 1) {
//            //if input short only use above to get a word cloud
//            $formatted_doc = substr($formatted_doc, 0,
//                PageProcessor::$max_description_len);
//            return [$formatted_doc, $word_cloud];
//        }
//        ksort($wc);
//        /* Calculate similarity measure between centroid and each sentence */
//        $sim = [];
//        for ($i=0; $i < $n; $i++) {
//            $a = $b1 = $b2 = $c1 = $c2 = $d = 0;
//            for ($k = 0; $k < $t; $k++) {
//                    $wck = $wc[$k];
//                    $idfk = $idf[$k];
//                    $tmp = substr_count($sentences[$i], $terms[$k]);
//                    $wik = ($tmp > 0) ? $idfk * (1 + log($tmp)) : 0;
//                    $a += ($wik * $wck * $idfk);
//                    $b1 += ($wik * $wik);
//                    $c1 += ($wck * $wck);
//            }
//            $b2 = sqrt($b1);
//            $c2 = sqrt($c1);
//            $d = $b2 * $c2;
//            if ($d == 0) {
//                $sim[$i] = 0;
//            } else {
//                $sim[$i] = $a / $d;
//            }
//        }
//        arsort($sim);
//        /* Getting how many sentences should be there in summary */
//        $top = self::summarySentenceCount($out_sentences, $sim);
//        $sum_array = [];
//        $sum_array = array_keys(array_slice($sim, 0, $top - 1, true));
//        sort($sum_array);
//        $summary = '';
//        foreach ($sum_array as $key) {
//            $summary .= $out_sentences[$key] . ". ";
//        }
//
//
//
//
//        if (self::OUTPUT_TO_FILE) {
//            $output_file_contents = "";
//            foreach ($sum_array as $key) {
//                $output_file_contents .= $out_sentences[$key] . ".\n";
//            }
//            file_put_contents(C\WORK_DIRECTORY . self::OUTPUT_FILE_PATH,
//                $output_file_contents);
//        }
        /* Summary of text summarization */
        return [$summary, $word_cloud];
    }
    /**
     * Calculates how many sentences to put in the summary to match the
     * MAX_DESCRIPTION_LEN.
     *
     * @param array $sentences sentences in doc in their original order
     * @param array $sim associative array of sentence-number-in-doc =>
     *      similarity score to centroid (sorted from highest to lowest score).
     * @return int number of sentences
     */
    public static function summarySentenceCount($sentences, $sim)
    {
        $top = null;
        $count = 0;
        foreach ($sim as $key => $value)
        {
            if ($count < PageProcessor::$max_description_len) {
                $count += strlen($sentences[$key]);
                $top++;
            }
        }
        return $top;
    }
    /**
     * Breaks any content into sentences by splitting it on spaces or carriage
     *   returns
     * @param string $content complete page.
     * @return array array of sentences from that content.
     */
    public static function getSentencesOriginal($content)
    {
        $lines = preg_split(
            '/(\.|\||\!|\?|！|？|。)\s+|(\n|\r)(\n|\r)+|\s{5}/',
            $content, 0, PREG_SPLIT_NO_EMPTY);
        $out = [];
        $sentence = "";
        $count = 0;
        $theshold_factor = 1;
        foreach ($lines as $line) {
            $sentence .= " " . $line;
            if (strlen($line) < 2) {
                continue;
            }
            if ($count < self::LONG_SENTENCE_THRESHOLD ||
                strlen($sentence) > $theshold_factor *
                    self::LONG_SENTENCE_LEN){
                $sentence = preg_replace("/\s+/ui", " ", $sentence);
                $out[] = trim($sentence);
                $count++;
                $theshold_factor =
                    pow(1.5, floor($count/self::LONG_SENTENCE_THRESHOLD));
            }
            $sentence = "";
        }
        if (trim($sentence) != "") {
            $sentence = preg_replace("/\s+/ui", " ", $sentence);
            $out[] = trim($sentence);
        }
        return $out;
    }
    /**
     * Formats the sentences to remove all characters except words,
     *   digits and spaces
     * @param string $sent complete page.
     * @return string formatted sentences.
     */
    public static function formatSentence($sent)
    {
        $sent = trim(preg_replace('/[^\p{L}\p{N}\s]+/u',
            ' ', mb_strtolower($sent)));
        return $sent;
    }
    /**
     * Formats the document to remove carriage returns, hyphens and digits
     * as we will not be using digits in word cloud.
     * The formatted document generated by this function is only used to
     * compute centroid.
     * @param string $content formatted page.
     * @return string formatted document.
     */
    public static function formatDoc($content)
    {
        $substitute = ['/[\n\r\-]+/', '/[^\p{L}\s\.]+/u', '/[\.]+/'];
        $content = preg_replace($substitute, ' ', mb_strtolower($content));
        return $content;
    }
    /**
     * This function does an additional processing on the page
     * such as removing all the tags from the page
     * @param string $page complete page.
     * @return string processed page.
     */
    public static function pageProcessing($page)
    {
        $substitutions = ['@<script[^>]*?>.*?</script>@si',
            '/\&nbsp\;|\&rdquo\;|\&ldquo\;|\&mdash\;/si',
            '@<style[^>]*?>.*?</style>@si', '/[\^\(\)]/',
            '/\[(.*?)\]/', '/\t\n/'
        ];
        $page = preg_replace($substitutions, ' ', $page);
        $page = preg_replace('/\s{2,}/', ' ', $page);
        $new_page = preg_replace("/\<br\s*(\/)?\s*\>/", "\n", $page);
        $changed = false;
        if ($new_page != $page) {
            $changed = true;
            $page = $new_page;
        }
        $page = preg_replace("/\<\/(h1|h2|h3|h4|h5|h6|table|tr|td|div|".
            "p|address|section)\s*\>/", "\n\n", $page);
        $page = preg_replace("/\<a/", " <a", $page);
        $page = preg_replace("/\&\#\d{3}(\d?)\;|\&\w+\;/", " ", $page);
        $page = preg_replace("/\</", " <", $page);
        $page = strip_tags($page);

        if ($changed) {
            $page = preg_replace("/(\r?\n[\t| ]*){2}/", "\n", $page);
        }
        $page = preg_replace("/(\r?\n[\t| ]*)/", "\n", $page);
        $page = preg_replace("/\n\n\n+/", "\n\n", $page);
        return $page;
    }
    /**
     * Calculate the term frequencies.
     * @param array $terms the list of all terms in the doc
     * @param array $sentences the sentences in the doc
     * @param string $doc complete raw page to generate the summary from.
     * @return array a two dimensional array where the word is the key and
     *      the frequency is the value
     */
    public static function getTermFrequencies($terms, $sentence, $doc)
    {
        $t = count($terms);
        $nk = [];
        $nk = array_fill(0, $t, 0);
        $nt = [];
        for ($j = 0; $j < $t; $j++) {
            $nk[$j] += preg_match_all("/\b" . $terms[$j] . "\b/iu",
                    $sentence, $matches);
        }
        $term_frequencies = [];
        for ($i = 0; $i <  count($nk); $i++ ) {
            //$additional_weight = self::getAdditionalWeight($terms[$i], $doc);
            $term_frequencies[$terms[$i]] = $nk[$i];// + $additional_weight;
        }
        return $term_frequencies;
    }
    /**
     * Normalize the term frequencies based on the sum of the squares.
     * @param array $term_frequencies the array with the terms as the key
     *      and its frequency as the value
     * @return array array of term frequencies normalized
     */
    public static function normalizeTermFrequencies($term_frequencies)
    {
        $sum_of_squares = 0;
        $result_sum = 0;
        if (count($term_frequencies) == 0) {
            $result = [];
        } else {
            foreach ($term_frequencies as $k => $v) {
                $sum_of_squares += ($v * $v);
            }
            $square_root = sqrt($sum_of_squares);
            foreach ($term_frequencies as $k => $v) {
                if ($square_root == 0) {
                    $result[$k] = 0;
                } else {
                    $result[$k] = ($v / $square_root);
                }
            }
            foreach ($result as $k => $v) {
                $result_sum += $v;
            }
        }
        return $result;
    }
    /**
     * Get the average sentence by adding up the values from each column and
     * dividing it by the rows in the array.
     * @param array $term_frequencies_normalized the array with the terms as
     *      the key and its normalized frequency as the value
     * @return array array of frequencies averaged
     */
    public static function getAverageSentence($term_frequencies_normalized)
    {
        $result = [];
        if (count($term_frequencies_normalized) != 0) {
            foreach ($term_frequencies_normalized as $k => $v) {
                foreach ($v as $l => $w) {
                    if (count($result) == 0) {
                        $result[$l] = $w;
                    } else {
                        if (@array_key_exists($l, $result)) {
                            $result[$l] = $result[$l] + $w;
                        } else {
                            $result[$l] = $w;
                        }
                    }
                }
            }
            $count = count($term_frequencies_normalized);
            foreach ($result as $k => $v) {
                $result[$k] = ($v / $count);
            }
        }
        return $result;
    }
    /**
     * Get the dot product of the normalized array and the average sentence
     * @param array $term_frequencies_normalized the array with the terms as
     *      the key and its normalized frequency as the value
     * @param array $average_sentence an array of each words average
     *      frequency value
     * @return array array of frequencies averaged
     */
    public static function getDotProduct($term_frequencies_normalized,
        $average_sentence)
    {
            $result = [];
            $count = 0;
            foreach ($term_frequencies_normalized as $k => $v) {
                $tempResult = 0;
                foreach ($v as $l => $w) {
                    if (@array_key_exists($l, $average_sentence)) {
                        $tempResult = $tempResult +
                            ($average_sentence[$l] * $w);
                    }
                }
                $result[$count] = $tempResult;
                $count++;
            }
            return $result;
    }
    /**
     * Compare the two values and return if b is greater than a
     * @param string $a the first value to compare
     * @param string $b the second value to compare
     * @return boolean if b is greater than a
     */
    public static function sortInAscendingOrder($a, $b)
    {
        return $b > $a ? 1 : -1;
    }
    /**
     * Returns a new array of sentences without the stop words
     * @param array $sentences the array of sentences to process
     * @param object $stop_obj the class that has the stopworedRemover method
     * @return array a new array of sentences without the stop words
     */
    public static function removeStopWords($sentences, $stop_obj)
    {
        $n = count($sentences);
        $result = [];
        if ($stop_obj && method_exists($stop_obj, "stopwordsRemover")) {
            for ($i = 0; $i < $n; $i++ ) {
                $result[$i] = $stop_obj->stopwordsRemover(
                    self::formatDoc($sentences[$i]));
             }
        } else {
            $result = $sentences;
        }
        return $result;
    }
    /**
     * Split up the sentences and return an array with all of the needed parts
     * @param array $sentences the array of sentences to process
     * @param string $lang the current locale
     * @param string $doc complete raw page to generate the summary from.
     * @return array an array with all of the needed parts
     */
    public static function splitSentences($sentences, $lang, $doc)
    {
        $result = [];

        $terms = [];
        $tf_index = 0;
        $tf_per_sentence = [];
        $tf_per_sentence_normalized = [];
        foreach ($sentences as $sentence) {
            $temp_terms = PhraseParser::segmentSegment($sentence, $lang);
            $terms = array_merge($terms, $temp_terms);
            $tf_per_sentence[$tf_index] =
                self::getTermFrequencies($temp_terms, $sentence, $doc);
            $tf_per_sentence_normalized[$tf_index] =
                self::normalizeTermFrequencies($tf_per_sentence[$tf_index]);
            $tf_index++;
        }
        $result[0] = $terms;
        $result[1] = $tf_per_sentence;
        $result[2] = $tf_per_sentence_normalized;
        return $result;
    }
    /**
     * Split up the sentences and return an array with all of the needed parts
     * @param array $tf_dot_product_per_sentence an array that holds the dot
            product of each sentence.  It should be sorted from highest to
            lowest when it is passed to this method.
     * @param array $sentences the array of sentences to process
     * @return string a string that represents the summary
     */
    public static function getSummary($tf_dot_product_per_sentence,
            $sentences)
    {
        $result = "";
        $result_length = 0;
        $i = 0;
        foreach ($tf_dot_product_per_sentence as $k => $v) {
            if ($result_length + strlen($sentences[$k]) >
                PageProcessor::$max_description_len) {
                break;
            } else {
                $result_length += strlen($sentences[$k]);
                if ($i == 0) {
                    $i = 1;
                    $result = $sentences[$k] . ". ";
                    if (self::OUTPUT_TO_FILE) {
                        $output_file_contents = $sentences[$k] . ". ";
                    }
                } else {
                    $result .= " " . $sentences[$k] . ". ";
                    if (self::OUTPUT_TO_FILE) {
                        $output_file_contents = $output_file_contents .
                            "\r\n" . $sentences[$k] . ". ";
                    }
                }
            }
        }
        if (self::OUTPUT_TO_FILE) {
            file_put_contents(C\WORK_DIRECTORY . self::OUTPUT_FILE_PATH,
                $output_file_contents);
        }
        return $result;
    }




    public static $q;
	public static $lineCount = 0;
	public static $matrix;
	public static $senten;
	public static $senMatrix;
	public static $words;
	public static $ignores;
	public static $rr;
	public static $cc;
	public static function main($args){
		//makeIgnorelists();//remove stop words
		//makeFinalWSMatrix();
		//double [][]A = copy(matrix);
        //List<Matrix> ev = new LinkedList<Matrix>();
        //
        ///*
        //double[][] A
        //= new double[][] {
        //		{1.000, 0.000, 0.000, 0.000, 0.000, 1.000},
        //		{1.000, 0.000, 0.000, 0.000, 0.000, 1.000},
        //		{1.000, 0.000, 0.000, 0.000, 0.000 ,0.000},
        //		{1.000, 0.000, 0.000, 0.000, 0.000 ,0.000},
        //		{1.000, 0.000, 0.000, 1.000, 0.000, 1.000},
        //		{0.000, 1.000, 0.000, 0.000, 0.000, 0.000},
        //		{0.000, 1.000, 0.000, 0.000, 0.000, 0.000},
        //		{0.000, 0.000, 1.000, 0.000, 0.000, 0.000},
        //		{0.000, 0.000, 1.000, 0.000, 0.000 ,0.000},
        //		{0.000, 0.000, 0.000, 1.000, 0.000, 1.000},
        //		{0.000, 0.000, 0.000, 1.000, 0.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{2.000, 0.000, 0.000, 0.000, 0.000, 1.000},
        //		{3.000, 1.000, 0.000, 0.000, 0.000, 1.000},
        //		{0.000, 0.000, 1.000, 0.000, 0.000, 0.000},
        //		{0.000, 0.000, 1.000, 0.000, 0.000 ,0.000},
        //		{0.000, 0.000, 0.000, 1.000, 0.000, 1.000},
        //		{0.000, 0.000, 0.000, 1.000, 0.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{2.000, 0.000, 0.000, 0.000, 0.000, 1.000},
        //		{3.000, 1.000, 0.000, 0.000, 0.000, 1.000},
        //		{1.000, 0.000, 0.000, 0.000, 0.000, 1.000},
        //		{1.000, 0.000, 0.000, 0.000, 0.000, 1.000},
        //		{1.000, 0.000, 0.000, 0.000, 0.000 ,0.000},
        //		{1.000, 0.000, 0.000, 0.000, 0.000 ,0.000},
        //		{1.000, 0.000, 0.000, 1.000, 0.000, 1.000},
        //		{0.000, 1.000, 0.000, 0.000, 0.000, 0.000},
        //		{0.000, 1.000, 0.000, 0.000, 0.000, 0.000},
        //		{0.000, 0.000, 1.000, 0.000, 0.000, 0.000},
        //		{0.000, 0.000, 1.000, 0.000, 0.000 ,0.000},
        //		{0.000, 0.000, 0.000, 1.000, 0.000, 1.000},
        //		{0.000, 0.000, 0.000, 1.000, 0.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{2.000, 0.000, 0.000, 0.000, 0.000, 1.000},
        //		{3.000, 1.000, 0.000, 0.000, 0.000, 1.000},
        //		{0.000, 0.000, 1.000, 0.000, 0.000, 0.000},
        //		{0.000, 0.000, 1.000, 0.000, 0.000 ,0.000},
        //		{0.000, 0.000, 0.000, 1.000, 0.000, 1.000},
        //		{0.000, 0.000, 0.000, 1.000, 0.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{2.000, 0.000, 0.000, 0.000, 0.000, 1.000},
        //		{3.000, 1.000, 0.000, 0.000, 0.000, 1.000},
        //		{1.000, 0.000, 0.000, 0.000, 0.000, 1.000},
        //		{1.000, 0.000, 0.000, 0.000, 0.000, 1.000},
        //		{1.000, 0.000, 0.000, 0.000, 0.000 ,0.000},
        //		{1.000, 0.000, 0.000, 0.000, 0.000 ,0.000},
        //		{1.000, 0.000, 0.000, 1.000, 0.000, 1.000},
        //		{0.000, 1.000, 0.000, 0.000, 0.000, 0.000},
        //		{0.000, 1.000, 0.000, 0.000, 0.000, 0.000},
        //		{0.000, 0.000, 1.000, 0.000, 0.000, 0.000},
        // 		{0.000, 0.000, 1.000, 0.000, 0.000 ,0.000},
        //		{0.000, 0.000, 0.000, 1.000, 0.000, 1.000},
        //		{0.000, 0.000, 0.000, 1.000, 0.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{2.000, 0.000, 0.000, 0.000, 0.000, 1.000},
        //		{3.000, 1.000, 0.000, 0.000, 0.000, 1.000},
        //		{0.000, 0.000, 1.000, 0.000, 0.000, 0.000},
        //		{0.000, 0.000, 1.000, 0.000, 0.000 ,0.000},
        //		{0.000, 0.000, 0.000, 1.000, 0.000, 1.000},
        //		{0.000, 0.000, 0.000, 1.000, 0.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{2.000, 0.000, 0.000, 0.000, 0.000, 1.000},
        //		{3.000, 1.000, 0.000, 0.000, 0.000, 1.000},
        //		{1.000, 0.000, 0.000, 0.000, 0.000, 1.000},
        //		{1.000, 0.000, 0.000, 0.000, 0.000, 1.000},
        //		{1.000, 0.000, 0.000, 0.000, 0.000 ,0.000},
        //		{1.000, 0.000, 0.000, 0.000, 0.000 ,0.000},
        //		{1.000, 0.000, 0.000, 1.000, 0.000, 1.000},
        //		{0.000, 1.000, 0.000, 0.000, 0.000, 0.000},
        //		{0.000, 1.000, 0.000, 0.000, 0.000, 0.000},
        //		{0.000, 0.000, 1.000, 0.000, 0.000, 0.000},
        //		{0.000, 0.000, 1.000, 0.000, 0.000 ,0.000},
        //		{0.000, 0.000, 0.000, 1.000, 0.000, 1.000},
        //		{0.000, 0.000, 0.000, 1.000, 0.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{2.000, 0.000, 0.000, 0.000, 0.000, 1.000},
        //		{3.000, 1.000, 0.000, 0.000, 0.000, 1.000},
        //		{0.000, 0.000, 1.000, 0.000, 0.000, 0.000},
        //		{0.000, 0.000, 1.000, 0.000, 0.000 ,0.000},
        //		{0.000, 0.000, 0.000, 1.000, 0.000, 1.000},
        //		{0.000, 0.000, 0.000, 1.000, 0.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{0.000, 0.000, 0.000, 0.000, 1.000, 0.000},
        //		{2.000, 0.000, 0.000, 0.000, 0.000, 1.000},
        //		{3.000, 1.000, 0.000, 0.000, 0.000, 1.000}
        //
        //};
        //
        //
        //
        //   double[][] A
        //= new double[][] {
        //		{4.000, 0.000, 0.000, 0.000, 0.000, 1.000},
        //		{3.000, 0.000, 0.000, 0.000, 0.000, 1.000},
        //		{1.000, 2.000, 0.000, 0.000, 0.000 ,0.000},
        //		{3.000, 3.000, 0.000, 2.000, 0.000 ,0.000},
        //		{1.000, 0.000, 0.000, 1.000, 0.000, 1.000},
        //		{1.000, 0.000, 0.000, 0.000, 0.000 ,0.000},
        //		{1.000, 0.000, 0.000, 2.000, 0.000 ,0.000},
        //		{1.000, 2.000, 0.000, 1.000, 0.000, 1.000}};
        //
        //*/
        ////double [][] A = new double[][] {{1,1,1},{-1,3,1}};
        //
        ////double [][] A = new double [][] {{0.5, 0.5,-0.5},{0,0,-2},{1.5, -0.5,4.5}};
        //
        //rr= A.length;
        //cc = A[0].length;
        //
	    ////int n = a1.length;
    	////double[][] A = new double[n][n];
        //
        ////double[][] A = { { 1, 2,3, 1,2,2}, { 4,5,6,2,1,2 }, {2,1,3,1,1,3}, {1,1,0,1,1,5}, {2,1,0,0,1,3}};
        //
        //int n = A.length;
        //
        //
        //
        //double[][] AT = transpose(A);
        //double [][] AAT = matrixMultiplication(AT, A); // a*at
        //// double[][] aat = (double[][])AAT.clone();
        //printM(AAT);
        //
        //n = AAT.length;
        //
        //
        //double[][] I = new double[n][n];
        //q = new double[n][];
        //
        //
        //
    	//double[][] o = (double[][])A.clone();
    	//int i = 0;
        //for(i = 0; i < n; i++)
	    //    for(int j = 0; j < n; j++)
	    //    	I[i][j] = (i == j) ? 1 : 0;
        //
        //System.out.println("Starting Matrix");
        //printM(A);
        //
        //int j = 0;
        //A = lanczos(AAT);
        //
        //double[][] l = (double[][])A.clone();
        //
        ////dsfsdfsdfsdfsd
        //System.out.println(" ");
        //System.out.println("Generating a tri-diagonal matrix");
        //printM(A);
        //System.out.println(" ");
        //
        //double[][][] qrArrays;
        //boolean iteration= true;
        //i = 0;
        //double count =0;
        //
        //while(iteration && count <30)
        //{
        //	qrArrays = qRDecompose(A);
        //    A = matrixMultiplication(qrArrays[1],qrArrays[0]);
        //
        //    if(checkSubDiagonal(A))
        //    {
        //    	iteration = false;
        //    }
        //    count ++;
        //}
        //
        //System.out.println(" ");
        //System.out.println("QR factoriztion");
        //printM(A);
        ////don't put .3f in calculating eigen
        //double [] eigen = new double[n];
        //
        //for(i=0; i<n;i++)
        //	for(j=0; j <n; j++)
        //	{
        //		if(i==j)
        //		{
        //			if(Math.abs(A[i][j])<0.001D)  A[i][j]=0;
        //			eigen[i] = A[i][j];
        //		}
        //
        //	}
        //
        ////sorting
        //
        //for(int out=eigen.length-1; out>1; out--)
        //{
        //	 for(int in=0; in<out; in++)
        //	     if( Math.abs(eigen[in]) < Math.abs(eigen[in+1]))
        //	     {
        //	    	 double temp = eigen[in];
        //	    	 eigen[in] = eigen[in+1];
        //	    	 eigen[in+1] = temp;
        //
        //	      }
        //}
        ///*
        //for(i=0; i<n; i++)
        //{
        //	double s = eigen[i];
        //	for(int k=i+1; k<n; k++)
        //	{
        //		if(Double.parseDouble(String.format("%.3f",eigen[k])) == Double.parseDouble(String.format("%.3f",s)))
        //			eigen[k]=0;
        //	}
        //}
        //*/
        //for(i=0; i<n;i++)
        //System.out.println(Double.parseDouble(String.format("%.3f",eigen[i])));
        //System.out.println("Eigenvalues sorted");
        //for(i=0; i<n;i++)
        //	System.out.print(Math.sqrt(eigen[i]) + "  ");
        //
        //double x[][] = copy(l);
        //for(int k=0; k<n; k++)
        //{
        //	for(i=0; i<n;i++)
        //		for(j=0; j <n; j++)
        //		{
        //			if(i==j)
        //			{
        //				x[i][j] =  x[i][j]-eigen[k];
        //			}
        //
        //		}
        //
        //	 System.out.println("");
        //     Matrix d = new Matrix(x);
        //     //d.show();
        //
        //
        //    // Matrix fm = d.solve();
        //
     	//	double [][] ff =inverse(d.data);
  		//	Matrix fm = new Matrix(ff);
     	//	Matrix fs = fm.getNorm();
        //
  		//	 ev.add(fs);
        //     x = copy(l);
        //    // printM(l);
        //
        //}
        //
        //Matrix eigenvectors = getV(ev);
        //System.out.println("eigenvvvvvv");
        //
        //eigenvectors.show();
        //// transpose so that q can be in column vector, right now it's horizontal
        //Matrix lancvectors = new Matrix(q).transpose();
        //lancvectors.getRidOfNegativeZero();
        //System.out.println("");
        //lancvectors.show();
        //System.out.println("Vector U");
        //Matrix left = lancvectors.times(eigenvectors.Clone());
        //left.show();
        //System.out.println("Vector S");
        ////new Matrix(l).show();
        //Matrix singular = getS(eigen);
        //singular.show();
        //System.out.println("Transpose of vector V");
        //
        //Matrix a = new Matrix(o);
        //
        //Matrix at = a.transpose();
        ///*
        //System.out.println("aaaa");
		//at.show();
		// System.out.println("atttt");
		//left.show();
		//*/
		//Matrix r = at.times(left);
        //
		//r=r.getMultiNorm();
        //
        //
		//r = getTransposeOfV(r);
		//r.show();
        //
		//LinkedList<Integer> sen = getSentences(r.data,2);
		//System.out.println("Summary: ");
		//printSentences(sen);
        //
        //
		////System.out.println("Multiplication of three matrices above");
		////Matrix out = left.times(singular).times(r);
		////out.show();
        
        self::makeIgnorelists();
		self::makeFinalWSMatrix();
		$A = self::copy(self::$matrix);
        $ev = array();
        self::$rr = count($A);
        self::$cc = count($A[0]);
        $n = count($A);
        $AT = self::transpose($A);
        $AAT = self::matrixMultiplication($AT, $A); // a*at
        self::printM($AAT);
        $n = count($AAT);
        $I = array();
        self::$q = array();
   	    $o = self::copy($A);
    	$i = 0;
        for ($i = 0; $i < $n; $i++) {
	        for ($j = 0; $j < $n; $j++) {
	        	$I[$i][$j] = ($i == $j) ? 1 : 0;
            }
        }
        print("Starting Matrix\n");
        self::printM($A);
        $j = 0;
        $A = self::lanczos($AAT);
        $l = self::copy($A);
        print(" \n");
        print("Generating a tri-diagonal matrix\n");
        self::printM($A);
        print(" \n");
        $qrArrays = array();
        $iteration = true;
        $i = 0;
        $count = 0.0;
        while ($iteration && $count < 30) {
        	$qrArrays = self::qRDecompose($A);
            $A = self::matrixMultiplication($qrArrays[1], $qrArrays[0]);
            if (self::checkSubDiagonal($A)) {
            	$iteration = false;
            }
            $count++;
        }
        print(" \n");
        print("QR factoriztion\n");
        self::printM($A);
        //don't put .3f in calculating eigen
        $eigen = array();
        for ($i = 0; $i < $n; $i++) {
        	for ($j = 0; $j < $n; $j++) {
        		if ($i == $j) {
        			if (abs($A[$i][$j]) < floatval(0.001)) {
                        $A[$i][$j] = 0;
                    }
        			$eigen[$i] = $A[$i][$j];
        		}
        	}
        }
        //sorting
        for ($out = count($eigen) - 1; $out > 1; $out--) {
        	 for ($in = 0; $in < $out; $in++) {
        	     if (abs($eigen[$in]) < abs($eigen[$in + 1])) {
        	    	 $temp = $eigen[$in];
        	    	 $eigen[$in] = $eigen[$in + 1];
        	    	 $eigen[$in + 1] = $temp;
        	      }
            }
        }
        for ($i = 0; $i < $n; $i++) {
            print(number_format($eigen[$i], 3));
        }
        print("Eigenvalues sorted\n");
        for ($i = 0; $i < $n; $i++) {
        	print(sqrt($eigen[$i]) . "  ");
        }
        $x = self::copy($l);
        for ($k = 0; $k < $n; $k++) {
        	for ($i = 0; $i < $n; $i++) {
        		for ($j = 0; $j < $n; $j++)  {
                    if ($i == $j) {
        				$x[$i][$j] = $x[$i][$j] - $eigen[$k];
        			}
        		}
            }
        	print("\n");
            $d = new Matrix($x);
     		$ff = self::inverse($d->data);
  			$fm = new Matrix($ff);
     		$fs = $fm->getNorm();
            $ev[] = $fs;
            $x = self::copy($l);
        }
        $eigenvectors = self::getV($ev);
        print("eigenvvvvvv\n");
        $eigenvectors->show();
        // transpose so that q can be in column vector,
        //right now it's horizontal
        $l_temp = new Matrix(self::$q);
        $lancvectors = $l_temp->transpose();
        $lancvectors->getRidOfNegativeZero();
        print("\n");
        $lancvectors->show();
        print("Vector U\n");
        $left = $lancvectors->times($eigenvectors->cClone());
        $left->show();
        print("Vector S\n");
        $singular = self::getS($eigen);
        $singular->show();
        print("Transpose of vector V\n");
        $a = new Matrix($o);
        $at = $a->transpose();
        $r = $at->times($left);
        $r = $r->getMultiNorm();
        $r = self::getTransposeOfV($r);
	    $r->show();
	    $sen = self::getSentences($r->data, 2);
   	    print("Summary: \n");
        self::printSentences($sen);
    }


    public static function checkSubDiagonal($A)
    {
    	//for(int i=0; i < A.length; i++)
    	//{
    	//	for(int j=i+1; j <A.length; j++)
    	//	{
    	//		if(Math.abs(A[j][i]) > 0.001D)
        //
    	//		//if(Double.parseDouble(String.format("%.2f",A[j][i])) !=0)
    	//		return false;
    	//	}
    	//}
        //
    	//return true;
        for ($i = 0; $i < count($A); $i++) {
    		for ($j= $i + 1; $j < count($A); $j++) {
                    if (abs($A[$j][$i]) > floatval("0.001")) {
                        //if(Double.parseDouble(String.format("%.2f",A[j][i])) !=0)
                        return false;
                    }
                }
    	}
    	return true;
    }

    public static function getTransposeOfV($V)
	{
        //return V.transpose();
		return $V->transpose();
	}

    public static function getS($eigen)
    {
	    //double[][] S = new double[eigen.length][eigen.length];
	    //for(int i=0; i < eigen.length; i++)
		//{
		//   double val = Math.abs(eigen[i]);
		//   for(int j=0; j<eigen.length; j++)
		//	{
		//		 if(i==j)
		//		 {
		//			 S[i][j]= Math.sqrt(val);
		//		 }
		//	}
		//}
        //
	    //return new Matrix(S);
        $S = array();
        for ($i = 0; $i < count($eigen); $i++) {
            $val = abs($eigen[$i]);
            for ($j = 0; $j < count($eigen); $j++) {
                if ($i == $j) {
                    $S[$i][$j]= sqrt($val);
                }
            }
        }
        for ($i = 0; $i < count($eigen); $i++) {
            for ($j = 0; $j < count($eigen); $j++) {
                if (!isset($S[$i][$j])) {
                    $S[$i][$j] = 0;
                }
            }
        }
        return new Matrix($S);
    }

    public static function getV($ev)
	{
		//ListIterator<Matrix> mitr = ev.listIterator();
        //
		//Matrix V = new Matrix(ev.size(), ev.size());
		//int j=0;
		//while(mitr.hasNext())
		//{
		//	Matrix e = mitr.next();
		//	for(int i=0;i<ev.size();i++)
		//	{
		//		V.data[i][j] = e.data[i][0];
		//	}
        //
		//	j++;
        //
		//}
        //
		//return V;
		$V = new Matrix(count($ev), count($ev));
		$j = 0;
		while ($j < count($ev)) {
			$e = $ev[$j];
			for ($i = 0; $i < count($ev); $i++) {
				$V->data[$i][$j] = $e->data[$i][0];
			}
			$j++;
        }
		return $V;
	}

    public static function qRDecompose($M)
    {
        //double[][][] arrays = new double[2][][];
        //
        //int n = M.length;
        //double[][] A = (double[][]) M.clone();
        //double[][] Q = new double[n][];
        //double[][] R = new double[n][n];
        //
        //int i = 0;
        //int j = 1;
        //while(i<n)
        //{
        //
        //	R[i][i] = Math.sqrt(dot(A[i],A[i]));
        //	if(R[i][i]==0) //added
        //		R[i][i]=0.001; //added
        //
        //	Q[i] = vectorScalarMultiplication(A[i],1/R[i][i]);
        //    while(j<n)
        //    {
        //    	R[j][i] = dot(Q[i],A[j]);
        //        A[j] = vectorMinus(A[j],vectorScalarMultiplication(Q[i],R[j][i]));
        //        j++;
        //
        //     }
        //     i++;
        //     j=i+1;
        //}
        //
        //arrays[0] = Q;
        //arrays[1] = R;
        //return arrays;
        $arrays = array();
        $n = count($M);
        $A = self::copy($M);
        $Q = array();
        $R = array();
        $i = 0;
        $j = 1;
        while ($i < $n) {
            $R[$i][$i] = sqrt(self::dot($A[$i],$A[$i]));
        	if($R[$i][$i] == 0) { //added
                $R[$i][$i] = 0.001; //added
            }
        	$Q[$i] = self::vectorScalarMultiplication($A[$i], 1 / $R[$i][$i]);
            while ($j < $n) {
            	$R[$j][$i] = self::dot($Q[$i], $A[$j]);
                $A[$j] = self::vectorMinus($A[$j],
                    self::vectorScalarMultiplication($Q[$i], $R[$j][$i]));
                $j++;
            }
            $i++;
            $j = $i + 1;
        }
        for ($i = 0; $i < $n; $i++) {
            for ($j = 0; $j < $n; $j++) {
                if (!isset($R[$i][$j])) {
                    $R[$i][$j] = 0;
                }
            }
        }
        $arrays[0] = $Q;
        $arrays[1] = $R;
        return $arrays;
    }


    public static function lanczos($M)
	{
		//int n = M.length;
	    //double [][] temp = new double[1][n];
        //double[] b = new double[n+1];
        //double[] a = new double[n+1];
        //double[][] I = new double[n][n];
        //double[] zeroVector = zerorize(n);
	    //double[] columnVector;
	    //double[][] lanczosM = new double[n][];
	    ///*
	    //double [] vvv = {2,2,1,1,2,0,0,0,0,1,0,0,0,0,1,1};
	    //double bbb = Math.sqrt(dot(vvv,vvv));
        //
        //
        //vvv = vectorScalarMultiplication(vvv,1/bbb);
	    //*/
	    //int i = 0;
        //for(i = 0; i < n; i++)
	    //    for(int j = 0; j < n; j++)
	    //    	I[i][j] = (i == j) ? 1 : 0;
        //
        ////considering index 0 as 1
        //i=0;
        //b[0] = 0;
        //q[0] =zerorize(n);
        //q[0][0] = 1;
        //
        //a[0] = dot(q[0],matrixVectorMultiplication(M,q[0]));
        //temp[0] =  product(matrixMinus(M,matrixScalarMult(I,a[0])),q[0]);
        //double [] temp2 = copyV(temp[0]);
        //for(int k=0; k <=i ;k++)
  		//  temp[0] =vectorMinus(temp[0],vectorScalarMultiplication(q[k],dot(temp2,q[k])));
        //
        //b[0] = Math.sqrt(dot(temp[0],temp[0]));
        //
        //
        //q[1] = vectorScalarMultiplication(temp[0],1/b[0]);
        //i++;
        //
        //
        //while(i<n-1) // if n, index out of bound
	    //{
	    //	a[i] = dot(q[i],matrixVectorMultiplication(M,q[i]));
        //
        //
        //
	    //	temp[0] =  vectorMinus(product(matrixMinus(M,matrixScalarMult(I,a[i])),q[i]),vectorScalarMultiplication(q[i-1],b[i-1]));
	    //	double [] temp1 = copyV(temp[0]);
	    //	for(int k=0; k <=i ;k++)
	    //	{
	    //		temp[0] =vectorMinus(temp[0],vectorScalarMultiplication(q[k],dot(temp1,q[k])));
        //
	    //	}
	    //	b[i] = Math.sqrt(dot(temp[0],temp[0]));
	    //	//if(Double.isInfinite(b[i]))
        //
        //
        //
	    //	if(b[i]==0)
	    //    	b[i]=0.00001;
	    //    //if (b[i] !=0)
	    //    q[i+1] = vectorScalarMultiplication(temp[0],1/b[i]);
	    //    i++;
	    // }
        //System.out.println("!!!!");
        ////double [] bb= matrixVectorMultiplication(M,q[i]);
        //
        //for(int u=0; u<q[i].length; u++)
        //{
        //
        //	System.out.print(q[i][u]+ " ");
        //
        //}
        //System.out.println("!!!!");
        //printM(M);
        //
        //
        //a[i] = dot(q[i],matrixVectorMultiplication(M,q[i]));
        //
        //
        //
	    ////constructing return
	    ////initial
	    //i = 0;
	    //int k=0;
	    //columnVector = (double[]) zeroVector.clone();
	    //columnVector[i] = a[k];
	    //columnVector[i+1] = b[k];
	    //lanczosM[i] = columnVector;
        //
	    ////mid
	    //i++;
	    //k++;
	    //while(i<n-1)
	    //{
	    //	columnVector = (double[]) zeroVector.clone();
	    //    columnVector[i-1] = b[k-1];
	    //    columnVector[i] = a[k];
	    //    columnVector[i+1] = b[k];
	    //    lanczosM[i] = columnVector;
	    //    i++;
	    //    k++;
	    // }
        //
	    ///*
	    // System.out.println(n);
        //
        //
	    //for(int j=0; j <n;j++)
	    //	System.out.println(b[j]);
	    //System.out.println(k+ "           dsafsfddsasdafsda");
	    //*/
        //
	    ////end
        //
        //
	    //columnVector = (double[]) zeroVector.clone();
	    //columnVector[i-1] = b[k-1];
	    //columnVector[i] = a[k];
	    //lanczosM[i] = columnVector;
        //
	    //return lanczosM;
        $n = count($M);
	    $temp = array();
        $b = array();
        $a = array();
        $I = array();
        $zeroVector = self::zerorize($n);
	    $columnVector = array();
	    $lanczosM = array();
	    $i = 0;
        for ($i = 0; $i < $n; $i++) {
	        for ($j = 0; $j < $n; $j++) {
	        	$I[$i][$j] = ($i == $j) ? 1 : 0;
            }
        }
        //considering index 0 as 1
        $i = 0;
        $b[0] = 0;
        self::$q[0] = self::zerorize($n);
        self::$q[0][0] = 1;
        $a[0] = self::dot(self::$q[0], self::matrixVectorMultiplication($M, self::$q[0]));
        $temp[0] = self::product(self::matrixMinus($M, 
            self::matrixScalarMult($I, $a[0])), self::$q[0]);
        $temp2 = self::copyV($temp[0]);
        for ($k = 0; $k <= $i; $k++) {
  		    $temp[0] = self::vectorMinus($temp[0],
                self::vectorScalarMultiplication(self::$q[$k],
                self::dot($temp2,self::$q[$k])));
        }
        $b[0] = sqrt(self::dot($temp[0], $temp[0]));
        self::$q[1] = self::vectorScalarMultiplication($temp[0], 1 / $b[0]);
        $i++;
        while ($i < $n - 1) { // if n, index out of bound
	    	$a[$i] = self::dot(self::$q[$i],
                self::matrixVectorMultiplication($M, self::$q[$i]));
	    	$temp[0] =  self::vectorMinus(self::product(self::matrixMinus($M,
                self::matrixScalarMult($I, $a[$i])), self::$q[$i]),
                self::vectorScalarMultiplication(self::$q[$i - 1], $b[$i - 1]));
	    	$temp1 = self::copyV($temp[0]);
	    	for ($k = 0; $k <= $i; $k++) {
	    		$temp[0] = self::vectorMinus($temp[0],
                    self::vectorScalarMultiplication(self::$q[$k],
                    self::dot($temp1, self::$q[$k])));
	    	}
	    	$b[$i] = sqrt(self::dot($temp[0], $temp[0]));
	    	if ($b[$i] == 0) {
	        	$b[$i] = 0.00001;
            }
	        self::$q[$i + 1] =
                self::vectorScalarMultiplication($temp[0], 1 / $b[$i]);
	        $i++;
	    }
        print("!!!!");
        for ($u = 0; $u < count(self::$q[$i]); $u++) {
        	print(self::$q[$i][$u] . " ");
        }
        print("!!!!\n");
        self::printM($M);
        $a[$i] = self::dot(self::$q[$i],
            self::matrixVectorMultiplication($M, self::$q[$i]));
	    //constructing return
	    //initial
	    $i = 0;
	    $k = 0;
	    $columnVector = self::copyV($zeroVector);
	    $columnVector[$i] = $a[$k];
	    $columnVector[$i + 1] = $b[$k];
	    $lanczosM[$i] = $columnVector;
	    //mid
	    $i++;
	    $k++;
	    while ($i < $n - 1) {
	    	$columnVector = self::copyV($zeroVector);
	        $columnVector[$i - 1] = $b[$k - 1];
	        $columnVector[$i] = $a[$k];
	        $columnVector[$i + 1] = $b[$k];
	        $lanczosM[$i] = $columnVector;
	        $i++;
	        $k++;
	    }
        //end
	    $columnVector = self::copyV($zeroVector);
	    $columnVector[$i - 1] = $b[$k - 1];
	    $columnVector[$i] = $a[$k];
	    $lanczosM[$i] = $columnVector;

	    return $lanczosM;
	}

    private static function sproduct($a, $b)
    {
    	//double s =0;
    	//for (int i = 0; i < a[0].length; i++)
		//{
	    //  for (int j = 0; j < b.length; j++)
	    //  {
	    //	  s =s+ a[0][i]*b[j];
	    //  }
	    //}
    	//return s;
        $s = 0;
    	for ($i = 0; $i < count($a[0]); $i++) {
            for ($j = 0; $j < count($b); $j++) {
                $s = $s + $a[0][$i] * $b[$j];
            }
	    }
    	return s;
    }

    private static function transposeV($ds) 
    {
    	//double [][] v = new double [1][ds.length];
    	//for (int j = 0; j < ds.length; j++)
        //     v[0][j] = ds[j];
    	//return v;
        $v = array();
    	for ($j = 0; $j < count($ds); $j++) {
            $v[0][$j] = $ds[$j];
        }
    	return $v;
	}


	public static function copy($temp)
	{
        //double [][] m = new double[temp.length][temp[0].length];
		//for (int i = 0; i < temp.length; i++)
		//{
	    //  for (int j = 0; j < temp[0].length; j++)
	    //  {
	    //	  m[i][j] = temp[i][j];
	    //  }
	    //}
		//return m;
        $m = array();
		for ($i = 0; $i < count($temp); $i++) {
            for ($j = 0; $j < count($temp[0]); $j++) {
                $m[$i][$j] = $temp[$i][$j];
            }
	    }
		return $m;
	}

    public static function matrixScalarMult($M, $k)
    {
        //int n = M.length; //Number of collums
        //double[][] result = new double[n][];
        //int i = 0;
        //while(i<n)
        //    {
        //        result[i] = vectorScalarMultiplication(M[i],k);
        //        i++;
        //    }
        //return result;
        $n = count($M); //Number of collums
        $result = array();
        $i = 0;
        while ($i < $n) {
            $result[$i] = self::vectorScalarMultiplication($M[$i], $k);
            $i++;
        }
        return $result;
    }
    public static function product($M, $v)
    {
    	// int n = M.length;
        // int m = M[0].length;
        // double[] x = new double[n];
        //
        // for(int i=0; i<m; i++)
        // {
        // 	for(int j=0; j <n; j++)
        // 	{
        // 		x[i] = x[i]+M[j][i]*v[j];
        //
        // 	}
        //
        //}
        //return x;
        $n = count($M);
        $m = count($M[0]);
        $x = array();
        for ($i = 0; $i < $m; $i++) {
            for ($j = 0; $j < $n; $j++) {
                if (isset($x[$i])) {
                    $x[$i] = $x[$i] + $M[$j][$i] * $v[$j];
                } else {
                    $x[$i] = $M[$j][$i] * $v[$j];
                }
            }
        }
        return $x;
    }


    public static function dot($u, $v)
    {
        //int n = v.length;
        //double sum = 0;
        //for(int i=0; i<n; i++)
        //	sum = sum + u[i]*v[i];
        //
        //return sum;
        $n = count($v);
        $sum = floatval("0.0");
        for ($i = 0; $i < $n; $i++) {
        	$sum = $sum + $u[$i] * $v[$i];
        }
        return $sum;
    }

    public static function inverse($M)
    {
        //int m = M.length;
        //int n = M[0].length;
        //
        //if(m!=n)
        //    {System.out.println("Can't take inverse of non-square matrix!");}
        //double[][] inv = new double[m][];
        //double[] u = new double[m];
        //int i = 0;
        //while(i<m)
        //    {
        //        u[i]=0;
        //        i++;
        //    }
        //double[][][] temp = qRDecompose(M);
        //i=0;
        //while(i<m)
        //    {
        //        u[i]=1;
        //        inv[i] = qRBacksub(temp,u);
        //        u[i]=0;
        //        i++;
        //    }
        //return inv;
        $m = count($M);
        $n = count($M[0]);
        if($m != $n) {
            print("Can't take inverse of non-square matrix!\n");
        }
        $inv = array();
        $u = array();
        $i = 0;
        while ($i < $m) {
            $u[$i] = 0;
            $i++;
        }
        $temp = self::qRDecompose($M);
        $i = 0;
        while ($i < $m) {
            $u[$i] = 1;
            $inv[$i] = self::qRBacksub($temp, $u);
            $u[$i] = 0;
            $i++;
        }
        return $inv;
    }




    public static function qRBacksub($M, $b)
    {
        //int m = M[0].length;
        //int n = M[0][1].length;
        //double[] x = new double[m];
        //double[][] qm = M[0];
        //double[][] rm = M[1];
        //b = product(transpose(qm),b);
        //int i = m-1;
        //int k = m;
        //double sum = 0;
        //while(i>-1)
        //    {
        //        while(k<m)
        //            {
        //                sum = sum + rm[k][i]*x[k];
        //                k++;
        //            }
        //
        //        x[i] = (b[i] - sum)/rm[i][i];
        //        k=i;
        //        i = i-1;
        //        sum = 0;
        //    }
        //return x;
        $m = count($M[0]);
        $n = count($M[0][1]);
        $x = array();
        $qm = $M[0];
        $rm = $M[1];
        $b = self::product(self::transpose($qm), $b);
        $i = $m - 1;
        $k = $m;
        $sum = floatval("0.0");
        while ($i > -1) {
            while ($k < $m) {
                $sum = $sum + $rm[$k][$i] * $x[$k];
                $k++;
            }
            $x[$i] = ($b[$i] - $sum) / $rm[$i][$i];
            $k = $i;
            $i = $i - 1;
            $sum = floatval("0.0");
        }
        return $x;
    }

    public static function transpose($M)
    {
        //int n = M.length;
        //int m = M[0].length;
        //double[][] A = new double[m][n];
        //
        //for (int i = 0; i < n; i++)
        //    for (int j = 0; j < m; j++)
        //        A[j][i] = M[i][j];
        //return A;
        $n = count($M);
        $m = count($M[0]);
        $A = array();
        for ($i = 0; $i < $n; $i++) {
            for ($j = 0; $j < $m; $j++) {
                $A[$j][$i] = $M[$i][$j];
            }
        }
        return $A;
     }

    public static function vectorPlus($u, $v)
    {
        //int n = u.length;
        //double[] A = new double[n];
        //for(int i=0; i<n; i++)
        //{
        //	A[i] = u[i] + v[i];
        //    i++;
        //}
        //return A;
        $n = count($u);
        $A = array();
        for ($i = 0; $i < $n; $i++) {
        	$A[$i] = $u[$i] + $v[$i];
            $i++;
        }
        return $A;
    }

    public static function  matrixMinus($M, $N)
    {
        //int n = M.length;
        //double[][] A = new double[n][];
        //for(int i=0; i<n; i++)
        //{
        //    A[i] = vectorMinus(M[i],N[i]);
        //
        //}
        //return A;
        $n = count($M);
        $A = array();
        for ($i = 0; $i < $n; $i++) {
            $A[$i] = self::vectorMinus($M[$i], $N[$i]);
        }
        return $A;
    }

    public static function vectorMinus($u, $v)
    {
        //int n = u.length;
        //double[] A = new double[n];
        //for(int i=0; i<n; i++)
        //{
        //	A[i] = u[i] - v[i];
        //}
        //return A;
        $n = count($u);
        $A = array();
        for ($i = 0; $i < $n; $i++) {
        	$A[$i] = $u[$i] - $v[$i];
        }
        return $A;
    }

    public static function vectorScalarMultiplication($v, $k)
    {
        //int n = v.length;
        //double[] A = new double[n];
        //for(int i=0; i<n; i++)
        //{
        //    A[i] = v[i]*k;
        //
        //
        //}
        //return A;
        $n = count($v);
        $A = array();
        for ($i = 0; $i < $n; $i++) {
            $A[$i] = $v[$i] * $k;
        }
        return $A;
    }

    public static function matrixMultiplication($M, $N) //$M is 5/41 $N is 41 /5
    {
        //int n = M.length;
        //int m = N.length;
        //double[][] A = new double[m][];
        //for (int i=0; i<m; i++)
        //{
        //	A[i] = matrixVectorMultiplication(M,N[i]);
        //
        //}
        //return A;

        //$n = count($M);
        $m = count($N);
        $A = array();
        for ($i = 0; $i < $m; $i++) {
        	$A[$i] = self::matrixVectorMultiplication($M, $N[$i]);/*debug_print_backtrace();*/
        }
        return $A;
    }

    public static function matrixVectorMultiplication($M, $v)
    {
        //int n = M.length;
        //int m = M[0].length;
        //double[] x = new double[m];
        //
        //for(int i=0; i<m; i++)
        //{
        //	for(int j=0; j <n; j++)
        //	{
        //		x[i] = x[i]+M[j][i]*v[j];
        //
        //	if (Math.abs(Double.parseDouble(String.format("%.3f",x[i]))) == 0.0f)  //added abs
        //		x[i]= 0.0f; //should be 0
        //	}
        //
        //}
        //return x;

        $n = count($M);
        $m = count($M[0]);
        $x = array();
        for ($i = 0; $i < $m; $i++) {
            for ($j = 0; $j < $n; $j++) {
                if (!isset($v[$j])) {
                    $v[$j] = 0;
                }
                if (isset($x[$i])) {
            	    $x[$i] = $x[$i] + $M[$j][$i] * $v[$j];
                } else {
                    $x[$i] = $M[$j][$i] * $v[$j];
                }
            	if (abs(floatval(number_format($x[$i], 3))) ==
                    floatval("0.0")) { //added abs
            		$x[$i] = floatval("0.0"); //should be 0
                }


            }
        }
        return $x;
    }


    public static function zerorize($n)
	{
		//double[] z = new double[n];
	    //for(int i = 0; i<n;i++)
	    //	z[i] = 0;
	    //return z;
        $z = array();
	    for ($i = 0; $i < $n; $i++) {
	    	$z[$i] = 0;
        }
	    return $z;
	}

    public static function printM($M)
	{
    	// for(int i=0; i<M.length; i++)
        // {
        // 	for(int j=0; j <M[0].length; j++)
        // 	{
	    //		System.out.print(String.format("%.3f",M[i][j]) + " ");
	    //    }
        //
	    //	System.out.println("  ");
	    //}

        for ($i = 0; $i < count($M); $i++) {
            for ($j = 0; $j < count($M[0]); $j++) {
                print(number_format(floatval($M[$i][$j]), 3) . " ");
            }
            print("  \n");
        }
	}

    public static function copyV($temp)
    {
    	//double [] m = new double[temp.length];
		//for (int i = 0; i < temp.length; i++)
		//{
		//	m[i] = temp[i];
	    //}
		//return m;
        $m = array();
		for ($i = 0; $i < count($temp); $i++) {
			$m[$i] = $temp[$i];
	    }
		return $m;
    }

    public static function getSentences($M, $num)
    {
        //double max;
    	//LinkedList<Integer> list = new LinkedList<Integer>();
        //
    	//int j=0;
    	//for(int i=0; i < num; i++)
    	//{
        //
    	//	max = M[i][j];
    	//	for(int k = j+1; k < M[0].length; k++)
    	//	{
    	//		 if(Math.abs(M[i][k]) > Math.abs(max))
    	//		 {
    	//			 j=k;
    	//			 max = M[i][k];
        //
    	//		 }
    	//	}
    	//	list.add(new Integer(j));
    	//	j=0;
    	//}
        //
    	//return list;
        $max = 0.0;
    	$list = array();
    	$j = 0;
    	for ($i = 0; $i < $num; $i++) {
    		$max = $M[$i][$j];
    		for ($k = $j + 1; $k < count($M[0]); $k++) {
                if(abs($M[$i][$k]) > abs($max)) {
				    $j = $k;
				    $max = $M[$i][$k];
			    }
            }
    		$list[] = $j;
    		$j = 0;
    	}
    	return $list;
    }

    public static function printSentences($sens)
    {
    	//for(Integer aa : sens)
		//{
		//	//System.out.println(aa.intValue());
    	//	System.out.println(senMatrix[aa.intValue()]);
		//}
        for ($i = 0; $i < count($sens); $i++) {
            print(self::$senMatrix[$sens[$i]] . "\n");
        }
    }

    public static function words($senStrings)
    {
		//words = new HashSet <String>();
        //
    	// for(int i=0; i < senStrings.length; i++)
    	// {
    	//	  StringTokenizer parser = new StringTokenizer(senStrings[i], " \t\n\r\f.,;:!?'-()");
    	//	  while (parser.hasMoreTokens())
    	//	  {
    	//		  final String currentWord = parser.nextToken();
    	//		  if(!ignores.contains(currentWord))
    	//			  words.add(currentWord);
        //
    	//	  }
        //
    	//}
        self::$words = array();

    	 for ($i = 0; $i < count($senStrings); $i++) {
    		$parser = strtok($senStrings[$i], " \t\n\r\f.,;:!?'-()");
            while ($parser !== false) {
                $currentWord = $parser;
                //this should check for case mb_strtolower()
                if (!in_array($currentWord, self::$ignores, true) &&
                        !in_array($currentWord, self::$words, true)) {
                    self::$words[] = $currentWord;
                }
                $parser = strtok(" \t\n\r\f.,;:!?'-()");
            }
    	 }
    }

	public static function makeWSMatrix($senStrings)
	{
		//SortedSet<String> ss = new TreeSet<String>(words);
		//Object [] slist = ss.toArray();
        //
		//for(int k=0; k < slist.length; k++)
		//{
        //
		//	for(int i=0; i < senStrings.length; i++)
	    //	 {
        //
		//		int count =0;
		//		String line = senStrings[i];
		//		//System.out.println((String)slist[k]);
		//		Pattern hunter = Pattern.compile((String)slist[k]);
		//		 Matcher fit = hunter.matcher(line);
		//		while(fit.find())
		//		{
		//			count++;
		//		}
	    //		 //System.out.println(count+"");
		//		matrix[k][i]= count;
	    //	 }
        //
        //
        //
		//}
        $slist = self::$words;
        asort($slist);
		//for ($k = 0; $k < count($slist); $k++) {
        $k = 0;
                foreach ($slist as $item) {
			for ($i = 0; $i < count($senStrings); $i++) {
				$line = $senStrings[$i];
				$count = preg_match_all("/" . $item . "/u",
                    $line, $matches);
	    		self::$matrix[$k][$i] = $count;
	    	 }
                 $k = $k + 1;
		}
	}
	//fills in the senMatrix string array and senten linked list
	private static function countLines($line)
	{
		  //String[] sentences = line.split("[.?!]+\\s*");
		  ///*
		  //for(String a : sentences){
		  //  System.out.println(a);
		  //}
		  //*/
		  //Pattern pat = Pattern.compile("[.?!]+\\s*");
		  //Matcher mat = pat.matcher(line);
          //
		  //  int start = 0, end = 0;
		  //  while(mat.find()) {
		  //    start = end;
		  //    end = mat.end();
		  //    senten.add(line.substring(start, end));
		  //  }
		  //senMatrix = new String[senten.size()];
		  //int in=0;
		  //for(String s: senten)
		  //{
		  //	  senMatrix[in] = s;
		  //	  in++;
		  //}
        self::$senten = preg_split(
            '/[.?!]+\\s*/ui',
            $line, 0, PREG_SPLIT_NO_EMPTY);
        self::$senMatrix = self::$senten;
	}

	public static function makeFinalWSMatrix()
	{
		//BufferedReader r = null;
		// String thisLine;
   	  	//try {
		//	r = new BufferedReader(new FileReader(".\\a.txt"));
   	  	//} catch (FileNotFoundException e1) {
   		//   e1.printStackTrace();
   	  	//}
   	  	//String lines ="";
   	  	//try
   	  	//{
   	  	//	while ((thisLine = r.readLine()) != null)
   	  	//	{
   	  	//		lines = lines+thisLine;
		//    }
   	    //}catch (IOException e)
   	    //{
   	    //	e.printStackTrace();
   	    //}
   	    //countLines(lines);
   	    ////System.out.println(senMatrix.length+"");
   	    //words(senMatrix);
   	    ////System.out.println(words.size()+"");
   	    //SortedSet<String> ss = new TreeSet<String>(words);
   	    //Object [] slist = ss.toArray();
        //
   	    ///*
   	    //for(Object a: slist)
   	    //{
   	    //	System.out.println(a);
   	    //}
		//*/
   	    //matrix = new double[words.size()][senMatrix.length];
   	    //makeWSMatrix(senMatrix);
        //
   	    //for(int m =0; m <matrix.length; m++)
   	    //{
   	    //	for(int n=0; n <matrix[0].length;n++)
   	    //		System.out.print(matrix[m][n]+ "  ");
   	    //	System.out.println("");
   	    //}
		$thisLine = "";
        $lines = "";
		$r = file("c:/temp/a.txt");
        for ($i = 0; $i < count($r); $i++) {
            $thisLine = $r[$i];
            $lines = $lines . $thisLine;
        }
   	    self::countLines($lines);
        self::words(self::$senMatrix);
   	    self::$matrix = array();
   	    self::makeWSMatrix(self::$senMatrix);
   	    print("AAT\n");for ($m = 0; $m < count(self::$matrix); $m++) {
   	    	for ($n = 0; $n < count(self::$matrix[0]); $n++) {
                print(number_format(self::$matrix[$m][$n], 1) . "  ");
            }
   	    	print("\n");
   	    }
	}

	public static function makeIgnorelists()
	{
		//ignores = new HashSet<String>();
		//BufferedReader r = null;
		//String thisLine;
  	  	//try {
		//	r = new BufferedReader(new FileReader(".\\ignore.txt"));
  	  	//} catch (FileNotFoundException e1) {
  		//   e1.printStackTrace();
  	  	//}
  	    //String lines ="";
  	  	//try
  	  	//{
  	  	//	while ((thisLine = r.readLine()) != null)
  	  	//	{
  	  	//		ignores.add(thisLine);
		//    }
  	    //}catch (IOException e)
  	    //{
  	    //	e.printStackTrace();
  	    //}
        
        //we need these to get the stop words based on the locale
        $r = file("c:/temp/ignore.txt");
        for ($i = 0; $i < count($r); $i++) {
            $thisLine = $r[$i];
            self::$ignores[] = trim($thisLine);
        }
       /* self::$ignores = ['a','able','about','above','abst',
        'accordance','according','based','accordingly','across','act',
        'actually','added','adj','affected','affecting','affects','after',
        'afterwards','again','against','ah','all','almost','alone','along',
        'already','also','although','always','am','among','amongst','an','and',
        'announce','another','any','anybody','anyhow','anymore','anyone',
        'anything','anyway','anyways','anywhere','apparently','approximately',
        'are','aren','arent','arise','around','as','aside','ask','asking','at',
        'auth','available','away','awfully','b','back','be','became','because',
        'become','becomes','becoming','been','before','beforehand','begin',
        'beginning','beginnings','begins','behind','being','believe','below',
        'beside','besides','between','beyond','biol','both','brief','briefly',
        'but','by','c','ca','came','can','cannot','cant','cause','causes',
        'certain','certainly','co','com','come','comes','contain','containing',
        'contains','could','couldnt','d','date','did','didnt',
        'different','do','does','doesnt','doing',
        'done','dont','down','downwards',
        'due','during','e','each','ed','edu','effect','eg','eight','eighty',
        'either','else','elsewhere','end',
        'ending','enough','especially','et',
        'et-al','etc','even','ever','every',
        'everybody','everyone','everything'
        ,'everywhere','ex','except','f','far','few','ff','fifth','first',
        'five','fix','followed','following','follows','for','former',
        'formerly','forth','found','four','from','further','furthermore',
        'g','gave','get','gets','getting','give','given','gives','giving','go',
        'goes','gone','got','gotten','h','had','happens','hardly','has','hasnt',
        'have','havent','having','he','hed','hence','her','here','hereafter',
        'hereby','herein','heres','hereupon','hers','herself','hes','hi','hid',
        'him','himself','his','hither','home','how','howbeit',
        'however', 'http', 'https', 'hundred','i','id','ie','if','ill',
        'im','immediate','immediately',
        'importance','important','in','inc','indeed','index','information',
        'instead','into','invention','inward','is','isnt','it','itd','itll',
        'its','itself','ive','j','just','k','keep','keeps',
        'kept','kg','km','know',
        'known','knows','l','largely','last','lately',
        'later','latter','latterly',
        'least','less','lest','let','lets','like','liked','likely','line',
        'little','ll','look','looking','looks','ltd','m','made','mainly','make',
        'makes','many','may','maybe','me','mean','means','meantime','meanwhile',
        'merely','mg','might','million','miss','ml','more','moreover','most',
        'mostly','mr','mrs','much','mug','must','my','myself','n','na','name',
        'namely','nay','nd','near','nearly','necessarily','necessary','need',
        'needs','neither','never','nevertheless','new','next',
        'nine','ninety','no',
        'nobody','non','none','nonetheless','noone',
        'nor','normally','nos','not',
        'noted','nothing','now','nowhere','o','obtain',
        'obtained','obviously','of',
        'off','often','oh','ok','okay','old','omitted','on','once','one','ones',
        'only','onto','or','ord','other','others',
        'otherwise','ought','our','ours',
        'ourselves','out','outside','over','overall','owing','own','p','page',
        'pages','part','particular','particularly',
        'past','per','perhaps','placed',
        'please','plus','poorly','possible','possibly','potentially','pp',
        'predominantly','present','previously',
        'primarily','probably','promptly',
        'proud','provides','put','q','que','quickly','quite','qv','r','ran',
        'rather','rd','re','readily','really','recent','recently','ref','refs',
        'regarding','regardless','regards','related','relatively','research',
        'respectively','resulted','resulting',
        'results','right','run','s','said',
        'same','saw','say','saying','says','sec',
        'section','see','seeing','seem',
        'seemed','seeming','seems',
        'seen','self','selves','sent','seven','several',
        'shall','she','shed','shell',
        'shes','should','shouldnt','show','showed','shown','showns','shows',
        'significant','significantly','similar','similarly','since',
        'six','slightly',
        'so','some','somebody','somehow','someone','somethan',
        'something','sometime',
        'sometimes','somewhat','somewhere','soon',
        'sorry','specifically','specified',
        'specify','specifying','still','stop','strongly','sub','substantially',
        'successfully','such','sufficiently','suggest','sup','sure','t','take',
        'taken','taking','tell','tends','th','than',
        'thank','thanks','thanx','that',
        'thatll','thats','thatve','the','their',
        'theirs','them','themselves','then',
        'thence','there','thereafter','thereby','thered','therefore','therein',
        'therell','thereof','therere','theres','thereto','thereupon','thereve',
        'these','they','theyd','theyll','theyre',
        'theyve','think','this','those',
        'thou','though','thoughh','thousand','throug',
        'through','throughout','thru',
        'thus','til','tip','to','together','too',
        'took','toward','towards','tried',
        'tries','truly','try','trying','ts','twice','two','u','un','under',
        'unfortunately','unless','unlike','unlikely','until','unto','up','upon',
        'ups','us','use','used','useful','usefully','usefulness','uses','using',
        'usually','v','value','various','ve','very',
        'via','viz','vol','vols','vs',
        'w','want','wants','was','wasnt','way','we',
        'wed','welcome','well','went',
        'were','werent','weve','what','whatever',
        'whatll','whats','when','whence',
        'whenever','where','whereafter','whereas','whereby','wherein','wheres',
        'whereupon','wherever','whether','which','while','whim','whither','who',
        'whod','whoever','whole','wholl','whom','whomever','whos','whose','why',
        'widely','willing','wish','with','within',
        'without','wont','words','world',
        'would','wouldnt','www','x','y','yes','yet','you','youd','youll','your',
        'youre','yours','yourself','yourselves','youve','z','zero'];*/
	}
}