eXorithm – Execute Algorithm: View / Run Algorithm number_string

function number_string ($number

{

  $names = array

    0=>"zero", 1=>"one", 2=>"two", 3=>"three", 4=>"four"

    5=>"five", 6=>"six", 7=>"seven", 8=>"eight", 9=>"nine"

    10=>"ten", 11=>"eleven", 12=>"twelve", 13=>"thirteen", 14=>"fourteen"

    15=>"fifteen", 16=>"sixteen", 17=>"seventeen", 18=>"eighteen", 19=>"nineteen"

    20=>"twenty", 30=>"thirty", 40=>"forty", 50=>"fifty"

    60=>"sixty", 70=>"seventy", 80=>"eighty", 90=>"ninety"

  );

  

  $triplets = array

    100=>"hundred"

    1000=>"thousand"

    1000000=>"million"

    1000000000=>"billion"

    1000000000000=>"trillion"

    1000000000000000=>"quadrillion"

    1000000000000000000=>"quintillion"

    1000000000000000000000=>"sextillion"

    1000000000000000000000000=>"septillion"

    1000000000000000000000000000=>"octillion"

    1000000000000000000000000000000=>"nonillion"

  );

  

  krsort$names);

  krsort$triplets);

  

  if (abs$number) > PHP_INT_MAX) 

    throw new Exception'Maximum integer size for this version of PHP is '.PHP_INT_MAX);

  

  $prefix = ''

  $str = ''

  if ($number<0) {

    $prefix = 'negative '

    $number = $number*-1;

  }

  

  $remainder = 0;

  

  if ($number>=100) {

    

    foreach ($triplets as $num=>$name) {

      if ($num<=$number) {

        $str = $name

        $remainder = $number % $num

        $number = floor$number$num);

        break

      }

    }

    

    // how many of the triplets?

    $str = number_string$number).' '$str

    

    if ($remainder<100) $separator = ' and '

    else $separator = ', '

    

  } else {

    

    foreach ($names as $num=>$name) {

      if ($num<=$number) {

        $str = $name

        $remainder = $number % $num

        break

      }

    }

    

    $separator = '-'

  }

  

  // remainder to tack on?

  if ($remainder>0) {

    $str = $str$separatornumber_string$remainder);

  }

  

  return $prefix$str

eXorithm – Execute Algorithm: View / Run Algorithm draw_bezier

function draw_bezier ($p0$p1$p2$p3$detail$show_bounds
{
  $x0$p0[0];$x1$p1[0];$x2$p2[0];$x3$p3[0];
  $y0$p0[1];$y1$p1[1];$y2$p2[1];$y3$p3[1];
  
  $cx=3*($x1$x0);
  $bx=3*($x2$x1)-$cx
  $ax$x3$x0$cx$bx
  
  $cy=3*($y1$y0);
  $by=3*($y2$y1)-$cy
  $ay$y3$y0$cy$by
  
  // generate the bezier points
  for$i=0; $i<=$detail$i++) {
    $t = $i$detail
    $x = $ax$t$t$t$bx$t$t$cx$t$x0
    $y = $ay$t$t$t$by$t$t$cy$t$y0
    $points$i] = array$x$y);
  }
  
  $width=400;
  $height=400;
  $imageimage_create_alpha$width$height);
  
  $cimagecolorallocate$image,0,0,0);
  $c2imagecolorallocate$image,200,200,200);
  
  // determine scale so curve shows within our image
  $minxmin$x0$x1$x2$x3);
  $maxxmax$x0$x1$x2$x3);
  $minymin$y0$y1$y2$y3);
  $maxymax$y0$y1$y2$y3);
  if ($maxx==$minx
    $scale = ($height-1)/($maxy$miny);
  else if ($maxy==$miny
    $scale = ($width-1)/($maxx$minx);
  else
    $scale = min(($width-1)/($maxx$minx), ($height-1)/($maxy$miny));
  
  if ($show_bounds) {
    imageline$image, ($x0$minx)*$scale, ($y0$miny)*$scale, ($x1$minx)*$scale, ($y1$miny)*$scale$c2);
    imageline$image, ($x1$minx)*$scale, ($y1$miny)*$scale, ($x2$minx)*$scale, ($y2$miny)*$scale$c2);
    imageline$image, ($x2$minx)*$scale, ($y2$miny)*$scale, ($x3$minx)*$scale, ($y3$miny)*$scale$c2);
  }
  
  // draw the bezier
  for ($i=1;$icount$points);$i++) {
    imageline$image, ($points$i-1][0]-$minx)*$scale, ($points$i-1][1]-$miny)*$scale, ($points$i][0]-$minx)*$scale, ($points$i][1]-$miny)*$scale$c);
  }
             
  return $image

