Let’s suppose you want to calculate cos(200) using the power series for cosine. The\u00a0n<\/em>th term of that series is<\/p>\n (\u22121)n<\/em><\/sup> x<\/em>2n<\/em><\/sup> \/ (2n<\/em>)!<\/p>\n This is an alternating series, and so the error in truncating the series after n<\/em> terms is bounded by the size of the n<\/em>+1 term, if<\/em> you’ve gone far enough out in the series that the terms are monotonically decreasing in absolute value.<\/p>\n To calculate cos(200) to machine precision, i.e. with an error of less than 2\u221252<\/sup>, we’d need to sum the series up to n<\/em> where<\/p>\n | 2002n<\/em>+2<\/sup> \/ (2n<\/em> + 2)! | < 2\u221252<\/sup><\/p>\n Actually, that will insure that the absolute<\/em> error is small enough, but not that the relative<\/em> error is small enough; if the value of cos(200) is small, we’d need more terms. Let’s ignore that and assume we’re only concerned with absolute error.<\/p>\n Turns out we’d need 287 terms. That’s a lot of terms. But you might say “That’s fine. I’m not in a hurry, and it’s just more work for the computer, not for me.” OK, so let’s try.<\/p>\n This prints -3.6840358571084123e+67. You may suspect the answer is incorrect since values of cosine are on the order of 1, not on the order of 1067<\/sup>. Something went spectacularly bad. On closer inspection, it’s remarkable the code didn’t crash.<\/p>\n If you changed When we don’t overflow, we have a different problem: catastrophic cancellation. You can’t calculate a number between \u22121 and 1 as an alternating sum of numbers as large as 1080<\/sup>. You’d need more than 80 + 16 = 96 decimal places of precision to compute the sum accurately, and floating point only gives you between 15 and 16 decimal places of precision.<\/p>\n So how would<\/em> you calculate cos(200)? The first step would be to use some sort of range reduction on 200. You could reduce 200 mod 2\u03c0 to get a smaller number to work with.<\/p>\n Using a power series to compute the cosine of 5.221255477432827 is feasible, but not optimal. There’s also another problem: the naive range reduction above loses some precision.<\/p>\n The error is small, but it’s still an order of magnitude larger than machine precision. You can’t simply reduce n<\/em> mod 2\u03c0 with ordinary float division because the integer part of n<\/em> \/ 2\u03c0 pushes some digits of precision off the right end. I intend to write about how range reduction works in future posts.<\/p>\n","protected":false},"excerpt":{"rendered":" Calculus professors with no experience in numerical computing will tell students that computers calculate trig functions with power series. They don’t. I worked on the implementation of trig functions in hardware, and I can assure you we didn’t just use power series. Power series are an excellent way calculate functions near the center of the […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[5,9],"tags":[],"class_list":["post-247572","post","type-post","status-publish","format-standard","hentry","category-computing","category-math"],"acf":[],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\n","aioseo_head_json":{"title":"How not to calculate cosine","description":"Calculus professors with no experience in numerical computing will tell students that computers calculate trig functions with power series. They don't.","canonical_url":"https:\/\/www.johndcook.com\/blog\/2026\/08\/07\/how-not-to-calculate-cos\/","robots":"max-image-preview:large","keywords":"","webmasterTools":{"miscellaneous":""},"schema":null,"og:locale":"en_US","og:site_name":"John D. Cook | Applied Mathematics Consulting","og:type":"article","og:title":"How not to calculate cosine","og:description":"Calculus professors with no experience in numerical computing will tell students that computers calculate trig functions with power series. They don't.","og:url":"https:\/\/www.johndcook.com\/blog\/2026\/08\/07\/how-not-to-calculate-cos\/","article:published_time":"2026-08-07T15:11:10+00:00","article:modified_time":"2026-08-07T15:11:25+00:00","twitter:card":"summary","twitter:title":"How not to calculate cosine","twitter:description":"Calculus professors with no experience in numerical computing will tell students that computers calculate trig functions with power series. They don't.","twitter:image":"https:\/\/www.johndcook.com\/blog\/wp-content\/uploads\/2022\/05\/twittercard.png"},"aioseo_meta_data":{"post_id":"247572","title":null,"description":"Calculus professors with no experience in numerical computing will tell students that computers calculate trig functions with power series. They don't.","keywords":null,"keyphrases":{"focus":{"keyphrase":"","score":0,"analysis":{"keyphraseInTitle":{"score":0,"maxScore":9,"error":1}}},"additional":[]},"primary_term":null,"canonical_url":null,"og_title":null,"og_description":null,"og_object_type":"default","og_image_type":"default","og_image_url":null,"og_image_width":null,"og_image_height":null,"og_image_custom_url":null,"og_image_custom_fields":null,"og_video":"","og_custom_url":null,"og_article_section":null,"og_article_tags":null,"twitter_use_og":false,"twitter_card":"default","twitter_image_type":"default","twitter_image_url":null,"twitter_image_custom_url":null,"twitter_image_custom_fields":null,"twitter_title":null,"twitter_description":null,"schema":{"blockGraphs":[],"customGraphs":[],"default":{"data":{"Article":[],"Course":[],"Dataset":[],"FAQPage":[],"Movie":[],"Person":[],"Product":[],"ProductReview":[],"Car":[],"Recipe":[],"Service":[],"SoftwareApplication":[],"WebPage":[]},"graphName":"Article","isEnabled":true},"graphs":[]},"schema_type":"default","schema_type_options":null,"pillar_content":false,"robots_default":true,"robots_noindex":false,"robots_noarchive":false,"robots_nosnippet":false,"robots_nofollow":false,"robots_noimageindex":false,"robots_noodp":false,"robots_notranslate":false,"robots_max_snippet":"-1","robots_max_videopreview":"-1","robots_max_imagepreview":"large","priority":null,"frequency":"default","location":null,"local_seo":null,"breadcrumb_settings":null,"limit_modified_date":false,"created":"2026-08-07 14:02:31","updated":"2026-08-07 15:11:25","ai":{"faqs":[],"keyPoints":[],"schemas":[],"titles":[],"descriptions":[],"socialPosts":{"email":{"subject":"","preview":"","content":""},"linkedin":[],"twitter":[],"facebook":[],"instagram":[]}},"seo_analyzer_scan_date":null},"aioseo_breadcrumb":" In a footnote to the previous post<\/a>, I said that Python’s math library can calculate the logarithm of extremely large numbers but not the cosine. This post will expand on that comment.<\/p>\n In this post I’ll use n<\/em> = 200! as my example rather than 1000! nbecause this value of N<\/em> is larger than the largest representable floating point number but small enough to be more convenient to work with.<\/p>\n Suppose someone calculates 200! for you:<\/p>\n You could now calculate log(n<\/em>) using<\/p>\n n<\/em> = 7.886578673647905 \u00d7 10374<\/sup><\/p>\n and so<\/p>\n log(n<\/em>) = log(7.886578673647905 \u00d7 10374<\/sup>) The key thing that makes this possible is that the least significant digits of n<\/em> only effect the least significant digits of log(n<\/em>). In the calculation above I kept the first 16 digits of\u00a0n<\/em>. Python couldn’t make use of any more digits, and had no need of any more digits, in order to produce the logarithm to machine precision.<\/p>\n Cosine doesn’t work that way. The cosine of\u00a0n<\/em> depends on the remainder when\u00a0n<\/em> is divided by 2\u03c0, and that remainder depends on every single digit of n<\/em>. I’ll illustrate that below.<\/p>\n Using cos(n<\/em> + 10i<\/em><\/sup>)<\/p>\n for i running from 0 to 374, tweaking each digit one at a time. (Except when a digit is a 9 and the addition results in a carry.)<\/p>\n Here’s what a plot of the results look like.<\/p>\n The value of cos(n<\/em>) is about \u22120.985, but the values above are all over the map. We can look at the range by projecting all the points over to the left edge then rotating a quarter turn:<\/p>\n The remarkable thing about this image is that there are a few gaps, i.e. a few values the cosine does not<\/em> take on.<\/p>\n Here’s a more sophisticated way to look at it. The sequence 10i<\/em><\/sup> mod 2\u03c0 is dense in [0, 2\u03c0], and so by going far enough out in the sequence, we can find a value that shifts the phase of n<\/em> by any desired amount within any given tolerance.<\/p>\n Every digit in\u00a0n<\/em> matters, and changing any digit can change the value of cosine to be essentially any value. You cannot calculate the cosine of an enormous number without using some kind of extended precision arithmetic. There are clever range reduction algorithms that minimize the amount of extended arithmetic necessary, but extended arithmetic cannot be completely eliminated.<\/p>\n","protected":false},"excerpt":{"rendered":" In a footnote to the previous post, I said that Python’s math library can calculate the logarithm of extremely large numbers but not the cosine. This post will expand on that comment. In this post I’ll use n = 200! as my example rather than 1000! nbecause this value of N is larger than the […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[5],"tags":[],"class_list":["post-247561","post","type-post","status-publish","format-standard","hentry","category-computing"],"acf":[],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\n","aioseo_head_json":{"title":"Calculating the cosine of numbers outside the range of floats","description":"Why you can calculate the log of a huge number more easily than the cosine. Demonstration that every digit is maximally important.","canonical_url":"https:\/\/www.johndcook.com\/blog\/2026\/08\/07\/cos200\/","robots":"max-image-preview:large","keywords":"","webmasterTools":{"miscellaneous":""},"schema":null,"og:locale":"en_US","og:site_name":"John D. Cook | Applied Mathematics Consulting","og:type":"article","og:title":"Calculating the cosine of numbers outside the range of floats","og:description":"Why you can calculate the log of a huge number more easily than the cosine. Demonstration that every digit is maximally important.","og:url":"https:\/\/www.johndcook.com\/blog\/2026\/08\/07\/cos200\/","article:published_time":"2026-08-07T13:19:07+00:00","article:modified_time":"2026-08-07T13:29:27+00:00","twitter:card":"summary","twitter:title":"Calculating the cosine of numbers outside the range of floats","twitter:description":"Why you can calculate the log of a huge number more easily than the cosine. Demonstration that every digit is maximally important.","twitter:image":"https:\/\/www.johndcook.com\/blog\/wp-content\/uploads\/2022\/05\/twittercard.png"},"aioseo_meta_data":{"post_id":"247561","title":"Calculating the cosine of numbers outside the range of floats","description":"Why you can calculate the log of a huge number more easily than the cosine. Demonstration that every digit is maximally important.","keywords":null,"keyphrases":{"focus":{"keyphrase":"","score":0,"analysis":{"keyphraseInTitle":{"score":0,"maxScore":9,"error":1}}},"additional":[]},"primary_term":null,"canonical_url":null,"og_title":null,"og_description":null,"og_object_type":"default","og_image_type":"default","og_image_url":null,"og_image_width":null,"og_image_height":null,"og_image_custom_url":null,"og_image_custom_fields":null,"og_video":"","og_custom_url":null,"og_article_section":null,"og_article_tags":null,"twitter_use_og":false,"twitter_card":"default","twitter_image_type":"default","twitter_image_url":null,"twitter_image_custom_url":null,"twitter_image_custom_fields":null,"twitter_title":null,"twitter_description":null,"schema":{"blockGraphs":[],"customGraphs":[],"default":{"data":{"Article":[],"Course":[],"Dataset":[],"FAQPage":[],"Movie":[],"Person":[],"Product":[],"ProductReview":[],"Car":[],"Recipe":[],"Service":[],"SoftwareApplication":[],"WebPage":[]},"graphName":"Article","isEnabled":true},"graphs":[]},"schema_type":"default","schema_type_options":null,"pillar_content":false,"robots_default":true,"robots_noindex":false,"robots_noarchive":false,"robots_nosnippet":false,"robots_nofollow":false,"robots_noimageindex":false,"robots_noodp":false,"robots_notranslate":false,"robots_max_snippet":"-1","robots_max_videopreview":"-1","robots_max_imagepreview":"large","priority":null,"frequency":"default","location":null,"local_seo":null,"breadcrumb_settings":null,"limit_modified_date":false,"created":"2026-08-07 11:54:58","updated":"2026-08-07 14:02:59","ai":{"faqs":[],"keyPoints":[],"schemas":[],"titles":[],"descriptions":[],"socialPosts":{"email":{"subject":"","preview":"","content":""},"linkedin":[],"twitter":[],"facebook":[],"instagram":[]}},"seo_analyzer_scan_date":null},"aioseo_breadcrumb":" The previous post<\/a> pointed out that the following code such as the following unexpectedly works.<\/p>\n If you don’t find this unexpected, note that if you replace In this post I’d like to look at how you might calculate log(1000!) with less capable software, and even without software.<\/p>\n One approach would be to sum the logarithms of the numbers 1 through 1000. This will give essentially the same result as above, with a little difference in the last couple decimal places due to rounding error.<\/p>\n If you have a way to calculate 1000! but not a way to cast it to a floating point number, you could do this manually.<\/p>\n This tells us 1000! = 4.023872600770937 \u00d7 102567<\/sup>. Therefore<\/p>\n log(1000!) = log(4.023872600770937) + 2567 log(10)<\/p>\n which only requires working with numbers of modest size.<\/p>\n Now suppose it’s 1964. You don’t have a computer, or even a calculator, but you do have a copy of the recently published Handbook of Mathematical Functions by Abramowitz and Stegun (A&S). You turn to Table 6.6 “Factorials for large arguments.” This has values of factorial for 100, 200, 300, \u2026, 1000, so you can simply look up your answer to 20 decimal places.<\/p>\n That was too easy; I didn’t expect that to be there when I started writing this post. If you wanted to compute log(950!), for example, you’d have to work harder. You could find A&S equation 6.1.41 (Stirling’s series) which says<\/p>\n So how would you use this formula to calculate log(1000!)? Since n<\/em>! = \u0393(n<\/em> + 1), you set z<\/em> = 1001.<\/p>\n You’d need to decide how many terms you need to use. Assuming the error is on the order of the first term you leave out, you’d reason that you could probably stop with the 1\/12z<\/em> term because the next term is between 10\u221211<\/sup> and 10\u221212<\/sup>.<\/p>\n You find Table 4.2 has natural logarithms, but not for 1001. You can look up log(1.001), however, and at the bottom of the same page is log(10) to 16 decimal places, and you can find log(10) to 24 decimal places in Table 1.1. So you calculate<\/p>\n log(1001) = log(1.001 \u00d7 10\u00b3) = log(1.001) + 3 log(10).<\/p>\n You can find log(2) and log(\u03c0) in Table 1.1, and average them to find \u00bd log(2\u03c0).<\/p>\n Here’s Python code to simulate the hand calculations.<\/p>\n This result differs from the one at the top of the post only in the last decimal place.<\/p>\n Doing calculations with tables is not as simple as “just look it up.” It takes a bit of skill.<\/p>\n [1] The code will also fail if you replace Update<\/strong>: The next post<\/a> expands on why computing the cosine of a large number is more difficult than computing the log.<\/p>\n","protected":false},"excerpt":{"rendered":" The previous post pointed out that the following code such as the following unexpectedly works. >>> from math import log, factorial >>> log(factorial(1000)) 5912.128178488163 If you don’t find this unexpected, note that if you replace math.log with numpy.log the code will fail [1]. Functions like natural logarithm operate on real numbers. Real numbers are represented […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[9],"tags":[],"class_list":["post-247553","post","type-post","status-publish","format-standard","hentry","category-math"],"acf":[],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\n","aioseo_head_json":{"title":"Calculating log(1000!)","description":"How would you compute log(1000!) without software that handles enormous numbers? How would you calculate it by hand?","canonical_url":"https:\/\/www.johndcook.com\/blog\/2026\/08\/06\/log1000\/","robots":"max-image-preview:large","keywords":"","webmasterTools":{"miscellaneous":""},"schema":null,"og:locale":"en_US","og:site_name":"John D. Cook | Applied Mathematics Consulting","og:type":"article","og:title":"Calculating log(1000!)","og:description":"How would you compute log(1000!) without software that handles enormous numbers? How would you calculate it by hand?","og:url":"https:\/\/www.johndcook.com\/blog\/2026\/08\/06\/log1000\/","article:published_time":"2026-08-06T13:23:43+00:00","article:modified_time":"2026-08-07T13:42:02+00:00","twitter:card":"summary","twitter:title":"Calculating log(1000!)","twitter:description":"How would you compute log(1000!) without software that handles enormous numbers? How would you calculate it by hand?","twitter:image":"https:\/\/www.johndcook.com\/blog\/wp-content\/uploads\/2022\/05\/twittercard.png"},"aioseo_meta_data":{"post_id":"247553","title":null,"description":"How would you compute log(1000!) without software that handles enormous numbers? How would you calculate it by hand?","keywords":null,"keyphrases":{"focus":{"keyphrase":"","score":0,"analysis":{"keyphraseInTitle":{"score":0,"maxScore":9,"error":1}}},"additional":[]},"primary_term":null,"canonical_url":null,"og_title":null,"og_description":null,"og_object_type":"default","og_image_type":"default","og_image_url":null,"og_image_width":null,"og_image_height":null,"og_image_custom_url":null,"og_image_custom_fields":null,"og_video":"","og_custom_url":null,"og_article_section":null,"og_article_tags":null,"twitter_use_og":false,"twitter_card":"default","twitter_image_type":"default","twitter_image_url":null,"twitter_image_custom_url":null,"twitter_image_custom_fields":null,"twitter_title":null,"twitter_description":null,"schema":{"blockGraphs":[],"customGraphs":[],"default":{"data":{"Article":[],"Course":[],"Dataset":[],"FAQPage":[],"Movie":[],"Person":[],"Product":[],"ProductReview":[],"Car":[],"Recipe":[],"Service":[],"SoftwareApplication":[],"WebPage":[]},"graphName":"Article","isEnabled":true},"graphs":[]},"schema_type":"default","schema_type_options":null,"pillar_content":false,"robots_default":true,"robots_noindex":false,"robots_noarchive":false,"robots_nosnippet":false,"robots_nofollow":false,"robots_noimageindex":false,"robots_noodp":false,"robots_notranslate":false,"robots_max_snippet":"-1","robots_max_videopreview":"-1","robots_max_imagepreview":"large","priority":null,"frequency":"default","location":null,"local_seo":null,"breadcrumb_settings":null,"limit_modified_date":false,"created":"2026-08-06 11:14:31","updated":"2026-08-07 14:02:59","ai":{"faqs":[],"keyPoints":[],"schemas":[],"titles":[],"descriptions":[],"socialPosts":{"email":{"subject":"","preview":"","content":""},"linkedin":[],"twitter":[],"facebook":[],"instagram":[]}},"seo_analyzer_scan_date":null},"aioseo_breadcrumb":" Last week I wrote a post<\/a> on hiding cryptographic keys in decks of cards. I wrote some code for that post that shouldn’t work, but before fixing I noticed that it in fact did work.<\/p>\n The code computes logarithms for integers larger than the largest representable float. For example, the largest float is on the order of 10308<\/sup>, and yet the following code works.<\/p>\n The While playing around with this I also noticed that you can define floats larger than the largest float without warnings.<\/p>\n This isn’t a feature of The expression returns That explains the following behavior:<\/p>\n The expressions Last week I wrote a post on hiding cryptographic keys in decks of cards. I wrote some code for that post that shouldn’t work, but before fixing I noticed that it in fact did work. The code computes logarithms for integers larger than the largest representable float. For example, the largest float is on the […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[9],"tags":[169],"class_list":["post-247547","post","type-post","status-publish","format-standard","hentry","category-math","tag-python"],"acf":[],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\n","aioseo_head_json":{"title":"The code that didn\u2019t break","description":"A couple oddities in math with very large numbers in Python","canonical_url":"https:\/\/www.johndcook.com\/blog\/2026\/08\/05\/math-log\/","robots":"max-image-preview:large","keywords":"python","webmasterTools":{"miscellaneous":""},"schema":null,"og:locale":"en_US","og:site_name":"John D. Cook | Applied Mathematics Consulting","og:type":"article","og:title":"The code that didn\u2019t break","og:description":"A couple oddities in math with very large numbers in Python","og:url":"https:\/\/www.johndcook.com\/blog\/2026\/08\/05\/math-log\/","article:published_time":"2026-08-05T18:26:25+00:00","article:modified_time":"2026-08-06T10:56:48+00:00","twitter:card":"summary","twitter:title":"The code that didn\u2019t break","twitter:description":"A couple oddities in math with very large numbers in Python","twitter:image":"https:\/\/www.johndcook.com\/blog\/wp-content\/uploads\/2022\/05\/twittercard.png"},"aioseo_meta_data":{"post_id":"247547","title":null,"description":"A couple oddities in math with very large numbers in Python","keywords":null,"keyphrases":{"focus":{"keyphrase":"","score":0,"analysis":{"keyphraseInTitle":{"score":0,"maxScore":9,"error":1}}},"additional":[]},"primary_term":null,"canonical_url":null,"og_title":null,"og_description":null,"og_object_type":"default","og_image_type":"default","og_image_url":null,"og_image_width":null,"og_image_height":null,"og_image_custom_url":null,"og_image_custom_fields":null,"og_video":"","og_custom_url":null,"og_article_section":null,"og_article_tags":null,"twitter_use_og":false,"twitter_card":"default","twitter_image_type":"default","twitter_image_url":null,"twitter_image_custom_url":null,"twitter_image_custom_fields":null,"twitter_title":null,"twitter_description":null,"schema":{"blockGraphs":[],"customGraphs":[],"default":{"data":{"Article":[],"Course":[],"Dataset":[],"FAQPage":[],"Movie":[],"Person":[],"Product":[],"ProductReview":[],"Car":[],"Recipe":[],"Service":[],"SoftwareApplication":[],"WebPage":[]},"graphName":"Article","isEnabled":true},"graphs":[]},"schema_type":"default","schema_type_options":null,"pillar_content":false,"robots_default":true,"robots_noindex":false,"robots_noarchive":false,"robots_nosnippet":false,"robots_nofollow":false,"robots_noimageindex":false,"robots_noodp":false,"robots_notranslate":false,"robots_max_snippet":"-1","robots_max_videopreview":"-1","robots_max_imagepreview":"large","priority":null,"frequency":"default","location":null,"local_seo":null,"breadcrumb_settings":null,"limit_modified_date":false,"created":"2026-08-05 17:47:04","updated":"2026-08-06 11:53:56","ai":{"faqs":[],"keyPoints":[],"schemas":[],"titles":[],"descriptions":[],"socialPosts":{"email":{"subject":"","preview":"","content":""},"linkedin":[],"twitter":[],"facebook":[],"instagram":[]}},"seo_analyzer_scan_date":null},"aioseo_breadcrumb":" A few days ago I wrote a post on counting rooted trees<\/a>. That post looked at the sequence c<\/em>(n<\/em>) which counts the number of rooted trees with n<\/em> nodes. Here one node is distinguished as the root, but the nodes below the root are not distinguished from each other; all that matters is how the nodes are connected.<\/p>\n The number of rooted trees with n<\/em> nodes is the same as the number of ways to configure n<\/em> \u2212 1 non-overlapping circles. Not only are the counts the same, there is a natural correspondence between the trees and the circles. It’s not obvious that there should be such a correspondence, with the right notation the correspondence is sort of a pun.<\/p>\n The standard way to represent unlabeled trees is as a multiset<\/a> of their children. We use a multiset, not a set, because some elements will be repeated. We represent a leaf as a pair of parentheses: There is only one rooted tree with one node: There is only one rooted tree with one two nodes: There are two rooted trees with three nodes, and we can represent them as The four rooted trees with four nodes can be represented as Here are the nine rooted trees with five nodes:<\/p>\n The correspondence with non-overlapping circles removes the outer parentheses then joins the rest to form circles, with nested parentheses corresponding to concentric circles. A more geometric way to see the correspondence is to start at the bottom of the tree, replace leaves with circles, then work your way up circling connected components.<\/p>\n A few days ago I wrote a post on counting rooted trees. That post looked at the sequence c(n) which counts the number of rooted trees with n nodes. Here one node is distinguished as the root, but the nodes below the root are not distinguished from each other; all that matters is how the […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[],"class_list":["post-247540","post","type-post","status-publish","format-standard","hentry","category-uncategorized"],"acf":[],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\n","aioseo_head_json":{"title":"Enumerating trees and circles","description":"There's a one-to-one correspondence between rooted trees and non-overlapping circles","canonical_url":"https:\/\/www.johndcook.com\/blog\/2026\/08\/05\/enumerating-trees-and-circles\/","robots":"max-image-preview:large","keywords":"","webmasterTools":{"miscellaneous":""},"schema":null,"og:locale":"en_US","og:site_name":"John D. Cook | Applied Mathematics Consulting","og:type":"article","og:title":"Enumerating trees and circles","og:description":"There's a one-to-one correspondence between rooted trees and non-overlapping circles","og:url":"https:\/\/www.johndcook.com\/blog\/2026\/08\/05\/enumerating-trees-and-circles\/","article:published_time":"2026-08-05T14:49:35+00:00","article:modified_time":"2026-08-06T11:10:52+00:00","twitter:card":"summary","twitter:title":"Enumerating trees and circles","twitter:description":"There's a one-to-one correspondence between rooted trees and non-overlapping circles","twitter:image":"https:\/\/www.johndcook.com\/blog\/wp-content\/uploads\/2022\/05\/twittercard.png"},"aioseo_meta_data":{"post_id":"247540","title":null,"description":"There's a one-to-one correspondence between rooted trees and non-overlapping circles","keywords":null,"keyphrases":{"focus":{"keyphrase":"","score":0,"analysis":{"keyphraseInTitle":{"score":0,"maxScore":9,"error":1}}},"additional":[]},"primary_term":null,"canonical_url":null,"og_title":null,"og_description":null,"og_object_type":"default","og_image_type":"default","og_image_url":null,"og_image_width":null,"og_image_height":null,"og_image_custom_url":null,"og_image_custom_fields":null,"og_video":"","og_custom_url":null,"og_article_section":null,"og_article_tags":null,"twitter_use_og":false,"twitter_card":"default","twitter_image_type":"default","twitter_image_url":null,"twitter_image_custom_url":null,"twitter_image_custom_fields":null,"twitter_title":null,"twitter_description":null,"schema":{"blockGraphs":[],"customGraphs":[],"default":{"data":{"Article":[],"Course":[],"Dataset":[],"FAQPage":[],"Movie":[],"Person":[],"Product":[],"ProductReview":[],"Car":[],"Recipe":[],"Service":[],"SoftwareApplication":[],"WebPage":[]},"graphName":"Article","isEnabled":true},"graphs":[]},"schema_type":"default","schema_type_options":null,"pillar_content":false,"robots_default":true,"robots_noindex":false,"robots_noarchive":false,"robots_nosnippet":false,"robots_nofollow":false,"robots_noimageindex":false,"robots_noodp":false,"robots_notranslate":false,"robots_max_snippet":"-1","robots_max_videopreview":"-1","robots_max_imagepreview":"large","priority":null,"frequency":"default","location":null,"local_seo":null,"breadcrumb_settings":null,"limit_modified_date":false,"created":"2026-08-05 12:48:37","updated":"2026-08-06 11:53:56","ai":{"faqs":[],"keyPoints":[],"schemas":[],"titles":[],"descriptions":[],"socialPosts":{"email":{"subject":"","preview":"","content":""},"linkedin":[],"twitter":[],"facebook":[],"instagram":[]}},"seo_analyzer_scan_date":null},"aioseo_breadcrumb":"from math import *\r\n\r\ns = 0\r\nfor n in range(288):\r\n s += (-1)**n * 200**(2*n) \/ factorial(2*n)\r\nprint(s)\r\n<\/pre>\n
200<\/code> to 200.0<\/code> above, the code would crash. Calculating 200.0**(2*n)<\/code> overflows when n<\/em> = 67. But when we calculate 200**(2*n)<\/code>, the result is an integer. And we’re dividing by factorial(2*n)<\/code>, which is also an integer. Both of these integers become too large to fit in a float, but their ratio<\/em> has a maximum value of around 1080<\/sup>, smaller than the maximum float, which is on the order of 10308<\/sup>.<\/p>\n>>> from math import cos, pi\r\n>>> x = 200 % (2*pi)\r\n>>> x\r\n5.221255477432827\r\n<\/pre>\n
>>> cos(x)\r\n0.48718767500701254\r\n>>> cos(x) - cos(200)\r\n6.661338147750939e-15\r\n<\/pre>\n
78865786736479050355236321393218506229513597768717326329474253324435\\\r\n94499634033429203042840119846239041772121389196388302576427902426371\\\r\n05061926624952829931113462857270763317237396988943922445621451664240\\\r\n25403329186413122742829485327752424240757390324032125740557956866022\\\r\n60319041703240623517008587961789222227896237038973747200000000000000\\\r\n00000000000000000000000000000000000\r\n<\/pre>\n
\n= log(7.886578673647905) + 374 log(10) = 863.2319871924055.<\/p>\nbc -l<\/code> and setting the scale to 400, I can calculated n<\/em> then calculate<\/p>\n n = 1\r\n for (i = 1; i <= 200; i++) n *= i\r\n scale = 400\r\n for (i = 1; i <= 374; i++) {\r\n x = c(n+10^i)\r\n scale = 16\r\n print x\/1, \"\\n\"\r\n scale = 400\r\n }\r\n<\/pre>\n![](\"https:\/\/www.johndcook.com\/cos200factorial1.png\")
<\/p>\n![](\"https:\/\/www.johndcook.com\/cos200factorial2.png\")
<\/p>\n>>> from math import log, factorial\r\n>>> log(factorial(1000))\r\n5912.128178488163\r\n<\/pre>\n
math.log<\/code> with numpy.log<\/code> the code will fail [1]. Functions like natural logarithm operate on real numbers. Real numbers are represented as floating point numbers in programming languages, and 1000! factorial is too large to represent as a standard floating point number. (More on that here<\/a>.)<\/p>\n>>> s = str(factorial(1000))\r\n>>> s[:16]\r\n'4023872600770937'\r\n>>> len(s)\r\n2568\r\n<\/pre>\n
Calculating by hand<\/h2>\n
![\"\\begin{align*}](\"https:\/\/www.johndcook.com\/AS6.1.41.svg\")
<\/p>\nlog2 = 0.6931_47180_55994_53094_172321 # Table 1.1\r\nlog10 = 2.3025_85092_99404_56840_179915 # Table 1.1\r\nlogpi = 1.1447_29885_84940_01741_43427 # Table 1.1\r\nlog1_001 = 0.00099_95003_330835 # Table 4.2\r\n\r\nz = 1001\r\nlogz = log1_001 + 3*log10\r\ns = (z - 0.5)*logz - z + (log2 + logpi)\/2 + 1\/(12*z)\r\n\r\nprint(s)\r\n<\/pre>\n
Related posts<\/h2>\n
\n
math.log<\/code> with math.cos<\/code>. Both logarithm and cosine return moderate sized real numbers when given enormous inputs like 1000!, so representing the output as a float is not the problem. But logarithms of huge numbers can be computed with ordinary precision functions, as above. But computing the cosine of a huge number requires extended precision.<\/p>\n>>> import math\r\n>>> math.log10(10**400)\r\n400.0\r\n<\/pre>\n
log<\/code>, log2<\/code>, and log10<\/code> functions have some code inside that handles large integers specially. It doesn’t simply convert the integers to floats before taking the logarithm. If it did, it would overflow. If you replace math<\/code> with numpy<\/code> above, the code will fail. NumPy’s implementation of logarithms is more what I would expect.<\/p>\n>>> math.log(1e308)\r\n709.1962086421661\r\n>>> math.log(1e309)\r\ninf\r\n<\/pre>\n
math.log<\/code> but of how Python handles scientific notation. The expression 1e308<\/code> is the floating point representation of 10308<\/sup>. It is a float, not an int.<\/p>\n>>> type(1e308)\r\n<class 'float'>\r\n<\/pre>\n
1e309<\/code> is also a float. But since it’s larger than is possible for a float, Python interprets it as inf<\/code>. The code<\/p>\nmath.log(1e309)<\/pre>\n
inf<\/code> based on the reasoning that log(\u221e) = \u221e.<\/p>\n>>> 1e309 == 1e310\r\nTrue\r\n<\/pre>\n
1e309<\/code> and 1e310<\/code> are equal because both are alternate ways of writing inf<\/code>.<\/p>\n","protected":false},"excerpt":{"rendered":"![](\"https:\/\/www.johndcook.com\/rooted_trees_order_1_to_4.svg\")
<\/p>\n()<\/code>.<\/p>\n()<\/code>.<\/p>\n(())<\/code>. Here the outer parentheses represent the root node and the inner parentheses represent its child.<\/p>\n((()))<\/code> and ((),())<\/code>. The first is the straight line tree: a node that has a single child node that has a single child node. The second is a node that branches to two nodes. (Here’s where we need multisets.)<\/p>\n(((())))<\/code>, ((((),()))<\/code>, ((),(()))<\/code>, and ((),(),(),())<\/code>.<\/p>\n((((()))))\r\n((((),())))\r\n(((),(())))\r\n(((),(),()))\r\n((()),(()))\r\n((),((())))\r\n((),((),()))\r\n((),(),(()))\r\n((),(),(),())\r\n<\/pre>\n
![](\"https:\/\/www.johndcook.com\/nonoverlapping_circles2.png\")
<\/p>\n","protected":false},"excerpt":{"rendered":"
![\"M(n)](\"https:\/\/www.johndcook.com\/metallic_ratio_def.svg\")
<\/p>\n