However, you may find a time to work with data at the binary level in PHP (and many other programming languages). Here’s a quick guide to understanding binary numbers and the common operators for handling them.

“Normal” Numbers – Base Ten, Decimal System

When you deal with numbers, you are probably using the “Base Ten” or “Decimal” number system. These are numbers made up of a set of ten different digits – zero through nine.

A given quantity – like 512 – is created with a series of digits. The position of the digit tells us how much the digit actually represents. The ’2′ here is in the units place, so it simply represents 2. The 1 is in the tens place, so it actually represents 10. The 5 is in the hundreds place, so it represents 500.

The number could be re-written as:

500 + 10 + 2 = 512

You’ll notice a pattern here. Each new place is worth ten times the previous place. The third digit (the hundreds place) is worth 10 * 10. If we added a fourth place, it would be worth 10 * 100 (1000).

This gives us a nifty little mathematical formula – which is why this is called “base ten” numbering. The nth digit (where zero is the right-most digit) is worth 10^n. Here’s the number 1024 re-written to illustrate this.

(1 * 10^3) + (0 * 10^2) + (2 * 10^1) + (4 * 10^0) = 1024

This is a lot of work to read a number that we intuitively know is worth 1,024. However, it helps to understand how binary numbers work.

Binary Numbers – The Base Two System

While base ten numbers are simple enough for humans to work with, computers are designed to use a binary or base two numbering system.

The simplest unit of information is a binary bit – a 0 or a 1.

To create complex numbers, we can string together 0′s and 1′s. For example, a number could be written as 0010 0101.

To understand what this value means, we can apply the same rules as we did above. However, since this is a base two system instead of a base ten system, each place is multiplied by 2^n.

Let’s start with a smaller example – 1111.

(1 * 2^3) + (1 * 2^2) + (1 * 2^1) + (1 * 2^0)
    = 8 + 4 + 2 + 1
    = 15

These rules can be expanded to represent byte-sized numbers (8-bits, or 2^8, or 255) or even larger numbers.

Manipulating Bits and Bytes – Bitwise Operators

Most programming languages come with some built in operators to handle bits. These help make very basic comparisons and manipulations of numbers.

These typically include the ‘and’ or intersection operator, the ‘or’ or union operator, and the ‘xor’ or exclusive-or operator. We’ll just take a look at the ‘and’ and ‘or’ operators right now. [Note: I use the terms intersection and union because I think they make it much easier to understand, if you are at all familiar with math sets and statistics. They aren’t typical ‘coding’ terms).

The ‘and’ or intersection operator – the ‘&’ character in PHP – compares two binary numbers and returns a new binary number with a ’1′ in every unit in which both numbers have a ’1′. If both numbers have a value in the second place, then the return number will have a value in the second place. If only one number has a value in the third place, then the return number will have no value in the third place.

0111 & 0101 = 0101
0101 & 1010 = 0000
1111 & 1111 = 1111

If you imagine ’0111′ and ’0101′ as sets of numbers ({4, 2, 1} and {4, 1} respectively), then the result of a bitwise ‘and’ operation is the simple intersection of the two sets.

The bitwise ‘or’ operator – a | in PHP – returns a value in each place that either number has a value. So if only one number has a value in the first place, the result will have a value in the first place. A place will only have no value if neither number had a value there.

0111 | 0101 = 0111
0101 1110 | 1010 0001 = 1111 1111
0000 1111 | 1111 0000 = 1111 1111

These operators aren’t used very much, but it is important to recognize them. If you don’t know what they are, it is easy to confuse them with the standard logical operators – || and &&.

For example, the following two lines of code have very different meanings.

$x = 124;
$y = 36;
$bitwise = $x & $y;
$logical = $x && $y;

In the first comparison ($x & $y), we’re finding the bitwise intersection of the two values. This would be…

0111 1100 & 0010 0100 = 0010 0100

In base ten terms, $bitwise would be equal to 36. In the second example ($x && $y), we’re looking for a simple boolean comparison. In this case, both $x and $y have a value, so the comparison will return ’1′ or ‘true’.

Is This Useful…? Comparing Constant Flags

You may be thinking to yourself, “When will I ever use this?”