eXorithm – Execute Algorithm: View / Run Algorithm locate_country

function locate_country ($country

{

  $data = file_get_contents"http://maps.google.com/maps/geo?output=csv&q="urlencode$country));

  $arr = explode","$data);

  if (count$arr)>=4) {

    if ($arr[0]==200) {

      return array'latitude'=>$arr[2], 'longitude'=>$arr[3]);

    } else {

      throw new Exception'Country could not be geocoded');

    }

  } else {

    throw new Exception'Country could not be geocoded');

  }

eXorithm – Execute Algorithm: View / Run Algorithm flip_image

function flip_image ($image$mode

{

  $width = imagesx$image);

  $height = imagesy$image);

  

  $src_x = 0;

  $src_y = 0;

  $src_width = $width

  $src_height = $height

  

  switch ( $mode ) {

      

    case 'vertical'//vertical

      $src_y      =   $height -1;

      $src_height =   -$height

      break

      

    case 'horizontal'//horizontal

      $src_x      =   $width -1;

      $src_width  =   -$width

      break

      

    case 'both'//both

      $src_x      =   $width -1;

      $src_y      =   $height -1;

      $src_width  =   -$width

      $src_height =   -$height

      break

      

    default

      return $image

  }

  

  $imgdest = imagecreatetruecolor$width$height);

  imagealphablending$imgdest, false);

  imagesavealpha$imgdest, true);

  

  if (imagecopyresampled$imgdest$image, 0, 0, $src_x$src_y , $width$height$src_width$src_height)) {

    return $imgdest

  }

  

  return $image

eXorithm – Execute Algorithm: View / Run Algorithm draw_upc_barcode

function draw_upc_barcode ($number$show_numbers
{
  $number = str_replacearray'-'' '), ''$number);
  
  if (strlen$number)!=12)
    throw new Exception"UPC number must have 12 digits");
  
  for ($i=0;$i<12;$i++) {
    if (!is_numeric$number$i]))
      throw new Exception"UPC number must contain only digits");
  }
  
  $lcodes = array
    '0001101'
    '0011001'
    '0010011'
    '0111101'
    '0100011'
    '0110001'
    '0101111'
    '0111011'
    '0110111'
    '0001011'
  );
  
  $rcodes = array
    '1110010'
    '1100110'
    '1101100'
    '1000010'
    '1011100'
    '1001110'
    '1010000'
    '1000100'
    '1001000'
    '1110100'
  );
  
  $code = '101'
  for ($i=0;$i<6;$i++) {
    $code .= $lcodes$number$i]];
  }
  $code .= '01010'
  for ($i=6;$i<12;$i++) {
    $code .= $rcodes$number$i]];
  }
  $code .= '101'
  
  // create image
  $width=190;
  $height=100;
  $image = image_create_alpha$width$height);
  
  $white = imagecolorallocate$image, 255, 255, 255);
  imagefilledrectangle$image, 0, 0, $width$height$white);
  
  // draw lines
  $black = imagecolorallocate$image, 0, 0, 0);
  for ($i=0;$istrlen$code);$i++) {
    if ($code$i]=='1') {
      imageline$image$i*2,0, $i*2, $height$black);
      imageline$image$i*2+1,0, $i*2+1, $height$black);
    }
  }
  
  // draw numbers
  if ($show_numbers) {
    imagefilledrectangle$image, 6, $height-16, 90, $height$white);
    imagefilledrectangle$image, 98, $height-16, 182, $height$white);
    for ($i=0;$i<6;$i++) {
      imagestring$image, 2, 11+$i*14, $height-14, $number$i], $black);
    }
    for ($i=6;$i<12;$i++) {
      imagestring$image, 2, 19+$i*14, $height-14, $number$i], $black);
    }
  }
  
  return $image

