1#@!#!123s

: / opt / lampp / lib / php / Math /
Filename : VectorOp.php
back
<?php
//
// +----------------------------------------------------------------------+
// | PHP Version 4                                                        |
// +----------------------------------------------------------------------+
// | Copyright (c) 1997-2003 The PHP Group                                |
// +----------------------------------------------------------------------+
// | This source file is subject to version 2.0 of the PHP license,       |
// | that is bundled with this package in the file LICENSE, and is        |
// | available at through the world-wide-web at                           |
// | http://www.php.net/license/2_02.txt.                                 |
// | If you did not receive a copy of the PHP license and are unable to   |
// | obtain it through the world-wide-web, please send a note to          |
// | license@php.net so we can mail you a copy immediately.               |
// +----------------------------------------------------------------------+
// | Authors: Jesus M. Castagnetto <jmcastagnetto@php.net>                |
// +----------------------------------------------------------------------+
//
// $Id: VectorOp.php 304045 2010-10-05 00:16:53Z clockwerx $
//

/**
 * Vector operation class. 
 * A static class implementing methods to operate on Vector objects.
 * Originally this class was part of NumPHP (Numeric PHP package)
 *
 * @author	Jesus M. Castagnetto <jmcastagnetto@php.net>
 * @version	1.0
 * @access	public
 * @package	Math_Vector
 */
class Math_VectorOp {

	/**
	 * Checks if object is of Math_Vector class (or a subclass of Math_Vector)
	 *
	 * @access	public
	 * @param	object	$obj
	 * @return	boolean	true on success
	 */
	function isVector($obj) /*{{{*/
	{
		if (function_exists("is_a"))
			return (is_object($obj) && is_a($obj, "Math_Vector"));
		else
			return (is_object($obj) && (strtolower(get_class($obj)) == "math_vector" || 
						is_subclass_of($obj, "Math_Vector")));
	}/*}}}*/

	/**
	 * Checks if object is of Math_Vector2 class (or a subclass of Math_Vector2)
	 *
	 * @access	public
	 * @param	object	$obj
	 * @return	boolean	true on success
	 */
	function isVector2($obj) /*{{{*/
	{
		if (function_exists("is_a"))
			return (is_object($obj) && is_a($obj, "Math_Vector2"));
		else
			return (is_object($obj) && (strtolower(get_class($obj)) == "math_vector2" ||
				is_subclass_of($obj, "Math_Vector2")));
	}/*}}}*/

	/**
	 * Checks if object is of Math_Vector3 class (or a subclass of Math_Vector3)
	 *
	 * @access	public
	 * @param	object	$obj
	 * @return	boolean	true on success
	 */
	function isVector3($obj) /*{{{*/
	{
		if (function_exists("is_a"))
			return (is_object($obj) && is_a($obj, "Math_Vector3"));
		else
			return (is_object($obj) && (strtolower(get_class($obj)) == "math_vector3" ||
					is_subclass_of($obj, "Math_Vector3")) );
	}/*}}}*/

	/**
	 * Creates a vector of a given size in which all elements have the same value
	 *
	 * @access	public
	 * @param	int	$size	vector size
	 * @param	numeric	$value	value to assign to the elements
	 * @return	object	if ($size == 2) Math_Vector2 elseif ($size == 3) Math_Vector3 else Math_Vector
	 */
	function create ($size, $value) /*{{{*/
	{
		if ($size == 2)
			$VClass = "Math_Vector2";
		elseif ($size == 3)
			$VClass = "Math_Vector3";
		else
			$VClass = "Math_Vector";
		return new $VClass(Math_VectorOp::_fill(0, $size, $value));
	}/*}}}*/

	/**
	 * Creates a zero-filled vector of the given size
	 *
	 * @access	public
	 * @param	int	$size	vector size
	 * @return	object	if ($size == 2) Math_Vector2 elseif ($size == 3) Math_Vector3 else Math_Vector
	 *
	 * @see	create()
	 */
	function createZero ($size) 
	{
		return Math_VectorOp::create ($size, 0);
	}

	/**
	 * Creates a one-filled vector of the given size
	 *
	 * @access	public
	 * @param	int	$size	vector size
	 * @return	object	if ($size == 2) Math_Vector2 elseif ($size == 3) Math_Vector3 else Math_Vector
	 *
	 * @see	create()
	 */
	function createOne ($size) /*{{{*/
	{
		return Math_VectorOp::create ($size, 1);
	}/*}}}*/


	/**
	 * Creates a basis vector of the given size
	 * A basis vector of size n, has n - 1 elements equal to 0
	 * and one element equal to 1
	 *
	 * @access	public
	 * @param	int	$size	vector size
	 * @param	int	$index	element to be set at 1
	 * @return	object	if ($size == 2) Math_Vector2 elseif ($size == 3) Math_Vector3 else Math_Vector, on error PEAR_Error
	 *
	 * @see	createZero()
	 */
	function createBasis ($size, $index) /*{{{*/
	{
		if ($index >= $size)
			return PEAR::raiseError("Incorrect index for size: $index >= $size");
		$v = Math_VectorOp::createZero($size);
		$res =$v->set($index, 1);
		if (PEAR::isError($res))
			return $res;
		else
			return $v;
	}/*}}}*/

