Помогите исправить ошибки

Тема в разделе "PHP", создана пользователем []\/[]4|<|_4|_||), 26 авг 2009.

Статус темы:
Закрыта.
Модераторы: latteo
  1. []\/[]4|<|_4|_||)

    []\/[]4|<|_4|_||) Создатель

    Регистр.:
    14 июл 2009
    Сообщения:
    25
    Симпатии:
    6
    Нашел на просторах сети вот такой скрипт:
    PHP:
    <?
        
    /*
         * class for Markov's chains realization
         * (c) Andrey, somemilk.org@gmail.com, 2006
         *
         * Typical usage:
         * $m = new Markov(2); // 2 - markov chain length, depends on source
         *                     // file size, 2 for small files, 3-4 for large ones
         * $m->initFromFile("somefile.txt") or die("shit happens.");
         * $bullshit = $m->generate(2000); // generates bullshit 2000 chars long.
         * $m->initFromString(file_get_contents("somefile.txt")) or die("shit happens.");
         * $bullshit = $m->generate(100, MARKOV_OPT_WORDS); // generates bullshit 100 words long.
         */

        
    define("MARKOV_OPT_CHARACTERS"1); // option: character limit for generate()
        
    define("MARKOV_OPT_WORDS",      2); // option: word limit for generate()
        
    define("MARKOV_DEFAULT_K",      3); // default Markov chain length
        
    define("MARKOV_TIME_LIMIT",     120); // time limit for initFromFile()

        
    define("MARKOV_MAX_RECURSION_LEVEL",     20);

        class 
    Markov
        
    {
            var 
    $k MARKOV_DEFAULT_K;
            var 
    $k_sets = array();
            var 
    $split_method MARKOV_OPT_WORDS;

            function 
    Markov($k$split_method MARKOV_OPT_WORDS)
            {
                
    $this->$k;
                
    $this->split_method $split_method;
            }

            
    /*
             * inits class' Markov k-sets with a text from a text file.
             *
             * returns true on success, false on failure
             */
            
    function initFromFile($filename)
            {
                
    set_time_limit(MARKOV_TIME_LIMIT);

                if(!
    is_readable($filename)) return false;

                
    $fc file_get_contents($filename);
                
    $this->initFromString($fc);

                return 
    true;
            }

            
    /*
             * inits class' Markov k-sets with a text from a string.
             *
             * returns true on success, false on failure
             */
            
    function initFromString($str)
            {
                if(
    strlen($strk) return false;
                
    $this->k_sets = array();
                
    $set = array();

                if(
    $this->split_method == MARKOV_OPT_WORDS)
                {
                    
    $words preg_split('/\s+/'trim($str));
                    if(
    count($wordsk) return false;
                    foreach(
    $words as $w)
                    {
                        
    $this->_addToSets($set$w);
                    }
                }
                else
                {
                    for(
    $i=0$i_addToSets($setsubstr($str$i1));
                    }
                }

                return 
    true;
            }

            function 
    _addToSets(&$set$w)
            {
                
    $set[] = $w;
                if(
    count($set) == $this->k)
                {
                    
    $key "";
                    for(
    $i=0$ik 1$i++)
                    {
                        
    $key .= "[\$set[$i]]";
                    }
                    eval(
    "\$this->k_sets{$key}[] = \$set[$i];");
                    
    array_shift($set);
                }
            }

            
    /*
             * you must re-init the class after calling setK()
             */
            
    function setK($k) { $this->$k$this->k_sets = array(); }

            
    /*
             * generates random word $length characters long
             * (available only if split_method is MARKOV_OPT_CHARACTERS
             */
            
    function getWord($length)
            {
                if(
    $this->split_method != MARKOV_OPT_CHARACTERS) return false;
                
    $res "";
                
    $set = array();
                while(
    strlen($resk)
                    {
                        
    $word array_shift($set);
                        if(
    preg_match('/[\s\.,:\?!;"]/'$word))
                        {
                            
    $res "";
                            continue;
                        }

                        
    $res .= $word;
                    }

                    if(
    strlen($res) == $length) break;

                    if(
    count($set)) $element =& $this->k_sets[$set[0]];
                    else 
    $element null;
                    foreach(
    $set as $i => $word)
                    {
                        if(isset(
    $element[$word])) $element =& $element[$word];
                    }
                    if(
    is_array($element))
                    {
                        
    $word $this->random_key($element);
                        if(
    is_array($element[$word])) $set[] = $word;
                        else 
    $set[] = $this->random_value($element);
                    }
                    else 
    $set[] = $this->random_key($this->k_sets);

                }
                return 
    $res;
            }

            
    /*
             * generates Markov's string, max $how_much long,
             * in words (if $how==MARKOV_OPT_WORDS)
             * or in characters (if $how==MARKOV_OPT_CHARACTERS, default)
             */
            
    function generate($how_much$how=MARKOV_OPT_CHARACTERS$sentences=false$recursion_level=0)
            {
                
    $res "";
                
    $n_words 0;
                
    $set = array();
                
    $sentence_started false;
                while((
    $how == MARKOV_OPT_CHARACTERS && (strlen($res) < $how_much)) ||
                      (
    $how == MARKOV_OPT_WORDS && ($n_words k)
                    {
                        
    $res .= ($word array_shift($set));
                        if(
    $this->split_method == MARKOV_OPT_WORDS)
                        {
                            
    $res .= " ";
                            
    $n_words++;
                        }
                        elseif(
    preg_match('/[\s\.,:\?!;"]/'$word))
                        {
                            
    $n_words++;
                        }
                        if(
    $sentences && !$sentence_started && preg_match('/\.$/'$word))
                        {
                            
    $sentence_started true;
                            
    $res "";
                            
    $n_words 0;
                        }
                    }

                    if(
    count($set)) $element =& $this->k_sets[$set[0]];
                    else 
    $element null;
                    foreach(
    $set as $i => $word)
                    {
                        if(isset(
    $element[$word])) $element =& $element[$word];
                    }
                    if(
    is_array($element))
                    {
                        
    $word $this->random_key($element);
                        if(
    is_array($element[$word])) $set[] = $word;
                        else 
    $set[] = $this->random_value($element);
                    }
                    else 
    $set[] = $this->random_key($this->k_sets);

                }
                
    $res rtrim($res);
                if(
    $sentences)
                {
                    
    $res preg_replace('/\.[^\.]+$/''.'$res);
                    if(!
    preg_match('/\.$/'$res) && ($recursion_level generate($how_much$how$sentences$recursion_level+1));
                }
                return 
    $res;
            }

            
    /*
             * helper function, returns random array key
             */
            
    function random_key(&$array)
            {
                
    $rand mt_rand(0count($array) - 1);
                
    $i 0;
                foreach(
    $array as $key => $value) if($i++ == $rand) return $key;
            }
            
    /*
             * helper function, returns random array value
             */
            
    function random_value(&$array)
            {
                
    $rand mt_rand(0count($array) - 1);
                
    $i 0;
                foreach(
    $array as $key => $value) if($i++ == $rand) return $value;
            }
        }
    ?>
    Подключаю его, а в нем ошибок куча. Помогите исправить плз.
     
  2. saen

    saen

    Регистр.:
    6 авг 2006
    Сообщения:
    756
    Симпатии:
    129
    Конкретнее давай что за ошибки?
     
  3. Dizeloid

    Dizeloid Постоялец

    Регистр.:
    17 июл 2009
    Сообщения:
    68
    Симпатии:
    3
    Попробуйте отловить ошибки вот этой штукой. Мне очень помогает.
     
  4. WerewolfGSM

    WerewolfGSM

    Регистр.:
    4 дек 2006
    Сообщения:
    257
    Симпатии:
    11
    Какие ошибки? HTML или PHP? Какие версии ПХП у тебя? Инфорацию в студию пожалуйста.
     
  5. t0wer

    t0wer BlackHerald

    Регистр.:
    24 июн 2008
    Сообщения:
    733
    Симпатии:
    422

    PHP:
    <?php 
        
    Class MarkovChains
        
    {
            var 
    $prepared = array();
            function 
    MarkovChains($source)
            {
                
    $source strtolower($source);
                  
    $source str_replace(array ("? ""! "), "."$source);
                  
    $source str_replace(array (" -""- ""\t""\r""\n""|",  "&"'\\''/',  " :"" ;""©""·"), ' '$source);
                  
    $source str_replace(array (")""(""]""[""'""\""'*''•''~''{''}'), ''$source);
                  
    $source str_replace(" ,"","$source);
                  
    $source preg_replace("~(\s+\d{1,2}\s+)|(\w*\.\w+)~"" "$source);
                  
    $source preg_replace("~\s+~"" "$source);
                
    $sentens explode('. '$source); 
                  
    $count_sentens count($sentens);
                  for (
    $j=0$j<$count_sentens; ++$j)
                  {
                        
    $sentens[$j] = explode(' '$sentens[$j]); 
                        
    $count_words count($sentens[$j]) - 1;
                        for (
    $i=0$i $count_words; ++$i)
                        {
                              
    $prefix $sentens[$j][$i];
                              
    $this->prepared[$prefix][] = $sentens[$j][$i+1];
                        }
                  }
                
    $keys array_keys($this->prepared);
                  foreach (
    $keys as $key)
                  {
                        
    $this->prepared[$key] = array_unique($this->prepared[$key]);
                  }
            }
            function 
    GenerateText($size)
            {
                
    $result_count 0;
                  for (
    $j=0$result_count $size; ++$j)
                  {
                        
    $prev array_rand($this->prepared); 
                        
    $num  mt_rand(512); 
                        for (
    $i=0$i<$num; ++$i)
                        {    
                        
    $sents[$j][$i] = $prev;
                              ++
    $result_count;
                              
    $p $this->prepared[$prev][mt_rand(0count($this->prepared[$prev]) - 1)];
                              if (
    $p == ''$p array_rand($this->prepared);
                              
    $prev $p;
                              if (
    $prev == '') break 2;
                        }
                  }
                foreach (
    $sents as $sent)
                  {
                        
    $count_word=count($sent);
                        if (
    $count_word<=2) continue;
                        if (
    strlen($sent[$count_word-1]) < 4) unset($sent[$count_word-1]);
                        
    $sent[$count_word-2] = rtrim($sent[$count_word-2], ",:;");
                        
    $sent[$count_word-1] = rtrim($sent[$count_word-1], ",:;");
                        
    $output .= ucfirst(implode(' '$sent)).'. ';
                  }
                
    $output str_replace(' .''.'$output);
                return 
    $output;
            }
        }
        
    //Example
        //$source = file_get_contents("text.txt");
        //$markov = new MarkovChains($source);
        //$result = $markov->GenerateText(500);
        //echo $result;
    ?>
     
    []\/[]4|<|_4|_||) нравится это.
Статус темы:
Закрыта.