While anyone working with computer code should understand how binary numbers work, there will probably be very few cases in which you manipulate numerical values in a binary format. The rest of the world works with decimal numbers – and your programming language is designed to do the same thing.

However, there are some cases where you will want to use bitwise numbers and comparisons. A perfect example is the use of constants and flags.

Let’s say that a function takes 16 parameters. Each of these parameters is a simple “True” or “False.”

You could write the function take sixteen different parameters and use sixteen different variables. However, this would make function calls quite long – especially if you usually only make two or three parameters true.

Instead, you can pass one value as a parameter. This value – 16 bits long – includes 16 individual flags to tell the function whether a specific parameter is true or false.

If every parameter is set to true, this value would be “1111 1111 1111 1111″. If only the first parameter should be set to true, this value would be “0000 0000 0000 0001″.

Each flag is represented by a specific place in this binary number. The first flag is “0001,” the second flag is “0010,” the third flag is “0100,” etc.

Your code wouldn’t be very readable if you referred to each flag by its numerical value. Instead, you can define constant values. For example, FUNCTION_FLAG_ONE would represent “0001,” “FUNCTION_FLAG_TWO would represent “0010,” etc. These constants would follow whatever naming convention you usually use.

The value of this is that you can easily set any number of flags with the use of the bitwise ‘or’ operator.

For example, let’s say you want to set flags one, seven, and fifteen to true.

$flags = FUNCTION_FLAG_ONE | 
    FUNCTION_FLAG_SEVEN | FUNCTION_FLAG_FIFTEEN;

The result would be ’0100 0000 0100 0001.’

Inside the function, you could then use the bitwise ‘and’ operator to see which flags were set. For example, this would let you check to see if the fifteenth flag was set to true.

$fifteen = $flags & FUNCTION_FLAG_FIFTEEN;

Although your function’s code will have to do some legwork to find out which flags were set and which ones were not, this makes the function call itself much more efficient and readable.

Like the file functions, each method is slightly different. Knowing how each operates will help you choose which function to use when you want to work with directories in your PHP script.

PHP 4 – opendir, readdir, closedir

The traditional method of working with directories is very similar to the traditional method of working with files. You open a directory and save it as a resource in a variable. Then, you read through it until the end. Finally, you close it to tidy things up.

$dirName = 'images';
 
$dir = opendir($dirName);
while ($filename = readdir($dir)) {
  echo $filename . '<br />';
}
 
closedir($dir);

That simple script will open a directory (‘images’), read every filename in the directory, and then clean up the directory resource.

The readdir() function goes through the files as they are stored in the filesystem. There’s no real logic to their order – they just come the way they are. Each time you use readdir(), the pointer in the $dir resource is moved to the next file.

PHP 5 – A Convenience Function, scandir

In PHP 5, a new convenience function was introduced to handle all of the major directory functions with one call. Similar to the way file_get_contents handles all of the file writing, scandir handles all of the directory listing.

With a single function, scandir opens a given directory, reads all of the files into an array, and closes the directory.

$dirname = 'images';
 
$filenames = scandir($dirname);
foreach ($filenames as $file) {
  echo $file . '<br />';
}

This slightly shorter snippet of code accomplishes the same thing as the original example. As an added bonus, the filenames are already stored in an array ($filenames). The filenames are also sorted alphabetically.

You could of course achieve the same end with the original directory functions – but you’d have to add more lines of code to store the data in an array and then sort it. One of the biggest reasons to use scandir() is that it’s a convenience.

There’s also one functional difference between the two. scandir() never actually accesses a file – so it’s “Last Accessed Time” will remain the same. When you use readdir() to cycle through a directory, each file is accessed – resetting the “Last Accessed Time.”

This often won’t matter, but it could play an important role in a script that works directly with a file’s “Last Accessed Time.”

The Versatile Choice – glob

The most versatile choice is glob(). Like scandir, it returns an array of filenames. However, glob allows you to specify a pattern to match – so only the matching filenames are returned.

The pattern follows all of the rules for wildcards when using a command like dir. For example, this will get all of the files in the ‘images’ directory.

$dirName = 'images';
 