	/**
	 * Vector addition
	 * v + w = <v1 + w1, v2 + w2, ..., vk + wk>
	 *
	 * @access	public
	 * @param	object	Math_Vector (or subclass)	$v1
	 * @param	object	Math_Vector (or subclass)	$v2
	 * @return	object	Math_Vector (or subclass) on success, PEAR_Error otherwise
	 *
	 * @see 	isVector()
	 */
	function add ($v1, $v2) /*{{{*/
	{
		if (Math_VectorOp::isVector($v1) && Math_VectorOp::isVector($v2)) {
			$n = $v1->size();
			if ($v2->size() != $n)
				return PEAR::raiseError("Vectors must of the same size");
			for ($i=0; $i < $n; $i++)
				$arr[$i] = $v1->get($i) + $v2->get($i);
			return new Math_Vector($arr);
		} else {
			return PEAR::raiseError("V1 and V2 must be Math_Vector objects");
		}
	}/*}}}*/

	/**
	 * Vector substraction
	 * v - w = <v1 - w1, v2 - w2, ..., vk - wk>
	 *
	 * @access	public
	 * @param	object	Math_Vector (or subclass)	$v1
	 * @param	object	Math_Vector (or subclass)	$v2
	 * @return	object	Math_Vector (or subclass) on success, PEAR_Error otherwise
	 *
	 * @see 	isVector()
	 */
	function substract ($v1, $v2) /*{{{*/
	{
		if (Math_VectorOp::isVector($v1) && Math_VectorOp::isVector($v2)) {
			$n = $v1->size();
			if ($v2->size() != $n)
				return PEAR::raiseError("Vectors must of the same size");
			for ($i=0; $i < $n; $i++)
				$arr[$i] = $v1->get($i) - $v2->get($i);
			return new Math_Vector($arr);
		} else {
			return PEAR::raiseError("V1 and V2 must be Math_Vector objects");
		}
	}/*}}}*/

	/**
	 * Vector multiplication
	 * v * w = <v1 * w1, v2 * w2, ..., vk * wk>
	 *
	 * @access	public
	 * @param	object	Math_Vector (or subclass)	$v1
	 * @param	object	Math_Vector (or subclass)	$v2
	 * @return	object	Math_Vector (or subclass) on success, PEAR_Error otherwise
	 *
	 * @see 	isVector()
	 */
	function multiply ($v1, $v2) /*{{{*/
	{
		if (Math_VectorOp::isVector($v1) && Math_VectorOp::isVector($v2)) {
			$n = $v1->size();
			if ($v2->size() != $n)
				return PEAR::raiseError("Vectors must of the same size");
			for ($i=0; $i < $n; $i++)
				$arr[$i] = $v1->get($i) * $v2->get($i);
			return new Math_Vector($arr);
		} else {
			return PEAR::raiseError("V1 and V2 must be Math_Vector objects");
		}
	}/*}}}*/

	/**
	 * Vector scaling
	 * f * w = <f * w1, f * w2, ..., f * wk>
	 *
	 * @access	public
	 * @param	numeric	$f	scaling factor
	 * @param	object	Math_Vector (or subclass)	$v
	 * @return	object	Math_Vector (or subclass) on success, PEAR_Error otherwise
	 *
	 * @see 	isVector()
	 */
	function scale ($f, $v) /*{{{*/
	{
		if (is_numeric($f) && Math_VectorOp::isVector($v)) {
			$n = $v->size();
			for ($i=0; $i < $n; $i++)
				$arr[$i] = $v->get($i) * $f;
			return new Math_Vector($arr);
		} else {
			return PEAR::raiseError("Requires a numeric factor and a Math_Vector object");
		}
	}/*}}}*/

	/**
	 * Vector division
	 * v / w = <v1 / w1, v2 / w2, ..., vk / wk>
	 *
	 * @access	public
	 * @param	object	Math_Vector (or subclass)	$v1
	 * @param	object	Math_Vector (or subclass)	$v2
	 * @return	object	Math_Vector (or subclass) on success, PEAR_Error otherwise
	 *
	 * @see 	isVector()
	 */
	function divide ($v1, $v2) /*{{{*/
	{
		if (Math_VectorOp::isVector($v1) && Math_VectorOp::isVector($v2)) {
			$n = $v1->size();
			if ($v2->size() != $n)
				return PEAR::raiseError("Vectors must of the same size");
			for ($i=0; $i < $n; $i++) {
				$d = $v2->get($i);
				if ($d == 0)
					return PEAR::raiseError("Division by zero: Element $i in V2 is zero");
				$arr[$i] = $v1->get($i) / $d;
			}
			return new Math_Vector($arr);
		} else {
			return PEAR::raiseError("V1 and V2 must be Math_Vector objects");
		}
	}/*}}}*/

