## Tag: "Code"

Three-dimensional computer graphics is an exciting aspect of computing because of the amazing visual effects that can be created for display. All of this is created from an enormous number of calculations that manipulate virtual models, which are constructed from some form of geometric definition. While the math involved for some aspects of computer graphics and animation can become quite complex, the fundamental mathematics that is required is very accessible. Beyond learning some new mathematic notation, a basic three-dimensional view can be constructed with algorithms that only require basic arithmetic and a little bit of trigonometry.

I demonstrate how to perform some basic operations with two key constructs for 3D graphics, without the rigorous mathematic introduction. Hopefully the level of detail that I use is enough for anyone that doesn't have a strong background in math, but would very much like to play with 3D APIs. I introduce the math that you *must* be familiar with in this entry, and in two future posts I demonstrate how to manipulate geometric models and apply the math towards the display of a 3D image.

## Linear Algebra

The type of math that forms the basis of 3D graphics is called linear algebra. In general, linear algebra is quite useful for solving systems of linear equations. Rather than go into the details of linear algebra, and all of its capabilities, we are going to simply focus on two related constructs that are used heavily within the topic, the *matrix* and the *vertex*.

### Matrix

The Matrix provides an efficient mechanism to translate, scale, rotate, and convert between different coordinate systems. This is used extensively to manipulate the geometric models for environment calculations and display.

These are all examples of valid matrices:

\( \left\lbrack \matrix{a & b & c \cr d & e & f} \right\rbrack, \left\lbrack \matrix{10 & -27 \cr 0 & 13 \cr 7 & 17} \right\rbrack, \left\lbrack \matrix{x^2 & 2x \cr 0 & e^x} \right\rbrack\)

Square matrices are particularly important, that is a matrix with the same number of columns and rows. There are some operations that can only be performed on a square matrix, which I will introduce shortly. The notation for matrices, in general, uses capital letters as the variable names. Matrix dimensions can be specified as a shorthand notation, and to also identify an indexed position within the matrix. As far as I am aware, row-major indexing is *always* used for consistency, that is, the first index represents the row, and the second represents the column.

\( A= [a_{ij}]= \left\lbrack \matrix{a_{11} & a_{12} & \ldots & a_{1n} \cr a_{21} & a_{22} & \ldots & a_{2n} \cr \vdots & \vdots & \ddots & \vdots \cr a_{m1} & a_{m2} & \ldots & a_{mn} } \right\rbrack \)

### Vector

The vector is a special case of a matrix, where there is only a single row *or* a single column; also a common practice is to use lowercase letters to represent vectors:

\( u= \left\lbrack \matrix{u_1 & u_2 & u_3} \right\rbrack \), \( v= \left\lbrack \matrix{v_1\cr v_2\cr v_3} \right\rbrack\)

## Operations

The mathematical shorthand notation for matrices is very elegant. It simplifies these equations that would be quite cumbersome, otherwise. There are only a few operations that we are concerned with to allow us to get started. Each operation has a basic algorithm to follow to perform a calculation, and the algorithm easily scales with the dimensions of a matrix.

Furthermore, the relationship between math and programming is not always clear. I have a number of colleagues that are excellent programmers and yet they do not consider their math skills very strong. I think that it could be helpful to many to see the conversion of the matrix operations that I just described from mathematical notation into code form. Once I demonstrate how to perform an operation with the mathematical notation and algorithmic steps, I will also show a basic C++ implementation of the concept to help you understand how these concepts map to actual code.

The operations that I implement below assume a Matrix class with the following interface:

C++

`class Matrix` | |

`{` | |

`public:` | |

` // Ctor and Dtor omitted ` | |

` ` | |

` // Calculate and return a reference to the specified element.` | |

` double& element(size_t row, size_t column);` | |

` ` | |

` // Resizes this Matrix to have the specified size.` | |

` void resize(size_t row, size_t column);` | |

` ` | |

` // Returns the number rows.` | |

` size_t rows();` | |

` ` | |

` // Returns the number of columns.` | |

` size_t columns();` | |

`private:` | |

` std::vector<double> data;` | |

`};` |

### Transpose

*Transpose* is a unary operation that is performed on a single matrix, and it is represented by adding a *superscript* T to target matrix.

For example, the transpose of a matrix A is represented with A^{T}.

The transpose "flips" the orientation of the matrix so that each row becomes a column, and each original column is transformed into a row. I think that a few examples will make this concept more clear.

