php moxing,解释结构模型的php代码

php代码

/*************************************************************************************************/* 本程序是专门用来处理解释结构模型ISM中相关的矩阵运算，主要概念有如

* 算子：

* 单位矩阵：

* 可达矩阵：

* 可达步骤以及对应的矩阵：

* λ 截距：

* 先行集合：

* 可达集合：

* 骨架矩阵：

* 要素抽取获得缩减矩阵：

*/

class ism_mat

{

//全局变

var $array_number = array(); //以数组形式表达矩阵

var $element = 1; //布尔矩阵中的要素 默认为1，表示1*1的矩阵

var $numColumns = 0; //矩阵列的数目 这个是冗余的参数本矩阵就是等于要素的

var $numRows = 0; //矩阵行的

var $element_name= array(); // 要素的名称

/***********************************************************************

*构造 ism_matrix 的类型

* 参数类型 ( 二维数组，整型) (array(1=>array(1,2,2,3,)2=>array(4,6,5,7)),6)

* 对值大于1的强制转换成模糊数字型

* new ism_mat(6) 类似的给出一个6*6的矩阵

***********************************************************************/

function ism_mat()

{

$nArgs = func_num_args();

if ($nArgs == 0)

{

$array_number=array();

$this->element = 3;

$this->numRows = 3; //行 从 获得第二

$this->numColumns = 3;//列 从 第二个参数获

}

if ($nArgs == 1 )

{

if(is_array(func_get_arg(0)))

{

$array_number = func_get_arg(0);

}

else

{

if(is_int(func_get_arg(0)))

{

$this->element = func_get_arg(0);

}

$array_number=array();

}

}

if($nArgs == 2) //如果是2

{

$array_number = func_get_arg(0);

$this->element = func_get_arg(1); //要素 从第二个参数获

$this->numRows = func_get_arg(1); //行 从 获得第二

$this->numColumns = func_get_arg(1);//列 从 第二个参数获

}

if($nArgs > 2) //如果是3

{

$array_number = func_get_arg(0);

$this->element = func_get_arg(1); //要素 从第二个参数获

$this->numRows = func_get_arg(1); //行 从 获得第二

$this->numColumns = func_get_arg(1);//列 从 第二个参数获

$this->element_name=func_get_arg(2);//要素的名称

}

$numberColumns = 0; //

$numberRows = 0; //

if(empty($array_number) == false) //数组内容不为空

{

foreach($array_number as $i => $rows) //检查

{

foreach($rows as $j => $number) //如果值为0则移除

{

if($number != 0 && abs($number)<=1 )

{

$this->array_number[$i][$j] = $number;

}

if ($number != 0 && abs($number)>1)

{

$this->array_number[$i][$j] = 1;

}

if($j >= $numberColumns)

{

$numberColumns = $j;

}

}

if($i >=$numberRows)

{

$numberRows = $i;

}

}

//php的数组下标定义为0开始，加1符合数学上的习惯

$numberRows++;

$numberColumns++;

}

$name_count=count($this->element_name);

$maxlen=max($numberRows , $this->numRows,$numberColumns ,$this->numColumns,$this->element,$name_count);

$this->numRows = $maxlen;

$this->numColumns = $maxlen;

$this->element = $maxlen;

if($name_count <=$maxlen)

{

$i=0;

$name=$this->element_name;

//print_r($name);

unset($this->element_name);

foreach($name as $v)

{

$this->element_name[$i]=$v;

$i++;

}

for ($i=$name_count;$i

{

$this->element_name[$i]=$i.'号';

}

}

}

/***************************************************************

* ISM矩阵变换

* 输入新的名字数组$arrayname(name1…… name_n )

* 这个名字数组必须与原来的 ism对象中的 一样，顺序

* 根据新的排列，返回一个新的 ism矩阵

**************************************************************/

function transform_by_name($new_name_array)

{

$old_name_array=$this->element_name;

$numb=$this->array_number;

$result = array_diff($old_name_array, $new_name_array);

$e=$this->element;

if(empty($result)== true && $this->element==count($new_name_array))

{

//检查输入的名字列表是

$get_name_old_num=array();

for($k=0;$k

{

//获得名称原来的序号

$get_name_old_num[$k] = array_search($new_name_array[$k], $old_name_array);

}

for($i=0;$i

{

for($j=0;$j

{

$old_x=$get_name_old_num[$i];

$old_y=$get_name_old_num[$j];

if(empty($numb[$old_x][$old_y]) == false)

{

$new_array_number[$i][$j]=1;

}

else

{

unset($new_array_number[$i][$j]);

}

}

}

}

else

{

echo" 输入的名字跟原来变换的不同，所有的名字要相同！";

}

$new_mat=new ism_mat($new_array_number,$e,$new_name_array);

return $new_mat ;

}

/***************************************************************

*元素互换，获得一个新的矩阵

* 0 7 表示第1个与 第8个交换

**************************************************************/

function exchange_e_by_num($num_1, $num_2)

{

$e=$this->element;

$new_mat=new ism_mat($this->array_number,$e,$this->element_name);

if($num_1

{

for($i=0;$i

{

if($i!=$num_1 and $i!=$num_2)

{

$new_mat->array_number[$num_2][$i]=$this->array_number[$num_1][$i];

$new_mat->array_number[$i][$num_2]=$this->array_number[$i][$num_1];

$new_mat->array_number[$num_1][$i]=$this->array_number[$num_2][$i];

$new_mat->array_number[$i][$num_1]=$this->array_number[$i][$num_2];

}

else

{

$new_mat->array_number[$num_2][$num_1]=$this->array_number[$num_1][$num_2];

$new_mat->array_number[$num_2][$num_2]=$this->array_number[$num_1][$num_1];

$new_mat->array_number[$num_1][$num_1]=$this->array_number[$num_2][$num_2];

$new_mat->array_number[$num_1][$num_2]=$this->array_number[$num_2][$num_1];

}

}

$new_mat->element_name[$num_2]=$this->element_name[$num_1];

$new_mat->element_name[$num_1]=$this->element_name[$num_2];

}

return $new_mat ;

}

/***************************************************************

* 通过元素名称交换，获得 ism中的布尔矩阵的值，返回矩阵中所有的

**************************************************************/

function exchange_e_by_name($name_1, $name_2)

{

$e=$this->element;

$num_1 = array_search($name_1, $this->element_name);

$num_2 = array_search($name_2, $this->element_name);

//print_r($num_2);

if( $num_1>=0 and $num_2>=0 )

{

$new_mat=$this->exchange_e_by_num($num_1,$num_2);

//print_r($new_mat);

}

else

{

echo "输入的要换的要素名称有错误，滴点眼药水，看看。为了不影响您计算，返回原来的矩阵";

//$new_mat=$this;

//$new_mat=new ism_mat($this->array_number,$this->element,$this->element_name);

}

return $new_mat ;

}

/***************************************************************

* 获得 ism中的布尔矩阵的值，返回矩阵中所有的

**************************************************************/

function get_data()

{

for($i = 0; $i < $this->element; $i++)

{

for($j = 0; $j < $this->element; $j++)

{

if(empty($this->array_number[$i][$j]) == false)

{

$the_numbers[$i][$j] = $this->array_number[$i][$j];

$the_numbers[$i][$j]>=1 ? 1: $the_numbers[$i][$j];

$the_numbers[$i][$j]<=0.0001? 0: $the_numbers[$i][$j];

$the_numbers[$i][$j]=='' ? 0:$the_numbers[$i][$j];

}

else

{

$the_numbers[$i][$j] = 0;

}

}

}

return $the_numbers;

}

/***************************************************************

* 得到相乘矩阵 即原始矩阵+单位矩阵

**************************************************************/

function b()

{

for($i = 0; $i < $this->element; $i++)

{

for($j = 0; $j < $this->element; $j++)

{

if(empty($this->array_number[$i][$j]) == false )

{

$the_numbers[$i][$j] = $this->array_number[$i][$j];

$the_numbers[$i][$j]>=1?1:$the_numbers[$i][$j];

$the_numbers[$i][$j]<=0?0:$the_numbers[$i][$j];

}

else

{

$the_numbers[$i][$j] = 0;

}

}

}

for($i = 0; $i < $this->element; $i++)

{

$the_numbers[$i][$i]=1;

}

$the_b_mat=new ism_mat($the_numbers,$this->element,$this->element_name);

return $the_b_mat;

}

/**************************************************************************

* 返回某个矩阵坐标的值 即对应行与列元素的值，注意下标

*************************************************************************/

function get_value($i, $j)

{

$the_value = 0;

if($i-1 < $this->get_num_rows() and $j-1 < $this->get_num_columns())

{

if(empty($this->array_number[$i-1][$j-1]) == false)

{

$the_value = $this->number[$i-1][$j-1];

}

}

else

{

echo "
\n\n\n 搞错了注意参数，超过了ism矩阵中的要素的值的范围 !\n\n\n\
";

}

return $the_value;

}

/**************************************************************************

* 返回ism_矩阵的求解可达矩阵,过程中所有的矩阵

* 返回矩阵格式对象

* 格式为 array(1=>ism_mat(data1),

2=>ism_mat(data2),……)

*************************************************************************/

function get_r_mat_step_data()

{

$i=1;

$i_mat= $this->i();

$b=$this->plus($i_mat);

$r_mat_step_data[1]=$b;

while ($i < 50 and $r_mat_step_data[$i]!=$r_mat_step_data[$i-1])

{

$r_mat_step_data[$i+1]=$r_mat_step_data[$i]->muti($b);

$i++;

}

return $r_mat_step_data;

}

/**************************************************************************

* 返回可达矩阵

* 矩阵

*************************************************************************/

function r_mat()

{

$r_step=$this->get_r_mat_step_data();

$the_last=$r_step[count($r_step)-1];

$the_reached_matrix =new ism_mat ($the_last->array_number,$the_last->element,$the_last->element_name);

return $the_reached_matrix;

}

/**************************************************************************

* 返回层次分解模型的各个步骤，超级傻逼的一个过程！！！此过程为结果优先

* 返回 一个数组

* 格式为 array(1=>array( 可达矩阵(), 可达矩阵转置， 上面两个的交集， lev_e=),

* 2=>array( 可达矩阵(), 可达矩阵转置， 上面两个的交集， lev_e=),

* )

*

*************************************************************************/

function get_r_f_level_data()

{

if($this->is_r_mat($this)==true)

{

$reached_matrix=$this;

}

else

{

$reached_matrix=$this->r_mat();//可达矩阵

}

$reached_transpose_matrix = $reached_matrix->transpose();//可达矩阵的转置矩阵

$reached_meet_matrix = $reached_matrix->meet($reached_transpose_matrix);//交集矩阵

$array_e_zero =array();

//$the_mat_level_data[1]= array(r_mat=>$reached_matrix,t_mat=>$reached_transpose_matrix,m_mat=>$reached_meet_matrix,lev=>$level_element);

//print_r($the_mat_level_data[1]);

$j=1;

do

{

$array_e_zero=array();

for ($len=0;$lenelement;$len++)

{

$a_line = $reached_matrix->array_number[$len];

$meet_line = $reached_meet_matrix->array_number[$len];

if($a_line==$meet_line and empty($a_line)==false)

{

$array_e_zero[$len]=$len;

}

}

if (empty($array_e_zero)==false)

{

$the_mat_level_data[$j][r_mat]=$reached_matrix;

$the_mat_level_data[$j][t_mat]=$reached_transpose_matrix;

$the_mat_level_data[$j][m_mat]=$reached_meet_matrix;

$the_mat_level_data[$j][lev]=$array_e_zero;

$reached_matrix = $reached_matrix->set_e_zero($array_e_zero);

$reached_transpose_matrix = $reached_transpose_matrix->set_e_zero($array_e_zero);

$reached_meet_matrix=$reached_meet_matrix->set_e_zero($array_e_zero);

}

$j++;

}

while( empty($array_e_zero)==false and $j <= $reached_matrix->element);

return $the_mat_level_data;

}

/**************************************************************************

* 返回层次分解模型的各个步骤，的一个过程！！！此过程为原因优先g_frist_

* 返回 一个数组

* 格式为 array(1=>array( 可达矩阵(), 可达矩阵转置， 上面两个的交集， lev_e=),

* 2=>array( 可达矩阵(), 可达矩阵转置， 上面两个的交集， lev_e=),

* )

*************************************************************************/

function get_g_f_level_data()

{

if($this->is_r_mat($this)==true)

{

$reached_matrix=$this;

}

else

{

$reached_matrix=$this->r_mat();//可达矩阵

}

$reached_transpose_matrix = $reached_matrix->transpose();//可达矩阵的转置矩阵

$reached_meet_matrix = $reached_matrix->meet($reached_transpose_matrix);//交集矩阵

$array_e_zero =array();

//$the_mat_level_data[1]= array(r_mat=>$reached_matrix,t_mat=>$reached_transpose_matrix,m_mat=>$reached_meet_matrix,lev=>$level_element);

//print_r($the_mat_level_data[1]);

$j=1;

do

{

$array_e_zero=array();

for ($len=0;$lenelement;$len++)

{

$a_line = $reached_transpose_matrix->array_number[$len];//就这个地方

$meet_line = $reached_meet_matrix->array_number[$len];

if($a_line==$meet_line and empty($a_line)==false)

{

$array_e_zero[$len]=$len;

}

}

if (empty($array_e_zero)==false)

{

$the_mat_level_data[$j][r_mat]=$reached_matrix;

$the_mat_level_data[$j][t_mat]=$reached_transpose_matrix;

$the_mat_level_data[$j][m_mat]=$reached_meet_matrix;

$the_mat_level_data[$j][lev]=$array_e_zero;

$reached_matrix = $reached_matrix->set_e_zero($array_e_zero);

$reached_transpose_matrix = $reached_transpose_matrix->set_e_zero($array_e_zero);

$reached_meet_matrix=$reached_meet_matrix->set_e_zero($array_e_zero);

}

$j++;

}

while( empty($array_e_zero)==false and $j <= $reached_matrix->element);

return $the_mat_level_data;

}

/**************************************************************************

* 返回ism的区域划分，也就是，系统个数，各个系统有什么要素组成

* 返回二维数组，

*************************************************************************/

function get_group()

{

$arraygroup=array();

$bmatrix= $this->b();

$transpose=$this->transpose();

$u=$bmatrix->plus($transpose);

$g=$u->r_mat();

$data=$g->get_data();

for ($k=0;$k

{

$is_in=false;

for($j=0;$j

{

if($data[$j]==$data[$k])

{

$is_in=true;

}

}

if($is_in==false)

{

$arraydata[$k]=$data[$k];

}

}

$i=0;

foreach($arraydata as $v1)

{

$j=0;

foreach($v1 as $key=>$v)

{

if($v==1)

{

$arraygroup[$i][$j]=$key;

}

$j++;

}

$i++;

}

return $arraygroup;

}

/*****************************************************************************

* 获得矩阵内最大的独立系统

* 返回其中的

***************************************************************************/

function get_max_group_mat ()

{

$arraygroup=$this->get_group();

$size=array();

foreach($arraygroup as $k=>$v)

{

$size[$k]=count($v);

}

$max_group_size=max($size);

$max_group_size_index=array_search($max_group_size, $size);

$max_group=$arraygroup[$max_group_size_index];

$the_tmp_mat= $this;

$the_max_group_mat=$the_tmp_mat->group_mat_by_num ($max_group);

$the_max_group_mat= new ism_mat($the_max_group_mat->array_number,$the_max_group_mat->element,$the_max_group_mat->element_name);

return $the_max_group_mat;

}

/*****************************************************************************

* 输入一个数组

* 或者输入一组 数字的系列。 如 0、1、2、3、4、没有检查重复度，请调用的时候自动检测

* 矩阵是下标以 0开始的

* 返回 矩阵，要素是里面对应的要素的

* 给出一个新的矩阵， 要素为输入的里面的要素

***************************************************************************/

function group_mat_by_num ()

{

$nArgs = func_num_args();

//print_r($nArgs);

if ($nArgs == 0)

{

echo "没有输入的要素";

}

if ($nArgs == 1 )

{

if(is_array(func_get_arg(0)))

{

$array_num = func_get_arg(0);

}

elseif(is_int(func_get_arg(0)))

{

$array_num[0] =func_get_arg(0);

}

else

{

echo"输入要素的格式错误";

}

}

if ( $nArgs >1 )

{

for($i=0;$i

{

$array_num[$i]=func_get_arg($i);

}

}

//对输入的要素的名称排序

sort($array_num);

for ($i=0; $i

{

$element_name[$i]= $this->element_name[$array_num[$i]];

}

//print_r($element_name);

//echo '
';

//print_r($array_num);

$the_new_group_mat=new ism_mat(array(),count($array_num),$element_name);

$the_new_e= count($array_num);

for ($x=0; $x

{

$old_x=$array_num[$x];

for ($y=0; $y

{

$old_y=$array_num[$y];

$the_new_group_mat->array_number[$x][$y]=$this->array_number[$old_x][$old_y];

}

}

$the_new_group_mat=new ism_mat($the_new_group_mat->array_number,count($array_num),$element_name);

return $the_new_group_mat;

}

/**************************************************************************

* 返回ism的区域划分，也就是，系统个数，各个系统有什么要素组成

* 返回二维数组，

* 数组由，要素名称组成

*************************************************************************/

function get_group_e_name()

{

$arraygroup=array();

$bmatrix= $this->b();

$transpose=$this->transpose();

$u=$bmatrix->plus($transpose);

$g=$u->r_mat();

$data=$g->get_data();

for ($k=0;$k

{

$is_in=false;

for($j=0;$j

{

if($data[$j]==$data[$k])

{

$is_in=true;

}

}

if($is_in==false)

{

$arraydata[$k]=$data[$k];

}

}

$i=0;

foreach($arraydata as $v1)

{

$j=0;

foreach($v1 as $key=>$v)

{

if($v==1)

{

$arraygroup[$i][$j]=$key;

}

$j++;

}

$i++;

}

foreach($arraygroup as $i=>$group)

{

foreach($group as $j=>$num)

{

$arraygroup_name[$i][$j]=$this->element_name[$num];

}

}

return $arraygroup_name;

}

/*****************************************************************************

* 输入的是一个数组，数组中每个值是整数 为要素素的序号

*

* 这个东西小心使用，比如删除 array(0,0,0,0,0,0,0,0,0,0)表示一直删除第一个要素

*意义

**************************************************************************/

function del_e_by_some_num ($array_element_num)

{

$the_deduce=$this;

foreach($array_element_num as $v)

{

$the_deduce=$the_deduce->del_e_by_num($v);

}

return $the_deduce;

}

/*****************************************************************************

* 输入的是一个元素，值是整数 为要素的序号

* 矩阵是下标以 0开始的

* 返回 矩阵，对应的行与列删除，其它值，对应的左移，与右移动，

* 矩阵变小

***************************************************************************/

function del_e_by_num ($element_num)

{

$e=$this->element;

$element_name=$this->element_name;

$new_element=$e-1;

$new_element_name=array();

$new_array_number=array();

if(0<=$element_num and $element_num

{

for ($i=0;$i

{

$new_element_name[$i]=$element_name[$i];

}

for ($i=$element_num;$i

{

$new_element_name[$i]=$element_name[$i+1];

}

for ($i=0;$i

{

for ($j=0;$j

{

if( $i

{

$new_array_number[$i][$j]=$this->array_number[$i][$j];

}

elseif( $i=$element_num)

{

$new_array_number[$i][$j]=$this->array_number[$i][$j+1];

}

elseif( $i>=$element_num and $j

{

$new_array_number[$i][$j]=$this->array_number[$i+1][$j];

}

elseif( $i>=$element_num and $j>=$element_num)

{

$new_array_number[$i][$j]=$this->array_number[$i+1][$j+1];

}

}

}

$the_new_deduce_mat=new ism_mat($new_array_number,$new_element,$new_element_name);

}

else

{

echo "
\n\n\n搞错了参数，回去面壁下，认真检查！要删除的要素的值， 的参数请注意!\n\n\n\
";

}

//$set_e_zero_mat = new ism_mat($this->array_number,$e );

return $the_new_deduce_mat;

}

/*****************************************************************************

* 输入元素的名称，值是整数 为要素的序号

* 矩阵是下标以 0开始的

* 返回 矩阵，对应的行与列删除，其它值，对应的左移，与右移动，

* 矩阵变小

***************************************************************************/

function del_e_by_name ($name)

{

$element_num=array_search($name,$this->element_name);

$the_new_deduce_mat=$this->del_e_by_num($element_num);

return $the_new_deduce_mat;

}

/*****************************************************************************

* 输入元素的名称，值是整数 为要素的序号

* 矩阵是下标以 0开始的

* 返回 矩阵，对应的行与列删除，其它值，对应的左移，与右移动，

* 矩阵变小

***************************************************************************/

function del_e_by_array_name ($arrayname)

{

$the_new_deduce_mat=$this;

foreach($arrayname as $name)

{

$the_new_deduce_mat=$the_new_deduce_mat->del_e_by_name($name);

}

return $the_new_deduce_mat;

}

/*****************************************************************************

* 输入一个数组

* 或者输入一组 数字的系列。 如 0、1、2、3、4、没有检查重复度，请调用的时候自动检测

* 矩阵是下标以 0开始的

* 返回 矩阵，对应的行与列删除，其它值，对应的左移，与右移动，

* 矩阵变小

***************************************************************************/

function del_e_by_array_num ()

{

$nArgs = func_num_args();

//print_r($nArgs);

if ($nArgs == 0)

{

echo "没有要删除的要素";

}

if ($nArgs == 1 )

{

if(is_array(func_get_arg(0)))

{

$array_num = func_get_arg(0);

}

elseif(is_int(func_get_arg(0)))

{

$array_num[0] =func_get_arg(0);

}

else

{

echo"输入要素的格式错误";

}

}

if ( $nArgs >1 )

{

for($i=0;$i

{

$array_num[$i]=func_get_arg($i);

}

}

$the_new_deduce_mat=$this;

//print_r($array_num);

foreach($array_num as $num)

{

$arrayname[$num]=$the_new_deduce_mat->element_name[$num];

}

$the_new_deduce_mat=$the_new_deduce_mat->del_e_by_array_name($arrayname);

return $the_new_deduce_mat;

}

/*****************************************************************************

* 输入的是一个数组，这里暂时不做严格边界处理，每个数组必须整

* 矩阵是下标以 0开始的

* 返回 矩阵，对应的行与列清零的矩阵

***************************************************************************/

function deduce_e_by_ring ($array_element_num)

{

$e=$this->element;

$element_name=$this->element_name;

$size=count($array_element_num);

if($size

{

$new_e=$e-$size+1;

}

$min_num=min($array_element_num);

$set_e_zero_mat = new ism_mat($this->array_number,$e ,$this->element_name);

foreach($array_element_num as $i)

{

$the_group_name=$set_e_zero_mat->element_name[$i].'+'.$the_group_name;

}

$set_e_zero_mat->element_name[$min_num]=$the_group_name;

if( 0<=min($array_element_num) and max($array_element_num)element )

{

foreach( $array_element_num as $the_num)

{

for($i=0;$i

{

if ($i==$min_num)

{

for ($j=0;$j

{

if ($set_e_zero_mat->array_number[$the_num][$j]==1 )

{

$set_e_zero_mat->array_number[$min_num][$j]=1;

}

if ( $set_e_zero_mat->array_number[$j][$the_num]==1)

{

$set_e_zero_mat->array_number[$j][$min_num]=1;

}

}

}

}

}

$the_new_mat=new ism_mat($set_e_zero_mat->array_number,$set_e_zero_mat->element,$set_e_zero_mat->element_name);

foreach($array_element_num as $k=>$num)

{

if($num==$min_num)

{

unset($array_element_num[$k]);

}

}

$the_new_mat=$the_new_mat->del_e_by_array_num($array_element_num);

}

else

{

echo "
\n\n\n搞错了参数，回去面壁下，认真检查！$array_element_num 的参数请注意!\n\n\n\
";

}

$the_new_mat=new ism_mat($the_new_mat->array_number,$the_new_mat->element,$the_new_mat->element_name);

return $the_new_mat;

}

/**************************************************************************************

* 输入的是一个数组，数组里面为环路 用元素的名称标识,这里没有做严格的重复检查等等，调用的时候请注意

* 矩阵是下标以 0开始的

* 返回 矩阵，对应的行与列清零的矩阵

***************************************************************************/

function deduce_e_by_ring_name ($array_ring_name)

{

$array_ring_num=array();

foreach($array_ring_name as $key=>$name)

{

$array_ring_num[$key]=array_search($name,$this->element_name);

}

$the_new_mat=$this->deduce_e_by_ring($array_ring_num);

return $the_new_mat;

}

/**************************************************************************

* 返回ism的强连通子集，系统中构成环路的个数以及对应的组成

* 本处用的是一个经典的Tarjan算法 http://www.byvoid.com/blog/scc-tarjan/

* Robert Tarjan 的官方网站 http://www.cs.princeton.edu/~ret/

* 返回二维数组，

*************************************************************************/

function get_ring_use_Tarjan()

{

}

/**************************************************************************

* 返回ism的强连通子集，系统中构成环路的个数以及对应的组成

* 返回二维数组，

*************************************************************************/

function get_ring()

{

$arrayring=array();

$m=$this->r_mat(); //获得可达矩阵

$m_t=$m->transpose(); //可达矩阵的转置矩阵

$u=$m->meet($m_t); //可达矩阵 与 可达矩阵的转置矩阵 的 交集 矩阵

$data=$u->get_data();

for ($k=0;$k

{

$is_in=false;

for($j=0;$j

{

if($data[$j]==$data[$k])

{

$is_in=true;

}

}

if($is_in==false)

{

$arraydata[$k]=$data[$k];

}

}

$i=0;

foreach($arraydata as $v1)

{

$j=0;

foreach($v1 as $key=>$v)

{

if($v==1)

{

$arraytmp[$i][$j]=$key;

}

$j++;

}

if(count($arraytmp[$i])>1)

{

$arrayring[$i]=$arraytmp[$i];

}

$i++;

}

return $arrayring;

}

/**************************************************************************

* 返回ism的强连通子集，系统中构成环路的个数以及对应的要素名称

* 返回二维数组，

*************************************************************************/

function get_ring_e_name()

{

$arrayring_e_name=array();

$arrayring_e_number=$this->get_ring();

foreach($arrayring_e_number as $k=>$array_name_index)

{

foreach($array_name_index as $j=>$num)

{

$arrayring_e_name[$k][$j]=$this->element_name[$num];

}

}

return $arrayring_e_name;

}

/*****************************************************************************

* 给矩阵某一行某一列 的关系 赋值 $value 绝对值小于等于1，以后用来拓展的

***************************************************************************/

function set_value($i, $j, $value)

{

if($i-1 < $this->get_num_rows() and $j-1 < $this->get_num_columns())

{

if($value != 0 and abs($value)<=1)

{

$this->array_number[$i-1][$j-1] = $value;

}

elseif(abs($value)>1)

{

$this->array_number[$i-1][$j-1] = 1;

}

else

{

unset($this->array_number[$i-1][$j-1]);

}

}

else

{

echo "
\n\n\n搞错了参数，回去面壁下，认真检查！set_value 的参数请注意!\n\n\n\
";

}

}

/*****************************************************************************

* 清除某个要素，但是不减少矩阵的大小,注意此过程只是把对应的行与列清零

* 输入的是一个数组，这里暂时不做严格边界处理，每个数组必须整

* 矩阵是下标以 0开始的

* 返回 矩阵，对应的行与列清零的矩阵

***************************************************************************/

function set_e_zero ($array_element_num)

{

$e=$this->element;

$set_e_zero_mat = new ism_mat($this->array_number,$e ,$this->element_name);

if( 0<=min($array_element_num) and max($array_element_num)element )

{

foreach( $array_element_num as $the_num)

{

for($i=0;$i

{

unset($set_e_zero_mat->array_number[$the_num][$i]);

unset($set_e_zero_mat->array_number[$i][$the_num]);

}

}

}

else

{

echo "
\n\n\n搞错了参数，回去面壁下，认真检查！$array_element_num 的参数请注意!\n\n\n\
";

}

return $set_e_zero_mat;

}

/*************************************************************************

*随机填充根据矩阵要素的个数按比例填充，大于1的元素

**********************************************************************/

function rand_mat( $rate )

{

$random_numbers = array();

$e = $this->element;

if($rate==null || $rate<0)

{

$rate=2;

}

$totalnum=$rate * $e;

for ($i=0; $i

{

$x = mt_rand(0,$e-1);

$y = mt_rand(0,$e-1);

$random_numbers[$x][$y] = 1; //此处专门用来修改的,比如更改成模糊矩阵的方

}

$the_random_matrix = new ism_mat($random_numbers, $e,$this->element_name);

return $the_random_matrix;

}

/*******************************************

* 满阵 ， 布尔矩阵中所有的值都为 1

*******************************************/

function ones()

{

$array_fill = array();

$e= $this->element;

for($i = 0; $i < $e; $i++)

{

for($j = 0; $j < $e; $j++)

{

$array_fill[$i][$j] = 1;

}

}

$a_matrix_fill_ones = new ism_mat($array_fill,$e,$this->element_name);

return $a_matrix_fill_ones;

}

/*****************************************************

* 我日个去，查了下单位矩阵居然是叫 identity matrix.

* 矩阵中对角线的全部为1，其它的全部为0

*****************************************************/

function i()

{

$e = $this->element;

for($i = 0; $i < $e; $i++)

{

$id_numbers[$i][$i] = 1;

}

$the_identity_matrix = new ism_mat($id_numbers, $e,$this->element_name);

return $the_identity_matrix;

}

/***************************************************

* 计算转置矩阵 A_ij 变成 A_ji

* A' is $A->transpose() 转置矩阵

*****************************************************/

function transpose()

{

foreach($this->array_number as $i => $row)

{

foreach($row as $j => $number)

{

$the_transpose_data[$j][$i] = $number;

}

}

$the_transpose = new ism_mat($the_transpose_data, $this->element,$this->element_name);

return $the_transpose;

}

/************************************************************************

* 布尔矩阵相乘没有运用到具体的算子 采用的是大于1就等于1的截 的方

* A x B is $A->muti($B) 乘运算⊙(product

*如果对某个k，有 a_ik ＝1且b_kj ＝1，1≤k≤element

************************************************************************/

function muti($some_mat)

{

$easier = $some_mat->transpose();

if($this->get_num_columns() == $some_mat->get_num_rows() and $this->get_num_rows() == $some_mat->get_num_columns())

{

foreach($this->array_number as $i => $row)

{

foreach($easier->array_number as $j => $column)

{

$total = 0;

foreach($row as $k => $number)

{

if(empty($column[$k]) == false)

{

$total += $number * $column[$k];

}

}

$the_product_data[$i][$j] = $total;

if ($the_product_data[$i][$j]>1)

{

$the_product_data[$i][$j]=1;

}

}

}

$the_product = new ism_mat($the_product_data,$this->get_num_columns(),$this->element_name);

}

else

{

echo "\n\n\n 貌似出错了，请检查参数 \n\n\n";

}

return $the_product;

}

/************************************************************************

* 布尔矩阵交集没有运用到具体的算子 采用的是大于1就等于1的截 的方

* A x B is $A->meet($B)

*如果对某个k，有 a_ij ＝1且b_ij ＝1， c_ij =1 否则为0

************************************************************************/

function meet($some_mat)

{

$e=$this->element;

if($this->get_num_columns() == $some_mat->get_num_rows() and $this->get_num_rows() == $some_mat->get_num_columns())

{

for($i=0; $i

{

for($j=0; $j

{

if(empty($this->array_number[$i][$j]) == false)

{

if(empty($some_mat->array_number[$i][$j]) == false)

{

if($this->array_number[$i][$j]==1 and $some_mat->array_number[$i][$j]==1)

{

$the_data[$i][$j]=1;

}

}

}

else

{

if(empty($some_mat->array_number[$i][$j]) == false)

{

$the_data[$i][$j]=0;

}

}

}

}

$the_meet_mat = new ism_mat($the_data,$e,$this->element_name);

}

else

{

echo "\n\n\n 貌似出错了，请检查参数 \n\n\n";

}

return $the_meet_mat;

}

/***********************************************

* 矩阵大小检查，检查矩阵的行与列，是

************************************************/

function size_eq($some_mat)

{

$return = false;

if ($some_mat->get_num_rows() == $this->get_num_rows() and $some_mat->get_num_columns() == $this->get_num_columns())

{

$return = true;

}

return $return;

}

/**************************************************

* 检查是否为可达矩阵 自身相乘 不变认为是可达矩阵

************************************************/

function is_r_mat($some_mat)

{

$return = false;

$check =$some_mat->muti($some_mat);

if ( $check == $some_mat)

{

$return = true;

}

return $return;

}

/*************************************************

* 一个常数乘以矩阵 A * n = $A->s_times($n)

*没有什么鸟用，一个中间

************************************/

function s_times($value)

{

$the_mat = new ism_mat($this->array_number, $this->element,$this->element_name);

foreach($this->array_number as $i => $column)

{

foreach($column as $j => $number)

{

$the_mat->array_number[$i][$j] *= $value;

}

}

return $the_mat;

}

/**************************************************************

*矩阵与矩阵相减 A - B is $A->minus($B) 注意前提条

****************************************************************/

function minus($some_mat)

{

$substract = new ism_mat(array(), $this->element,$this->element_name);

if($this->size_eq($some_mat))

{

for($i = 0; $i < $this->get_num_rows(); $i++)

{

for($j = 0; $j < $this->get_num_columns(); $j++)

{

if(empty($this->array_number[$i][$j]) == false)

{

if(empty($some_mat->array_number[$i][$j]) == false)

{

$substract->array_number[$i][$j] = $this->array_number[$i][$j] - $some_mat->array_number[$i][$j];

if ($substract->array_number[$i][$j] >1)

{

$substract->array_number[$i][$j]=1;

}

if ($substract->array_number[$i][$j] <0)

{

$substract->array_number[$i][$j]=0;

}

}

else

{

$substract->array_number[$i][$j] = $this->array_number[$i][$j];

if ($substract->array_number[$i][$j] >1)

{

$substract->array_number[$i][$j]=1;

}

if ($substract->array_number[$i][$j] <0)

{

$substract->array_number[$i][$j]=0;

}

}

}

else

{

if(empty($some_mat->array_number[$i][$j]) == false)

{

$substract->array_number[$i][$j] = -1*$some_mat->array_number[$i][$j];

if ($substract->array_number[$i][$j] >1)

{

$substract->array_number[$i][$j]=1;

}

if ($substract->array_number[$i][$j] <0)

{

$substract->array_number[$i][$j]=0;

}

}

}

}

}

}

else

{

echo "\n\n\n 维度不同，矩阵无法相减 \n\n\n";

}

return $substract;

}

/*********************************************************************

* 布尔矩阵相加 A + B 对应的函数是 $A->plus($B) 注意两个的大小要相

**********************************************************************/

function plus($some_mat)

{

$add = new ism_mat($this->array_number, $this->get_num_rows(),$this->element_name);

if($this->size_eq($some_mat))

{

$some_mat = $some_mat->s_times(-1);

$add = $this->minus($some_mat);

}

else

{

echo "\n\n\n 大小不同，或者其它错误 \n\n\n";

}

return $add;

}

/*********************************************************************

* 获得骨架矩阵 S

* 对于可达矩阵(缩减矩阵) R I表示单位矩阵

* S=R-(R-I)(R-I)

**********************************************************************/

function s_mat()

{

$R=$this->r_mat();

$I=$R->i();

$tmp=$R->minus($I);

$tmp2=$tmp->muti($tmp);

$s_mat=$R->minus($tmp2);

return $s_mat;

}

/**********************************************************

* 获得行的

***********************************************************/

function get_num_rows()

{

return $this->numRows;

}

/**********************************************************

* 获得列的

***********************************************************/

function get_num_columns()

{

return $this->numColumns;

}

/******************************************************************

* 显示矩阵内容以0 1的方式显示

*

********************************************************************/

function echo_mat()

{

$numb = $this->array_number;

echo '

echo '

';

for($i=0;$ielement;$i++)

{

echo '

'.$this->element_name[$i].'';

}

echo '

'."\r\n";

for($i = 0; $i < $this->get_num_rows();$i++)

{

//echo '

';

echo '

'.$this->element_name[$i].'';

for($j = 0; $j < $this->get_num_columns(); $j++)

{

if(empty($numb[$i][$j]) == false)

{

echo "

".$numb[$i][$j]."";

}

else

{

echo "

　";

}

}

echo "

\n";

}

echo "

\n";

}

/******************************************************************

* 显示矩阵内容 以 要素的名称方式显示兼容非方阵的显示

*

********************************************************************/

function echo_e()

{

$numb = $this->array_number;

echo '

for($i = 0; $i < $this->get_num_rows();$i++)

{

if(empty($numb[$i])==false)

{

echo '

'.$this->element_name[$i].'';

for($j = 0; $j < $this->get_num_columns(); $j++)

{

if(empty($numb[$i][$j]) == false)

{

echo "".$this->element_name[$j]."、";

}

else

{

echo "";

}

}

echo "

\n";

}

}

echo "

\n";

}

/******************************************************************

* 用图形方式显示

* 返回的是 一列 ||(6:g)- (>[1,5,7,11]) () 这

********************************************************************/

function show_graphy()

{

$numb = $this->array_number;

for($i = 0; $i element;$i++)

{

echo "(".$i.':'.$this->element_name[$i].")";

if(empty($numb[$i]) == false)

{

$x=1;//判断一行中可达数目的标尺

echo '- (>[';

for($j=0;$jelement;$j++)

{

if( empty($this->array_number[$i][$j])==false and count($numb[$i])>$x)

{

echo $j;

echo',';

$x++;

}

elseif( empty($this->array_number[$i][$j])==false and count($numb[$i])==$x)

{

echo $j;

}

}

echo ']) ';

}

echo '()';

echo "\r\n";

echo "||";

}

}

/******************************************************************

* 用图形方式显示

* 返回的是 一列 ||(6:g)- (>[1,5,7,11]) 这

********************************************************************/

function show_rand_pos_graphy()

{

$numb = $this->array_number;

for($i = 0; $i element;$i++)

{

$null_num=mt_rand(0,5);

for($n=0;$n

{

echo "()";

}

if(empty($numb[$i]) == false)

{

$x=1;//判断一行中可达数目的标尺

echo "(".$i.':'.$this->element_name[$i]."";

echo '>[';

for($j=0;$jelement;$j++)

{

if( empty($this->array_number[$i][$j])==false and count($numb[$i])>$x)

{

echo $j;

echo',';

$x++;

}

elseif( empty($this->array_number[$i][$j])==false and count($numb[$i])==$x)

{

echo $j;

}

}

echo ']) ';

}

else

{

echo "(".$i.':'.$this->element_name[$i].")";

}

echo '()';

echo "\r\n";

echo "||";

}

}

}

?>

本文原创发布php中文网，转载请注明出处，感谢您的尊重！

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！