{"id":37058402,"url":"https://github.com/crookseta/missing-values","last_synced_at":"2026-01-14T06:35:53.398Z","repository":{"id":181074274,"uuid":"639648360","full_name":"crookseta/missing-values","owner":"crookseta","description":".Net 8 generic math compatible mathematic library.","archived":false,"fork":false,"pushed_at":"2025-12-25T17:54:39.000Z","size":3949,"stargazers_count":4,"open_issues_count":1,"forks_count":1,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-12-26T10:44:35.952Z","etag":null,"topics":["csharp","dotnet","float128","float256","floating-point","ieee754","int256","int512","math","numeric","octuple-precision","quadruple-precision","uint256","uint512"],"latest_commit_sha":null,"homepage":"","language":"C#","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/crookseta.png","metadata":{"files":{"readme":"README.md","changelog":"changelog/2.x.x/2.0.md","contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2023-05-11T23:11:28.000Z","updated_at":"2025-07-07T20:38:43.000Z","dependencies_parsed_at":null,"dependency_job_id":"337c8a39-18b4-48c5-b72c-47181a78bf09","html_url":"https://github.com/crookseta/missing-values","commit_stats":null,"previous_names":["crookseta/missing-values"],"tags_count":12,"template":false,"template_full_name":null,"purl":"pkg:github/crookseta/missing-values","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/crookseta%2Fmissing-values","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/crookseta%2Fmissing-values/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/crookseta%2Fmissing-values/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/crookseta%2Fmissing-values/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/crookseta","download_url":"https://codeload.github.com/crookseta/missing-values/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/crookseta%2Fmissing-values/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":28412211,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-01-14T05:26:33.345Z","status":"ssl_error","status_checked_at":"2026-01-14T05:21:57.251Z","response_time":107,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.5:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["csharp","dotnet","float128","float256","floating-point","ieee754","int256","int512","math","numeric","octuple-precision","quadruple-precision","uint256","uint512"],"created_at":"2026-01-14T06:35:52.831Z","updated_at":"2026-01-14T06:35:53.380Z","avatar_url":"https://github.com/crookseta.png","language":"C#","readme":"# MissingValues numeric library for .Net 8+\n\nMissingValues is a C# numeric library for C# that introduces support for large integers and higher precision floating-point numbers. It supports generic math.\n\n## Features\n\n### 256-Bit and 512-Bit Integers\n\nThe library implements 256-bit and 512-bit integers, for both signed (`Int256`/`Int512`) and unsigned (`UInt256`/`UInt512`) integer arithmetic operations.\n\nHere is a chart comparing the existing binary integers to the MissingValues integers:\n\n| Name    \t| Size     \t| Max Value                                                                                                                                                                                                      \t| Min Value                                                                                                                                                                                                      \t|\n|---------\t|----------\t|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\t|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------\t|\n| `sbyte` \t| 8 bits   \t| 127                                                                                                                                                                                                            \t| -128                                                                                                                                                                                                           \t|\n| `byte`  \t| 8 bits   \t| 255                                                                                                                                                                                                            \t| 0                                                                                                                                                                                                              \t|\n| `short`  \t| 16 bits  \t| 32,767                                                                                                                                                                                                         \t| -32,768                                                                                                                                                                                                        \t|\n| `ushort`\t| 16 bits  \t| 65,535                                                                                                                                                                                                         \t| 0                                                                                                                                                                                                              \t|\n| `int`\t\t| 32 bits  \t| 2,147,483,647                                                                                                                                                                                                  \t| -2,147,483,648                                                                                                                                                                                                 \t|\n| `uint`\t| 32 bits  \t| 4,294,967,295                                                                                                                                                                                                  \t| 0                                                                                                                                                                                                              \t|\n| `long`\t| 64 bits  \t| 9,223,372,036,854,775,807                                                                                                                                                                                      \t| -9,223,372,036,854,775,808                                                                                                                                                                                     \t|\n| `ulong`\t| 64 bits  \t| 18,446,744,073,709,551,615                                                                                                                                                                                     \t| 0                                                                                                                                                                                                              \t|\n| `Int128`\t| 128 bits \t| 170,141,183,460,469,231,731,687,303,715,884,105,727                                                                                                                                                            \t| −170,141,183,460,469,231,731,687,303,715,884,105,728                                                                                                                                                           \t|\n| `UInt128`\t| 128 bits \t| 340,282,366,920,938,463,463,374,607,431,768,211,455                                                                                                                                                            \t| 0                                                                                                                                                                                                              \t|\n| `Int256`\t| 256 bits \t| 57,896,044,618,658,097,711,785,492,504,343,953,926,634,992,332,820,282,019,728,792,003,956,564,819,967                                                                                                         \t| -57,896,044,618,658,097,711,785,492,504,343,953,926,634,992,332,820,282,019,728,792,003,956,564,819,968                                                                                                        \t|\n| `UInt256`\t| 256 bits \t| 115,792,089,237,316,195,423,570,985,008,687,907,853,269,984,665,640,564,039,457,584,007,913,129,639,935                                                                                                        \t| 0                                                                                                                                                                                                              \t|\n| `Int512`\t| 512 bits \t| 6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,047  \t| -6,703,903,964,971,298,549,787,012,499,102,923,063,739,682,910,296,196,688,861,780,721,860,882,015,036,773,488,400,937,149,083,451,713,845,015,929,093,243,025,426,876,941,405,973,284,973,216,824,503,042,048 \t|\n| `UInt512`\t| 512 bits \t| 13,407,807,929,942,597,099,574,024,998,205,846,127,479,365,820,592,393,377,723,561,443,721,764,030,073,546,976,801,874,298,166,903,427,690,031,858,186,486,050,853,753,882,811,946,569,946,433,649,006,084,095 \t| 0                                                                                                                                                                                                              \t|\n\n**Example Usage**\n\n```csharp\nusing MissingValues; // namespace\n\n// You can use the constructor:\nInt256 num1 = new Int256(0x8000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0000, 0x0000_0000_0000_0001);\n// You can use Parse():\nInt256 num2 = Int256.Parse(\"10000000000000000000000000000000000000000000000000000000000000000000000000000\");\n// Or you can convert any other number type:\nInt256 num3 = long.MaxValue;\n\n// sum = -57896044618658097711785492504343953926634992332820282019728792003956564819967 + 10000000000000000000000000000000000000000000000000000000000000000000000000000 + 9223372036854775807\nInt256 sum = num1 + num2 + num3;\n\nConsole.WriteLine($\"Sum: {sum}\");\n\n// Prints: -47896044618658097711785492504343953926634992332820282019719568631919710044160\n```\n### Quadruple-Precision and Octuple-Precision Floating-Point Number\n\nThe library introduces the `Quad` and `Octo` struct, representing a quadruple-precision floating-point and a octuple-precision floating-point number respectively. \nQuadruple-precision offers higher precision than standard `double` or `float` types, making it suitable for applications requiring extensive precision in numerical calculations.\n\nHere is a chart comparing the existing IEEE floating point numbers to `Quad` and `Octo`:\n\n| Name   \t| Size \t\t| Significand Digits \t| Decimal Digits \t| Max Exponent \t| Min Exponent \t| Max Value \t| Min Value  \t|\n|--------\t|--------\t|--------------------\t|----------------\t|--------------\t|--------------\t|-----------\t|------------\t|\n| Half   \t| 16 bits  \t| 11                 \t| 3.31           \t| 15           \t| -14          \t| ~65504     \t| ~-65500     \t|\n| Single \t| 32 bits  \t| 24                 \t| 7.22           \t| 127          \t| -126         \t| ~3.40e38   \t| ~-3.40e38   \t|\n| Double \t| 64 bits  \t| 53                 \t| 15.95          \t| 1023         \t| -1022        \t| ~1.80e308  \t| ~-1.79e308  \t|\n| Quad   \t| 128 bits \t| 113                \t| 34.02          \t| 16383        \t| -16382       \t| ~1.19e4932 \t| ~-1.18e4932 \t|\n| Octo   \t| 256 bits \t| 237                \t| 71.34          \t| 262143        | −262142       | ~1.61e78913 \t| ~-1.61e78913 \t|\n\n**Example Usage**\n```csharp\nusing MissingValues; // namespace\n\n// You can use the constructor:\nQuad num1 = new Quad(sign: false, exp: 0x4004, sig: new UInt128(0x0000_9400_0000_0000, 0x0000_0000_0000_0000));\n// You can use Parse():\nQuad num2 = Quad.Parse(\"2e24\");\n// Or you can convert any other number type:\nQuad num3 = 12.25d;\n\n// sum = 50,5 + 2000000000000000000000000 + 12,25\nQuad sum = num1 + num2 + num3;\n\nConsole.WriteLine($\"Sum: {sum}\");\n\n// Prints 2000000000000000000000062,75\n```","funding_links":[],"categories":[],"sub_categories":[],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcrookseta%2Fmissing-values","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fcrookseta%2Fmissing-values","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fcrookseta%2Fmissing-values/lists"}