\( A= \left\lbrack \matrix{a & b & c \cr d & e & f \cr g & h & i} \right\rbrack \)

\(A^T= \left\lbrack \matrix{a & d & g \cr b & e & h \cr c & f & i} \right\rbrack \)

The resulting matrix will contain the same set of values as the original matrix, only their position in the matrix changes.

\( B= \left\lbrack \matrix{1 & 25 & 75 & 100\cr 0 & 5 & -50 & -25\cr 0 & 0 & 10 & 22} \right\rbrack \)

\(B^T= \left\lbrack \matrix{1 & 0 & 0 \cr 25 & 5 & 0 \cr 75 & -50 & 10 \cr 100 & -25 & 22} \right\rbrack \)

It is very common to transpose a matrix, including vertices, before performing other operations. The reason will become clear for *matrix multiplication*.

\( u= \left\lbrack \matrix{u_1 & u_2 & u_3} \right\rbrack \)

\(u^T= \left\lbrack \matrix{u_1 \cr u_2 \cr u_3} \right\rbrack \)

### Matrix Addition

Addition can only be performed between two matrices that are the same size. By size, we mean that the number of rows and columns are the same for each matrix. Addition is performed by adding the values of the corresponding positions of both matrices. The sum of the values creates a new matrix that is the same size as the original two matrices provided to the add operation.

If

\( A= \left\lbrack \matrix{0 & -2 & 4 \cr -6 & 8 & 0 \cr 2 & -4 & 6} \right\rbrack, B= \left\lbrack \matrix{1 & 3 & 5 \cr 7 & 9 & 11 \cr 13 & 15 & 17} \right\rbrack \)

Then

\(A+B=\left\lbrack \matrix{1 & 1 & 9 \cr 1 & 17 & 11 \cr 15 & 11 & 23} \right\rbrack \)

The size of these matrices do not match in their current form.

\(U= \left\lbrack \matrix{4 & -8 & 5}\right\rbrack, V= \left\lbrack \matrix{-1 \\ 5 \\ 4}\right\rbrack \)

However, if we take the transpose of one of them, their sizes will match and they can then be added together. The size of the result matrix depends upon which matrix we perform the transpose operation on from the original expression.:

\(U^T+V= \left\lbrack \matrix{3 \\ -3 \\ 9} \right\rbrack \)

Or

\(U+V^T= \left\lbrack \matrix{3 & -3 & 9} \right\rbrack \)

Matrix addition has the same algebraic properties as with the addition of two scalar values:

#### Commutative Property:

#### Associative Property:

#### Identity Property:

#### Inverse Property:

The code required to implement *matrix addition* is relatively simple. Here is an example for the `Matrix`

class definition that I presented earlier:

C++

`void Matrix::operator+=(const Matrix& rhs)` | |

`{` | |

` if (rhs.data.size() == data.size())` | |

` {` | |

` // We can simply add each corresponding element` | |

` // in the matrix element data array.` | |

` for (size_t index = 0; index < data.size(); ++index)` | |

` {` | |

` data[index] += rhs.data[index];` | |

` }` | |

` }` | |

`}` | |

` ` | |

`Matrix operator+( const Matrix& lhs,` | |

` const Matrix& rhs)` | |

`{` | |

` Matrix result(lhs);` | |

` result += rhs;` | |

` ` | |

` return result;` | |

`}` |

### Scalar Multiplication

Scalar multiplication allows a single scalar value to be multiplied with every entry within a matrix. The result matrix is the same size as the matrix provided to the scalar multiplication expression:

If

\( A= \left\lbrack \matrix{3 & 6 & -9 \cr 12 & -15 & -18} \right\rbrack \)

Then

\( \frac{1}3 A= \left\lbrack \matrix{1 & 2 & -3 \cr 4 & -5 & -6} \right\rbrack, 0A= \left\lbrack \matrix{0 & 0 & 0 \cr 0 & 0 & 0} \right\rbrack, -A= \left\lbrack \matrix{-3 & -6 & 9 \cr -12 & 15 & 18} \right\rbrack, \)

Scalar multiplication with a matrix exhibits these properties, where *c* and *d* are scalar values:

#### Distributive Property:

#### Identity Property:

The implementation for scalar multiplication is even simpler than addition.

*Note: this implementation only allows the scalar value to appear before the Matrix object in multiplication expressions, which is how the operation is represented in math notation.*:

