解释结构模型的php代码

陌瑶吖_3148

陌瑶吖_3148

2016-05-25

2771人浏览

原创

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)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 element_name;
			//print_r($name);
			unset($this->element_name);
			foreach($name as $v)
			{
				$this->element_name[$i]=$v;
				$i++;
			}

			for ($i=$name_count;$ielement_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;$kelement;
		$new_mat=new ism_mat($this->array_number,$e,$this->element_name);
		if($num_1array_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 element; $i++)
		{
			for($j = 0; $j 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]element; $i++)
		{
			for($j = 0; $j 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]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 get_num_rows() and $j-1 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 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 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 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 for if foreach>$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;$ielement_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; $xarray_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 for if foreach>$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(0array_number[$i][$j];
					}
					elseif( $i=$element_num)
					{
						$new_array_number[$i][$j]=$this->array_number[$i][$j+1];
					}
					elseif( $i>=$element_num and $jarray_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;$ielement_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($sizearray_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( 0element )
		{
			foreach( $array_element_num as $the_num)
			{
				for($i=0;$iarray_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 for if foreach>$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 get_num_rows() and $j-1 get_num_columns())
		{
			if($value != 0 and abs($value)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( 0element )
		{
			foreach( $array_element_num as $the_num)
			{
				for($i=0;$iarray_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 || $rateelement_name);
		return $the_random_matrix;
	}
	/*******************************************
	* 满阵 , 布尔矩阵中所有的值都为 1
	*******************************************/
	function ones()
	{
		$array_fill = array();
		$e= $this->element;
		for($i = 0; $i element_name);
		return $a_matrix_fill_ones;
	}


	/*****************************************************
	* 我日个去,查了下单位矩阵居然是叫 identity matrix.
	* 矩阵中对角线的全部为1,其它的全部为0
	*****************************************************/
	function i()
	{
		$e = $this->element;
		for($i = 0; $i 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; $iarray_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 get_num_rows(); $i++)
			{
				for($j = 0; $j 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] 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] 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] 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>'."\n";
		echo '<tr>
<td></td>';
		for($i=0;$ielement;$i++)
		{
			echo '<td>'.$this->element_name[$i].'</td>';
		}
		echo '</tr>'."\r\n";
		for($i = 0; $i get_num_rows();$i++)
		{
			//echo '<tr>';
			echo '</tr>
<tr>
<td>'.$this->element_name[$i].'</td>';
			for($j = 0; $j get_num_columns(); $j++)
			{
				if(empty($numb[$i][$j]) == false)
				{
					echo "<td><font>".$numb[$i][$j]."</font></td>";
				}
				else
				{
					echo "<td>  </td>";
				}
			}
			echo "</tr>\n";
		}
		echo "</table>\n";
	}

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

						echo "<font>".$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 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;$nelement_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 "||";
		}
	}
}
?></count></count></count>

php免费学习视频:立即使用
踏上前端学习之旅,开启通往精通之路!从前端基础到项目实战,循序渐进,一步一个脚印,迈向巅峰!

PHP速学教程(入门到精通)
PHP速学教程(入门到精通)

PHP怎么学习?PHP怎么入门?PHP在哪学?PHP怎么学才快?不用担心,这里为大家提供了PHP速学教程(入门到精通),有需要的小伙伴保存下载就能学习啦!

下载

相关标签:

本站声明:本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系admin@php.cn

相关专题

更多
Navicat创建数据库教程
Navicat创建数据库教程

本专题整理Navicat创建数据库相关教程,介绍新建前的准备、基础设置和创建后的检查方法。内容兼顾入门学习及实际使用需求,帮助用户了解不同数据库类型下的操作差异,为后续建表、保存数据和日常管理提供参考。

2026.11.20

0

7

Navicat入门教程大全
Navicat入门教程大全

本专题整理Navicat入门教程,从认识软件界面到开展数据库操作,介绍初次使用需要了解的知识和方法。内容兼顾连接配置、数据管理及日常使用中的疑问,方便用户按学习进度查阅,为后续实践和独立操作打好基础。

2026.11.20

0

17

Navicat数据库连接配置指南
Navicat数据库连接配置指南

从确认数据库信息到建立可用连接,本专题串联Navicat连接数据库的相关知识和操作方法。既有初次配置时需要了解的基础内容,也有连接后的检查思路,方便用户按实际需求查阅教程,逐步熟悉数据库连接的设置流程。

2026.11.20

0

10

PHP8.6数组与数据处理教程
PHP8.6数组与数据处理教程

本专题汇总PHP8.6数组与数据处理教程,涵盖CSV读取和导出、引用遍历删除、array_filter回调模式、配置键名冲突、pathinfo文件名校验、GMP大整数进制转换及UTF-8正则筛选,说明升级兼容变化、输入范围和失败处理方法。

2026.11.20

0

8

PHP8.6升级迁移教程
PHP8.6升级迁移教程

本专题汇总PHP8.6升级迁移与弃用接口改造教程,涵盖反射调用、对象属性赋值、标识符更名、构造函数与__debugInfo调整,以及插件类名检查、常量导出、ArrayIterator排序、SPL和DTO查询参数转换,帮助梳理弃用提示并完成代码兼容改造。

2026.11.20

0

10

PHP8.6安装配置与FPM运维教程
PHP8.6安装配置与FPM运维教程

本专题汇总PHP8.6正式版安装部署与FPM运维教程,涵盖Linux并存安装、独立ini配置、扩展重新编译、Nginx切换与回滚、FPM状态监控和慢日志排查,以及环境变量、请求超时、OPcache刷新和预加载配置。

2026.11.20

0

10

Nginx CVE-2026-123007排查与防护指南
Nginx CVE-2026-123007排查与防护指南

Nginx HTTP/2漏洞该怎么修复?本专题围绕CVE-2026-123007,介绍安全版本升级、模块兼容检查和配置恢复方法,以及日志排查、权限设置等后续加固操作,方便你按实际部署情况查找对应教程。

2026.11.20

20

8

GoFrame框架Web开发与路由中间件
GoFrame框架Web开发与路由中间件

本专题聚焦GoFrame框架的Web开发,拆解路由注册与匹配规则、请求参数获取、参数校验与中间件执行顺序,说明统一响应、JWT鉴权、文件上传与接口文档生成的落地方式,并补充优雅重启与测试实践。

2026.11.17

60

15

GoFrame框架安装与gf命令行工具
GoFrame框架安装与gf命令行工具

本专题围绕GoFrame框架的安装与工具链配置展开,讲清Go版本要求、gf命令行的安装方式、代理镜像与依赖准备,说明项目初始化、热编译、交叉编译打包的做法,并整理安装阶段的常见报错与验证步骤。

2026.11.17

80

15

热门下载

更多
网站特效
/
网站源码
/
网站素材
/
前端模板

精品课程

更多
热门推荐
/
最新课程
phpStudy极速入门视频教程
phpStudy极速入门视频教程

共6课时 | 54.7万人学习

独孤九贱(4)_PHP视频教程
独孤九贱(4)_PHP视频教程

共89课时 | 134.3万人学习