eXorithm – Execute Algorithm: View / Run Algorithm simple_calculator

function simple_calculator ($number1$operator$number2

{

  // calculator

  

  switch ($operator) {

    case "plus"

      $res = $number1$number2

      break

    case "minus"

      $res = $number1$number2

      break

    case "times"

      $res = $number1$number2

      break

    case "divided by"

      $res = $number1$number2

      break

    default

      $res = 0;

  }

  

  return $res

eXorithm – Execute Algorithm: View / Run Algorithm raise_polygon

function raise_polygon ($points$height$direction$color
{
  // check points
  if ((count$points)==0) || ((count$points)%2)!=0)) {
    throw new Exception'The points must be an array with an even number of integers.');
  }
  
  // determine the extent of the polygon
  $maxx = $points[0];
  $maxy = $points[1];
  $minx = $points[0];
  $miny = $points[1];
  for ($i=2; $icount$points); $i$i+2) {
    $x = $points$i];
    $y = $points$i+1];
    if ($x$maxx$maxx = $x
    if ($y$maxy$maxy = $y
    if ($x$minx$minx = $x
    if ($y$miny$miny = $y
  }
  
  // determine the extent of the projection
  $proj_length = roundsqrt$height$height/2));
  switch ($direction) {
    case 'nw'
      $projx = $proj_length*-1;
      $projy = $proj_length*-1;
      break
    case 'ne'
      $projx = $proj_length
      $projy = $proj_length*-1;
      break
    case 'sw'
      $projx = $proj_length*-1;
      $projy = $proj_length
      break
    default
      $projx = $proj_length
      $projy = $proj_length
  }
  
  // determine where the polygon should be positioned
  for ($i=0; $icount$points); $i$i+2) {
    $points$i] = $points$i]-$minx+1;
    $points$i+1] = $points$i+1]-$miny+1;
    if ($projx<0) $points$i] = $points$i] - $projx
    if ($projy<0) $points$i+1] = $points$i+1] - $projy
  }
  
  // blank image
  $image = image_create_alpha$maxx$minx$proj_length+2, $maxy$miny$proj_length+2);
  
  // create the colors
  $r  = hexdecsubstr$color, 0, 2));
  $g  = hexdecsubstr$color, 2, 2));
  $b  = hexdecsubstr$color, 4, 2));
  $color = imagecolorallocate$image$r$g$b);
  
  // draw the first polygon
  imagepolygon$image$pointscount$points)/2, $color);
  
  // draw the lines + modify the points
  for ($i=0; $icount$points); $i$i+2) {
    imageline$image$points$i], $points$i+1], $points$i]+$projx$points$i+1]+$projy$color);
    $points$i] = $points$i]+$projx
    $points$i+1] = $points$i+1]+$projy
  }
  
  // draw the second polygon
  imagepolygon$image$pointscount$points)/2, $color);
  
  return $image

eXorithm – Execute Algorithm: View / Run Algorithm show_address

function show_address ($address

{

  $data = file_get_contents"http://maps.googleapis.com/maps/api/geocode/json?address="urlencode$address)."&sensor=false");

  $obj = json_decode$data);

  if ($obj) {

    if (isset$obj->results[0]->geometry->location)) {

      $loc = $obj->results[0]->geometry->location;

      return array'latitude'=>$loc->lat, 'longitude'=>$loc->lng);

    } else {

      throw new Exception'Lookup failed and/or address does not exist!');

    }

  } else {

    throw new Exception'Lookup failed and/or address does not exist!');

  }