$filenames = glob($dirName . '/*.*');
foreach ($filenames as $file) {
  echo $file . '<br />';
}

There is a very important difference between this and the other functions, though.

glob() returns paths, not filenames. In this case, the output will be something like ‘images/image.jpg,’ not just ‘image.jpg.’ The directory listing is based on the current working directory – so specifying a path (like we did) will cause that directory to be included in the returned path.

If you don’t want the full path shown, you can use some other functions to change the working directory – like using ‘cd’ in the command line. By default, the working directory is where the script is executing. In this case, we could change the working directory to ‘images’ to get filenames without the directory as part of the path.

chdir('images');

You can also use the GLOB_BRACE flag to pass multiple file extensions. For example, this would allow you to find all images with extension .jpeg, .png, or .gif.

chdir ('images');
 
$filenames = glob('*.{jpeg,png,gif}', GLOB_BRACE);
//  Notice there are NO spaces after the commas

glob() can be quite a powerful tool, indeed. If all you want is a list of files in a directory, you’ll probably want to stick to scandir() – so you don’t have to go messing with the working directory.

For anything else – like a selective list of files – you should make use of glob’s matching functionality rather than sorting through the filenames yourself.

A function would be much more useful to us if it was flexible – if it could generate a list of combinations for any size set of numbers. We can’t do this with the hard coded loop solution, so we need to come up with a better method.

The Function Concept

Logically, the best way to do this is to create a function that takes a set of numbers (one combination), the size of the set being chosen from (x in [xCy]), and the size of the set being chosen (y in [xCy]). The function would then use a sequential pattern to calculate the next possible combination and return it.

With this type of function, we could create a while loop that iterates through the whole set of possible combinations. We initialize it with the first possible combination, continue to execute while the function returns a combination, and finish when the function returns 0 – in which case there are no more combinations.

If we’re finding the possible combinations for (11 Choose 4), the main loop would look something like this.

$combo = array();
$total = 11;
$choose = 4;
 
while ( $combo = getNextCombo($combo, $total, $choose) ) {
  //  Process the combo here
  //  Store it in a file, an array, or something
  //  Or just out put it
  foreach ($combo as $number) {
    echo $number . ' ';
  }
  echo '<br />';
}

This initializes an empty array – $combo. Our function takes the array and populates it with the next possible combination.

If the array is empty, it’ll create the first combination – {1, 2, 3, 4}. Otherwise, it will increment that set by one to get the next possible combination set – {1, 2, 3, 5}. When the function receives a combination set it can’t possibly increment – {8, 9, 10, 11} – it returns false and the loop ends.

Ok… How Do We Build the Function?

Let’s start by creating the function, checking for an empty array, and returning the initial set. Then we can dive into how we go about incrementing one combination set to get the next one.

function getNextCombo($combo, $total, $choose) {
  if ( empty($combo) ) {
    //  Return the first set, i.e. {1, 2, 3, 4}
    for ($x = 1; $x <= $choose; $x++) {
      $combo[$x] = $x;
    }
 
    return $combo;    
  } else {
    //  Here we'll calculate the next combination
  }
 
  //  If we didn't return before, no combination was found
  return false;
}

That should be pretty self-explanatory. Now we can look at our pattern and develop a method of calculating the next possible combination.

The Pattern

In the last article on getting combinations, we identified the basic pattern to follow.

• Find the “deepest” number that can be incremented
• Increment it by one
• Set any “deeper” numbers to one plus the previous number

The “depeest” number would be the last digit. In the set {1, 2, 3, 4}, the fourth position would be considered deepest. Here’s the first step – and the most basic increment to do.

1 2 3 4
1 2 3 5

The fourth position, ’4′, is the deepest. It can be incremented. We increment it by one. There are no deeper numbers, so we’re done.

Let’s say the fourth position is maxed out. What happens?

1 2 3 11
1 2 4 5

We move back on position to the third position. This one, ’3′, is the deepest number that can be incremented. We increment it by one to 4. Then we go down the line and set each number after it to one more than the previous. In this case we only have to set the fourth digit to one more than the third, which is 5.

Let’s take a look at one more example.

1 2 10 11
1 3 4 5