C++

`void Matrix::operator*=(const double lhs)` | |

`{` | |

` for (size_t index = 0; index < data.size(); ++index)` | |

` {` | |

` data[index] *= rhs;` | |

` }` | |

`}` | |

` ` | |

`Matrix operator*( const double scalar,` | |

` const Matrix& rhs)` | |

`{` | |

` Matrix result(rhs);` | |

` result *= scalar;` | |

` ` | |

` return result;` | |

`}` |

### Matrix Multiplication

Everything seems very simple with matrices, at least once you get used to the new structure. Then you are introduced to *matrix multiplication*. The algorithm for multiplication is not difficult, however, it is much more labor intensive compared to the other operations that I have introduced to you. There are also a few more restrictions on the parameters for multiplication to be valid. Finally, unlike the addition operator, the matrix multiplication operator does not have all of the same properties as the multiplication operator for scalar values; specifically, the order of parameters matters.

#### Input / Output

Let's first address what you need to be able to multiply matrices, and what type of matrix you can expect as output. Once we have addressed the structure, we will move on to the process.

Given an the following two matrices:

\( A= \left\lbrack \matrix{a_{11} & \ldots & a_{1n} \cr \vdots & \ddots & \vdots \cr a_{m1} & \ldots & a_{mn} } \right\rbrack, B= \left\lbrack \matrix{b_{11} & \ldots & b_{1v} \cr \vdots & \ddots & \vdots \cr b_{u1} & \ldots & b_{uv} } \right\rbrack \)

A valid product for \( AB=C \) is only possible if number of columns \( n \) in \( A \) is equal to the number of rows \( u \) in \( B \). The resulting matrix \( C \) will have the dimensions \( m \times v \).

\( AB=C= \left\lbrack \matrix{c_{11} & \ldots & c_{1v} \cr \vdots & \ddots & \vdots \cr c_{m1} & \ldots & c_{mv} } \right\rbrack, \)

Let's summarize this in a different way, hopefully this arrangement will make the concept more intuitive:

One last form of the rules for matrix multiplication:

- The number of columns, \(n\), in matrix \( A \) must be equal to the number of rows, \(u\), in matrix \( B \):

\( n = u \)

- The output matrix \( C \) will have the number of rows, \(m\), in \(A\), and the number of columns, \(v\), in \(B\):

\( m \times v \)

- \(m\) and \(v\) do not have to be equal. The only requirement is that they are both greater-than zero:

\( m \gt 0,\)

\(v \gt 0 \)

#### How to Multiply

To calculate a single entry in the output matrix, we must multiply the element from each column in the first matrix, with the element in the corresponding row in the second matrix, and add all of these products together. We use the same row in the first matrix, \(A\), for which we are calculating the row element in \(C\). Similarly, we use the column in the second matrix, \(B\) that corresponds with the calculating column element in \(C\).

More succinctly, we can say we are *multiplying rows into columns*.

For example:

\( A= \left\lbrack \matrix{a_{11} & a_{12} & a_{13} \cr a_{21} & a_{22} & a_{23}} \right\rbrack, B= \left\lbrack \matrix{b_{11} & b_{12} & b_{13} & b_{14} \cr b_{21} & b_{22} & b_{23} & b_{24} \cr b_{31} & b_{32} & b_{33} & b_{34} } \right\rbrack \)

The number of columns in \(A\) is \(3\) and the number of rows in \(B\) is \(3\), therefore, we can perform this operation. The size of the output matrix will be \(2 \times 4\).

This is the formula to calculate the element \(c_{11}\) in \(C\) and the marked rows used from \(A\) and the columns from \(B\):

