{"id":3647,"date":"2019-06-29T00:01:42","date_gmt":"2019-06-29T07:01:42","guid":{"rendered":"https:\/\/c-for-dummies.com\/blog\/?p=3647"},"modified":"2019-06-22T11:20:48","modified_gmt":"2019-06-22T18:20:48","slug":"exponentiation","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=3647","title":{"rendered":"Exponentiation"},"content":{"rendered":"

The C language lacks an exponentiation operator, which would raise a base value to a certain power. For example: 2^8<\/code>, which in some programming languages is an expression to raise 2 to the 8th power. Instead, C uses the pow()<\/em> function.
\n
\nBefore powering forward, I’ll dispense with some jargon. Happily refer to Figure 1.<\/p>\n

\"\"

Figure 1. Mathematical stuff, beautifully illustrated.<\/p><\/div>\n

In the expression 2^8<\/code>, 2 is the base and 8 is the exponent. Using the format presented in Figure 1, this expression is written as 28<\/sup>. This format is common in written mathematics, but in C, it’s written as pow(2,8)<\/code>.<\/p>\n

Being a math noob as I am, I figured that the exponent argument must always be a positive integer value. Yes: I know! Math nerds, contain yourselves! The exponent argument in the pow()<\/em> function is a double<\/em>, so it can be any real value, not just positive integers.<\/p>\n

So I got thinking. What about fractional values? What about raising the power of 2 to the 1<\/sup>\/10<\/sub>th<\/sup> power? To wit:<\/p>\n

\r\n#include <stdio.h>\r\n#include <math.h>\r\n\r\nint main()\r\n{\r\n    int e;\r\n    double exponent;\r\n\r\n    exponent = 1.0;\r\n    for( e=0; e<21; e++ )\r\n    {\r\n        printf(\"2 to the %.4f power is %f\\n\",\r\n                exponent,\r\n                pow( 2, exponent)\r\n              );\r\n        exponent -= 0.05;\r\n    }\r\n\r\n    return(0);\r\n}<\/pre>\n
(Some compilers may require the math library to be linked in to create the program.)<\/p>\n
The for<\/em> loop decreases the exponent<\/code> value by .05 each turn, raising the power of 2 to fractional values. Here’s the output:<\/p>\n
2 to the 1.0000 power is 2.000000
\n2 to the 0.9500 power is 1.931873
\n2 to the 0.9000 power is 1.866066
\n2 to the 0.8500 power is 1.802501
\n2 to the 0.8000 power is 1.741101
\n2 to the 0.7500 power is 1.681793
\n2 to the 0.7000 power is 1.624505
\n2 to the 0.6500 power is 1.569168
\n2 to the 0.6000 power is 1.515717
\n2 to the 0.5500 power is 1.464086
\n2 to the 0.5000 power is 1.414214
\n2 to the 0.4500 power is 1.366040
\n2 to the 0.4000 power is 1.319508
\n2 to the 0.3500 power is 1.274561
\n2 to the 0.3000 power is 1.231144
\n2 to the 0.2500 power is 1.189207
\n2 to the 0.2000 power is 1.148698
\n2 to the 0.1500 power is 1.109569
\n2 to the 0.1000 power is 1.071773
\n2 to the 0.0500 power is 1.035265
\n2 to the -0.0000 power is 1.000000<\/code><\/p>\n
In the middle, you see 2 raised to the 0.5000 power, which is 21<\/sup>\/2<\/sub><\/sup> power, or the square root of two, 1.414214. If you’re clever, I suppose you could use the pow()<\/em> function with the fraction 0.5 and dispense with the companion sqrt()<\/em> function.<\/p>\n
Just as you can stuff a fraction into the exponent argument in the pow()<\/em> function, you can also dabble with negative numbers. Scary stuff.<\/p>\n
\r\n#include <stdio.h>\r\n#include <math.h>\r\n\r\nint main()\r\n{\r\n    int e;\r\n    double exponent;\r\n\r\n    exponent = -1.0;\r\n    for( e=0; e<20; e++ )\r\n    {\r\n        printf(\"2 to the %.4f power is %f\\n\",\r\n                exponent,\r\n                pow( 2, exponent)\r\n              );\r\n        exponent -= 0.2;\r\n    }\r\n\r\n    return(0);\r\n}<\/pre>\n
I have no idea what’s going on here, but the output is interesting:<\/p>\n
2 to the -1.0000 power is 0.500000
\n2 to the -1.2000 power is 0.435275
\n2 to the -1.4000 power is 0.378929
\n2 to the -1.6000 power is 0.329877
\n2 to the -1.8000 power is 0.287175
\n2 to the -2.0000 power is 0.250000
\n2 to the -2.2000 power is 0.217638
\n2 to the -2.4000 power is 0.189465
\n2 to the -2.6000 power is 0.164938
\n2 to the -2.8000 power is 0.143587
\n2 to the -3.0000 power is 0.125000
\n2 to the -3.2000 power is 0.108819
\n2 to the -3.4000 power is 0.094732
\n2 to the -3.6000 power is 0.082469
\n2 to the -3.8000 power is 0.071794
\n2 to the -4.0000 power is 0.062500
\n2 to the -4.2000 power is 0.054409
\n2 to the -4.4000 power is 0.047366
\n2 to the -4.6000 power is 0.041235
\n2 to the -4.8000 power is 0.035897<\/code><\/p>\n
I see that 2-1<\/sup> is 0.5000, or 1<\/sup>\/2<\/sub>. And 2-2<\/sup> is 0.2500 or 1<\/sup>\/4<\/sub>; 2-3<\/sup> is 0.1250 or 1<\/sup>\/8<\/sub>; and 2-4<\/sup> is 0.0625 or 1<\/sup>\/16<\/sub>. Fascinating.<\/p>\n
Somewhere on YouTube I’m sure I could watch a video that would explain how the math works, drop the term “logarithm” a few times and have me nodding me head in vague agreement. But then after watching this video, I’d probably watch the Vienna Philharmonic play the Imperial March<\/em> and forget all about the math. I prefer things that way.<\/p>\n","protected":false},"excerpt":{"rendered":"
I’m no math genius, which probably explains my newfound fascinations with the pow()<\/em> function. Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-3647","post","type-post","status-publish","format-standard","hentry","category-main"],"_links":{"self":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/3647","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=3647"}],"version-history":[{"count":7,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/3647\/revisions"}],"predecessor-version":[{"id":3661,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/3647\/revisions\/3661"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=3647"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=3647"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=3647"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}