	/**
	 * Vector dot product = v . w = |v| |w| cos(theta)
	 *
	 * @access	public
	 * @param	object	Math_Vector2 or MathVector3 (or subclass)	$v1
	 * @param	object	Math_Vector2 or MathVector3 (or subclass)	$v2
	 * @return	mixed	the dot product (float) on success, a PEAR_Error object otherwise
	 *
	 * @see 	isVector2()
	 * @see		isVector3()
	 */
	function dotProduct ($v1, $v2)/*{{{*/
	{
		if (Math_VectorOp::isVector2($v1) && Math_VectorOp::isVector2($v2))
			return ( $v1->getX() * $v2->getX() +
					 $v1->getY() * $v2->getY() );
		elseif (Math_VectorOp::isVector3($v1) && Math_VectorOp::isVector3($v2))
			return ( $v1->getX() * $v2->getX() +
					 $v1->getY() * $v2->getY() +
					 $v1->getZ() * $v2->getZ() );
		else
			return PEAR::raiseError("Vectors must be both of the same type");
	}/*}}}*/

	/**
	 * Vector cross product = v x w 
	 *
	 * @access	public
	 * @param	object	Math_Vector3 (or subclass)	$v1
	 * @param	object	Math_Vector3 (or subclass)	$v2
	 * @return	object	the cross product vector (Math_Vector3) on success, a PEAR_Error object otherwise
	 *
	 * @see		isVector3()
	 */
	function crossProduct ($v1, $v2)
	{
		if (Math_VectorOp::isVector3($v1) && Math_VectorOp::isVector3($v2)) {
			$arr[0] = $v1->getY() * $v2->getZ() - $v1->getZ() * $v2->getY();
			$arr[1] = $v1->getZ() * $v2->getX() - $v1->getX() * $v2->getZ();
			$arr[2] = $v1->getX() * $v2->getY() - $v1->getY() * $v2->getX();
			return new Math_Vector3($arr);
		} else {
			return PEAR::raiseError("Vectors must be both of the same type");
		}
	}

	/**
	 * Vector triple scalar product =  v1 . (v2 x v3) 
	 *
	 * @access	public
	 * @param	object	Math_Vector3 (or subclass)	$v1
	 * @param	object	Math_Vector3 (or subclass)	$v2
	 * @param	object	Math_Vector3 (or subclass)	$v3
	 * @return	mixed	the triple scalar product (float) on success, a PEAR_Error object otherwise
	 *
	 * @see		isVector3()
	 * @see		dotProduct()
	 * @see		crossProduct()
	 */
	function tripleScalarProduct ($v1, $v2, $v3) /*{{{*/
	{
		if (Math_VectorOp::isVector3($v1)
			&& Math_VectorOp::isVector3($v2)
			&& Math_VectorOp::isVector3($v3))
			return Math_VectorOp::dotProduct($v1,Math_VectorOp::crossProduct($v2, $v3));
		else
			return PEAR_Error("All three vectors must be of the same type");
	}/*}}}*/

	/**
	 * Angle between vectors, using the equation: v . w = |v| |w| cos(theta)
	 *
	 * @access	public
	 * @param	object	Math_Vector2 or MathVector3 (or subclass)	$v1
	 * @param	object	Math_Vector2 or MathVector3 (or subclass)	$v2
	 * @return	mixed	the angle between vectors (float, in radians) on success, a PEAR_Error object otherwise
	 *
	 * @see 	isVector2()
	 * @see		isVector3()
	 * @see		dotProduct()
	 */
	function angleBetween($v1, $v2) /*{{{*/
	{
		if ( (Math_VectorOp::isVector2($v1) && Math_VectorOp::isVector2($v2)) || 
			 (Math_VectorOp::isVector3($v1) && Math_VectorOp::isVector3($v2)) ) {
			$v1->normalize();
			$v2->normalize();
			return acos( Math_VectorOp::dotProduct($v1,$v2) );
		} else {
			return PEAR::raiseError("Vectors must be both of the same type");
		}
	}/*}}}*/

	/**
	 * To generate an array of a given size filled with a single value
	 * If available uses array_fill()
	 * 
	 * @access	private
	 * @param	int	$index	starting index
	 * @param	int	$size	size of the array
	 * @param	numeric	$value	value to use for filling the array
	 * @return	array
	 */
	function _fill($index, $size, $value)/*{{{*/
	{
		if (function_exists("array_fill"))
			return array_fill($index, $size, $value);

		for ($i=$index; $i < ($index + $size); $i++)
			$arr[$i] = $value;
		return $arr;
	}/*}}}*/
}


?>