Same thing here. We move back to the second digit to find one we can increment. We increment it. We then drag the others back to be one greater than it.

Writing This in Code

The following code should go in the else { } area of the function above.

The first thing we need to do is find the deepest number that can be incremented. The deepest digit can’t be incremented when it equals $total. The second deepest digit can’t be incremented when it equals ($total – 1). The next one at ($total – 2), then ($total – 3), etc.

This loop puts that pattern into practice.

$moveBack = 0;
  while ( ($combo[$choose - $moveBack] == $total - $moveBack) 
             && ($moveBack < $choose)) {
    $moveBack++;
  }

At the end, $moveBack will hold the number of spaces from the end of the deepest digit. If $moveBack == 0, then the deepest digit can be incremented. If $moveBack == 1, we have to move up one digit to increment. So on and so forth.

If $moveBack == $choose, we can stop counting. That means that no more digits can be incremented – we’ve counted all the way back to digit #0.

Incrementing to the Next Set

Now that we know which digit can be incremented, we can increment the whole set and return the array.

First, we should check if $moveBack == $choose (to see if we’re done). If it doesn’t, we start incrementing.

We start by incrementing $combo[$choose - $moveBack]. Then we loop through, decrementing $moveBack until it is 0 – and we update the deepest digit.

if ($moveBack != $choose) {
  //  Increment the deepest digit that can be incremented
  $combo[$choose - $moveBack]++;
 
  //  Loop through and set all other numbers based on this
  while ($moveBack > 0) {
    $moveBack--;
    $combo[$choose - $moveBack] = $combo[$choose - ($moveBack + 1)] + 1;			
  }
 
  //  $combo now holds the next combination
  return $combo;
} else {
  //  We couldn't increment.  The set passed
  //    to the function was the last possible set.
  return false;	
}

And… We’re Done

If you put all the pieces together correctly, you should now have a function that iterates through all of the possible combinations given a binomial coefficient.

If you were handling large sets (millions of possible combinations), you’d probably want to re-write this in a compiled language. However, the logic is simple and based simply on arrays – so it should be easily portable to any language.

A word of warning about storing the information. Don’t try to store all of the possible combinations in a giant array. It’ll choke up all your RAM and eventually kill the script. I forget how many combinations I tried to calculate that way, but PHP maxed out at 130mb of RAM and died.

Your best bet would be to write the combinations to a data file or a database as you go. This dumps the storage requirements into a more capable format.

So what do you do with this? I’m not really sure. I wrote the script for a guy who was working on a statistical program he was using for his doctoral thesis. I’m sure there are other specialized purposes for the script – statistics and probability.

If nothing else, it’s an interesting look at how to write a computer program to tackle a complex math problem.

Here’s the full source of the script, if you had trouble putting the pieces together.

function getNextCombo($combo, $total, $choose) {
  if ( empty($combo) ) {
    //  Return the first set, i.e. {1, 2, 3, 4}
    for ($x = 1; $x <= $choose; $x++) {
      $combo[$x] = $x;
    }
 
    return $combo;    
  } else {
    $moveBack = 0;
    while ( ($combo[$choose - $moveBack] == $total - $moveBack) 
             && ($moveBack < $choose)) {
      $moveBack++;
    }
  }
  if ($moveBack != $choose) {
    //  Increment the deepest digit that can be incremented
    $combo[$choose - $moveBack]++;
 
    //  Loop through and set all other numbers based on this
    while ($moveBack > 0) {
      $moveBack--;
      $combo[$choose - $moveBack] = $combo[$choose - ($moveBack + 1)] + 1;			
    }
    //  $combo now holds the next combination
    return $combo;
  } else {
    //  We couldn't increment.  The set passed
    //    to the function was the last possible set.
    return false;	
  }
  //  If we didn't return before, no combination was found
  return false;
}
 
$combo = array();
$total = 11;
$choose = 4;
 
while ( $combo = getNextCombo($combo, $total, $choose) ) {
  //  Process the combo here
  //  Store it in a file, an array, or something
  //  Or just out put it
  foreach ($combo as $number) {
    echo $number . ' ';
  }
  echo '<br />';
}