Long, long ago, I was an ardent assembly language programmer. I admired coding in assembly because the programs were small and fast. On the early microcomputers, that was a plus.
\n
\nThe problem with assembly is that it takes a heinously long time to produce a workable program. That’s because you pretty much have to code everything yourself, including math functions.<\/p>\n
For example, when I coded in Z80 and then 8086, a multiplication operator didn’t exist. When you wanted to multiply two numbers, you had to concoct a method on your own, either by adding values or by using a bit-shift operation, which doubled values. That’s the inspiration behind this week’s code:<\/p>\n
\r\n#include <stdio.h>\r\n\r\nint main()\r\n{\r\n int value,two,eight,ten;\r\n\r\n printf(\"Enter an integer value: \");\r\n scanf(\"%d\",&value);\r\n\r\n two = value << 1;\r\n eight = value << 3;\r\n ten = two + eight;\r\n\r\n printf(\"Ten times %d is %d.\\n\",value,ten);\r\n\r\n return(0);\r\n}<\/pre>\nBefore explaining the code, copy and paste it into your editor. Build and run to ensure that it works. Here’s some sample output:<\/p>\n
Enter an integer value: 14
\nTen times 14 is 140.<\/code><\/p>\nIt would have been really easy to include the line value*=10<\/code> in the code, which would have multiplied the original input by ten. But that doesn’t explain how us ancient Assembly coders did things.<\/p>\nThe key to the program’s success at multiplication is the <<<\/code> operator, which appears at Lines 10 and 11. That’s the bit-wise shift operator. Its effect on integer values is to multiply by a power of two. That’s what happens when the bits in an integer are shifted to the left. (Shifting to the right with >><\/code> divides an integer by a power of two.)<\/p>\nSo the operation at Line 10 shifts the bits in value<\/code> one position to the left. The value is effectively doubled and the result sotred in the two<\/code> variable.<\/p>\nThe operation at Line 11 shifts the bits in value<\/code> three positions to the left, which is the same as multiplying value<\/code> by 23<\/sup>, or 8. Coincidentally, that value is stored in the eight<\/code> variable.<\/p>\nLine 12 performs the “multiplication” by adding the value from variable two<\/code> plus the value of variable eight<\/code>. The end result, two + eight<\/code>, equals ten times the original value. That’s the way I did things in Assembly language back in the day.<\/p>\nThese operations work for values up to almost the full size of a signed int<\/code>, which is 2,147,483,647 on most systems. So if you specified the value 3000000000 in the program, the result gets hinkey. (You’d have to type the value<\/code> variable as a long<\/code> or long long<\/code> to handle such huge values.)<\/p>\nOh, and this code does not compile properly under C++. That’s because in C++ the <<<\/code> operator is used for stream input.<\/p>\n","protected":false},"excerpt":{"rendered":"It’s possible to mathematically manipulate integers by using the bit-shift operators in C. It’s not a necessary trick, but it’s something old time programmers would appreciate. Continue reading