\( \left\lbrack \matrix{\color{#B11D0A}{a_{11}} & \color{#B11D0A}{a_{12}} & \color{#B11D0A}{a_{13}} \cr a_{21} & a_{22} & a_{23}} \right\rbrack \times \left\lbrack \matrix{\color{#B11D0A}{b_{11}} & b_{12} & b_{13} & b_{14} \cr \color{#B11D0A}{b_{21}} & b_{22} & b_{23} & b_{24} \cr \color{#B11D0A}{b_{31}} & b_{32} & b_{33} & b_{34} } \right\rbrack = \left\lbrack \matrix{\color{#B11D0A}{c_{11}} & c_{12} & c_{13} & c_{14}\cr c_{21} & c_{22} & c_{23} & c_{24} } \right\rbrack \)

\( c_{11}= (a_{11}\times b_{11}) + (a_{12}\times b_{21}) + (a_{13}\times b_{31}) \)

To complete the multiplication, we need to calculate these other seven values \( c_{12}, c_{13}, c_{14}, c_{21}, c_{22}, c_{23}, c_{24}\). Here is another example for the element \(c_{23}\):

\( \left\lbrack \matrix{ a_{11} & a_{12} & a_{13} \cr \color{#B11D0A}{a_{21}} & \color{#B11D0A}{a_{22}} & \color{#B11D0A}{a_{23}} } \right\rbrack \times \left\lbrack \matrix{b_{11} & b_{12} & \color{#B11D0A}{b_{13}} & b_{14} \cr b_{21} & b_{22} & \color{#B11D0A}{b_{23}} & b_{24} \cr b_{31} & b_{32} & \color{#B11D0A}{b_{33}} & b_{34} } \right\rbrack = \left\lbrack \matrix{c_{11} & c_{12} & c_{13} & c_{14}\cr c_{21} & c_{22} & \color{#B11D0A}{c_{23}} & c_{24} } \right\rbrack \)

\( c_{23}= (a_{21}\times b_{13}) + (a_{22}\times b_{23}) + (a_{23}\times b_{33}) \)

Notice how the size of the output matrix changes. Based on this and the size of the input matrices you can end up with some interesting results:

\( \left\lbrack \matrix{a_{11} \cr a_{21} \cr a_{31} } \right\rbrack \times \left\lbrack \matrix{ b_{11} & b_{12} & b_{13} } \right\rbrack = \left\lbrack \matrix{c_{11} & c_{12} & c_{13} \cr c_{21} & c_{22} & c_{23} \cr c_{31} & c_{32} & c_{33} } \right\rbrack \)

\( \left\lbrack \matrix{ a_{11} & a_{12} & a_{13} } \right\rbrack \times \left\lbrack \matrix{b_{11} \cr b_{21} \cr b_{31} } \right\rbrack = \left\lbrack \matrix{c_{11} } \right\rbrack \)

Tip:

To help you keep track of which row to use from the first matrix and which column from the second matrix, create your result matrix of the proper size, then methodically calculate the value for each individual element.

The algebraic properties for the matrix multiplication operator do not match those of the scalar multiplication operator. These are the most notable:

#### Not Commutative:

The order of the factor matrices definitely matters.

I think it is very important to illustrate this fact. Here is a simple \(2 \times 2 \) multiplication performed two times with the order of the input matrices switched. I have highlighted the only two terms that the two resulting answers have in common:

\( \left\lbrack \matrix{a & b \cr c & d } \right\rbrack \times \left\lbrack \matrix{w & x\cr y & z } \right\rbrack = \left\lbrack \matrix{(\color{red}{aw}+by) & (ax+bz)\cr (cw+dy) & (cx+\color{red}{dz}) } \right\rbrack \)

\( \left\lbrack \matrix{w & x\cr y & z } \right\rbrack \times \left\lbrack \matrix{a & b \cr c & d } \right\rbrack = \left\lbrack \matrix{(\color{red}{aw}+cx) & (bw+dx)\cr (ay+cz) & (by+\color{red}{dz}) } \right\rbrack \)

#### Product of Zero:

#### Scalar Multiplication is Commutative:

#### Associative Property:

Multiplication is associative, however, take note that the relative order for all of the matrices remains the same.

#### Transpose of a Product:

The transpose of a product is equivalent to the product of transposed factors multiplied in reverse order

#### Code

We are going to use a two-step solution to create a general purpose matrix multiplication solution. The first step is to create a function that properly calculates a single element in the output matrix:

C++

`double Matrix::multiply_element(` | |

` const Matrix& rhs,` | |

` const Matrix& rhs,` | |

` const size_t i,` | |

` const size_t j` | |

`)` | |

`{` | |

` double product = 0;` | |

` ` | |

` // Multiply across the specified row, i, for the left matrix` | |

` // and the specified column, j, for the right matrix.` | |

` // Accumulate the total of the products ` | |

` // to return as the calculated result.` | |

` for (size_t col_index = 1; col_index <= lhs.columns(); ++col_index)` | |

` {` | |

` for (size_t row_index = 1; row_index <= rhs.rows(); ++row_index)` | |

` {` | |

` product += lhs.element(i, col_index) ` | |

` * rhs.element(row_index, j);` | |

` }` | |

` }` | |

` ` | |

` return product;` | |

`}` |

Now create the outer function that performs the multiplication to populate each field of the output matrix:

C++

`// Because we may end up creating a matrix with ` | |

`// an entirely new size, it does not make sense ` | |

`// to have a *= operator for this general-purpose solution.` | |

`Matrix& Matrix::operator*( const Matrix& lhs,` | |

` const Matrix& rhs)` | |

`{` | |

` if (lhs.columns() == rhs.rows())` | |

` {` | |

` // Resize the result matrix to the proper size.` | |

` this->resize(lhs.row(), rhs.columns());` | |

` ` | |

` // Calculate the value for each element` | |

` // in the result matrix.` | |

` for (size_t i = 1; i <= this->rows(); ++i)` | |

` {` | |

` for (size_t j = 1; j <= this->columns(); ++j)` | |

` {` | |

` element(i,j) = multiply_element(lhs, rhs, i, j);` | |

` }` | |

` }` | |

` }` | |

` ` | |

` return *this;` | |

`}` |

## Summary

3D computer graphics relies heavily on the concepts found in the branch of math called, *Linear Algebra*. I have introduced two basic constructs from Linear Algebra that we will need to move forward and perform the fundamental calculations for rendering a three-dimensional display. At this point I have only scratched the surface as to what is possible, and I have only demonstrated *how*. I will provide context and demonstrate the *what* and *why*, to a degree, on the path helping you begin to work with three-dimensional graphics libraries, even if math is not one of your strongest skills.

### References

Kreyszig, Erwin; "Chapter 7" from *Advanced Engineering Mathematics*, 7th ed., New York: John Wiley & Sons, 1993

I have started writing an entry that discusses the value of becoming familiar with the binary (base-2) and hexadecimal (base-16) number systems because they are generally more useful to a programmer than decimal (base-10). My daughter is currently in high-school and she is taking a programming course. One of the things that she is currently learning how to do is count in binary. So I decided to expand my explanation of conversion between number systems as a reference for her and all of those who would like a refresher. The entry following this one will describe how binary and hexadecimal will make you a more effective programmer.

## Place Value: *coefficient*·*radix*^{place}

To be able to convert numbers between different numerical bases, it is important to review the concept of place value. Each *place*, or column, in a number represents a value equal to number system *base* raised to the power of its place index starting at 0. The official name of the base-value is the *radix*. For example, consider the first three place values for a number system that has a radix of *b*.

b^{2}+b^{1}+b^{0}

^{2}+b

^{1}+b

^{0}

If we are dealing with decimal (base-10), the radix = 10 and we would have place values of:

10^{2} + 10^{1} + 10^{0}

^{2}+ 10

^{1}+ 10

^{0}

Now we have the 1's column, 10's column, and 100's column:

100 + 10 + 1

The number stored at each column in the number is called the *coefficient*. To construct the final number, we multiply the coefficient by its place-value and add the results at each place together. Here is the decimal number **237** broken down by place value:

2·b^{2} +3·b^{1} +7·b^{0}

^{2}+3·b

^{1}+7·b

^{0}

2·10^{2} + 3·10^{1} + 7·1^{0}

^{2}+ 3·10

^{1}+ 7·1

^{0}

200 + 30 + 7

237

Hopefully decimal form is so natural to you that **237** seems like a single number, rather than the sum of place values that are multiplied by their coefficient.

### The Binary Number System

There are 10 types of people, those that understand binary and those that don't

If you are wondering what the eight other types of people are, continue reading.

Binary is a *base-2* number system. This means that each column in a binary number represents a value of 2 raised to the power of its place index. A number system requires a number of symbols to represent each place value that is equal to its *Base* value, and zero is always the first symbol to include in this set. For instance, decimal (base ten) requires ten symbols: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}. Therefore, binary (base two) only requires two symbols: {0, 1}.

Adding the *radix* as a subscript after a number is a common notation to indicate the base-value of a number when there is a possibility for confusion. Unless the context specifically indicates a different number system, decimal form is assumed. For example, the value 2 in binary:

10_{2} = 2_{10}

_{2}= 2

_{10}

If we had used that notation in the joke at the beginning... well, it just wouldn't have been as funny.

Another place that you will see the subscript notation is when you study logarithms:

log_{a}x = log_{b}x / log_{b}a

_{a}x = log

_{b}x / log

_{b}a

I'll leave the details for logarithms for another time.

#### Counting in Binary

When learning *anything* new, it can be helpful to map something that you already know to the new topic. For a new number system, *counting* with both number systems can be a helpful exercise. Counting in all number systems uses the same process:

- Start with zero in the least significant column
- Count up until you have used all of the symbols in increasing order in the least significant, 1's, column
- When the limit is reached, increment the value in the next column, and reset the current column to zero.
- If the next column has used all of the symbols, increment the column after that and reset the current column.
- Once no further columns reach their limit, return to step 2 to continue counting.

Starting with decimal, if we count up from zero to 9, we get:

0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 ...*roll over*

*roll over*

We are now at step 3, we have reached the limit, so we increment the next column from an implied 0 to 1, and reset the current column for the result of:

10

Continuing to count, we increment the 1's column and *rolling over* the successive columns as necessary:

11 - 12 - 13 ... 98 - 99 ... *roll over*

*roll over*

100

Here is 0-15 in binary. When working with computers, and binary in general, you will typically see zeroes explicitly written for the more significant columns. We require 4 binary digits to represent 15.

Binary | Sum of Columns | Decimal | ||

0000 | 0 + 0 + 0 + 0 | 0 | ||

0001 | 0 + 0 + 0 + 1 | 1 | ||

0010 | 0 + 0 + 2 + 0 | 2 | ||

0011 | 0 + 0 + 2 + 1 | 3 | ||

0100 | 0 + 4 + 0 + 0 | 4 | ||

0101 | 0 + 4 + 0 + 1 | 5 | ||

0110 | 0 + 4 + 2 + 0 | 6 | ||

0111 | 0 + 4 + 2 + 1 | 7 | ||

1000 | 8 + 0 + 0 + 0 | 8 | ||

1001 | 8 + 0 + 0 + 1 | 9 | ||

1010 | 8 + 0 + 2 + 0 | 10 | ||

1011 | 8 + 0 + 2 + 1 | 11 | ||

1100 | 8 + 4 + 0 + 0 | 12 | ||

1101 | 8 + 4 + 0 + 1 | 13 | ||

1110 | 8 + 4 + 2 + 0 | 14 | ||

1111 | 8 + 4 + 2 + 1 | 15 |

### The Hexadecimal Number System

Hexadecimal is a *base-16* number system. Therefore, we will need sixteen symbols to represent the place values. We can start with the ten numbers used in decimal, and we use letters of the alphabet to represent the remaining six symbols. Although letter-case can matter in programming, the letters used in hexadecimal are case-insensitive. Here is a mapping of the hexadecimal values to decimal:

Decimal: |
{ | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | } |

Hexadecimal: |
{ | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F | } |

## Number Base Conversion

Let's discuss how to convert between number systems with different base values. Specifically, we will describe how to convert from "Decimal to Base_{x}" and "Base_{x} to Decimal".

### Decimal to Base_{x}

Here is the algorithm to convert a number in decimal to a different base:

- Divide the decimal number by the radix of the target base
- The remainder from step 1 becomes the value for the current column.
- Use the quotient (answer) from step 1 as the decimal value to calculate the next column.
- Return to step 1 and repeat until the quotient is zero.

Let's return to the number **237** and convert it to a binary number:

decimal: | `237` | |||||

radix: | `2` | |||||

Decimal | Radix | Quotient | Remainder | |||

237 | / | 2 | 118 | `1` (2^{0}) | ||

118 | / | 2 | 59 | `0` (2^{1}) | ||

59 | / | 2 | 29 | `1` (2^{2}) | ||

29 | / | 2 | 14 | `1` (2^{3}) | ||

14 | / | 2 | 7 | `0` (2^{4}) | ||

7 | / | 2 | 3 | `1` (2^{5}) | ||

3 | / | 2 | 1 | `1` (2^{6}) | ||

1 | / | 2 | 0 | `1` (2^{7}) | ||

binary: | `11101101` |

Here is **237** converted to a hexadecimal number:

decimal: | `237` | |||||

radix: | `16` | |||||

Decimal | Radix | Quotient | Remainder | |||

237 | / | 16 | 118 | `D` (16^{0}) | ||

118 | / | 16 | 59 | `E` (16^{1}) | ||

hexadecimal: | `ED` |

A common notation to represent hexadecimal when dealing with computers and in programming languages themselves, is to prepend an 'x' in front of the number like so: `xED`

.

Here is one more decimal-to-hexadecimal example:

decimal: | `3,134,243,038` | |||||

radix: | `16` | |||||

Decimal | Radix | Quotient | Remainder | |||

3,134,243,038 | / | 16 | 195,890,189 | `E (14)` (16^{0}) | ||

195,890,189 | / | 16 | 12,243,136 | `D (13)` (16^{1}) | ||

12,243,136 | / | 16 | 765,196 | `0 ( 0)` (16^{2}) | ||

765,196 | / | 16 | 47,824 | `C (12)` (16^{3}) | ||

47,824 | / | 16 | 2,989 | `0 ( 0)` (16^{4}) | ||

2,989 | / | 16 | 186 | `D (13)` (16^{5}) | ||

186 | / | 16 | 11 | `A (10)` (16^{6}) | ||

11 | / | 16 | 0 | `B (11)` (16^{7}) | ||

hexadecimal: | `xBAD0C0DE` |

### Base_{x} to Decimal

Actually, I have already demonstrated how to convert a number from a base different than ten, into decimal. Once again, here is the complete formula, where c_{x} represents the coefficients at each place-column.

c_{n}·b^{n} + ... + c_{2}·b^{2} + c_{1}·b^{1} + c_{0}·b^{0}

_{n}·b

^{n}+ ... + c

_{2}·b

^{2}+ c

_{1}·b

^{1}+ c

_{0}·b

^{0}

As an example, let's convert the binary answer back into decimal:

1·2^{7} + 1·2^{6} + 1·2^{5} + 0·2^{4} + 1·2^{3} + 1·2^{2} + 0·2^{1} + 1·2^{0}

^{7}+ 1·2

^{6}+ 1·2

^{5}+ 0·2

^{4}+ 1·2

^{3}+ 1·2

^{2}+ 0·2

^{1}+ 1·2

^{0}

1·128 + 1·64 + 1·32 + 0·16 + 1·8 + 1·4 + 0·2 + 1·1

128 + 64 + 32 + 8 + 4 + 1

237

### Base_{x} to Base_{y}

Is it possible to convert a number from Base_{x} directly to Base_{y} without converting to decimal (base-10) first?

Yes, however, you will need to perform all of your math operations in either Base_{x} or Base_{y}. The algorithms that I have presented are performed with base-10 since that is the number system most people are familiar with.

## Demonstration

Here is a short demonstration program to convert a decimal number into a value of any numeral base between 2-36.

Why between those two ranges?

Try to imagine how a base-1 number system would work with only the symbol {0} to work with. Alternatively, we can combine the numerical set: {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} with the alphabetic set: {A, B, C ... X, Y, Z} to create a set of 36 symbols.

C++

`// The set of possible symbols for representing other bases.` | |

`const char symbols[] = {'0', '1', '2', '3', '4', '5', ` | |

` '6', '7', '8', '9', 'A', 'B', ` | |

` 'C', 'D', 'E', 'F', 'G', 'H', ` | |

` 'I', 'J', 'K', 'L', 'M', 'N', ` | |

` 'O', 'P', 'Q', 'R', 'S', 'T', ` | |

` 'U', 'V', 'W', 'X', 'Y', 'Z'};` |

Here is the base-conversion algorithm from above written in C++.

C++

`void ConvertToBase( const unsigned long decimal,` | |

` const unsigned long radix)` | |

`{` | |

` unsigned long remainder[32] = {0};` | |

` unsigned long quotient = decimal;` | |

` unsigned char place = 0;` | |

` ` | |

` while (0 != quotient)` | |

` {` | |

` unsigned long value = quotient;` | |

` remainder[place] = value % radix;` | |

` quotient = (value - remainder[place]) / radix;` | |

` ` | |

` place++;` | |

` }` | |

` ` | |

` cout << decimal << " in base " << radix << " is ";` | |

` ` | |

` for (unsigned char index = 1; index <= place; index++)` | |

` {` | |

` cout << symbols[remainder[place - index]];` | |

` }` | |

`}` |

The values are from the examples above. You can modify the values that are used with the function calls to `ConvertToBase`

in the program below:

C++

`int main(int argc, char* argv[])` | |

`{` | |

` ConvertToBase(237, 2);` | |

` ConvertToBase(237, 10);` | |

` ConvertToBase(237, 16);` | |

` ConvertToBase(3134243038, 16);` | |

` ConvertToBase(3134243038, 36);` | |

` ` | |

` return 0;` | |

`}` |

#### Output:

237 in base 2 is 11101101 237 in base 10 is 237 237 in base 16 is ED 3134243038 in base 16 is BAD0C0DE 3134243038 in base 36 is 1FU1PEM

## Summary

Ever since you learned to count in decimal you have been using exponents with a base-10; it's just that no one ever made a big deal of this fact. To use a different numeral system, such as binary (base-2) or hexadecimal (base-16), you simply need to determine a set of symbols to represent the values and you can use the same counting rules that you use in base-10, except that you have a different number of symbols. Converting between any number system is possible, however, it is simplest to convert to decimal first if you want to continue to use base-10 arithmetic operations.

Rvalue references were introduced with C++11, and they are used to implement *move semantics* and *perfect-forwarding*. Both of these techniques are ways to eliminate copies of data parameters for efficiency. There is much confusion around this new feature that uses the `&&`

operator, because its meaning is often based on the context it is used. It is important to understand the subtleties around rvalue references in order for them to be effective. This entry will teach you how to use the rvalue reference with plenty of live-demonstrations.

I was amazed after I had converted only the first few portions of the `TypeList`

from the C++98 implementation to Modern C++. I have decided to convert my Alchemy API to use Modern C++ in order to truly learn the nuances by application of acquired knowledge. The code of these meta-programs are very elegant and completely readable. This really does feel like a new language, and an entirely new version of meta-programming.

The elegance enabled by the new constructs will allow me to present a complete `TypeList`

implementation for Modern C++ in this entry.

The keyword `auto`

has been given a new behavior since the C++11 Standard was ratified. Instantly I could appreciate the value of its new function when I considered things like declaring an iterator for a container. However, I was skeptical of any value that `auto`

could provide for general purpose use.

Now that I have had a chance to study this new keyword I believe that it is quite a valuable addition to Modern C++. While there are situations that could still cause some grief, they are not difficult to detect, and the solutions to the problem are straight-forward to apply

*A continuation of a series of blog entries that documents the design and implementation process of a library. The library is called, Network Alchemy[^]. Alchemy performs low-level data serialization with compile-time reflection. It is written in C++ using template meta-programming.*

The alterations required up to this point have been relatively minor to integrate `array`

s and `vector`

s into Alchemy. That does not mean that the solutions were clean and simple from the beginning. The exercise for integrating the serialization support of these containers was quite challenging. These containers became especially challenging because of the possibilities they created for flexibility with data management

*A continuation of a series of blog entries that documents the design and implementation process of a library. The library is called, Network Alchemy[^]. Alchemy performs low-level data serialization with compile-time reflection. It is written in C++ using template meta-programming.*

It's time to break some barriers that have existed within Alchemy since its inception, message with fixed sizes. While the storage policy concept that I use with the message buffer allows Alchemy to dynamically allocate memory for messages, the current structure of the library only allows messages whose size is known at compile-time.

There is already so much value in what Alchemy is capable of accomplishing, even with the static size limitation. However, the only way for Alchemy to expand and reach its potential, is to remove this limitation and provide support for dynamically sized messages. This entry will demonstrate the changes that were required to achieve this goal.

*A continuation of a series of blog entries that documents the design and implementation process of a library. The library is called, Network Alchemy[^]. Alchemy performs low-level data serialization with compile-time reflection. It is written in C++ using template meta-programming.*

Once Alchemy was functional and supported a fundamental set of types, I had other development teams in my department approach me about using Alchemy on their product. Unfortunately, there was one type I had not given *any* consideration to up to this point, arrays. This group needed the ability to have variable sized messages, where the array payload started at the last byte of the fixed-format message. At that point, I had no clean solution to help deal with that problem.

I have previously written about code rot (code decay). This post is about decay in a different context. Essentially there are three sets of types in C++ that will decay, lose information. This entry will describe the concept, the circumstances, and in some cases ways to avoid type decay from occurring. This is an important topic for me to cover because the addition of support for arrays in Alchemy would have been much more difficult without knowledge of this concept.

A few weeks ago I wrote an entry on SFINAE[^], and I mentioned `enable_if`

. At that point I had never been able to successfully apply `enable_if`

. I knew this construct was possible because of SFINAE, however, I was letting the differences between *SFINAE* and *template specialization* confuse me. I now have a better understanding and wanted to share my findings.

## Recent Comments