欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  php教程

解释结构模型的php代码

程序员文章站 2022-04-10 14:49:26
...
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<$maxlen;$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<$e;$k++)
			{
				//获得名称原来的序号
				$get_name_old_num[$k] = array_search($new_name_array[$k], $old_name_array);
			}
			for($i=0;$i<$e;$i++)
			{
				for($j=0;$j<$e;$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<$e and $num_2<$e and $num_1!=$num_2)
		{
			for($i=0;$i<$e;$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 "<br><br>\n\n\n  搞错了注意参数,超过了ism矩阵中的要素的值的范围 !\n\n\n\<br><br>";
		}
		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;$len<$reached_matrix->element;$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;$len<$reached_matrix->element;$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<count($data);$k++)
		{
			$is_in=false;
			for($j=0;$j<$k;$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<$nArgs;$i++)
			{
				$array_num[$i]=func_get_arg($i);
			}
		}

		//对输入的要素的名称排序
		sort($array_num);
		for ($i=0; $i<count($array_num);$i++)
		{
			$element_name[$i]= $this->element_name[$array_num[$i]];
		}
//				print_r($element_name);
//				echo '<br>';
//				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<$the_new_e;$x++)
		{
			$old_x=$array_num[$x];
			for ($y=0; $y<$the_new_e;$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<count($data);$k++)
		{
			$is_in=false;
			for($j=0;$j<$k;$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<$e)
		{
			for ($i=0;$i<$element_num;$i++)
			{
				$new_element_name[$i]=$element_name[$i];
			}
			for ($i=$element_num;$i<$e-1;$i++)
			{
				$new_element_name[$i]=$element_name[$i+1];
			}

			for ($i=0;$i<$e-1;$i++)
			{
				for ($j=0;$j<$e-1;$j++)
				{
					if( $i<$element_num and $j<$element_num)
					{
						$new_array_number[$i][$j]=$this->array_number[$i][$j];
					}
					elseif( $i<$element_num and $j>=$element_num)
					{
						$new_array_number[$i][$j]=$this->array_number[$i][$j+1];
					}
					elseif( $i>=$element_num and $j<$element_num)
					{
						$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 "<br><br>\n\n\n搞错了参数,回去面壁下,认真检查!要删除的要素的值, 的参数请注意!\n\n\n\<br><br>";
		}
		//$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<$nArgs;$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<$e)
		{
			$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)<$this->element )
		{
			foreach( $array_element_num as $the_num)
			{
				for($i=0;$i<$e;$i++)
				{
					if ($i==$min_num)
					{
						for ($j=0;$j<$e;$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 "<br><br>\n\n\n搞错了参数,回去面壁下,认真检查!$array_element_num 的参数请注意!\n\n\n\<br><br>";
		}
		$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<count($data);$k++)
		{
			$is_in=false;
			for($j=0;$j<$k;$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 "<br><br>\n\n\n搞错了参数,回去面壁下,认真检查!set_value 的参数请注意!\n\n\n\<br><br>";
		}
	}

	/*****************************************************************************
	 * 清除某个要素,但是不减少矩阵的大小,注意此过程只是把对应的行与列清零
	 * 输入的是一个数组,这里暂时不做严格边界处理,每个数组必须整
	 *   矩阵是下标以 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)<$this->element )
		{
			foreach( $array_element_num as $the_num)
			{
				for($i=0;$i<$e;$i++)
				{
					unset($set_e_zero_mat->array_number[$the_num][$i]);
					unset($set_e_zero_mat->array_number[$i][$the_num]);
				}
			}
		}
		else
		{
			echo "<br><br>\n\n\n搞错了参数,回去面壁下,认真检查!$array_element_num 的参数请注意!\n\n\n\<br><br>";
		}
		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<$totalnum; $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<$e;$i++)
			{
				for($j=0; $j<$e;$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 '<table  border="1" bgColor="#EEEE00">'."\n";
		echo '<tr><td></td>';
		for($i=0;$i<$this->element;$i++)
		{
			echo '<td>'.$this->element_name[$i].'</td>';
		}
		echo '</tr>'."\r\n";
		for($i = 0; $i < $this->get_num_rows();$i++)
		{
			//echo '<tr>';
			echo '<tr><td>'.$this->element_name[$i].'</td>';
			for($j = 0; $j < $this->get_num_columns(); $j++)
			{
				if(empty($numb[$i][$j]) == false)
				{
					echo "<td><font color=red>".$numb[$i][$j]."</font></td>";
				}
				else
				{
					echo "<td>  </td>";
				}
			}
			echo "</tr>\n";
		}
		echo "</table>\n";
	}

	/******************************************************************
	* 显示矩阵内容 以 要素的名称方式显示兼容非方阵的显示
	*
	********************************************************************/
	function echo_e()
	{
		$numb = $this->array_number;
		echo '<table  border="1" bgColor="#EEEE00">'."\n";
		for($i = 0; $i < $this->get_num_rows();$i++)
		{
			if(empty($numb[$i])==false)
			{
				echo '<tr><td>'.$this->element_name[$i].'</td><td>';
				for($j = 0; $j < $this->get_num_columns(); $j++)
				{
					if(empty($numb[$i][$j]) == false)
					{

						echo "<font color=red>".$this->element_name[$j]."、</font>";
					}
					else
					{
						echo "";
					}
				}
				echo "</td></tr>\n";
			}
		}
		echo "</table>\n";
	}

	/******************************************************************
	* 用图形方式显示
	* 返回的是  一列 ||(6:g)- (>[1,5,7,11]) () 这
	********************************************************************/
	function show_graphy()
	{
		$numb = $this->array_number;
		for($i = 0; $i <$this->element;$i++)
		{
			echo "(".$i.':'.$this->element_name[$i].")";
			if(empty($numb[$i]) == false)
			{
				$x=1;//判断一行中可达数目的标尺
				echo '- (>[';
				for($j=0;$j<$this->element;$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 <$this->element;$i++)
		{
			$null_num=mt_rand(0,5);
			for($n=0;$n<$null_num;$n++)
			{
				echo "()";
			}
			if(empty($numb[$i]) == false)
			{
				$x=1;//判断一行中可达数目的标尺
				echo "(".$i.':'.$this->element_name[$i]."";
				echo '>[';
				for($j=0;$j<$this->element;$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 "||";
		}
	}
}
?>