PageRenderTime 74ms CodeModel.GetById 16ms RepoModel.GetById 0ms app.codeStats 1ms

/assessment/macros.php

https://github.com/xiongchiamiov/IMathAS
PHP | 2318 lines | 2171 code | 64 blank | 83 comment | 355 complexity | 3567ac3b6e55cc03ea76356575efc90d MD5 | raw file
    

  1. <?php

    2. 

  2. //IMathAS:  Core randomizers and display macros

    3. 

  3. //(c) 2006 David Lippman

    4. 

  4. 

    5. 

  5. 

    6. 

  6. array_push($allowedmacros,"exp","sec","csc","cot","sech","csch","coth","rand","rrand","rands","rrands","randfrom","randsfrom","jointrandfrom","diffrandsfrom","nonzerorand","nonzerorrand","nonzerorands","nonzerorrands","diffrands","diffrrands","nonzerodiffrands","nonzerodiffrrands","singleshuffle","jointshuffle","makepretty","makeprettydisp","showplot","addlabel","showarrays","horizshowarrays","showasciisvg","listtoarray","arraytolist","calclisttoarray","sortarray","consecutive","gcd","lcm","calconarray","mergearrays","sumarray","dispreducedfraction","diffarrays","intersectarrays","joinarray","unionarrays","count","polymakepretty","polymakeprettydisp","makexpretty","makexprettydisp","calconarrayif","in_array","prettyint","prettyreal","arraystodots","subarray","showdataarray","arraystodoteqns","array_flip","arrayfindindex","fillarray","array_reverse","root");

    7. 

  7. array_push($allowedmacros,"numtowords","randname","randmalename","randfemalename","randnames","randmalenames","randfemalenames","randcity","randcities","prettytime","definefunc","evalfunc","safepow","arrayfindindices","stringtoarray","strtoupper","strtolower","ucfirst","makereducedfraction","stringappend","stringprepend","textonimage","addplotborder","addlabelabs","makescinot","today","numtoroman","sprintf","arrayhasduplicates","addfractionaxislabels","decimaltofraction","ifthen","multicalconarray","htmlentities","formhoverover","formpopup","connectthedots","jointsort","stringpos","stringlen","stringclean","substr","makexxpretty","makexxprettydisp","forminlinebutton");

    8. 

  8. function mergearrays($a,$b) {

    9. 

  9. 	if (!is_array($a)) {

    10. 

  10. 		$a = array($a);

    11. 

  11. 	}

    12. 

  12. 	if (!is_array($b)) {

    13. 

  13. 		$b = array($b);

    14. 

  14. 	}

    15. 

  15. 	return array_merge($a,$b);

    16. 

  16. }

    17. 

  17. function arrayfindindex($n,$h) {

    18. 

  18. 	return array_search($n,$h);

    19. 

  19. }

    20. 

  20. function arrayfindindices($n,$h) {

    21. 

  21. 	return array_keys($h,$n);	

    22. 

  22. }

    23. 

  23. function stringlen($str) {

    24. 

  24. 	return strlen($str);

    25. 

  25. }

    26. 

  26. function stringpos($n,$h) {

    27. 

  27. 	$p = strpos($h,$n);

    28. 

  28. 	if ($p===false) {

    29. 

  29. 		$p = -1;

    30. 

  30. 	}

    31. 

  31. 	return $p;

    32. 

  32. }

    33. 

  33. function stringclean($str,$mode=0) {

    34. 

  34. 	switch($mode) {

    35. 

  35. 	case 0: return trim($str); break;

    36. 

  36. 	case 1: return preg_replace('/\s/','',$str); break;

    37. 

  37. 	case 2: return preg_replace('/\W/','',$str); break;

    38. 

  38. 	}

    39. 

  39. }

    40. 

  40. function stringtoarray($str) {

    41. 

  41.         $str_array=array();

    42. 

  42.         $len=strlen($str);

    43. 

  43.         for($i=0;$i<$len;$i++) {$str_array[]=$str{$i};}

    44. 

  44.         return $str_array;

    45. 

  45. }

    46. 

  46. function jointsort() {

    47. 

  47. 	$in = func_get_args();

    48. 

  48. 	if (count($in)<2 || !is_array($in[0]) || !is_array($in[1])) {

    49. 

  49. 		echo "jointsort needs at least two input arrays";

    50. 

  50. 		return array();

    51. 

  51. 	}

    52. 

  52. 	$a = array_shift($in);

    53. 

  53. 	asort($a);

    54. 

  54. 	$out = array();

    55. 

  55. 	foreach ($a as $k=>$v) {

    56. 

  56. 		for($i=0;$i<count($in);$i++) {

    57. 

  57. 			$out[$i][] = $in[$i][$k];

    58. 

  58. 		}

    59. 

  59. 	}

    60. 

  60. 	array_unshift($out,$a);

    61. 

  61. 	return $out;

    62. 

  62. }

    63. 

  63. 

    64. 

  64. //$funcs can be a string or an array of strings.  Each string should have format:

    65. 

  65. //"function,color,xmin,xmax,startmarker,endmarker,strokewidth,strokedash"

    66. 

  66. //not all entries are required.  To skip middle ones, leave them empty

    67. 

  67. function showplot($funcs) { //optional arguments:  $xmin,$xmax,$ymin,$ymax,labels,grid,width,height

    68. 

  68. 	if (!is_array($funcs)) {

    69. 

  69. 		settype($funcs,"array");

    70. 

  70. 	}

    71. 

  71. 	$settings = array(-5,5,-5,5,1,1,200,200);

    72. 

  72. 	for ($i = 1; $i < func_num_args(); $i++) {

    73. 

  73. 		$settings[$i-1] = func_get_arg($i);

    74. 

  74. 	}

    75. 

  75. 	$ymin = $settings[2];

    76. 

  76. 	$ymax = $settings[3];

    77. 

  77. 	$noyaxis = false;

    78. 

  78. 	if ($ymin==0 && $ymax==0) {

    79. 

  79. 		$ymin = -0.5;

    80. 

  80. 		$ymax = 0.5;

    81. 

  81. 		$noyaxis = true;

    82. 

  82. 		$settings[2] = -0.5;

    83. 

  83. 		$settings[3] = 0.5;

    84. 

  84. 	}

    85. 

  85. 	$xxmin = $settings[0] - 5*($settings[1] - $settings[0])/$settings[6];

    86. 

  86. 	$xxmax = $settings[1] + 5*($settings[1] - $settings[0])/$settings[6];

    87. 

  87. 	$yymin = $settings[2] - 5*($settings[3] - $settings[2])/$settings[7];

    88. 

  88. 	$yymax = $settings[3] + 5*($settings[3] - $settings[2])/$settings[7];

    89. 

  89. 	$yminauto = false;

    90. 

  90. 	$ymaxauto = false;

    91. 

  91. 	if (substr($ymin,0,4)=='auto') {

    92. 

  92. 		$yminauto = true;

    93. 

  93. 		if (strpos($ymin,':')!==false) {

    94. 

  94. 			$ypts = explode(':',$ymin);

    95. 

  95. 			$ymin = $ypts[1];

    96. 

  96. 		} else {

    97. 

  97. 			$ymin = -5;

    98. 

  98. 		}

    99. 

  99. 	}

    100. 

  100. 	if (substr($ymax,0,4)=='auto') {

    101. 

  101. 		$ymaxauto = true;

    102. 

  102. 		if (strpos($ymax,':')!==false) {

    103. 

  103. 			$ypts = explode(':',$ymax);

    104. 

  104. 			$ymax = $ypts[1];

    105. 

  105. 		} else {

    106. 

  106. 			$ymax = 5;

    107. 

  107. 		}

    108. 

  108. 	}

    109. 

  109. 	//$commands = "setBorder(5); initPicture({$settings[0]},{$settings[1]},{$settings[2]},{$settings[3]});";

    110. 

  110. 	//$alt = "Graph, window x {$settings[0]} to {$settings[1]}, y {$settings[2]} to {$settings[3]}.";

    111. 

  111. 	$commands = '';

    112. 

  112. 	$alt = '';

    113. 

  113. 	if (strpos($settings[4],':')) {

    114. 

  114. 		$settings[4] = str_replace(array('(',')'),'',$settings[4]);

    115. 

  115. 		$lbl = explode(':',$settings[4]);

    116. 

  116. 	}

    117. 

  117. 	if (is_numeric($settings[4]) && $settings[4]>0) {

    118. 

  118. 		$commands .= 'axes('.$settings[4].','.$settings[4].',1';

    119. 

  119. 	} else if (isset($lbl[0]) && is_numeric($lbl[0]) && $lbl[0]>0 && $lbl[1]>0) {

    120. 

  120. 		if (!isset($lbl[2])) {  //allow xscl:yscl:off for ticks but no labels

    121. 

  121. 			$commands .= 'axes('.$lbl[0].','.$lbl[1].',1';

    122. 

  122. 		} else {

    123. 

  123. 			$commands .= 'axes('.$lbl[0].','.$lbl[1].',null';

    124. 

  124. 		}

    125. 

  125. 	} else {

    126. 

  126. 		$commands .= 'axes(1,1,null';

    127. 

  127. 	}

    128. 

  128. 	

    129. 

  129. 	if (strpos($settings[5],':')) {

    130. 

  130. 		$settings[5] = str_replace(array('(',')'),'',$settings[5]);

    131. 

  131. 		$grid = explode(':',$settings[5]);

    132. 

  132. 	}

    133. 

  133. 	if (is_numeric($settings[5]) && $settings[5]>0) { 

    134. 

  134. 		$commands .= ','.$settings[5].','.$settings[5];

    135. 

  135. 	} else if (isset($grid[0]) && is_numeric($grid[0]) && $grid[0]>0 && $grid[1]>0) {

    136. 

  136. 		$commands .= ','.$grid[0].','.$grid[1];

    137. 

  137. 	} else {

    138. 

  138. 		$commands .= ',0,0';

    139. 

  139. 		//$commands .= ');';

    140. 

  140. 	}

    141. 

  141. 	if ($noyaxis==true) {

    142. 

  142. 		$commands .= ',1,0);';

    143. 

  143. 	} else {

    144. 

  144. 		$commands .= ');';

    145. 

  145. 	}

    146. 

  146. 	$absymin = 1E10;

    147. 

  147. 	$absymax = -1E10;	

    148. 

  148. 	foreach ($funcs as $function) {

    149. 

  149. 		if ($function=='') { continue;}

    150. 

  150. 		$alt .= "Start Graph";

    151. 

  151. 		$function = explode(",",$function);

    152. 

  152. 		//correct for parametric

    153. 

  153. 		$isparametric = false;

    154. 

  154. 		$isineq = false;

    155. 

  155. 		$isxequals = false;

    156. 

  156. 		if ($function[0]{0}=='[') { //strpos($function[0],"[")===0) {

    157. 

  157. 			$isparametric = true;

    158. 

  158. 			$xfunc = makepretty(str_replace("[","",$function[0]));

    159. 

  159. 			$xfunc = mathphp($xfunc,"t");

    160. 

  160. 			$xfunc = str_replace("(t)",'($t)',$xfunc);

    161. 

  161. 			$yfunc = makepretty(str_replace("]","",$function[1]));

    162. 

  162. 			$yfunc = mathphp($yfunc,"t");

    163. 

  163. 			$yfunc = str_replace("(t)",'($t)',$yfunc);

    164. 

  164. 			array_shift($function);

    165. 

  165. 			$evalxfunc = create_function('$t','return('.$xfunc.');');

    166. 

  166. 			$evalyfunc = create_function('$t','return('.$yfunc.');');

    167. 

  167. 		} else if ($function[0]{0}=='<' || $function[0]{0}=='>') {

    168. 

  168. 			$isineq = true;

    169. 

  169. 			if ($function[0]{1}=='=') {

    170. 

  170. 				$ineqtype = substr($function[0],0,2);

    171. 

  171. 				$func = makepretty(substr($function[0],2));

    172. 

  172. 			} else {

    173. 

  173. 				$ineqtype = $function[0]{0};

    174. 

  174. 				$func = makepretty(substr($function[0],1));

    175. 

  175. 			}

    176. 

  176. 			$func = mathphp($func,"x");

    177. 

  177. 			$func = str_replace("(x)",'($x)',$func);

    178. 

  178. 			$evalfunc = create_function('$x','return('.$func.');');	

    179. 

  179. 		} else if (strlen($function[0])>1 && $function[0]{0}=='x' && ($function[0]{1}=='<' || $function[0]{1}=='>' || $function[0]{1}=='=')) {

    180. 

  180. 			$isxequals = true;

    181. 

  181. 			if ($function[0]{1}=='=') {

    182. 

  182. 				$val = substr($function[0],2);

    183. 

  183. 			} else {

    184. 

  184. 				$isineq = true;

    185. 

  185. 				if ($function[0]{2}=='=') {

    186. 

  186. 					$ineqtype = substr($function[0],1,2);

    187. 

  187. 					$val= substr($function[0],3);

    188. 

  188. 				} else {

    189. 

  189. 					$ineqtype = $function[0]{1};

    190. 

  190. 					$val = substr($function[0],2);

    191. 

  191. 				}

    192. 

  192. 			}

    193. 

  193. 		} else {

    194. 

  194. 			$func = makepretty($function[0]);

    195. 

  195. 			$func = mathphp($func,"x");

    196. 

  196. 			$func = str_replace("(x)",'($x)',$func);

    197. 

  197. 			$evalfunc = create_function('$x','return('.$func.');');

    198. 

  198. 		}

    199. 

  199. 		

    200. 

  200. 		//even though ASCIIsvg has a plot function, we'll calculate it here to hide the function

    201. 

  201. 		

    202. 

  202. 		

    203. 

  203. 		$path = '';

    204. 

  204. 		if (isset($function[1]) && $function[1]!='') {

    205. 

  205. 			$path .= "stroke=\"{$function[1]}\";";

    206. 

  206. 			$alt .= ", Color {$function[1]}";

    207. 

  207. 		} else {

    208. 

  208. 			$path .= "stroke=\"black\";";

    209. 

  209. 			$alt .= ", Color black";

    210. 

  210. 		}

    211. 

  211. 		if (isset($function[6]) && $function[6]!='') {

    212. 

  212. 			$path .= "strokewidth=\"{$function[6]}\";";

    213. 

  213. 		} else {

    214. 

  214. 			$path .= "strokewidth=\"1\";";

    215. 

  215. 		}

    216. 

  216. 		if ($isineq && strlen($ineqtype)==1) {  //is < or >

    217. 

  217. 			$path .= "strokedasharray=\"5\";";

    218. 

  218. 			$alt .= ", Dashed";

    219. 

  219. 		} else if (isset($function[7]) && $function[7]!='') {

    220. 

  220. 			if ($function[7]=="dash") {

    221. 

  221. 				$path .= "strokedasharray=\"5\";";

    222. 

  222. 				$alt .= ", Dashed";

    223. 

  223. 			} else {

    224. 

  224. 				$path .= "strokedasharray=\"none\";";

    225. 

  225. 			}

    226. 

  226. 		} else {

    227. 

  227. 			$path .= "strokedasharray=\"none\";";

    228. 

  228. 		}

    229. 

  229. 		$path .= "fill=\"none\";";

    230. 

  230. 		

    231. 

  231. 		if ($isxequals) { //handle x-equals case separately

    232. 

  232. 			$alt .= "<table class=stats><thead><tr><th>x</th><th>y</th></thead></tr><tbody>";

    233. 

  233. 			$alt .= "<tr><td>$val</td><td>$ymin</td></tr>";

    234. 

  234. 			$alt .= "<tr><td>$val</td><td>$ymax</td></tr>";

    235. 

  235. 			$alt .= '</tbody></table>';

    236. 

  236. 			$path .= "line([$val,$ymin],[$val,$ymax]);";

    237. 

  237. 			$path .= "stroke=\"none\";strokedasharray=\"none\";";

    238. 

  238. 			if ($function[1]=='red' || $function[1]=='green') {

    239. 

  239. 				$path .= "fill=\"trans{$function[1]}\";";

    240. 

  240. 			} else {

    241. 

  241. 				$path .= "fill=\"transblue\";";

    242. 

  242. 			}

    243. 

  243. 			if ($isineq) {

    244. 

  244. 				if ($ineqtype{0}=='<') {

    245. 

  245. 					$path .= "rect([$xxmin,$yymin],[$val,$yymax]);";

    246. 

  246. 					$alt .= "Shaded left";

    247. 

  247. 				} else {

    248. 

  248. 					$path .= "rect([$val,$yymin],[$xxmax,$yymax]);";

    249. 

  249. 					$alt .= "Shaded right";

    250. 

  250. 				}

    251. 

  251. 			}

    252. 

  252. 			$commands .= $path;

    253. 

  253. 			continue;

    254. 

  254. 		}

    255. 

  255. 		$avoid = array();

    256. 

  256. 		$domainlimited = false;

    257. 

  257. 		if (isset($function[2]) && $function[2]!='') {

    258. 

  258. 			$xmin = $function[2]; 

    259. 

  259. 			$domainlimited = true;

    260. 

  260. 		} else {$xmin = $settings[0];}

    261. 

  261. 		if (isset($function[3]) && $function[3]!='') {

    262. 

  262. 			$xmaxarr = explode('!',$function[3]);

    263. 

  263. 			$xmax = $xmaxarr[0];

    264. 

  264. 			$avoid = array_slice($xmaxarr,1);

    265. 

  265. 			$domainlimited = true;

    266. 

  266. 		} else {$xmax = $settings[1];}

    267. 

  267. 		

    268. 

  268. 		if ($GLOBALS['sessiondata']['graphdisp']==0) {

    269. 

  269. 			$dx = 1;

    270. 

  270. 			$alt .= "<table class=stats><thead><tr><th>x</th><th>y</th></thead></tr><tbody>";

    271. 

  271. 			$stopat = ($xmax-$xmin)+1;

    272. 

  272. 		} else {

    273. 

  273. 			$dx = ($xmax - $xmin + ($domainlimited?0:10*($xmax-$xmin)/$settings[6]) )/100;

    274. 

  274. 			$stopat = ($domainlimited?101:102);

    275. 

  275. 			if ($xmax==$xmin) {

    276. 

  276. 				$stopat = 1;

    277. 

  277. 			}

    278. 

  278. 		}

    279. 

  279. 		$lasty = 0;

    280. 

  280. 		$lastl = 0;

    281. 

  281. 		$px = null;

    282. 

  282. 		$py = null;

    283. 

  283. 		$pathstr = '';

    284. 

  284. 		$firstpoint = false;

    285. 

  285. 		for ($i = 0; $i<$stopat;$i++) {

    286. 

  286. 			if ($isparametric) {

    287. 

  287. 				$t = $xmin + $dx*$i + 1E-10;

    288. 

  288. 				if (in_array($t,$avoid)) { continue;}

    289. 

  289. 				$x = round($evalxfunc($t),3);//round(eval("return ($xfunc);"),3);

    290. 

  290. 				$y = round($evalyfunc($t),3);//round(eval("return ($yfunc);"),3);

    291. 

  291. 				$alt .= "<tr><td>$x</td><td>$y</td></tr>";

    292. 

  292. 			} else {

    293. 

  293. 				$x = $xmin + $dx*$i + 1E-10 - ($domainlimited?0:5*($xmax-$xmin)/$settings[6]);

    294. 

  294. 				if (in_array($x,$avoid)) { continue;}

    295. 

  295. 				//echo $func.'<br/>';

    296. 

  296. 				$y = round($evalfunc($x),3);//round(eval("return ($func);"),3);

    297. 

  297. 				$alt .= "<tr><td>".($xmin + $dx*$i)."</td><td>$y</td></tr>";

    298. 

  298. 			}

    299. 

  299. 			

    300. 

  300. 			if (isNaN($y)) {

    301. 

  301. 				continue;

    302. 

  302. 			}

    303. 

  303. 			if ($py===null) { //starting line

    304. 

  304. 				

    305. 

  305. 			} else if ($y>$ymax || $y<$ymin) { //going or still out of bounds

    306. 

  306. 				if ($py <= $ymax && $py >= $ymin) { //going out

    307. 

  307. 					if ($y>$ymax) { //going up

    308. 

  308. 						$iy = $ymax + 5*($ymax-$ymin)/$settings[7];

    309. 

  309. 					} else { //going down

    310. 

  310. 						$iy = $ymin - 5*($ymax-$ymin)/$settings[7];

    311. 

  311. 					}

    312. 

  312. 					$ix = ($x-$px)*($iy - $py)/($y-$py) + $px;

    313. 

  313. 					if ($lastl == 0) {$pathstr .= "path([";} else { $pathstr .= ",";}

    314. 

  314. 					$pathstr .= "[$px,$py],[$ix,$iy]]);";

    315. 

  315. 					$lastl = 0;

    316. 

  316. 				} else { //still out

    317. 

  317. 					

    318. 

  318. 				}

    319. 

  319. 			} else if ($py>$ymax || $py<$ymin) { //coming or staying in bounds?

    320. 

  320. 				if ($y <= $ymax && $y >= $ymin) { //coming in

    321. 

  321. 					if ($py>$ymax) { //going up

    322. 

  322. 						$iy = $ymax + 5*($ymax-$ymin)/$settings[7];

    323. 

  323. 					} else { //going down

    324. 

  324. 						$iy = $ymin - 5*($ymax-$ymin)/$settings[7];

    325. 

  325. 					}

    326. 

  326. 					$ix = ($x-$px)*($iy - $py)/($y-$py) + $px;

    327. 

  327. 					if ($lastl == 0) {$pathstr .= "path([";} else { $pathstr .= ",";}

    328. 

  328. 					$pathstr .= "[$ix,$iy]";

    329. 

  329. 					$lastl++;

    330. 

  330. 				} else { //still out

    331. 

  331. 					

    332. 

  332. 				}

    333. 

  333. 			} else {//all in

    334. 

  334. 				if ($lastl == 0) {$pathstr .= "path([";} else { $pathstr .= ",";}

    335. 

  335. 				$pathstr .= "[$px,$py]";

    336. 

  336. 				$lastl++;

    337. 

  337. 			}

    338. 

  338. 			$px = $x;

    339. 

  339. 			$py = $y;

    340. 

  340. 			/*if (abs($y-$lasty) > ($ymax-$ymin)) {

    341. 

  341. 				if ($lastl > 1) { $pathstr .= ']);'; $lastl = 0;}

    342. 

  342. 				$lasty = $y;

    343. 

  343. 			} else {

    344. 

  344. 				if ($lastl == 0) {$pathstr .= "path([";} else { $pathstr .= ",";}

    345. 

  345. 				$pathstr .= "[$x,$y]";

    346. 

  346. 				$lasty = $y;

    347. 

  347. 				$lastl++;

    348. 

  348. 				if ($y<$absymin) {

    349. 

  349. 					$absymin = $y;

    350. 

  350. 				}

    351. 

  351. 				if ($y>$absymax) {

    352. 

  352. 					$absymax = $y;

    353. 

  353. 				}

    354. 

  354. 			}

    355. 

  355. 			*/

    356. 

  356. 		}

    357. 

  357. 		if ($lastl > 0) {$pathstr .= "]);";}

    358. 

  358. 		$path .= $pathstr;

    359. 

  359. 		$alt .= "</tbody></table>\n";

    360. 

  360. 		

    361. 

  361. 		if ($isineq) {

    362. 

  362. 			

    363. 

  363. 			$pathstr = substr($pathstr,0,-3);

    364. 

  364. 			preg_match('/^path\(\[\[(-?[\d\.]+),(-?[\d\.]+).*(-?[\d\.]+),(-?[\d\.]+)\]$/',$pathstr,$matches);

    365. 

  365. 			$sig = ($xxmax-$xxmin)/100;

    366. 

  366. 			$ymid = ($yymax + $yymin)/2;

    367. 

  367. 			if ($ineqtype{0}=='<') {

    368. 

  368. 				if (abs($matches[3] - $xxmax)>$sig && $matches[4]>$ymid) {

    369. 

  369. 					$pathstr .= ",[$xxmax,$yymax]"; //need to add upper right corner	

    370. 

  370. 				}

    371. 

  371. 				$pathstr .= ",[$xxmax,$yymin],[$xxmin,$yymin]";

    372. 

  372. 				if (abs($matches[1] - $xxmin)>$sig  && $matches[2]>$ymid) {

    373. 

  373. 					$pathstr .= ",[$xxmin,$yymax]"; //need to add upper left corner	

    374. 

  374. 				}

    375. 

  375. 				$pathstr .= ']);';

    376. 

  376. 			} else {

    377. 

  377. 				if (abs($matches[3] - $xxmax)>$sig && $matches[4]<$ymid) {

    378. 

  378. 					$pathstr .= ",[$xxmax,$yymin]"; //need to add lower right corner	

    379. 

  379. 				}

    380. 

  380. 				$pathstr .= ",[$xxmax,$yymax],[$xxmin,$yymax]";

    381. 

  381. 				if (abs($matches[1] - $xxmin)>$sig  && $matches[2]<$ymid) {

    382. 

  382. 					$pathstr .= ",[$xxmin,$yymin]"; //need to add lower left corner	

    383. 

  383. 				}

    384. 

  384. 				$pathstr .= ']);';

    385. 

  385. 			}

    386. 

  386. 			if ($function[1]=='red' || $function[1]=='green') {

    387. 

  387. 				$path .= "fill=\"trans{$function[1]}\";";

    388. 

  388. 			} else {

    389. 

  389. 				$path .= "fill=\"transblue\";";

    390. 

  390. 			}

    391. 

  391. 			$path .= "stroke=\"none\";strokedasharray=\"none\";$pathstr";

    392. 

  392. 		}

    393. 

  393. 		if (isset($function[5]) && $function[5]=='open') {

    394. 

  394. 			$path .= "dot([$x,$y],\"open\");";

    395. 

  395. 			$alt .= "Open dot at $x,$y";

    396. 

  396. 		} else if (isset($function[5]) && $function[5]=='closed') {

    397. 

  397. 			$path .= "dot([$x,$y],\"closed\");";

    398. 

  398. 			$alt .= "Closed dot at $x,$y";

    399. 

  399. 		}

    400. 

  400. 		if (isset($function[4]) && $function[4]=='open') {

    401. 

  401. 			if ($isparametric) {

    402. 

  402. 				$t = $xmin;

    403. 

  403. 				$x = round(eval("return ($xfunc);"),3);

    404. 

  404. 				$y = round(eval("return ($yfunc);"),3);

    405. 

  405. 			} else {

    406. 

  406. 				$x = $xmin; $y = round(eval("return ($func);"),4); 

    407. 

  407. 			}

    408. 

  408. 			$path .= "dot([$x,$y],\"open\");";

    409. 

  409. 			if ($y<$absymin) {

    410. 

  410. 				$absymin = $y;

    411. 

  411. 			}

    412. 

  412. 			if ($y>$absymax) {

    413. 

  413. 				$absymax = $y;

    414. 

  414. 			}

    415. 

  415. 			$alt .= "Open dot at $x,$y";

    416. 

  416. 		} else if (isset($function[4]) && $function[4]=='closed') {

    417. 

  417. 			if ($isparametric) {

    418. 

  418. 				$t = $xmin;

    419. 

  419. 				$x = round(eval("return ($xfunc);"),3);

    420. 

  420. 				$y = round(eval("return ($yfunc);"),3);

    421. 

  421. 			} else {

    422. 

  422. 				$x = $xmin; $y = round(eval("return ($func);"),4); 

    423. 

  423. 			}

    424. 

  424. 			$path .= "dot([$x,$y],\"closed\");";

    425. 

  425. 			if ($y<$absymin) {

    426. 

  426. 				$absymin = $y;

    427. 

  427. 			}

    428. 

  428. 			if ($y>$absymax) {

    429. 

  429. 				$absymax = $y;

    430. 

  430. 			}

    431. 

  431. 			$alt .= "Closed dot at $x,$y";

    432. 

  432. 		}

    433. 

  433. 		

    434. 

  434. 		$commands .= $path;

    435. 

  435. 	}

    436. 

  436. 	if ($yminauto) {

    437. 

  437. 		$settings[2] = max($absymin,$ymin);

    438. 

  438. 	}

    439. 

  439. 	if ($ymaxauto) {

    440. 

  440. 		$settings[3] = min($absymax,$ymax);

    441. 

  441. 	}

    442. 

  442. 	$commands = "setBorder(5); initPicture({$settings[0]},{$settings[1]},{$settings[2]},{$settings[3]});".$commands;

    443. 

  443. 	$alt = "Graph, window x {$settings[0]} to {$settings[1]}, y {$settings[2]} to {$settings[3]}.".$alt;

    444. 

  444. 	

    445. 

  445. 	if ($GLOBALS['sessiondata']['graphdisp']==0) {

    446. 

  446. 		return $alt;

    447. 

  447. 	} else {

    448. 

  448. 		return "<embed type='image/svg+xml' align='middle' width='$settings[6]' height='$settings[7]' src='{$GLOBALS['imasroot']}/javascript/d.svg' script='$commands' />\n";

    449. 

  449. 	}

    450. 

  450. }

    451. 

  451. 

    452. 

  452. function addplotborder($plot,$left,$bottom=5,$right=5,$top=5) {

    453. 

  453. 	return str_replace("setBorder(5)","setBorder($left,$bottom,$right,$top)",$plot);	

    454. 

  454. 	

    455. 

  455. }

    456. 

  456. 

    457. 

  457. function addlabel($plot,$x,$y,$lbl) {

    458. 

  458. 	if (func_num_args()>4) {

    459. 

  459. 		$color = func_get_arg(4);

    460. 

  460. 	} else {

    461. 

  461. 		$color = "black";

    462. 

  462. 	}

    463. 

  463. 	if (func_num_args()>6) {

    464. 

  464. 		$loc = func_get_arg(5);

    465. 

  465. 		$angle = func_get_arg(6);

    466. 

  466. 		$plot = str_replace("' />","fontfill=\"$color\";text([$x,$y],\"$lbl\",\"$loc\",\"$angle\");' />",$plot);

    467. 

  467. 	} elseif (func_num_args()>5) {

    468. 

  468. 		$loc = func_get_arg(5);

    469. 

  469. 		$plot = str_replace("' />","fontfill=\"$color\";text([$x,$y],\"$lbl\",\"$loc\");' />",$plot);

    470. 

  470. 	} else {

    471. 

  471. 		$plot = str_replace("' />","fontfill=\"$color\";text([$x,$y],\"$lbl\");' />",$plot);

    472. 

  472. 	}

    473. 

  473. 	return $plot;

    474. 

  474. }

    475. 

  475. function addlabelabs($plot,$x,$y,$lbl) {

    476. 

  476. 	if (func_num_args()>4) {

    477. 

  477. 		$color = func_get_arg(4);

    478. 

  478. 	} else {

    479. 

  479. 		$color = "black";

    480. 

  480. 	}

    481. 

  481. 	if (func_num_args()>6) {

    482. 

  482. 		$loc = func_get_arg(5);

    483. 

  483. 		$angle = func_get_arg(6);

    484. 

  484. 		$plot = str_replace("' />","fontfill=\"$color\";textabs([$x,$y],\"$lbl\",\"$loc\",\"$angle\");' />",$plot);

    485. 

  485. 	} elseif (func_num_args()>5) {

    486. 

  486. 		$loc = func_get_arg(5);

    487. 

  487. 		$plot = str_replace("' />","fontfill=\"$color\";textabs([$x,$y],\"$lbl\",\"$loc\");' />",$plot);

    488. 

  488. 	} else {

    489. 

  489. 		$plot = str_replace("' />","fontfill=\"$color\";textabs([$x,$y],\"$lbl\");' />",$plot);

    490. 

  490. 	}

    491. 

  491. 	return $plot;

    492. 

  492. }

    493. 

  493. 

    494. 

  494. function addfractionaxislabels($plot,$step) {

    495. 

  495. 	if (strpos($step,'/')===false) {

    496. 

  496. 		$num = $step; $den = 1;

    497. 

  497. 	} else {

    498. 

  498. 		list($num,$den) = explode('/',$step);

    499. 

  499. 	}

    500. 

  500. 	$ispi = false;

    501. 

  501. 	if (strpos($num,'pi')!==false) {

    502. 

  502. 		$ispi = true;

    503. 

  503. 		$num = str_replace('pi','',$num);

    504. 

  504. 		if ($num=='') { $num = 1;}

    505. 

  505. 	}

    506. 

  506. 	preg_match('/initPicture\(([\-\d\.]+),([\-\d\.]+),([\-\d\.]+),([\-\d\.]+)\)/',$plot,$matches);

    507. 

  507. 	$xmin = $matches[1];

    508. 

  508. 	$xmax = $matches[2];

    509. 

  509. 	$yrange = $matches[4] - $matches[2];

    510. 

  510. 	$stepn = $num/$den;

    511. 

  511. 	if ($ispi) { $stepn *= M_PI;}

    512. 

  512. 	if ($stepn==0) {echo "error: bad step size on pilabels"; return;}

    513. 

  513. 	$step = ceil($xmin/$stepn);

    514. 

  514. 	$totstep = ceil(($xmax-$xmin)/$stepn);

    515. 

  515. 	$tm = -.03*$yrange;

    516. 

  516. 	$tx = .03*$yrange;

    517. 

  517. 	$outst = 'fontfill="black";strokewidth=0.5;stroke="black";';

    518. 

  518. 	for ($i=0; $i<$totstep; $i++) {

    519. 

  519. 		$x = $step*$stepn;

    520. 

  520. 		if (abs($x)<.01) {$step++; continue;}

    521. 

  521. 		$g = gcd($step*$num,$den);

    522. 

  522. 		$n = ($step*$num)/$g;  $d = $den/$g;

    523. 

  523. 		if ($ispi) {

    524. 

  524. 			if ($n==1) {

    525. 

  525. 				$xd = '&pi;';

    526. 

  526. 			} else if ($n==-1) {

    527. 

  527. 				$xd = '-&pi;';

    528. 

  528. 			} else {

    529. 

  529. 				$xd = "$n&pi;";

    530. 

  530. 			}

    531. 

  531. 		} else {

    532. 

  532. 			$xd = $n;

    533. 

  533. 		}

    534. 

  534. 		if ($d!=1) {$xd .= "/$d";}

    535. 

  535. 		$outst .= "line([$x,$tm],[$x,$tx]); text([$x,0],\"$xd\",\"below\");";

    536. 

  536. 		$step++;

    537. 

  537. 	}

    538. 

  538. 	return str_replace("' />","$outst' />",$plot);

    539. 

  539. 	

    540. 

  540. }

    541. 

  541. 

    542. 

  542. function connectthedots($xarray,$yarray,$color='black',$thick=1,$startdot='',$enddot='') {

    543. 

  543. 	if (count($xarray)!=count($yarray)) {

    544. 

  544. 		echo "Error: x array and y array need to have the same number of elements";

    545. 

  545. 	}

    546. 

  546. 	$outarr = array();

    547. 

  547. 	for ($i=1; $i<count($xarray); $i++) {

    548. 

  548. 		if ($i==1) {$ed = $startdot;} else {$ed = '';}

    549. 

  549. 		if ($i==count($xarray)-1) {$sd = $enddot;} else {$sd = '';}

    550. 

  550. 		if ($xarray[$i-1]==$xarray[$i]) {

    551. 

  551. 			//vertical line

    552. 

  552. 			$outarr[] = "[{$xarray[$i]},t],$color,{$yarray[$i]},{$yarray[$i-1]},$sd,$ed,$thick";

    553. 

  553. 		} else {

    554. 

  554. 			$xd = $xarray[$i-1] - $xarray[$i];

    555. 

  555. 			$yd = $yarray[$i-1] - $yarray[$i];

    556. 

  556. 			$outarr[] = "[{$xarray[$i]}+t*($xd),{$yarray[$i]}+t*($yd)],$color,0,1,$sd,$ed,$thick";

    557. 

  557. 		}

    558. 

  558. 	}

    559. 

  559. 	return $outarr;

    560. 

  560. }

    561. 

  561. 

    562. 

  562. function showasciisvg($script) {

    563. 

  563. 	if (func_num_args()>2) {

    564. 

  564. 		$width = func_get_arg(1);

    565. 

  565. 		$height = func_get_arg(2);

    566. 

  566. 	} else {

    567. 

  567. 		$width = 200; $height = 200;

    568. 

  568. 	}

    569. 

  569. 	$script = str_replace("'",'"',$script);

    570. 

  570. 	return "<embed type='image/svg+xml' align='middle' width='$width' height='$height' src='{$GLOBALS['imasroot']}/javascript/d.svg' script='$script' />\n";

    571. 

  571. }

    572. 

  572. 

    573. 

  573. 

    574. 

  574. function showarrays() {

    575. 

  575. 	$alist = func_get_args();

    576. 

  576. 	if (count($alist)<2) {return false;}

    577. 

  577. 	if (count($alist)%2==1) {

    578. 

  578. 		$format = substr($alist[count($alist)-1],0,1);

    579. 

  579. 	} 

    580. 

  580. 	if (count($alist)<4 && is_array($alist[0])) {

    581. 

  581. 		for ($i=0;$i<count($alist[0]);$i++) {

    582. 

  582. 			$newalist[] = $alist[0][$i];

    583. 

  583. 			$newalist[] = $alist[1][$i];

    584. 

  584. 		}

    585. 

  585. 		$alist = $newalist;

    586. 

  586. 	}

    587. 

  587. 	$out = '<table class=stats><thead><tr>';

    588. 

  588. 	for ($i = 0; $i<floor(count($alist)/2); $i++) {

    589. 

  589. 		$out .= "<th scope=\"col\">{$alist[2*$i]}</th>";

    590. 

  590. 	}

    591. 

  591. 	$out .= "</tr></thead><tbody>";

    592. 

  592. 	for ($j = 0; $j<count($alist[1]); $j++) {

    593. 

  593. 		$out .="<tr>";

    594. 

  594. 		for ($i = 0; $i<floor(count($alist)/2); $i++) {

    595. 

  595. 			if ($format=='c' || $format=='C') {

    596. 

  596. 				$out .= '<td class="c">';

    597. 

  597. 			} else if ($format=='r' || $format=='R') {

    598. 

  598. 				$out .= '<td class="r">';

    599. 

  599. 			} else if ($format=='l' || $format=='L') {

    600. 

  600. 				$out .= '<td class="l">';

    601. 

  601. 			} else {

    602. 

  602. 				$out .= '<td>';

    603. 

  603. 			}

    604. 

  604. 			$out .= "{$alist[2*$i+1][$j]}</td>";

    605. 

  605. 		}

    606. 

  606. 		$out .="</tr>";

    607. 

  607. 	}

    608. 

  608. 	$out .= "</tbody></table>\n";

    609. 

  609. 	return $out;

    610. 

  610. }

    611. 

  611. 

    612. 

  612. 

    613. 

  613. function horizshowarrays() {

    614. 

  614. 	$alist = func_get_args();

    615. 

  615. 	if (count($alist)<2) {return false;}

    616. 

  616. 

    617. 

  617. 	

    618. 

  618. 	$out = '<table class=stats>';

    619. 

  619. 	for ($i=0; $i<count($alist)/2; $i++) {

    620. 

  620. 		$out .= "<tr><th scope=\"row\"><b>{$alist[2*$i]}</b></th>";

    621. 

  621. 		$out .= "<td>" . implode("</td><td>",$alist[2*$i+1]) . "</td></tr>\n";

    622. 

  622. 	}

    623. 

  623. 	$out .= "</tbody></table>\n";

    624. 

  624. 	return $out;

    625. 

  625. }

    626. 

  626. 

    627. 

  627. 

    628. 

  628. function clean($exp) {

    629. 

  629. 	$exp = preg_replace('/(\+|\-)\s+(\+|\-)/',"$1$2",$exp);

    630. 

  630. 	//$exp = str_replace(" ", "", $exp);  //caused problems with "x > -3"

    631. 

  631. 	$exp = str_replace("+-","-",$exp);

    632. 

  632. 	$exp = str_replace("-+","-",$exp);

    633. 

  633. 	$exp = str_replace("--","+",$exp);

    634. 

  634. 	//$exp = preg_replace('/^1\*?([a-zA-Z\(])/',"$1",$exp);

    635. 

  635. 	//$exp = preg_replace('/([^\d\^\.])1\*?([a-zA-Z\(])/',"$1$2",$exp);

    636. 

  636. 	return $exp;

    637. 

  637. }

    638. 

  638. 

    639. 

  639. function xclean($exp) {

    640. 

  640. 	//goals are to cleam up  1*, 0*  0+  0-  a^0  a^1

    641. 

  641. 	$exp = clean($exp);

    642. 

  642. 	$exp = preg_replace('/^([a-zA-Z])\^0/','1',$exp); //x^0 -> 1

    643. 

  643. 	$exp = preg_replace('/(\d)\*?([a-zA-Z])\^0$/',"$1",$exp);   //3x^0  -> 3

    644. 

  644. 	$exp = preg_replace('/(\d)\*?([a-zA-Z])\^0([^\d\.])/',"$1$3",$exp); //3x^0+4 -> 3+4

    645. 

  645. 	$exp = preg_replace('/([^\d])\*?([a-zA-Z])\^0$/',"$1 1",$exp); //y*x^0 -> y*1,  y+x^0 -> y+1

    646. 

  646. 	$exp = preg_replace('/([^\d])\*?([a-zA-Z])\^0([^\d\.])/',"$1 1 $3",$exp);  //y*x^0+3 -> y*1+3,  y+x^0+z -> y+1+z

    647. 

  647. 	$exp = preg_replace('/^0\s*\*?[^\+\-\.]+\+?/','',$exp); // 0*23+x

    648. 

  648. 	$exp = preg_replace('/^0\s*([\+\-])/',"$1",$exp);  //0+x, 0-x

    649. 

  649. 	$exp = preg_replace('/[\+\-]\s*0\s*\*?[^\.\+\-]+/','',$exp); //3+0x-4 -> 3-4

    650. 

  650. 	$exp = preg_replace('/[\+\-]\s*0\s*([\+\-])/',"$1",$exp);  //3+0+4 -> 3+4

    651. 

  651. 	$exp = preg_replace('/^1\s*\*?([a-zA-Z])/',"$1",$exp);  //1x -> x

    652. 

  652. 	$exp = preg_replace('/([^\d\^\.])1\s*\*?([a-zA-Z\(])/',"$1$2",$exp);  //3+1x -> 3+x

    653. 

  653. 	$exp = preg_replace('/\^1([^\d])/',"$1",$exp); //3x^1+4 =>3x+4 

    654. 

  654. 	$exp = preg_replace('/\^1$/','',$exp);  //4x^1 -> 4x

    655. 

  655. 	$exp = clean($exp);

    656. 

  656. 	if ($exp{0}=='+') {

    657. 

  657. 		$exp = substr($exp,1);

    658. 

  658. 	}

    659. 

  659. 	return $exp;

    660. 

  660. }

    661. 

  661. 

    662. 

  662. function polyclean($exp) {

    663. 

  663. 	$exp = clean($exp);

    664. 

  664. 	

    665. 

  665. 	$i = 0;

    666. 

  666. 	$outstr = '';

    667. 

  667. 	$p = 0;

    668. 

  668. 	$parr = array('','','');

    669. 

  669. 	$onpow = false;

    670. 

  670. 	$lastsign = '+';

    671. 

  671. 	$exp .= '+';

    672. 

  672. 	while ($i<strlen($exp)) {

    673. 

  673. 		$c = $exp{$i};

    674. 

  674. 		if (($c >='0' && $c<='9') || $c=='.' || $c=='/' || $c=='(' || $c==')') {

    675. 

  675. 			if ($onpow) {

    676. 

  676. 				$parr[2] .= $c;

    677. 

  677. 			} else {

    678. 

  678. 				$parr[0] .= $c;

    679. 

  679. 			}

    680. 

  680. 		} else if (($c<='z' && $c>='a') || ($c<='Z' && $c>='A')) {

    681. 

  681. 			$parr[1] .= $c;

    682. 

  682. 		} else if ($c=='^') {

    683. 

  683. 			$onpow = true;

    684. 

  684. 		} else if ($c == '+' || $c == '-') {

    685. 

  685. 			if ($i+1<strlen($exp) && $parr[2]=='' && $onpow) {

    686. 

  686. 				$n = $exp{$i+1};

    687. 

  687. 				if ($c=='-' && (($n>= '0' && $n<='9') || $n=='.')) {

    688. 

  688. 					$parr[2] .= '-';

    689. 

  689. 					$i++;

    690. 

  690. 					continue;

    691. 

  691. 				}

    692. 

  692. 			}

    693. 

  693. 			if ($parr[0]=='0') {

    694. 

  694. 				$parr = array('','','');

    695. 

  695. 				$onpow = false;

    696. 

  696. 				$i++;

    697. 

  697. 				$lastsign = $c;

    698. 

  698. 				continue;

    699. 

  699. 			} else {

    700. 

  700. 				if ($outstr!='' || $lastsign=='-') {

    701. 

  701. 					$outstr .= $lastsign;

    702. 

  702. 				}

    703. 

  703. 				

    704. 

  704. 			}

    705. 

  705. 			if ($parr[2]=='0' || ($parr[2]=='' && $parr[1]=='')) {

    706. 

  706. 				if ($parr[1]=='') {

    707. 

  707. 					$outstr .= $parr[0]; // n

    708. 

  708. 				} else {

    709. 

  709. 					if ($parr[0] == '') {

    710. 

  710. 						$outstr .= 1; // x^0

    711. 

  711. 					} else {

    712. 

  712. 						$outstr .= $parr[0]; //n x^0

    713. 

  713. 					}

    714. 

  714. 				}

    715. 

  715. 			} else if ($parr[2]=='') {

    716. 

  716. 				if ($parr[0]=='1') {

    717. 

  717. 					$outstr .= $parr[1];

    718. 

  718. 				} else {

    719. 

  719. 					$outstr .= $parr[0].' '.$parr[1];

    720. 

  720. 				}

    721. 

  721. 			} else if ($parr[2]=='1') {

    722. 

  722. 				if ($parr[0]=='1') {

    723. 

  723. 					$outstr .= $parr[1];

    724. 

  724. 				} else {

    725. 

  725. 					$outstr .= $parr[0] . ' ' . $parr[1]; //n x^1

    726. 

  726. 				}

    727. 

  727. 			} else {

    728. 

  728. 				if ($parr[0]=='1') {

    729. 

  729. 					$outstr .= $parr[1] . '^' . $parr[2]; // 1 x^m

    730. 

  730. 				} else {

    731. 

  731. 					$outstr .= $parr[0] . ' ' . $parr[1] . '^' . $parr[2]; // n x^m

    732. 

  732. 				}

    733. 

  733. 			}

    734. 

  734. 			$lastsign = $c;

    735. 

  735. 			$parr = array('','','');

    736. 

  736. 			$onpow = false;

    737. 

  737. 		}

    738. 

  738. 		$i++;

    739. 

  739. 	}

    740. 

  740. 	return $outstr;

    741. 

  741. 	/*

    742. 

  742. 	$exp = clean($exp);

    743. 

  743. 	if ($exp{0}=='+') {

    744. 

  744. 		$exp = substr($exp,1);

    745. 

  745. 	}

    746. 

  746. 	return $exp;

    747. 

  747. 	*/

    748. 

  748. }

    749. 

  749. 

    750. 

  750. function makepretty($exp) {

    751. 

  751. 	if (is_array($exp)) {

    752. 

  752. 		for ($i=0;$i<count($exp);$i++) {

    753. 

  753. 			$exp[$i]=clean($exp[$i]);

    754. 

  754. 		}

    755. 

  755. 	} else {

    756. 

  756. 		$exp = clean($exp);

    757. 

  757. 	}

    758. 

  758. 	return $exp;

    759. 

  759. }

    760. 

  760. 

    761. 

  761. function makexpretty($exp) {

    762. 

  762. 	if (is_array($exp)) {

    763. 

  763. 		for ($i=0;$i<count($exp);$i++) {

    764. 

  764. 			$exp[$i]=xclean($exp[$i]);

    765. 

  765. 		}

    766. 

  766. 	} else {

    767. 

  767. 		$exp = xclean($exp);

    768. 

  768. 	}

    769. 

  769. 	return $exp;

    770. 

  770. }

    771. 

  771. 

    772. 

  772. function makexxpretty($exp,$funcs=array()) {

    773. 

  773. 	if (is_array($exp)) {

    774. 

  774. 		for ($i=0;$i<count($exp);$i++) {

    775. 

  775. 			$exp[$i] = clean($exp[$i]);

    776. 

  776. 			$exp[$i]=cleanbytoken($exp[$i],$funcs);

    777. 

  777. 		}

    778. 

  778. 	} else {

    779. 

  779. 		$exp = clean($exp);

    780. 

  780. 		$exp = cleanbytoken($exp,$funcs);

    781. 

  781. 	}

    782. 

  782. 	return $exp;

    783. 

  783. }

    784. 

  784. 

    785. 

  785. function polymakepretty($exp) {

    786. 

  786. 	if (is_array($exp)) {

    787. 

  787. 		for ($i=0;$i<count($exp);$i++) {

    788. 

  788. 			$exp[$i]=polyclean($exp[$i]);

    789. 

  789. 		}

    790. 

  790. 	} else {

    791. 

  791. 		$exp = polyclean($exp);

    792. 

  792. 	}

    793. 

  793. 	return $exp;

    794. 

  794. }

    795. 

  795. 

    796. 

  796. 

    797. 

  797. 

    798. 

  798. function makeprettydisp($exp) {

    799. 

  799. 	if (is_array($exp)) {

    800. 

  800. 		for ($i=0;$i<count($exp);$i++) {

    801. 

  801. 			$exp[$i]="`".clean($exp[$i])."`";

    802. 

  802. 		}

    803. 

  803. 	} else {

    804. 

  804. 		$exp = "`".clean($exp)."`";

    805. 

  805. 	}

    806. 

  806. 	return $exp;

    807. 

  807. }

    808. 

  808. 

    809. 

  809. function makexprettydisp($exp) {

    810. 

  810. 	if (is_array($exp)) {

    811. 

  811. 		for ($i=0;$i<count($exp);$i++) {

    812. 

  812. 			$exp[$i]="`".xclean($exp[$i])."`";

    813. 

  813. 		}

    814. 

  814. 	} else {

    815. 

  815. 		$exp = "`".xclean($exp)."`";

    816. 

  816. 	}

    817. 

  817. 	return $exp;

    818. 

  818. }

    819. 

  819. 

    820. 

  820. function makexxprettydisp($exp,$funcs=array()) {

    821. 

  821. 	if (is_array($exp)) {

    822. 

  822. 		for ($i=0;$i<count($exp);$i++) {

    823. 

  823. 			$exp[$i] = clean($exp[$i]);

    824. 

  824. 			$exp[$i]="`".cleanbytoken($exp[$i],$funcs)."`";

    825. 

  825. 		}

    826. 

  826. 	} else {

    827. 

  827. 		$exp = clean($exp);

    828. 

  828. 		$exp = "`".cleanbytoken($exp,$funcs)."`";

    829. 

  829. 	}

    830. 

  830. 	return $exp;

    831. 

  831. }

    832. 

  832. 

    833. 

  833. function polymakeprettydisp($exp) {

    834. 

  834. 	if (is_array($exp)) {

    835. 

  835. 		for ($i=0;$i<count($exp);$i++) {

    836. 

  836. 			$exp[$i]="`".polyclean($exp[$i])."`";

    837. 

  837. 		}

    838. 

  838. 	} else {

    839. 

  839. 		$exp = "`".polyclean($exp)."`";

    840. 

  840. 	}

    841. 

  841. 	return $exp;

    842. 

  842. }

    843. 

  843. 

    844. 

  844. 

    845. 

  845. function makeprettyarray($a) {

    846. 

  846. 	for ($i=0;$i<count($a);$i++) {

    847. 

  847. 		$a = makepretty($a);

    848. 

  848. 	}

    849. 

  849. }

    850. 

  850. 

    851. 

  851. 

    852. 

  852. function makeprettydisparray($a) {

    853. 

  853. 	for ($i=0;$i<count($a);$i++) {

    854. 

  854. 		$a = "`".makepretty($a)."`";

    855. 

  855. 	}

    856. 

  856. }

    857. 

  857. 

    858. 

  858. 

    859. 

  859. function rrand($min,$max,$p) {

    860. 

  860. 	if (func_num_args()!=3) { echo "rrand expects 3 arguments"; return $min;}

    861. 

  861. 	if ($max < $min) {echo "Need min&lt;max"; return $min;}

    862. 

  862. 	if ($p==0) {echo "Error with rrand: need to set step size"; return false;}

    863. 

  863. 	return($min + $p*rand(0,($max-$min)/$p));	

    864. 

  864. }

    865. 

  865. 

    866. 

  866. 

    867. 

  867. function rands($min,$max,$n) {

    868. 

  868. 	if (func_num_args()!=3) { echo "rands expects 3 arguments"; return $min;}

    869. 

  869. 	if ($max < $min) {echo "Need min&lt;max"; return $min;}

    870. 

  870. 	for ($i = 0; $i < $n; $i++) {

    871. 

  871. 		$r[$i] = rand($min,$max);

    872. 

  872. 	}

    873. 

  873. 	return $r;

    874. 

  874. }

    875. 

  875. 

    876. 

  876. 

    877. 

  877. function rrands($min,$max,$p,$n) {

    878. 

  878. 	if (func_num_args()!=4) { echo "rrands expects 4 arguments"; return $min;}

    879. 

  879. 	if ($max < $min) {echo "Need min&lt;max"; return $min;}

    880. 

  880. 	if ($p==0) {echo "Error with rrands: need to set step size"; return false;}

    881. 

  881. 	for ($i = 0; $i < $n; $i++) {

    882. 

  882. 		$r[$i] = $min + $p*rand(0,($max-$min)/$p);

    883. 

  883. 	}

    884. 

  884. 	return $r;

    885. 

  885. }

    886. 

  886. 

    887. 

  887. 

    888. 

  888. function randfrom($lst) {

    889. 

  889. 	if (func_num_args()!=1) { echo "randfrom expects 1 argument"; return 1;}

    890. 

  890. 	if (!is_array($lst)) {

    891. 

  891. 		$lst = explode(",",$lst);

    892. 

  892. 	}

    893. 

  893. 	return $lst[rand(0,count($lst)-1)];	

    894. 

  894. }

    895. 

  895. 

    896. 

  896. 

    897. 

  897. function randsfrom($lst,$n) {

    898. 

  898. 	if (func_num_args()!=2) { echo "randsfrom expects 2 arguments"; return 1;}

    899. 

  899. 	if (!is_array($lst)) {

    900. 

  900. 		$lst = explode(",",$lst);

    901. 

  901. 	}

    902. 

  902. 	for ($i=0; $i<$n;$i++) {

    903. 

  903. 		$r[$i] = $lst[rand(0,count($lst)-1)];

    904. 

  904. 	}

    905. 

  905. 	return $r;	

    906. 

  906. }

    907. 

  907. 

    908. 

  908. 

    909. 

  909. function jointrandfrom($lst1,$lst2) {

    910. 

  910. 	if (func_num_args()!=2) { echo "jointrandfrom expects 2 arguments"; return array(1,1);}

    911. 

  911. 	if (!is_array($lst1)) {

    912. 

  912. 		$lst1 = explode(",",$lst1);

    913. 

  913. 	}

    914. 

  914. 	if (!is_array($lst2)) {

    915. 

  915. 		$lst2 = explode(",",$lst2);

    916. 

  916. 	}

    917. 

  917. 	$l = rand(0,min(count($lst1)-1,count($lst2)-1));

    918. 

  918. 	return array($lst1[$l],$lst2[$l]);

    919. 

  919. }

    920. 

  920. 

    921. 

  921. 

    922. 

  922. function diffrandsfrom($lst,$n) {

    923. 

  923. 	if (func_num_args()!=2) { echo "diffrandsfrom expects 2 arguments"; return array();}

    924. 

  924. 	if (!is_array($lst)) {

    925. 

  925. 		$lst = explode(",",$lst);

    926. 

  926. 	}

    927. 

  927. 	shuffle($lst);

    928. 

  928. 	return array_slice($lst,0,$n);	

    929. 

  929. }

    930. 

  930. 

    931. 

  931. 

    932. 

  932. function nonzerorand($min,$max) {

    933. 

  933. 	if (func_num_args()!=2) { echo "nonzerorand expects 2 arguments"; return $min;}

    934. 

  934. 	$min = ceil($min);

    935. 

  935. 	$max = floor($max);

    936. 

  936. 	if ($max < $min) {echo "Need min&lt;max"; return $min;}

    937. 

  937. 	if ($min==0 && $max==0) {

    938. 

  938. 		echo "min=0, max=0 bad."; return 0;

    939. 

  939. 	}

    940. 

  940. 	do {

    941. 

  941. 		$ret = rand($min,$max);

    942. 

  942. 	} while ($ret == 0);

    943. 

  943. 	return $ret;

    944. 

  944. }

    945. 

  945. 

    946. 

  946. 

    947. 

  947. function nonzerorrand($min,$max,$p) {

    948. 

  948. 	if (func_num_args()!=3) { echo "nonzerorrand expects 3 arguments"; return $min;}

    949. 

  949. 	if ($max < $min) {echo "Need min&lt;max"; return $min;}

    950. 

  950. 	if ($min==0 && $max==0) {

    951. 

  951. 		echo "min=0, max=0 bad."; return 0;

    952. 

  952. 	}

    953. 

  953. 	if ($p==0) {echo "Error with nonzerorrand: need to set step size"; return false;}

    954. 

  954. 	do {

    955. 

  955. 		$ret = $min + $p*rand(0,($max-$min)/$p);

    956. 

  956. 	} while (abs($ret)< 1e-14);

    957. 

  957. 	return $ret;

    958. 

  958. }

    959. 

  959. 

    960. 

  960. 

    961. 

  961. function nonzerorands($min,$max,$n) {

    962. 

  962. 	if (func_num_args()!=3) { echo "nonzerorands expects 3 arguments"; return $min;}

    963. 

  963. 	$min = ceil($min);

    964. 

  964. 	$max = floor($max);

    965. 

  965. 	if ($max < $min) {echo "Need min&lt;max"; return $min;}

    966. 

  966. 	if ($min==0 && $max==0) {

    967. 

  967. 		echo "min=0, max=0 bad."; return 0;

    968. 

  968. 	}

    969. 

  969. 	for ($i = 0; $i < $n; $i++) {	

    970. 

  970. 		do {

    971. 

  971. 			$r[$i] = rand($min,$max);

    972. 

  972. 		} while ($r[$i] == 0);

    973. 

  973. 	}

    974. 

  974. 	return $r;

    975. 

  975. }

    976. 

  976. 

    977. 

  977. 

    978. 

  978. function nonzerorrands($min,$max,$p,$n) {

    979. 

  979. 	if (func_num_args()!=4) { echo "nonzerorrands expects 4 arguments"; return $min;}

    980. 

  980. 	if ($max < $min) {echo "Need min&lt;max"; return $min;}

    981. 

  981. 	if ($min==0 && $max==0) {

    982. 

  982. 		echo "min=0, max=0 bad."; return 0;

    983. 

  983. 	}

    984. 

  984. 	if ($p==0) {echo "Error with nonzerorrands: need to set step size"; return false;}

    985. 

  985. 	for ($i = 0; $i < $n; $i++) {	

    986. 

  986. 		do {

    987. 

  987. 			$r[$i] = $min + $p*rand(0,($max-$min)/$p);

    988. 

  988. 		} while (abs($r[$i]) <1e-14);

    989. 

  989. 	}

    990. 

  990. 	return $r;

    991. 

  991. }

    992. 

  992. 

    993. 

  993. 

    994. 

  994. function diffrands($min,$max,$n) {

    995. 

  995. 	if (func_num_args()!=3) { echo "diffrands expects 3 arguments"; return $min;}

    996. 

  996. 	if ($max < $min) {echo "Need min&lt;max"; return $min;}

    997. 

  997. 	if ($n<.1*($max-$min)) {

    998. 

  998. 		$out = array();

    999. 

  999. 		while (count($out)<$n) {

    1000. 

  1000. 			$x = rand($min,$max);

    1001. 

  1001. 			if (!in_array($x,$out)) {

    1002. 

  1002. 				$out[] = $x;

    1003. 

  1003. 			}

    1004. 

  1004. 		}

    1005. 

  1005. 		return $out;

    1006. 

  1006. 	} else {

    1007. 

  1007. 		$r = range($min,$max);

    1008. 

  1008. 		while ($n>count($r)) {

    1009. 

  1009. 			$r = array_merge($r,$r);

    1010. 

  1010. 		}

    1011. 

  1011. 		shuffle($r);

    1012. 

  1012. 		return array_slice($r,0,$n);

    1013. 

  1013. 	}

    1014. 

  1014. }

    1015. 

  1015. 

    1016. 

  1016. 

    1017. 

  1017. function diffrrands($min,$max,$p,$n) {

    1018. 

  1018. 	if (func_num_args()!=4) { echo "diffrrands expects 4 arguments"; return $min;}

    1019. 

  1019. 	if ($max < $min) {echo "Need min&lt;max"; return $min;}

    1020. 

  1020. 	if ($p==0) {echo "Error with diffrrands: need to set step size"; return false;}

    1021. 

  1021. 	$maxi = ($max-$min)/$p;

    1022. 

  1022. 	if ($n<.1*$maxi) {

    1023. 

  1023. 		$out = array();

    1024. 

  1024. 		

    1025. 

  1025. 		while (count($out)<$n) {

    1026. 

  1026. 			$x = $min + $p*rand(0,$maxi);

    1027. 

  1027. 			if (!in_array($x,$out)) {

    1028. 

  1028. 				$out[] = $x;

    1029. 

  1029. 			}

    1030. 

  1030. 		}

    1031. 

  1031. 		return $out;

    1032. 

  1032. 	} else {

    1033. 

  1033. 		$r = range(0,$maxi);

    1034. 

  1034. 		while ($n>count($r)) {

    1035. 

  1035. 			$r = array_merge($r,$r);

    1036. 

  1036. 		}

    1037. 

  1037. 		shuffle($r);

    1038. 

  1038. 		$r = array_slice($r,0,$n);

    1039. 

  1039. 		for ($i=0;$i<$n;$i++) {

    1040. 

  1040. 			$r[$i] = $min+$p*$r[$i];

    1041. 

  1041. 		}

    1042. 

  1042. 		return $r;

    1043. 

  1043. 	}

    1044. 

  1044. }

    1045. 

  1045. 

    1046. 

  1046. 

    1047. 

  1047. function nonzerodiffrands($min,$max,$n) {

    1048. 

  1048. 	if (func_num_args()!=3) { echo "nonzerodiffrands expects 3 arguments"; return $min;}

    1049. 

  1049. 	$min = ceil($min);

    1050. 

  1050. 	$max = floor($max);

    1051. 

  1051. 	if ($max < $min) {echo "Need min&lt;max"; return $min;}

    1052. 

  1052. 	if ($min==0 && $max==0) {

    1053. 

  1053. 		echo "min=0, max=0 bad."; return 0;

    1054. 

  1054. 	}

    1055. 

  1055. 	if ($n<.1*($max-$min)) {

    1056. 

  1056. 		$out = array();

    1057. 

  1057. 		while (count($out)<$n) {

    1058. 

  1058. 			$x = rand($min,$max);

    1059. 

  1059. 			if ($x!=0 && !in_array($x,$out)) {

    1060. 

  1060. 				$out[] = $x;

    1061. 

  1061. 			}

    1062. 

  1062. 		}

    1063. 

  1063. 		return $out;

    1064. 

  1064. 	} else {

    1065. 

  1065. 		$r = range($min,$max);

    1066. 

  1066. 		if ($min < 0 && $max > 0) {

    1067. 

  1067. 			array_splice($r,-1*$min,1);

    1068. 

  1068. 		}

    1069. 

  1069. 		shuffle($r);

    1070. 

  1070. 		return array_slice($r,0,$n);

    1071. 

  1071. 	}

    1072. 

  1072. }

    1073. 

  1073. 

    1074. 

  1074. 

    1075. 

  1075. function nonzerodiffrrands($min,$max,$p,$n) {

    1076. 

  1076. 	if (func_num_args()!=4) { echo "nonzerodiffrrands expects 4 arguments"; return $min;}

    1077. 

  1077. 	if ($max < $min) {echo "Need min&lt;max"; return $min;}

    1078. 

  1078. 	if ($p==0) {echo "Error with nonzerodiffrrands: need to set step size"; return false;}

    1079. 

  1079. 	if ($min==0 && $max==0) {

    1080. 

  1080. 		echo "min=0, max=0 bad."; return 0;

    1081. 

  1081. 	}

    1082. 

  1082. 	$maxi = ($max-$min)/$p;

    1083. 

  1083. 	if ($n<.1*$maxi) {

    1084. 

  1084. 		$out = array();

    1085. 

  1085. 		

    1086. 

  1086. 		while (count($out)<$n) {

    1087. 

  1087. 			$x = $min + $p*rand(0,$maxi);

    1088. 

  1088. 			if (abs($x)>1e-14 && !in_array($x,$out)) {

    1089. 

  1089. 				$out[] = $x;

    1090. 

  1090. 			}

    1091. 

  1091. 		}

    1092. 

  1092. 		return $out;

    1093. 

  1093. 	} else {

    1094. 

  1094. 		$r = range(0,$maxi);

    1095. 

  1095. 		if ($min < 0 && $max > 0) {

    1096. 

  1096. 			array_splice($r,-1*$min/$p,1);

    1097. 

  1097. 		}

    1098. 

  1098. 		shuffle($r);

    1099. 

  1099. 		$r = array_slice($r,0,$n);

    1100. 

  1100. 		for ($i=0;$i<$n;$i++) {

    1101. 

  1101. 			$r[$i] = $min+$p*$r[$i];

    1102. 

  1102. 		}

    1103. 

  1103. 		return $r;

    1104. 

  1104. 	}

    1105. 

  1105. 	

    1106. 

  1106. }

    1107. 

  1107. 

    1108. 

  1108. 

    1109. 

  1109. function singleshuffle($a) {

    1110. 

  1110. 	if (!is_array($a)) {

    1111. 

  1111. 		$a = explode(",",$a);

    1112. 

  1112. 	}

    1113. 

  1113. 	shuffle($a);

    1114. 

  1114. 	if (func_num_args()>1) {

    1115. 

  1115. 		return array_slice($a,0,func_get_arg(1));

    1116. 

  1116. 	} else {

    1117. 

  1117. 		return $a;

    1118. 

  1118. 	}

    1119. 

  1119. }

    1120. 

  1120. 

    1121. 

  1121. 

    1122. 

  1122. function jointshuffle($a1,$a2) {  //optional third & fourth params $n1 and $n2

    1123. 

  1123. 	if (!is_array($a1)) {

    1124. 

  1124. 		$a1 = explode(",",$a1);

    1125. 

  1125. 	}

    1126. 

  1126. 	if (!is_array($a2)) {

    1127. 

  1127. 		$a2 = explode(",",$a2);

    1128. 

  1128. 	}

    1129. 

  1129. 	$r = array_rand($a1,count($a1));

    1130. 

  1130. 	shuffle($r);

    1131. 

  1131. 	for ($j=0;$j<count($r);$j++) {

    1132. 

  1132. 		$ra1[$j] = $a1[$r[$j]];

    1133. 

  1133. 		$ra2[$j] = $a2[$r[$j]];

    1134. 

  1134. 	}

    1135. 

  1135. 	if (func_num_args() > 2) { 

    1136. 

  1136. 		$n=func_get_arg(2);

    1137. 

  1137. 		if (func_num_args() > 3) {$n2 = func_get_arg(3);} else {$n2 = $n;}

    1138. 

  1138. 		return array(array_slice($ra1,0,$n),array_slice($ra2,0,$n2));

    1139. 

  1139. 	} else {

    1140. 

  1140. 

    1141. 

  1141. 		return array($ra1,$ra2);

    1142. 

  1142. 	}

    1143. 

  1143. }

    1144. 

  1144. 

    1145. 

  1145. 

    1146. 

  1146. function listtoarray($l) {

    1147. 

  1147. 	if (func_num_args()>1 && ($GLOBALS['sessiondata']['isteacher'] || isset($GLOBALS['teacherid']))) {

    1148. 

  1148. 		echo "Warning:  listtoarray expects one argument, more than one provided";

    1149. 

  1149. 	}

    1150. 

  1150. 	return (explode(",",$l));	

    1151. 

  1151. }

    1152. 

  1152. 

    1153. 

  1153. 

    1154. 

  1154. function arraytolist($a, $sp=false) {

    1155. 

  1155. 	if ($sp) {

    1156. 

  1156. 		return (implode(', ',$a));

    1157. 

  1157. 	} else {

    1158. 

  1158. 		return (implode(',',$a));

    1159. 

  1159. 	}

    1160. 

  1160. }

    1161. 

  1161. 

    1162. 

  1162. function joinarray($a,$s) {

    1163. 

  1163. 	return (implode($s,$a));

    1164. 

  1164. }

    1165. 

  1165. 

    1166. 

  1166. 

    1167. 

  1167. function calclisttoarray($l) {

    1168. 

  1168. 	$l = explode(",",$l);

    1169. 

  1169. 	foreach ($l as $k=>$tocalc) {

    1170. 

  1170. 		eval('$l[$k] = ' . mathphp($tocalc,null).';');

    1171. 

  1171. 	}

    1172. 

  1172. 	return $l;

    1173. 

  1173. }

    1174. 

  1174. 

    1175. 

  1175. 

    1176. 

  1176. function sortarray($a) {

    1177. 

  1177. 	if (!is_array($a)) {

    1178. 

  1178. 		$a = explode(",",$a);

    1179. 

  1179. 	}

    1180. 

  1180. 	if (func_num_args()>1) {

    1181. 

  1181. 		$dir = func_get_arg(1);

    1182. 

  1182. 	}

    1183. 

  1183. 	if (isset($dir) && $dir=="rev") {

    1184. 

  1184. 		if (is_numeric($a[0])) {

    1185. 

  1185. 			rsort($a, SORT_NUMERIC);

    1186. 

  1186. 		} else {

    1187. 

  1187. 			rsort($a);

    1188. 

  1188. 		}

    1189. 

  1189. 	} else {

    1190. 

  1190. 		if (is_numeric($a[0])) {

    1191. 

  1191. 			sort($a, SORT_NUMERIC);

    1192. 

  1192. 		} else {

    1193. 

  1193. 			sort($a);

    1194. 

  1194. 		}

    1195. 

  1195. 	}

    1196. 

  1196. 	return $a;

    1197. 

  1197. }

    1198. 

  1198. 

    1199. 

  1199. 

    1200. 

  1200. function consecutive($min,$max,$step=1) {

    1201. 

  1201. 	$a = array();

    1202. 

  1202. 	if ($min<$max && $step>0) {

    1203. 

  1203. 		for ($i=$min;$i<$max+$step/100.0;$i+=$step) {

    1204. 

  1204. 			$a[] = $i;

    1205. 

  1205. 		}

    1206. 

  1206. 	} else if ($min > $max && $step < 0) {

    1207. 

  1207. 		for ($i=$min;$i>$max+$step/100.0;$i+=$step) {

    1208. 

  1208. 			$a[] = $i;

    1209. 

  1209. 		}

    1210. 

  1210. 	} else if (abs($min-$max) < .9*abs($step)) {

    1211. 

  1211. 		$a[] = $min;

    1212. 

  1212. 	} else {

    1213. 

  1213. 		echo "Invalid inputs to consecutive";

    1214. 

  1214. 	}

    1215. 

  1215. 	return $a;

    1216. 

  1216. }

    1217. 

  1217. 

    1218. 

  1218. 

    1219. 

  1219. function gcd($n,$m){ //greatest common divisor

    1220. 

  1220. 	$m = round(abs($m));

    1221. 

  1221. 	$n = round(abs($n));

    1222. 

  1222. 	if(!$m)return$n;

    1223. 

  1223. 	if(!$n)return$m;

    1224. 

  1224. 	return $m<$n?gcd($m,$n%$m):gcd($n,$m%$n);

    1225. 

  1225. }

    1226. 

  1226. function lcm($n, $m) //least common multiple 

    1227. 

  1227. { 

    1228. 

  1228.    return round($m*($n/gcd($n,$m))); 

    1229. 

  1229. } 

    1230. 

  1230. 

    1231. 

  1231. function dispreducedfraction($n,$d,$dblslash=false) {

    1232. 

  1232. 	return '`'.makereducedfraction($n,$d,$dblslash).'`';

    1233. 

  1233. }

    1234. 

  1234. 

    1235. 

  1235. function makereducedfraction($n,$d,$dblslash=false) {

    1236. 

  1236. 	$g = gcd($n,$d);

    1237. 

  1237. 	$n = $n/$g;

    1238. 

  1238. 	$d = $d/$g;	

    1239. 

  1239. 	if ($d<0) {

    1240. 

  1240. 		$n = $n*-1;

    1241. 

  1241. 		$d = $d*-1;

    1242. 

  1242. 	}

    1243. 

  1243. 	if ($d==1) {

    1244. 

  1244. 		return "$n";

    1245. 

  1245. 	} else {

    1246. 

  1246. 		if ($dblslash) {

    1247. 

  1247. 			return "$n//$d";

    1248. 

  1248. 		} else {

    1249. 

  1249. 			return "$n/$d";

    1250. 

  1250. 		}

    1251. 

  1251. 	}

    1252. 

  1252. }

    1253. 

  1253. 

    1254. 

  1254. //use: calconarray($a,"x^$p")

    1255. 

  1255. function calconarray($array,$todo) {

    1256. 

  1256. 	/*global $disallowedwords,$allowedmacros;

    1257. 

  1257. 	$todo = str_replace($disallowedwords,"",$todo);

    1258. 

  1258. 	$todo = clean($todo);

    1259. 

  1259. 	$rsnoquote = preg_replace('/"[^"]*"/','""',$todo);

    1260. 

  1260. 	$rsnoquote = preg_replace('/\'[^\']*\'/','\'\'',$rsnoquote);

    1261. 

  1261. 	if (preg_match_all('/([$\w]+)\s*\([^\)]*\)/',$rsnoquote,$funcs)) {

    1262. 

  1262. 		for ($i=0;$i<count($funcs[1]);$i++) {

    1263. 

  1263. 			if (strpos($funcs[1][$i],"$")===false) {

    1264. 

  1264. 				if (!in_array($funcs[1][$i],$allowedmacros)) {

    1265. 

  1265. 					echo "{$funcs[1][$i]} is not an allowed function<BR>\n";

    1266. 

  1266. 					return false;

    1267. 

  1267. 				}

    1268. 

  1268. 			}

    1269. 

  1269. 		}

    1270. 

  1270. 	}

    1271. 

  1271. 	*/

    1272. 

  1272. 	$todo = mathphp($todo,'x',false,false);

    1273. 

  1273. 	$todo = str_replace('(x)','($x)',$todo);

    1274. 

  1274. 	return array_map(create_function('$x','return('.$todo.');'),$array);	

    1275. 

  1275. }

    1276. 

  1276. 

    1277. 

  1277. function multicalconarray() {

    1278. 

  1278. 	$args = func_get_args();

    1279. 

  1279. 	$nargs = count($args);

    1280. 

  1280. 	$todo = array_shift($args);

    1281. 

  1281. 	$vars = array_shift($args);

    1282. 

  1282. 	$vars = explode(',',$vars);

    1283. 

  1283. 	if ($nargs-2 != count($vars)) {

    1284. 

  1284. 		echo "incorrect number of data arrays";

    1285. 

  1285. 		return false;

    1286. 

  1286. 	}

    1287. 

  1287. 		

    1288. 

  1288. 	$todo = mathphp($todo,implode('|',$vars),false,false);

    1289. 

  1289. 	if ($todo=='0;') { return 0;}

    1290. 

  1290. 	for ($i=0;$i<count($vars);$i++) {

    1291. 

  1291. 		$todo = str_replace('('.$vars[$i].')','($'.$vars[$i].')',$todo);

    1292. 

  1292. 	}

    1293. 

  1293. 

    1294. 

  1294. 	$varlist = '$'.implode(',$',$vars);

    1295. 

  1295. 	$evalstr = "return(array_map(create_function('$varlist','return($todo);')";

    1296. 

  1296. 	$cnt = count($args[0]);

    1297. 

  1297. 	for ($i=0; $i<count($args); $i++) {

    1298. 

  1298. 		$evalstr .= ',$args['.$i.']';

    1299. 

  1299. 		if (count($args[$i])!=$cnt) {

    1300. 

  1300. 			echo "unequal element count in arrays";

    1301. 

  1301. 			return false;

    1302. 

  1302. 		}

    1303. 

  1303. 	}

    1304. 

  1304. 	$evalstr .= '));';

    1305. 

  1305. 	return eval($evalstr);	

    1306. 

  1306. }

    1307. 

  1307. 

    1308. 

  1308. 

    1309. 

  1309. //use: calconarray($a,"x + .01","floor(x)==x")

    1310. 

  1310. function calconarrayif($array,$todo,$ifcond) {

    1311. 

  1311. 	/*global $disallowedwords,$allowedmacros;

    1312. 

  1312. 	$todo = str_replace($disallowedwords,"",$todo);

    1313. 

  1313. 	$todo = clean($todo);

    1314. 

  1314. 	$ifcond = clean($ifcond);

    1315. 

  1315. 	$rsnoquote = preg_replace('/"[^"]*"/','""',$todo);

    1316. 

  1316. 	$rsnoquote = preg_replace('/\'[^\']*\'/','\'\'',$rsnoquote);

    1317. 

  1317. 	if (preg_match_all('/([$\w]+)\s*\([^\)]*\)/',$rsnoquote,$funcs)) {

    1318. 

  1318. 		for ($i=0;$i<count($funcs[1]);$i++) {

    1319. 

  1319. 			if (strpos($funcs[1][$i],"$")===false) {

    1320. 

  1320. 				if (!in_array($funcs[1][$i],$allowedmacros)) {

    1321. 

  1321. 					echo "{$funcs[1][$i]} is not an allowed function<BR>\n";

    1322. 

  1322. 					return false;

    1323. 

  1323. 				}

    1324. 

  1324. 			}

    1325. 

  1325. 		}

    1326. 

  1326. 	}

    1327. 

  1327. 	*/

    1328. 

  1328. 	$todo = mathphp($todo,'x',false,false);

    1329. 

  1329. 	$todo = str_replace('(x)','($x)',$todo);

    1330. 

  1330. 	/*

    1331. 

  1331. 	$rsnoquote = preg_replace('/"[^"]*"/','""',$ifcond);

    1332. 

  1332. 	$rsnoquote = preg_replace('/\'[^\']*\'/','\'\'',$rsnoquote);

    1333. 

  1333. 	if (preg_match_all('/([$\w]+)\s*\([^\)]*\)/',$rsnoquote,$funcs)) {

    1334. 

  1334. 		$ismath = true;

    1335. 

  1335. 		for ($i=0;$i<count($funcs[1]);$i++) {

    1336. 

  1336. 			if (strpos($funcs[1][$i],"$")===false) {

    1337. 

  1337. 				if (!in_array($funcs[1][$i],$allowedmacros)) {

    1338. 

  1338. 					echo "{$funcs[1][$i]} is not an allowed function<BR>\n";

    1339. 

  1339. 					return false;

    1340. 

  1340. 				}

    1341. 

  1341. 			}

    1342. 

  1342. 		}

    1343. 

  1343. 	}

    1344. 

  1344. 	$ifcond = str_replace('!=','#=',$ifcond);

    1345. 

  1345. 	*/

    1346. 

  1346. 	$ifcond = mathphp($ifcond,'x',false,false);

    1347. 

  1347. 	//$ifcond = str_replace('#=','!=',$ifcond);

    1348. 

  1348. 	$ifcond = str_replace('(x)','($x)',$ifcond);

    1349. 

  1349. 	

    1350. 

  1350. 	$iffunc = create_function('$x','return('.$ifcond.');');

    1351. 

  1351. 	

    1352. 

  1352. 	$tmpfunc = create_function('$x','return('.$todo.');');

    1353. 

  1353. 	foreach($array as $k=>$x) {

    1354. 

  1354. 		if ($iffunc($x)) {

    1355. 

  1355. 			$array[$k] = $tmpfunc($x);

    1356. 

  1356. 		}

    1357. 

  1357. 	}

    1358. 

  1358. 	return $array;	

    1359. 

  1359. }

    1360. 

  1360. 

    1361. 

  1361. function sumarray($array) {

    1362. 

  1362. 	return array_sum($array);

    1363. 

  1363. }

    1364. 

  1364. 

    1365. 

  1365. function intersectarrays($a1,$a2) {

    1366. 

  1366. 	return array_values(array_intersect($a1,$a2));

    1367. 

  1367. }

    1368. 

  1368. 

    1369. 

  1369. function diffarrays($a1,$a2) {

    1370. 

  1370. 	return array_values(array_diff($a1,$a2));

    1371. 

  1371. }

    1372. 

  1372. 

    1373. 

  1373. function unionarrays($a1,$a2) {

    1374. 

  1374. 	foreach ($a2 as $v) {

    1375. 

  1375. 		if (!in_array($v,$a1)) {

    1376. 

  1376. 			$a1[] = $v;

    1377. 

  1377. 		}

    1378. 

  1378. 	}

    1379. 

  1379. 	return array_values($a1);

    1380. 

  1380. }

    1381. 

  1381. 

    1382. 

  1382. function prettyint($n) {

    1383. 

  1383. 	return number_format($n);

    1384. 

  1384. }

    1385. 

  1385. function prettyreal($n,$d) {

    1386. 

  1386. 	return number_format($n,$d);

    1387. 

  1387. }

    1388. 

  1388. 

    1389. 

  1389. function makescinot($n,$d=8,$f="x") {

    1390. 

  1390. 	if ($n==0) { return "0";}

    1391. 

  1391. 	$isneg = "";

    1392. 

  1392. 	if ($n<0) { $isneg = "-"; $n = abs($n);}

    1393. 

  1393. 	$exp = floor(log10($n));

    1394. 

  1394. 	$mant = round($n/pow(10,$exp),$d);

    1395. 

  1395. 	if ($f=="*") {

    1396. 

  1396. 		return "$isneg $mant * 10^($exp)";

    1397. 

  1397. 	} else if ($f=="E") {

    1398. 

  1398. 		return "$isneg $mant E $exp";

    1399. 

  1399. 	} else {

    1400. 

  1400. 		return "$isneg $mant xx 10^($exp)";

    1401. 

  1401. 	}

    1402. 

  1402. }

    1403. 

  1403. 

    1404. 

  1404. function stringappend($v,$s) {

    1405. 

  1405. 	if (is_array($v)) {

    1406. 

  1406. 		foreach($v as $k=>$y) {

    1407. 

  1407. 			$v[$k] = $v[$k].$s;

    1408. 

  1408. 		}

    1409. 

  1409. 	} else {

    1410. 

  1410. 		$v = $v.$s;

    1411. 

  1411. 	}

    1412. 

  1412. 	return $v;

    1413. 

  1413. }

    1414. 

  1414. function stringprepend($v,$s) {

    1415. 

  1415. 	if (is_array($v)) {

    1416. 

  1416. 		foreach($v as $k=>$y) {

    1417. 

  1417. 			$v[$k] = $s.$v[$k];

    1418. 

  1418. 		}

    1419. 

  1419. 	} else {

    1420. 

  1420. 		$v = $s.$v;

    1421. 

  1421. 	}

    1422. 

  1422. 	return $v;

    1423. 

  1423. }

    1424. 

  1424. 

    1425. 

  1425. function arraystodots($x,$y) {

    1426. 

  1426. 	$out = array();

    1427. 

  1427. 	for ($i=0;$i<count($x);$i++)  {

    1428. 

  1428. 		$out[] = $x[$i].','.$y[$i];	

    1429. 

  1429. 	}

    1430. 

  1430. 	return $out;

    1431. 

  1431. }

    1432. 

  1432. 

    1433. 

  1433. function arraystodoteqns($x,$y,$color='blue') {

    1434. 

  1434. 	$out = array();

    1435. 

  1435. 	for ($i=0;$i<count($x);$i++)  {

    1436. 

  1436. 		$out[] = $y[$i].','.$color.','.$x[$i].','.$x[$i].','.'closed';

    1437. 

  1437. 	}

    1438. 

  1438. 	return $out;

    1439. 

  1439. }

    1440. 

  1440. 	

    1441. 

  1441. 

    1442. 

  1442. function subarray($a) {

    1443. 

  1443. 	if (is_array(func_get_arg(1))) {

    1444. 

  1444. 		$args = func_get_arg(1);

    1445. 

  1445. 	} else {

    1446. 

  1446. 		$args = func_get_args();

    1447. 

  1447. 		array_shift($args);

    1448. 

  1448. 	}

    1449. 

  1449. 	if (count($args)<1) {return array();}

    1450. 

  1450. 	$out = array();

    1451. 

  1451. 	for ($i=0;$i<count($args);$i++) {

    1452. 

  1452. 		if (strpos($args[$i],':')!==false) {

    1453. 

  1453. 			$p = explode(':',$args[$i]);

    1454. 

  1454. 			array_splice($out,count($out),0,array_slice($a,$p[0],$p[1]-$p[0]+1));

    1455. 

  1455. 		} else {

    1456. 

  1456. 			$out[] = $a[$args[$i]];

    1457. 

  1457. 		}

    1458. 

  1458. 	}

    1459. 

  1459. 	return $out;

    1460. 

  1460. }

    1461. 

  1461. 

    1462. 

  1462. function showdataarray($a,$n=1) {

    1463. 

  1463. 	if (!is_array($a)) {

    1464. 

  1464. 		return '';

    1465. 

  1465. 	}

    1466. 

  1466. 	$out = '<table class=stats><tbody>';

    1467. 

  1467. 	$cnt = 0;

    1468. 

  1468. 	while ($cnt<count($a)) {

    1469. 

  1469. 		$out .= '<tr>';

    1470. 

  1470. 		for ($i=0;$i<$n;$i++) {

    1471. 

  1471. 			if (isset($a[$cnt])) {

    1472. 

  1472. 				$out .= '<td>'.$a[$cnt].'</td>';

    1473. 

  1473. 			} else {

    1474. 

  1474. 				$out .= '<td></td>';

    1475. 

  1475. 			}

    1476. 

  1476. 			$cnt++;

    1477. 

  1477. 		}

    1478. 

  1478. 		$out .= '</tr>';

    1479. 

  1479. 	}

    1480. 

  1480. 	$out .= '</tbody></table>';

    1481. 

  1481. 	return $out;

    1482. 

  1482. }

    1483. 

  1483. 

    1484. 

  1484. $ones = array( "", " one", " two", " three", " four", " five", " six", " seven", " eight", " nine", " ten", " eleven", " twelve", " thirteen", " fourteen", " fifteen", " sixteen", " seventeen", " eighteen", " nineteen");

    1485. 

  1485. $onesth = array(""," first"," second", " third", " fourth", " fifth", " sixth", " seventh", " eighth", " ninth", "tenth"," eleventh", " twelfth", " thirteenth", " fourteenth"," fifteenth", " sixteenth", " seventeenth", " eighteenth"," nineteenth"); 

    1486. 

  1486. $tens = array( "", "", " twenty", " thirty", " forty", " fifty", " sixty", " seventy", " eighty", " ninety");

    1487. 

  1487. $tensth = array("","","twentieth", "thirtieth", "fortieth", "fiftieth", "sixtieth", "seventieth", "eightieth", "ninetieth");

    1488. 

  1488. $triplets = array( "", " thousand", " million", " billion", " trillion", " quadrillion", " quintillion", " sextillion", " septillion", " octillion", " nonillion");

    1489. 

  1489. $placevals = array( "", "tenth", "hundredth", "thousandth", "ten-thousandth", "hundred-thousandth", "millionth", "ten-millionth", "hundred-millionth", "billionth");

    1490. 

  1490.  // recursive fn, converts three digits per pass

    1491. 

  1491. function convertTri($num, $tri, $doth=false) {

    1492. 

  1492.   global $ones, $onesth, $tens, $tensth, $triplets;

    1493. 

  1493. 

    1494. 

  1494.   // chunk the number, ...rxyy

    1495. 

  1495.   $r = (int) ($num / 1000);

    1496. 

  1496.   $x = ($num / 100) % 10;

    1497. 

  1497.   $y = $num % 100;

    1498. 

  1498. 

    1499. 

  1499.   // init the output string

    1500. 

  1500.   $str = "";

    1501. 

  1501. 

    1502. 

  1502.   // do hundreds

    1503. 

  1503.   if ($x > 0)

    1504. 

  1504.    $str = $ones[$x] . " hundred";

    1505. 

  1505. 

    1506. 

  1506.   // do ones and tens

    1507. 

  1507.   if ($y < 20) {

    1508. 

  1508. 	  if ($doth && $tri==0) {

    1509. 

  1509. 		  $str .= $onesth[$y];

    1510. 

  1510. 	  } else {

    1511. 

  1511. 		  $str .= $ones[$y];

    1512. 

  1512. 	  }

    1513. 

  1513.   } else {

    1514. 

  1514. 	  if ($doth && $tri==0) {

    1515. 

  1515. 		  if ($y%10==0) {

    1516. 

  1516. 			  $str .= $tensth[(int) ($y / 10)]; 

    1517. 

  1517. 		  } else {

    1518. 

  1518. 			  $str .= $tens[(int) ($y / 10)] . $onesth[$y % 10];

    1519. 

  1519. 		  }

    1520. 

  1520. 	  } else {

    1521. 

  1521. 		 $str .= $tens[(int) ($y / 10)] . $ones[$y % 10];

    1522. 

  1522. 	  }

    1523. 

  1523.   }

    1524. 

  1524.   // add triplet modifier only if there

    1525. 

  1525.   // is some output to be modified...

    1526. 

  1526.   if ($str != "")

    1527. 

  1527.    $str .= $triplets[$tri];

    1528. 

  1528. 

    1529. 

  1529.   // continue recursing?

    1530. 

  1530.   if ($r > 0)

    1531. 

  1531.    return convertTri($r, $tri+1).$str;

    1532. 

  1532.   else

    1533. 

  1533.    return $str;

    1534. 

  1534.  }

    1535. 

  1535. 

    1536. 

  1536. function numtowords($num,$doth=false) {

    1537. 

  1537. 	global $placevals;

    1538. 

  1538. 	

    1539. 

  1539. 	if ($num==0) {

    1540. 

  1540. 		return "zero";

    1541. 

  1541. 	}

    1542. 

  1542. 	$int = floor($num);

    1543. 

  1543. 	$dec = 	$num-$int;

    1544. 

  1544. 	$out = '';

    1545. 

  1545. 	if ($int>0) {

    1546. 

  1546. 		$out .= convertTri($int,0,$doth);

    1547. 

  1547. 		if ($dec>0) {

    1548. 

  1548. 			$out .= " and ";

    1549. 

  1549. 		}

    1550. 

  1550. 	}

    1551. 

  1551. 	if ($dec>0) {

    1552. 

  1552. 		$cnt = 0;

    1553. 

  1553. 		while (abs($dec-round($dec))>1e-9 && $cnt<9) {

    1554. 

  1554. 			$dec *= 10;

    1555. 

  1555. 			$cnt++;

    1556. 

  1556. 		}

    1557. 

  1557. 		$out .= convertTri($dec,0);

    1558. 

  1558. 		$out .= ' '.$placevals[$cnt];

    1559. 

  1559. 		if ($dec!=1) {

    1560. 

  1560. 			$out .= 's';

    1561. 

  1561. 		}

    1562. 

  1562. 		

    1563. 

  1563. 	}

    1564. 

  1564. 	return trim($out);	

    1565. 

  1565. }

    1566. 

  1566. 

    1567. 

  1567. $namearray[0] = explode(',',"Aaron,Ahmed,Aidan,Alan,Alex,Alfonso,Andres,Andrew,Antonio,Armando,Arturo,Austin,Ben,Bill,Blake,Bradley,Brayden,Brendan,Brian,Bryce,Caleb,Cameron,Carlos,Casey,Cesar,Chad,Chance,Chase,Chris,Cody,Collin,Colton,Conner,Corey,Dakota,Damien,Danny,Darius,David,Deandre,Demetrius,Derek,Devante,Devin,Devonte,Diego,Donald,Dustin,Dylan,Eduardo,Emanuel,Enrique,Erik,Ethan,Evan,Francisco,Frank,Gabriel,Garrett,Gerardo,Gregory,Ian,Isaac,Jacob,Jaime,Jake,Jamal,James,Jared,Jason,Jeff,Jeremy,Jesse,John,Jordan,Jose,Joseph,Josh,Juan,Julian,Julio,Justin,Juwan,Keegan,Ken,Kevin,Kyle,Landon,Levi,Logan,Lucas,Luis,Malik,Manuel,Marcus,Mark,Matt,Micah,Michael,Miguel,Nate,Nick,Noah,Omar,Paul,Quinn,Randall,Ricardo,Ricky,Roberto,Roy,Russell,Ryan,Salvador,Sam,Santos,Scott,Sergio,Shane,Shaun,Skyler,Spencer,Stephen,Taylor,Tevin,Todd,Tom,Tony,Travis,Trent,Trevor,Trey,Tristan,Tyler,Wade,Warren,Wyatt,Zach");

    1568. 

  1568. $namearray[1] = explode(',',"Adriana,Adrianna,Alejandra,Alexandra,Alexis,Alice,Alicia,Alma,Amanda,Amber,Amy,Andrea,Angela,Anna,April,Ariana,Ashley,Ashton,Autumn,Bianca,Bria,Brianna,Brittany,Brooke,Caitlyn,Carissa,Carolyn,Carrie,Cassandra,Catherine,Chasity,Chelsea,Chloe,Christy,Ciara,Claudia,Colleen,Courtney,Cristina,Crystal,Dana,Danielle,Delaney,Destiny,Diana,Elizabeth,Emily,Emma,Erica,Erin,Esmeralda,Gabrielle,Guadalupe,Haley,Hanna,Heather,Hillary,Holly,Jacqueline,Jamie,Jane,Jasmine,Jenna,Jennifer,Jessica,Julia,Karen,Karina,Karissa,Karla,Kathryn,Katie,Kayla,Kelly,Kelsey,Kendra,Kimberly,Kori,Kristen,Kristina,Krystal,Kylie,Laura,Lauren,Leah,Linda,Lindsey,Mackenzie,Madison,Maggie,Mariah,Marissa,Megan,Melissa,Meredith,Michelle,Mikayla,Miranda,Molly,Monique,Morgan,Naomi,Natalie,Natasha,Nicole,Nina,Noelle,Paige,Patricia,Rachael,Raquel,Rebecca,Renee,Riley,Rosa,Samantha,Sarah,Savannah,Shannon,Shantel,Sierra,Sonya,Sophia,Stacy,Stephanie,Summer,Sydney,Tatiana,Taylor,Tiana,Tiffany,Valerie,Vanessa,Victoria,Vivian,Wendy,Whitney,Zoe");

    1569. 

  1569. 

    1570. 

  1570. $cityarray = explode(',','Los Angeles,Dallas,Houston,Atlanta,Detroit,San Francisco,Minneapolis,St. Louis,Baltimore,Pittsburg,Cincinnati,Cleveland,San Antonio,Las Vegas,Milwaukee,Oklahoma City,New Orleans,Tucson,New York City,Chicago,Philadelphia,Miami,Boston,Phoenix,Seattle,San Diego,Tampa,Denver,Portland,Sacramento,Orlando,Kansas City,Nashville,Memphis,Hartford,Salt Lake City');

    1571. 

  1571. 

    1572. 

  1572. function randcities($n=1) {

    1573. 

  1573. 	global $cityarray;

    1574. 

  1574. 	$c = count($cityarray);

    1575. 

  1575. 	if ($n==1) {

    1576. 

  1576. 		return $cityarray[rand(0,$c-1)];

    1577. 

  1577. 	} else {

    1578. 

  1578. 		$out = $cityarray;

    1579. 

  1579. 		shuffle($out);

    1580. 

  1580. 		return array_slice($out,0,$n);

    1581. 

  1581. 	}

    1582. 

  1582. }

    1583. 

  1583. 

    1584. 

  1584. function randcity() {

    1585. 

  1585. 	return randcities(1);

    1586. 

  1586. }

    1587. 

  1587. 

    1588. 

  1588. function randnames($n=1,$gender=2) { 

    1589. 

  1589. 	global $namearray;

    1590. 

  1590. 	if ($n==1) { 

    1591. 

  1591. 		if ($gender==2) { 

    1592. 

  1592. 			$gender = rand(0,1); 

    1593. 

  1593. 		} 

    1594. 

  1594. 		return $namearray[$gender][rand(0,137)]; 

    1595. 

  1595. 	} else { 

    1596. 

  1596. 		$out = array(); 

    1597. 

  1597. 		$locs = diffrands(0,137,$n); 

    1598. 

  1598. 		for ($i=0; $i<$n;$i++) { 

    1599. 

  1599. 			if ($gender==2) { 

    1600. 

  1600. 				$gender = rand(0,1); 

    1601. 

  1601. 			}       

    1602. 

  1602. 			$out[] = $namearray[$gender][$locs[$i]]; 

    1603. 

  1603. 		} 

    1604. 

  1604. 		return $out;

    1605. 

  1605. 	} 

    1606. 

  1606. } 

    1607. 

  1607. 

    1608. 

  1608. function randmalenames($n=1) { 

    1609. 

  1609. 	return randnames($n,0); 

    1610. 

  1610. } 

    1611. 

  1611. function randfemalenames($n=1) { 

    1612. 

  1612.         return randnames($n,1); 

    1613. 

  1613. } 

    1614. 

  1614. function randname() {

    1615. 

  1615. 	return randnames(1,2);

    1616. 

  1616. }

    1617. 

  1617. function randmalename() {

    1618. 

  1618. 	return randnames(1,0);

    1619. 

  1619. }

    1620. 

  1620. function randfemalename() {

    1621. 

  1621. 	return randnames(1,1);

    1622. 

  1622. }

    1623. 

  1623. 

    1624. 

  1624. function prettytime($time,$in,$out) {

    1625. 

  1625. 	if ($in=='m') {

    1626. 

  1626. 		$time *= 60;

    1627. 

  1627. 	} else if ($in=='h') {

    1628. 

  1628. 		$time *= 60*60;

    1629. 

  1629. 	}

    1630. 

  1630. 	$hrs = $time/3600;

    1631. 

  1631. 	$min = $time/60;

    1632. 

  1632. 	$outst = '';

    1633. 

  1633. 	if (strpos($out,'clock')!==false) { //clock time

    1634. 

  1634. 		$ampm = ($hrs<12?"am":"pm");

    1635. 

  1635. 		$hrs = floor($hrs);

    1636. 

  1636. 		if ($out=='sclock') {

    1637. 

  1637. 			$min = floor($min -60*$hrs);

    1638. 

  1638. 			$sec = round($time - 60*$min - 3600*$hrs);

    1639. 

  1639. 			if ($min<10) {	$min = '0'.$min;}

    1640. 

  1640. 			if ($sec<10) {	$sec = '0'.$sec;}

    1641. 

  1641. 			$outst = "$hrs:$min:$sec $ampm";	

    1642. 

  1642. 		} else {

    1643. 

  1643. 			$min = round($min -60*$hrs);

    1644. 

  1644. 			if ($min<10) {	$min = '0'.$min;}

    1645. 

  1645. 			$outst = "$hrs:$min $ampm";

    1646. 

  1646. 		}

    1647. 

  1647. 		return $outst;

    1648. 

  1648. 		

    1649. 

  1649. 	}

    1650. 

  1650. 	if (strpos($out,'h')!==false) { //has hrs

    1651. 

  1651. 		if (strpos($out,'m')!==false) { //has min

    1652. 

  1652. 			$hrs = floor($hrs);

    1653. 

  1653. 			if (strpos($out,'s')!==false) {  //hrs min sec

    1654. 

  1654. 				$min = floor($min-60*$hrs);

    1655. 

  1655. 				$sec = round($time - 60*$min - 3600*$hrs,4);

    1656. 

  1656. 				$outst = "$hrs hour" . ($hrs>1 ? 's':'');

    1657. 

  1657. 				$outst .= ", $min minute" . ($min>1 ? 's':'');

    1658. 

  1658. 				$outst .= ", and $sec second" . ($sec!=1 ? 's':'');

    1659. 

  1659. 			} else { //hrs min

    1660. 

  1660. 				$min = round($min - 60*$hrs,4);

    1661. 

  1661. 				$outst = "$hrs hour" . ($hrs>1 ? 's':'');

    1662. 

  1662. 				$outst .= " and $min minute" . ($min!=1 ? 's':'');

    1663. 

  1663. 			}

    1664. 

  1664. 		} else { //no min

    1665. 

  1665. 			if (strpos($out,'s')!==false) {  //hrs sec

    1666. 

  1666. 				$hrs = floor($hrs);

    1667. 

  1667. 				$sec = round($time - 3600*$hrs,4);

    1668. 

  1668. 				$outst = "$hrs hour" . ($hrs>1 ? 's':'');

    1669. 

  1669. 				$outst .= " and $sec second" . ($sec!=1 ? 's':'');

    1670. 

  1670. 			} else {//just hrs

    1671. 

  1671. 				$hrs = round($hrs,4);

    1672. 

  1672. 				$outst = "$hrs hours" . ($hrs!=1 ? 's':'');

    1673. 

  1673. 			}

    1674. 

  1674. 		}

    1675. 

  1675. 	} else { //no hours

    1676. 

  1676. 		if (strpos($out,'m')!==false) { //

    1677. 

  1677. 			if (strpos($out,'s')!==false) {  //min sec

    1678. 

  1678. 				$min = floor($min);

    1679. 

  1679. 				$sec = round($time - 60*$min,4);

    1680. 

  1680. 				$outst = "$min minute" . ($min>1 ? 's':'');

    1681. 

  1681. 				$outst .= " and $sec second" . ($sec!=1 ? 's':'');

    1682. 

  1682. 			} else { //min only

    1683. 

  1683. 				$min = round($min,4);

    1684. 

  1684. 				$outst = "$min minute" . ($min!=1 ? 's':'');

    1685. 

  1685. 			}

    1686. 

  1686. 		} else if (strpos($out,'s')!==false) {  //sec

    1687. 

  1687. 			$time = round($time,4);

    1688. 

  1688. 			$outst = "$time second". ($sec!=1 ? 's':'');

    1689. 

  1689. 		}

    1690. 

  1690. 	}

    1691. 

  1691. 	return $outst;

    1692. 

  1692. }

    1693. 

  1693. 

    1694. 

  1694. function definefunc($func,$varlist) {

    1695. 

  1695. 	$vars = explode(',',$varlist);

    1696. 

  1696. 	/*$toparen = implode('|',$vars);

    1697. 

  1697. 	if ($toparen != '') {

    1698. 

  1698. 		$reg = "/(" . $toparen . ")(" . $toparen . ')$/';

    1699. 

  1699. 		  $func= preg_replace($reg,"($1)($2)",$func);	

    1700. 

  1700. 		  $reg = "/(" . $toparen . ")(sqrt|ln|log|sin|cos|tan|sec|csc|cot|abs)/";

    1701. 

  1701. 		  $func= preg_replace($reg,"($1)$2",$func);	

    1702. 

  1702. 		  $reg = "/(" . $toparen . ")(" . $toparen . ')([^a-df-zA-Z\(])/';

    1703. 

  1703. 		  $func= preg_replace($reg,"($1)($2)$3",$func);	

    1704. 

  1704. 		  $reg = "/([^a-zA-Z])(" . $toparen . ")([^a-zA-Z])/";

    1705. 

  1705. 		  $func= preg_replace($reg,"$1($2)$3",$func);	

    1706. 

  1706. 		  //need second run through to catch x*x

    1707. 

  1707. 		  $func= preg_replace($reg,"$1($2)$3",$func);	

    1708. 

  1708. 		  $reg = "/^(" . $toparen . ")([^a-zA-Z])/";

    1709. 

  1709. 		  $func= preg_replace($reg,"($1)$2",$func);

    1710. 

  1710. 		  $reg = "/([^a-zA-Z])(" . $toparen . ")$/";

    1711. 

  1711. 		  $func= preg_replace($reg,"$1($2)",$func);

    1712. 

  1712. 		  $reg = "/^(" . $toparen . ")$/";

    1713. 

  1713. 		  $func= preg_replace($reg,"($1)",$func);

    1714. 

  1714. 		  

    1715. 

  1715. 		  $reg = "/\(\((" . $toparen . ")\)\)/";

    1716. 

  1716. 		  $func= preg_replace($reg,"($1)",$func);

    1717. 

  1717. 		  $func= preg_replace($reg,"($1)",$func);  

    1718. 

  1718. 	}

    1719. 

  1719. 	*/

    1720. 

  1720. 	return array($func,$varlist);

    1721. 

  1721. }

    1722. 

  1722. 

    1723. 

  1723. function evalfunc($farr) {

    1724. 

  1724. 	$args = func_get_args();

    1725. 

  1725. 	array_shift($args);

    1726. 

  1726. 	if (is_array($farr)) {

    1727. 

  1727. 		list($func,$varlist) = $farr;

    1728. 

  1728. 		//$skipextracleanup = true;

    1729. 

  1729. 	} else {

    1730. 

  1730. 		$func = $farr;

    1731. 

  1731. 		$varlist = array_shift($args);

    1732. 

  1732. 		//$skipextracleanup = false;

    1733. 

  1733. 	}

    1734. 

  1734. 	$func = makepretty($func);

    1735. 

  1735. 	$vars = explode(',',$varlist);

    1736. 

  1736. 	if (count($vars)!=count($args)) {

    1737. 

  1737. 		echo "Number of inputs to function doesn't match number of variables";

    1738. 

  1738. 	}

    1739. 

  1739. 	$isnum = true;

    1740. 

  1740. 	for ($i=0;$i<count($args);$i++) {

    1741. 

  1741. 		if (!is_numeric($args[$i])) {

    1742. 

  1742. 			$isnum = false;

    1743. 

  1743. 		}

    1744. 

  1744. 	}

    1745. 

  1745. 	

    1746. 

  1746. 	$toparen = implode('|',$vars);

    1747. 

  1747. 	

    1748. 

  1748. 	if ($isnum) {

    1749. 

  1749. 		$func = mathphp($func,$toparen);

    1750. 

  1750. 		if ($func=='0;') { return 0;}

    1751. 

  1751. 		$toeval = '';

    1752. 

  1752. 		foreach ($vars as $i=>$var) {

    1753. 

  1753. 			$func = str_replace("($var)","(\$$var)",$func);

    1754. 

  1754. 			$toeval .= "\$$var = {$args[$i]};";

    1755. 

  1755. 		}

    1756. 

  1756. 		$toeval .= "\$out = $func;\n";

    1757. 

  1757. 		eval($toeval);

    1758. 

  1758. 		return $out;

    1759. 

  1759. 	} else { //just replacing

    1760. 

  1760. 		if ($toparen != '') { // && !$skipextracleanup) {

    1761. 

  1761. 			  $reg = "/(" . $toparen . ")(" . $toparen . ')$/';

    1762. 

  1762. 			  $func= preg_replace($reg,"($1)($2)",$func);	

    1763. 

  1763. 			  $reg = "/(" . $toparen . ")(sqrt|ln|log|sin|cos|tan|sec|csc|cot|abs)/";

    1764. 

  1764. 			  $func= preg_replace($reg,"($1)$2",$func);	

    1765. 

  1765. 			  $reg = "/(" . $toparen . ")(" . $toparen . ')([^a-df-zA-Z\(])/';

    1766. 

  1766. 			  $func= preg_replace($reg,"($1)($2)$3",$func);	

    1767. 

  1767. 			  $reg = "/([^a-zA-Z])(" . $toparen . ")([^a-zA-Z])/";

    1768. 

  1768. 			  $func= preg_replace($reg,"$1($2)$3",$func);	

    1769. 

  1769. 			  //need second run through to catch x*x

    1770. 

  1770. 			  $func= preg_replace($reg,"$1($2)$3",$func);	

    1771. 

  1771. 			  $reg = "/^(" . $toparen . ")([^a-zA-Z])/";

    1772. 

  1772. 			  $func= preg_replace($reg,"($1)$2",$func);

    1773. 

  1773. 			  $reg = "/([^a-zA-Z])(" . $toparen . ")$/";

    1774. 

  1774. 			  $func= preg_replace($reg,"$1($2)",$func);

    1775. 

  1775. 			  $reg = "/^(" . $toparen . ")$/";

    1776. 

  1776. 			  $func= preg_replace($reg,"($1)",$func);

    1777. 

  1777. 			  

    1778. 

  1778. 			  $reg = "/\(\((" . $toparen . ")\)\)/";

    1779. 

  1779. 			  $func= preg_replace($reg,"($1)",$func);

    1780. 

  1780. 			  $func= preg_replace($reg,"($1)",$func);  

    1781. 

  1781. 		}

    1782. 

  1782. 		foreach ($vars as $i=>$var) {

    1783. 

  1783. 			$func = str_replace("($var)","({$args[$i]})",$func);

    1784. 

  1784. 		}

    1785. 

  1785. 		$reg = '/^\((\d*?\.?\d*?)\)([^\d\.])/';

    1786. 

  1786. 		$func= preg_replace($reg,"$1$2",$func);

    1787. 

  1787. 		$reg = '/^\(([a-zA-Z])\)([^a-zA-Z])/';

    1788. 

  1788. 		$func= preg_replace($reg,"$1$2",$func);

    1789. 

  1789. 		

    1790. 

  1790. 		$reg = '/([^\d\.])\((\d*?\.?\d*?)\)$/';

    1791. 

  1791. 		$func= preg_replace($reg,"$1$2",$func);

    1792. 

  1792. 		$reg = '/([^a-zA-Z])\(([a-zA-Z])\)$/';

    1793. 

  1793. 		$func= preg_replace($reg,"$1$2",$func);

    1794. 

  1794. 		

    1795. 

  1795. 		$reg = '/([^\d\.])\((\d*?\.?\d*?)\)([^\d\.])/';

    1796. 

  1796. 		$func= preg_replace($reg,"$1$2$3",$func);

    1797. 

  1797. 		$reg = '/([^a-zA-Z])\(([a-zA-Z])\)([^a-zA-Z])/';

    1798. 

  1798. 		$func= preg_replace($reg,"$1$2$3",$func);

    1799. 

  1799. 		

    1800. 

  1800. 		return $func;

    1801. 

  1801. 	}

    1802. 

  1802. }

    1803. 

  1803. 

    1804. 

  1804. function textonimage() {

    1805. 

  1805. 	$args = func_get_args();

    1806. 

  1806. 	$img = array_shift($args);

    1807. 

  1807. 	$img = preg_replace('/^.*src="(.*?)".*$/',"$1",$img);

    1808. 

  1808. 	$out = '<div style="position: relative;">';

    1809. 

  1809. 	$out .= '<img src="'.$img.'" style="position: relative; top: 0px; left: 0px;" />';

    1810. 

  1810. 	while (count($args)>2) {

    1811. 

  1811. 		$text = array_shift($args);

    1812. 

  1812. 		$left = array_shift($args);

    1813. 

  1813. 		$top = array_shift($args);

    1814. 

  1814. 		$out .= "<div style=\"position: absolute; top: {$top}px; left: {$left}px;\">$text</div>";

    1815. 

  1815. 	}

    1816. 

  1816. 	$out .= '</div>';

    1817. 

  1817. 	return $out;

    1818. 

  1818. }

    1819. 

  1819. 

    1820. 

  1820. function today($str = "F j, Y") {

    1821. 

  1821. 	return (date($str));

    1822. 

  1822. }

    1823. 

  1823. 

    1824. 

  1824. function numtoroman($n,$uc=true) {

    1825. 

  1825. 	if ($uc) {

    1826. 

  1826. 		$lookup = array('M'=>1000,'CM'=>900,'D'=>500,'CD'=>400,'C'=>100,'XC'=>90,'L'=>50,'XL'=>40,'X'=>10,'IX'=>9,'V'=>5,'IV'=>4,'I'=>1,'<span style="border-top:1px solid;">SS</span>'=>0.5);

    1827. 

  1827. 	} else {

    1828. 

  1828. 		$lookup = array('m'=>1000,'cm'=>900,'d'=>500,'cd'=>400,'c'=>100,'xc'=>90,'l'=>50,'xl'=>40,'x'=>10,'ix'=>9,'v'=>5,'iv'=>4,'i'=>1,'<span style="border-top:1px solid;">ss</span>'=>0.5);

    1829. 

  1829. 	}

    1830. 

  1830. 	$roman = '';

    1831. 

  1831. 	foreach($lookup as $r=>$v) {

    1832. 

  1832. 		while($n >= $v) {

    1833. 

  1833. 			$roman .= $r;

    1834. 

  1834. 			$n -= $v;

    1835. 

  1835. 		}

    1836. 

  1836. 	}

    1837. 

  1837. 	return $roman;

    1838. 

  1838. }

    1839. 

  1839. 

    1840. 

  1840. function fillarray($v,$n,$s=0) {

    1841. 

  1841. 	return array_fill($s,$n,$v);

    1842. 

  1842. }

    1843. 

  1843. 

    1844. 

  1844. function arrayhasduplicates($arr) {

    1845. 

  1845. 	if (count($arr)==count(array_unique($arr))) {

    1846. 

  1846. 		return false;

    1847. 

  1847. 	} else {

    1848. 

  1848. 		return true;

    1849. 

  1849. 	}

    1850. 

  1850. }

    1851. 

  1851. 

    1852. 

  1852. function ifthen($c,$t,$f) {

    1853. 

  1853. 	return $c?$t:$f;

    1854. 

  1854. }

    1855. 

  1855. 

    1856. 

  1856. 

    1857. 

  1857. //adapted from http://www.mindspring.com/~alanh/fracs.html

    1858. 

  1858. function decimaltofraction($d,$format="fraction",$maxden = 5000) {

    1859. 

  1859. 	if (floor($d)==$d) {

    1860. 

  1860. 		return floor($d);

    1861. 

  1861. 	}

    1862. 

  1862. 	if ($d<0) {

    1863. 

  1863. 		$sign = '-';

    1864. 

  1864. 	} else {

    1865. 

  1865. 		$sign = '';

    1866. 

  1866. 	}

    1867. 

  1867. 	$d = abs($d);

    1868. 

  1868. 	$numerators = array(0, 1);

    1869. 

  1869. 	$denominators = array(1, 0);

    1870. 

  1870. 	

    1871. 

  1871. 	$d2 = $d;

    1872. 

  1872. 	$calcD = -1;

    1873. 

  1873. 	$prevCalcD = -1;

    1874. 

  1874. 	for ($i = 2; $i < 1000; $i++)  {

    1875. 

  1875. 		$L2 = floor($d2);

    1876. 

  1876. 		$numerators[$i] = $L2 * $numerators[$i-1] + $numerators[$i-2];

    1877. 

  1877. 		//if (Math.abs(numerators[i]) > maxNumerator) return;

    1878. 

  1878. 		$denominators[$i] = $L2 * $denominators[$i-1] + $denominators[$i-2];

    1879. 

  1879. 		if (abs($denominators[$i])>$maxden) {

    1880. 

  1880. 			break;

    1881. 

  1881. 		}

    1882. 

  1882. 		$calcD = $numerators[$i] / $denominators[$i];

    1883. 

  1883. 		if ($calcD == $prevCalcD) { break; }

    1884. 

  1884. 	

    1885. 

  1885. 		//appendFractionsOutput(numerators[i], denominators[i]);

    1886. 

  1886. 	

    1887. 

  1887. 		//if ($calcD == $d) { break;}

    1888. 

  1888. 		if (abs($calcD - $d)<1e-9) { break;}

    1889. 

  1889. 	

    1890. 

  1890. 		$prevCalcD = $calcD;

    1891. 

  1891. 	

    1892. 

  1892. 		$d2 = 1/($d2-$L2);

    1893. 

  1893. 	}

    1894. 

  1894. 	if (abs($numerators[$i]/$denominators[$i] - $d)>1e-9) {

    1895. 

  1895. 		return $d;

    1896. 

  1896. 	}

    1897. 

  1897. 	if ($format=="mixednumber") {

    1898. 

  1898. 		$w = floor($numerators[$i]/$denominators[$i]);

    1899. 

  1899. 		if ($w>0) {

    1900. 

  1900. 			$n = $numerators[$i] - $w*$denominators[$i];

    1901. 

  1901. 			return "{$sign}$w $n/".$denominators[$i];

    1902. 

  1902. 		} else {

    1903. 

  1903. 			return $sign.$numerators[$i].'/'.$denominators[$i];

    1904. 

  1904. 		}

    1905. 

  1905. 	} else {

    1906. 

  1906. 		return $sign.$numerators[$i].'/'.$denominators[$i];

    1907. 

  1907. 	}

    1908. 

  1908. }

    1909. 

  1909. 

    1910. 

  1910. function evalbasic($str) {

    1911. 

  1911. 	if (is_numeric($str)) {

    1912. 

  1912. 		return $str;

    1913. 

  1913. 	} else if (preg_match('/[^\d+\-\/\*\.]/',$str)) {

    1914. 

  1914. 		return $str;

    1915. 

  1915. 	} else {

    1916. 

  1916. 		eval("\$ret = $str;");

    1917. 

  1917. 		return $ret;

    1918. 

  1918. 	}

    1919. 

  1919. }

    1920. 

  1920. 

    1921. 

  1921. function formhoverover($label,$tip) {

    1922. 

  1922. 	if (function_exists('filter')) {

    1923. 

  1923. 		return '<span class="link" onmouseover="tipshow(this,\''.htmlentities(filter($tip),ENT_QUOTES).'\')" onmouseout="tipout()">'.$label.'</span>';

    1924. 

  1924. 	} else {

    1925. 

  1925. 		return '<span class="link" onmouseover="tipshow(this,\''.htmlentities($tip,ENT_QUOTES).'\')" onmouseout="tipout()">'.$label.'</span>';

    1926. 

  1926. 	}

    1927. 

  1927. }

    1928. 

  1928. 

    1929. 

  1929. function formpopup($label,$content,$width=600,$height=400,$type='link',$scroll='null',$id='popup') {

    1930. 

  1930. 	if ($scroll != null) {

    1931. 

  1931. 		$scroll = ','.$scroll;

    1932. 

  1932. 	}

    1933. 

  1933. 	if ($height=='fit') {

    1934. 

  1934. 		$height = "'fit'";

    1935. 

  1935. 	}

    1936. 

  1936. 	if (strpos($label,'<img')!==false) {

    1937. 

  1937. 		return str_replace('<img', '<img class="clickable" onClick="popupwindow(\''.$id.'\',\''.str_replace('\'','\\\'',htmlentities($content)).'\','.$width.','.$height.$scroll.')"',$label);

    1938. 

  1938. 	} else {

    1939. 

  1939. 		if ($type=='link') {

    1940. 

  1940. 			return '<span class="link" onClick="popupwindow(\''.$id.'\',\''.str_replace('\'','\\\'',htmlentities($content)).'\','.$width.','.$height.$scroll.')">'.$label.'</span>';

    1941. 

  1941. 		} else if ($type=='button') {

    1942. 

  1942. 			return '<span class="spanbutton" onClick="popupwindow(\''.$id.'\',\''.str_replace('\'','\\\'',htmlentities($content)).'\','.$width.','.$height.$scroll.')">'.$label.'</span>';

    1943. 

  1943. 		}

    1944. 

  1944. 	}

    1945. 

  1945. }

    1946. 

  1946. 

    1947. 

  1947. function forminlinebutton($label,$content,$style='button',$outstyle='block') {

    1948. 

  1948. 	if (isset($GLOBALS['inlinebuttoncnt'])) {

    1949. 

  1949. 		$r = $GLOBALS['inlinebuttoncnt'];

    1950. 

  1950. 		$GLOBALS['inlinebuttoncnt']++;

    1951. 

  1951. 		//$out = '';

    1952. 

  1952. 	} else {

    1953. 

  1953. 		$r = 1;

    1954. 

  1954. 		$GLOBALS['inlinebuttoncnt'] = 2;

    1955. 

  1955. 		//$out = '<script type="text/javascript">function toggleinlinebtn(n){var el=document.getElementById(n);el.style.display=="none"?el.style.display="":el.style.display="none";}</script>';

    1956. 

  1956. 	}

    1957. 

  1957. 	$label = str_replace('"','',$label);

    1958. 

  1958. 	if ($style=='classic') {

    1959. 

  1959. 		$out = '<input type="button" value="'.$label.'" onClick="toggleinlinebtn(\'inlinebtn'.$r.'\');" />';

    1960. 

  1960. 	} else if ($style=='link') {

    1961. 

  1961. 		$out = '<span class="link" onClick="toggleinlinebtn(\'inlinebtn'.$r.'\');">'.$label.'</span>';

    1962. 

  1962. 	} else {

    1963. 

  1963. 		$out = '<span class="spanbutton" onClick="toggleinlinebtn(\'inlinebtn'.$r.'\');">'.$label.'</span>';

    1964. 

  1964. 	}

    1965. 

  1965. 	if ($outstyle=='inline') {

    1966. 

  1966. 		$out .= ' <span id="inlinebtn'.$r.'" style="display:none;">'.$content.'</span>';

    1967. 

  1967. 	} else {

    1968. 

  1968. 		$out .= '<div id="inlinebtn'.$r.'" style="display:none;">'.$content.'</div>';

    1969. 

  1969. 	}

    1970. 

  1970. 	return $out;

    1971. 

  1971. }

    1972. 

  1972. 

    1973. 

  1973. function intervaltoineq($str,$var) {

    1974. 

  1974. 	if ($str=='DNE') {

    1975. 

  1975. 		return 'DNE';

    1976. 

  1976. 	}

    1977. 

  1977. 	$arr = explode('U',$str);

    1978. 

  1978. 	$out = array();

    1979. 

  1979. 	foreach ($arr as $v) {

    1980. 

  1980. 		$v = trim($v);

    1981. 

  1981. 		$sm = $v{0};

    1982. 

  1982. 		$em = $v{strlen($v)-1};

    1983. 

  1983. 		$pts = explode(',',substr($v,1,strlen($v)-2));

    1984. 

  1984. 		if ($pts[0]=='-oo') {

    1985. 

  1985. 			if ($pts[1]=='oo') {

    1986. 

  1986. 				$out[] = '"all real numbers"';

    1987. 

  1987. 			} else {

    1988. 

  1988. 				$out[] = $var . ($em==']'?'le':'lt') . $pts[1];

    1989. 

  1989. 			}

    1990. 

  1990. 		} else if ($pts[1]=='oo') {

    1991. 

  1991. 			$out[] = $var . ($sm=='['?'ge':'gt') . $pts[0];

    1992. 

  1992. 		} else {

    1993. 

  1993. 			$out[] = $pts[0] . ($sm=='['?'le':'lt') . $var . ($em==']'?'le':'lt') . $pts[1];

    1994. 

  1994. 		}

    1995. 

  1995. 	}

    1996. 

  1996. 	return implode(' \\ "or" \\ ',$out);

    1997. 

  1997. }

    1998. 

  1998. 

    1999. 

  1999. function cleanbytoken($str,$funcs = array()) {

    2000. 

  2000. 	$tokens = cleantokenize($str,$funcs);

    2001. 

  2001. 	//print_r($tokens);

    2002. 

  2002. 	$out = array();

    2003. 

  2003. 	$lasti = count($tokens)-1;

    2004. 

  2004. 	for ($i=0; $i<=$lasti; $i++) {

    2005. 

  2005. 		$token = $tokens[$i];

    2006. 

  2006. 		$lastout = count($out)-1;

    2007. 

  2007. 		if ($token[1]==3 && $token[0]==='0') { //is the number 0 by itself

    2008. 

  2008. 			if ($lastout>-1) { //if not first character

    2009. 

  2009. 				if ($out[$lastout] != '^') {

    2010. 

  2010. 					//( )0, + 0, x0

    2011. 

  2011. 					while ($lastout>-1 && $out[$lastout]!= '+' && $out[$lastout]!= '-') {

    2012. 

  2012. 						array_pop($out);

    2013. 

  2013. 						$lastout--;

    2014. 

  2014. 					}

    2015. 

  2015. 					if ($lastout>-1) {

    2016. 

  2016. 						array_pop($out);

    2017. 

  2017. 					}

    2018. 

  2018. 					

    2019. 

  2019. 				} else if ($out[$lastout] == '^') {

    2020. 

  2020. 					if ($lastout>=2 && ($out[$lastout-2]=='+'|| $out[$lastout-2]=='-')) {

    2021. 

  2021. 						//4x+x^0 -> 4x+1

    2022. 

  2022. 						array_splice($out,-2);

    2023. 

  2023. 						$out[] = 1;

    2024. 

  2024. 					} else if ($lastout>=2) {

    2025. 

  2025. 						//4x^0->4, 5(x+3)^0 -> 5

    2026. 

  2026. 						array_splice($out,-2);

    2027. 

  2027. 					} else if ($lastout==1) {

    2028. 

  2028. 						//x^0 -> 1

    2029. 

  2029. 						$out = array(1);

    2030. 

  2030. 					}

    2031. 

  2031. 				}

    2032. 

  2032. 			}

    2033. 

  2033. 			if ($i<$lasti) { //if not last character

    2034. 

  2034. 				if ($tokens[$i+1][0]=='^') {

    2035. 

  2035. 					//0^3

    2036. 

  2036. 					$i+=2; //skip over ^ and 3

    2037. 

  2037. 				} else {

    2038. 

  2038. 					while ($i<$lasti && $tokens[$i+1][0]!= '+' && $tokens[$i+1][0]!= '-') {

    2039. 

  2039. 						$i++;

    2040. 

  2040. 					}

    2041. 

  2041. 				}

    2042. 

  2042. 			}

    2043. 

  2043. 		} else if ($token[1]==3 && $token[0]==='1') {

    2044. 

  2044. 			$dontuse = false;

    2045. 

  2045. 			if ($lastout>-1) { //if not first character

    2046. 

  2046. 				if ($out[$lastout] != '^' && $out[$lastout]!='+' && $out[$lastout]!='-') {

    2047. 

  2047. 					//( )1, x1,*1

    2048. 

  2048. 					if ($out[$lastout]=='*') { //elim *

    2049. 

  2049. 						array_pop($out);

    2050. 

  2050. 					}

    2051. 

  2051. 					$dontuse = true;

    2052. 

  2052. 				} else if ($out[$lastout] == '^') {

    2053. 

  2053. 					if ($lastout>=1) {

    2054. 

  2054. 						//4+x^1 -> 4+x, 4x^1 -> 4x

    2055. 

  2055. 						array_pop($out);

    2056. 

  2056. 						$dontuse = true;

    2057. 

  2057. 					}

    2058. 

  2058. 				}

    2059. 

  2059. 			}

    2060. 

  2060. 			if ($i<$lasti) { //if not last character

    2061. 

  2061. 				if ($tokens[$i+1][0]=='^') {

    2062. 

  2062. 					//1^3

    2063. 

  2063. 					$i+=2; //skip over ^ and 3

    2064. 

  2064. 				} else if ($tokens[$i+1][0]=='*') {

    2065. 

  2065. 					$i++;  //skip over *

    2066. 

  2066. 					$dontuse = true;

    2067. 

  2067. 				} else if ($tokens[$i+1][0]!= '+' && $tokens[$i+1][0]!= '-' && $tokens[$i+1][0]!= '/') {

    2068. 

  2068. 					// 1x, 1(), 1sin

    2069. 

  2069. 					if ($lastout<2 || ($out[$lastout-1] != '^' || $out[$lastout] != '-')) { //exclude ^-1 case

    2070. 

  2070. 						$dontuse = true;

    2071. 

  2071. 					}

    2072. 

  2072. 				}

    2073. 

  2073. 			}

    2074. 

  2074. 			if (!$dontuse) {

    2075. 

  2075. 				$out[] = 1;

    2076. 

  2076. 			}

    2077. 

  2077. 		} else {

    2078. 

  2078. 			$out[] = $token[0];	

    2079. 

  2079. 		}	

    2080. 

  2080. 	}

    2081. 

  2081. 	if ($out[0]=='+') {

    2082. 

  2082. 		array_shift($out);

    2083. 

  2083. 	}

    2084. 

  2084. 	if (count($out)==0) {

    2085. 

  2085. 		return '0';

    2086. 

  2086. 	}

    2087. 

  2087. 	return implode('',$out);

    2088. 

  2088. }

    2089. 

  2089. 

    2090. 

  2090. 

    2091. 

  2091. function cleantokenize($str,$funcs) {

    2092. 

  2092. 	$knownfuncs = array_merge($funcs,array("sin","cos","sec","csc","tan","csc","cot","sinh","cosh","sech","csch","tanh","coth","arcsin","arccos","arcsec","arccsc","arctan","arccot","arcsinh","arccosh","arctanh","sqrt","ceil","floor","root","log","ln","abs","max","min"));

    2093. 

  2093. 	

    2094. 

  2094. 	$lookfor = array("e","pi");

    2095. 

  2095. 	$maxvarlen = 0;

    2096. 

  2096. 	foreach ($lookfor as $v) {

    2097. 

  2097. 		$l = strlen($v);

    2098. 

  2098. 		if ($l>$maxvarlen) {

    2099. 

  2099. 			$maxvarlen = $l;

    2100. 

  2100. 		}

    2101. 

  2101. 	}

    2102. 

  2102. 	$connecttolast = 0;

    2103. 

  2103. 	$i=0;

    2104. 

  2104. 	$cnt = 0;

    2105. 

  2105. 	$len = strlen($str);

    2106. 

  2106. 	$syms = array();

    2107. 

  2107. 	$lastsym = array();

    2108. 

  2108. 	while ($i<$len) {

    2109. 

  2109. 		$cnt++;

    2110. 

  2110. 		if ($cnt>100) {

    2111. 

  2111. 			exit;

    2112. 

  2112. 		}

    2113. 

  2113. 		$intype = 0;

    2114. 

  2114. 		$out = '';

    2115. 

  2115. 		$c = $str{$i};

    2116. 

  2116. 		$eatenwhite = 0;

    2117. 

  2117. 		if ($c>="a" && $c<="z" || $c>="A" && $c<="Z") {

    2118. 

  2118. 			//is a string or function name

    2119. 

  2119. 			

    2120. 

  2120. 			$intype = 2; //string like function name

    2121. 

  2121. 			do {

    2122. 

  2122. 				$out .= $c;

    2123. 

  2123. 				$i++;

    2124. 

  2124. 				if ($i==$len) {break;}

    2125. 

  2125. 				$c = $str{$i};

    2126. 

  2126. 			} while ($c>="a" && $c<="z" || $c>="A" && $c<="Z" || $c=='_'); // took out : || $c>='0' && $c<='9'  don't need sin3 type function names for cleaning

    2127. 

  2127. 			//check if it's a special word

    2128. 

  2128. 			if ($out=='e') {

    2129. 

  2129. 				$intype = 3;

    2130. 

  2130. 			} else if ($out=='pi') {

    2131. 

  2131. 				$intype = 3;

    2132. 

  2132. 			} else {

    2133. 

  2133. 				//eat whitespace

    2134. 

  2134. 				while ($c==' ') {

    2135. 

  2135. 					$i++;

    2136. 

  2136. 					$c = $str{$i};

    2137. 

  2137. 					$eatenwhite++;

    2138. 

  2138. 				}    

    2139. 

  2139. 				//if known function at end, strip off function

    2140. 

  2140. 				if ($c=='(' && !in_array($out,$knownfuncs)) {// moved to mathphppre-> || ($c=='^' && (substr($str,$i+1,2)=='-1' || substr($str,$i+1,4)=='(-1)'))) {

    2141. 

  2141. 					$outlen = strlen($out);

    2142. 

  2142. 					$outend = '';

    2143. 

  2143. 					for ($j=1; $j<$outlen-1; $j++) {

    2144. 

  2144. 						$outend = substr($out,$j);

    2145. 

  2145. 						if (in_array($outend,$knownfuncs)) {

    2146. 

  2146. 							$i = $i - $outlen + $j;

    2147. 

  2147. 							$c = $str{$i};

    2148. 

  2148. 							$out = substr($out,0,$j);

    2149. 

  2149. 							break;

    2150. 

  2150. 						}

    2151. 

  2151. 					}

    2152. 

  2152. 					

    2153. 

  2153. 				}

    2154. 

  2154. 				

    2155. 

  2155. 				//if there's a ( then it's a function if it's in our list

    2156. 

  2156. 				if ($c=='(' && $out!='e' && $out!='pi' && in_array($out,$knownfuncs)) {

    2157. 

  2157. 					//connect upcoming parens to function

    2158. 

  2158. 					$connecttolast = 2;

    2159. 

  2159. 				} else {

    2160. 

  2160. 					//is it a known function?

    2161. 

  2161. 					if (in_array($out,$knownfuncs)) {  

    2162. 

  2162. 						$intype = 6;

    2163. 

  2163. 					} else {

    2164. 

  2164. 						//if not, assume it's a variable

    2165. 

  2165. 						$intype = 4;		

    2166. 

  2166. 					}

    2167. 

  2167. 				}

    2168. 

  2168. 			}

    2169. 

  2169. 		} else if (($c>='0' && $c<='9') || ($c=='.'  && ($str{$i+1}>='0' && $str{$i+1}<='9')) ) { //is num

    2170. 

  2170. 			$intype = 3; //number

    2171. 

  2171. 			$cont = true;

    2172. 

  2172. 			//handle . 3 which needs to act as concat

    2173. 

  2173. 			if (isset($lastsym[0]) && $lastsym[0]=='.') {

    2174. 

  2174. 				$syms[count($syms)-1][0] .= ' ';

    2175. 

  2175. 			}

    2176. 

  2176. 			do {

    2177. 

  2177. 				$out .= $c;

    2178. 

  2178. 				$lastc = $c;

    2179. 

  2179. 				$i++;

    2180. 

  2180. 				if ($i==$len) {break;}

    2181. 

  2181. 				$c= $str{$i};

    2182. 

  2182. 				if (($c>='0' && $c<='9') || ($c=='.' && $str{$i+1}!='.' && $lastc!='.')) {

    2183. 

  2183. 					//is still num

    2184. 

  2184. 				} else if ($c=='e' || $c=='E') {

    2185. 

  2185. 					//might be scientific notation:  5e6 or 3e-6 

    2186. 

  2186. 					$d = $str{$i+1};

    2187. 

  2187. 					if ($d>='0' && $d<='9') {

    2188. 

  2188. 						$out .= $c;

    2189. 

  2189. 						$i++;

    2190. 

  2190. 						if ($i==$len) {break;}

    2191. 

  2191. 						$c= $str{$i};

    2192. 

  2192. 					} else if (($d=='-'||$d=='+') && ($str{$i+2}>='0' && $str{$i+2}<='9')) {

    2193. 

  2193. 						$out .= $c.$d;

    2194. 

  2194. 						$i+= 2;

    2195. 

  2195. 						if ($i>=$len) {break;}

    2196. 

  2196. 						$c= $str{$i};

    2197. 

  2197. 					} else {

    2198. 

  2198. 						$cont = false;

    2199. 

  2199. 					}	

    2200. 

  2200. 				} else {

    2201. 

  2201. 					$cont = false;

    2202. 

  2202. 				}	

    2203. 

  2203. 			} while ($cont);

    2204. 

  2204. 		} else if ($c=='(' || $c=='{' || $c=='[') { //parens or curlys

    2205. 

  2205. 			if ($c=='(') {

    2206. 

  2206. 				$intype = 4; //parens

    2207. 

  2207. 				$leftb = '(';

    2208. 

  2208. 				$rightb = ')';

    2209. 

  2209. 			} else if ($c=='{') {

    2210. 

  2210. 				$intype = 5; //curlys

    2211. 

  2211. 				$leftb = '{';

    2212. 

  2212. 				$rightb = '}';

    2213. 

  2213. 			} else if ($c=='[') {

    2214. 

  2214. 				$intype = 11; //array index brackets

    2215. 

  2215. 				$leftb = '[';

    2216. 

  2216. 				$rightb = ']';

    2217. 

  2217. 			}

    2218. 

  2218. 			$thisn = 1;

    2219. 

  2219. 			$inq = false;

    2220. 

  2220. 			$j = $i+1;

    2221. 

  2221. 			$len = strlen($str);

    2222. 

  2222. 			while ($j<$len) {

    2223. 

  2223. 				//read terms until we get to right bracket at same nesting level

    2224. 

  2224. 				//we have to avoid strings, as they might contain unmatched brackets

    2225. 

  2225. 				$d = $str{$j};

    2226. 

  2226. 				if ($inq) {  //if inquote, leave if same marker (not escaped)

    2227. 

  2227. 					if ($d==$qtype && $str{$j-1}!='\\') {

    2228. 

  2228. 						$inq = false;

    2229. 

  2229. 					}

    2230. 

  2230. 				} else {

    2231. 

  2231. 					if ($d=='"' || $d=="'") {

    2232. 

  2232. 						$inq = true; //entering quotes

    2233. 

  2233. 						$qtype = $d;

    2234. 

  2234. 					} else if ($d==$leftb) {

    2235. 

  2235. 						$thisn++;  //increase nesting depth

    2236. 

  2236. 					} else if ($d==$rightb) {

    2237. 

  2237. 						$thisn--; //decrease nesting depth

    2238. 

  2238. 						if ($thisn==0) {

    2239. 

  2239. 							//read inside of brackets, send recursively to interpreter

    2240. 

  2240. 							$inside = cleanbytoken(substr($str,$i+1,$j-$i-1), $funcs);

    2241. 

  2241. 							if ($inside=='error') {

    2242. 

  2242. 								//was an error, return error token

    2243. 

  2243. 								return array(array('',9));

    2244. 

  2244. 							}

    2245. 

  2245. 							//if curly, make sure we have a ;, unless preceeded by a $ which

    2246. 

  2246. 							//would be a variable variable

    2247. 

  2247. 							if ($rightb=='}' && $lastsym[0]!='$') {

    2248. 

  2248. 								$out .= $leftb.$inside.';'.$rightb;

    2249. 

  2249. 							} else {

    2250. 

  2250. 								$out .= $leftb.$inside.$rightb;

    2251. 

  2251. 							}

    2252. 

  2252. 							$i= $j+1;

    2253. 

  2253. 							break;

    2254. 

  2254. 						}

    2255. 

  2255. 					} else if ($d=="\n") {

    2256. 

  2256. 						//echo "unmatched parens/brackets - likely will cause an error";

    2257. 

  2257. 					}

    2258. 

  2258. 				}

    2259. 

  2259. 				$j++;

    2260. 

  2260. 			}

    2261. 

  2261. 			if ($j==$len) {

    2262. 

  2262. 				$i = $j;

    2263. 

  2263. 				echo "unmatched parens/brackets - likely will cause an error";

    2264. 

  2264. 			} else {

    2265. 

  2265. 				$c = $str{$i};

    2266. 

  2266. 			}

    2267. 

  2267. 		} else if ($c=='"' || $c=="'") { //string

    2268. 

  2268. 			$intype = 6;

    2269. 

  2269. 			$qtype = $c;

    2270. 

  2270. 			do {

    2271. 

  2271. 				$out .= $c;

    2272. 

  2272. 				$i++;

    2273. 

  2273. 				if ($i==$len) {break;}

    2274. 

  2274. 				$lastc = $c;

    2275. 

  2275. 				$c = $str{$i};

    2276. 

  2276. 			} while (!($c==$qtype && $lastc!='\\'));	

    2277. 

  2277. 			$out .= $c;

    2278. 

  2278. 							

    2279. 

  2279. 			$i++;

    2280. 

  2280. 			$c = $str{$i};

    2281. 

  2281. 		}  else {

    2282. 

  2282. 			//no type - just append string.  Could be operators

    2283. 

  2283. 			$out .= $c;

    2284. 

  2284. 			$i++;

    2285. 

  2285. 			if ($i<$len) {

    2286. 

  2286. 				$c = $str{$i};

    2287. 

  2287. 			}

    2288. 

  2288. 		}

    2289. 

  2289. 		while ($c==' ') { //eat up extra whitespace

    2290. 

  2290. 			$i++;

    2291. 

  2291. 			if ($i==$len) {break;}

    2292. 

  2292. 			$c = $str{$i};

    2293. 

  2293. 			if ($c=='.' && $intype==3) {//if 3 . needs space to act like concat

    2294. 

  2294. 				$out .= ' ';

    2295. 

  2295. 			}

    2296. 

  2296. 		}

    2297. 

  2297. 		//if parens or array index needs to be connected to func/var, do it

    2298. 

  2298. 		if ($connecttolast>0 && $intype!=$connecttolast) {

    2299. 

  2299. 			

    2300. 

  2300. 			$syms[count($syms)-1][0] .= $out;

    2301. 

  2301. 			$connecttolast = 0;

    2302. 

  2302. 			if ($c=='[') {// multidim array ref?

    2303. 

  2303. 				$connecttolast = 1;

    2304. 

  2304. 			}

    2305. 

  2305. 			

    2306. 

  2306. 		} else {

    2307. 

  2307. 			//add to symbol list, avoid repeat end-of-lines.

    2308. 

  2308. 			if ($intype!=7 || $lastsym[1]!=7) {

    2309. 

  2309. 				$lastsym = array($out,$intype);

    2310. 

  2310. 				$syms[] =  array($out,$intype);

    2311. 

  2311. 			}

    2312. 

  2312. 		}

    2313. 

  2313. 		

    2314. 

  2314. 	}

    2315. 

  2315. 	return $syms;

    2316. 

  2316. }

    2317. 

  2317. 

    2318. 

  2318. ?>

    2319. 

  2319.