PostgreSQL High Precision Mathematics Extension.

I have been trying to find active interest in a free for all use PostgreSQL extension, complete and available, on the public internet, that will support the following:

####################################################
# High Precision Numeric and Elementary Functions Support #
# In PostgreSQL v13 and beyond. #
# HPPM: High Precision PostgreSQL Mathematics. #
####################################################

-Integer Z, or Rational Mixed Decimal Q, numbers support in 64 bit PostgreSQL. Via HPZ, and HPQ, original types. In this specification, they are collectively referred to as HPX types.

There should be no range or multi range types or their supporting functions or special operators included for HPX types, at this point.

-The extension could be based on a library like GMP, written in C, being an appropriate basis to use, for all OS platforms involved. The point being, that there is already some support for this extension, in terms of its logic, publicly available in C that can be apprehended for this extension and its platforms.

-Real numbers are the values of Integer, non-recurring Rational Numbers and recurring, Irrational Numbers.
Recurring numbers can be appropriately truncated, via a finite Natural precision value, always at least 1, to obtain an approximating value. The approximating value can really be seen as a finite Rational value, possibly with integer or decimal parts, or both together. These numbers may be positive or negative, or zero, scalar values, may be integers, decimals or mixed numbers, and always do exist on the one dimensional number line.

-A defaulting number of significant figures (precision), stored inside each HPX data or type instance. This gets specified within each type variable before its use, or on data at type casting. Or a default precision is submitted instead. Precision can be accessed and changed later via precision functions.

Precision is set at data casting, type declaration, or from the default, and may be altered again later. Precision is always apprehended before external or internal evaluation begins. Precision is used to control numbers, and operations involving them, and the number output, when numeric manipulation happens.

If an HPX value is data on its own, without a variable or a coded expression, it takes the total default precision, if simply specified alone. If it is inserted into a table column with a different precision, then that precision is applied then. When an HPX calculated value is assigned into an HPX variable, it will try to skip ahead to the assignment variable, and take its precision from the result variable, which can be set up beforehand. If however, an HPX value, in a PostgreSQL code expression is sent straight into a RETURN statement or later, a SELECT statement, for example, then that datum will contain the highest precision value out of any of the previous values in the PostgreSQL expression which lead to it. But before anything is set or specified, a total default precision value of 20 is the beginning point.

#############################################
# precision(HPZ input, BIGINT input) returns HPZ; #
# precision(HPQ input, BIGINT input) returns HPQ; #
# #
# precision(HPZ input) returns BIGINT; #
# precision(HPQ input) returns BIGINT; #
# #
# expression(HPZ input) returns TEXT; #
# expression(HPQ input) returns TEXT; #
#############################################

-HPX values, as PostgreSQL data, can be displayed, but they sit on top of a few other phenomena. Forward and inverse accuracy, withstanding truncation, can be achieved by storing, encapsulating and operating with and normalising the mathematical expression (or just one value, via assignment). The expression has one or more links, from value(s) to variable(s) in the expression, via applying of precision adjustment at evaluation time, all internally. This system will uphold any precision, certainly ones within a very large range limit, controlled by the already available type, the BIGINT. It can enumerate digits of a frequency within the range of -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807. Though naturally evaluation will slow down, or not conclude in useful time frames, before these limits. That phenomenon can be allowed, and left to the context of the programmer to deal with or avoid as they may. They may try to minimise the extent of one internal expression by using re-substitution in the body of originating, PostgreSQL, code.

--------------------------------------------------------------
--At the point of PostgreSQL code input and execution:

select pi(1001) as pi;

--Within a table creation command:

create table example_table
(
id BIGSERIAL PRIMARY KEY,
a HPZ,
b HPQ(50)
);

INSERT INTO example_table(a,b) VALUES(0, 0.1);
INSERT INTO example_table(a,b) VALUES(100,1.1);
INSERT INTO example_table(a,b) VALUES(200,2.2);
INSERT INTO example_table(a,b) VALUES(300,3.3);
INSERT INTO example_table(a,b) VALUES(400,4.4);
INSERT INTO example_table(a,b) VALUES(500,5.5);
INSERT INTO example_table(a,b) VALUES(600,6.6);
INSERT INTO example_table(a,b) VALUES(700,7.7);
INSERT INTO example_table(a,b) VALUES(800,8.8);
INSERT INTO example_table(a,b) VALUES(900,9.9);

--Or as variables, in some function:

create or replace function example_function()
returns void
language plpgsql
as
$$

declare
a HPQ;
b HPQ;
c HPQ;

begin

BIGINT p=30;
precision(a,p);
precision(b,p);
a = 0.1;
b = 0.1;
precision(c,3);
c=a*b;
precision(c,p^2);
return void
end;
$$
--------------------------------------------------------------

-Value assignment to a typed variable by =.

-Operators. Base 10 Arithmetic and comparisons support on Base 10 HPZ and HPQ, with casting:

+,-,*,/,%,^,=,!=,<>,>,<,>=,<=, ::

These include full division and integer only division (from type inference), with no remainder, and a remainder calculating operator. There should be a defaulting ability of values not within these two types to automatically be cast up to HPZ or HPQ, where specified and appropriate in PostgreSQL expressions.

-Reified support with broader syntax and operations within PostgreSQL. Tables and related phenomena, Array types, Indexing, Variables and related phenomena,the Record type,
direct compatability with Aggregate and Window functions, and Partitions are all parts of a larger subset that should re-interact with HPZ or HPQ successfully.

-Ease of installation support. Particularly for Windows and Linux. *.exe, *.msi or *.rpm, *.deb, *.bin installers.
Upon a PostgreSQL standard installation. Installation and Activation instructions included, if unavoidable. The extension should literally just install and be applicable, with no loading command necessary, inside PostgreSQL. Every time the database process runs, by default.

#####################################################
# -Mathematical and Operational functions support: #
# #
# cast(HPZ as HPQ) returns HPQ; #
# cast(HPQ as HPZ) returns HPZ; #
# cast(TEXT as HPZ) returns HPZ; #
# cast(TEXT as HPQ) returns HPQ; #
# cast(HPQ as TEXT) returns TEXT; #
# cast(HPZ as TEXT) returns TEXT; #
# #
# cast(HPZ as SMALLINT) returns SMALLINT; #
# cast(SMALLINT as HPZ) returns HPZ; #
# cast(HPZ as INTEGER) returns INTEGER; #
# cast(INTEGER as HPZ) returns HPZ; #
# cast(HPZ as BIGINT) returns BIGINT; #
# cast(BIGINT as HPZ) returns HPZ; #
# cast(HPQ as REAL) returns REAL; #
# cast(REAL as HPQ) returns HPQ #
# cast(DOUBLE PRECISION as HPQ) returns HPQ; #
# cast(HPQ as DOUBLE PRECISION) returns DOUBLE PRECISION; #
# cast(HPQ as DECIMAL) returns DECIMAL; #
# cast(DECIMAL as HPQ) returns HPQ; #
# cast(HPQ as NUMERIC) returns NUMERIC; #
# cast(NUMERIC as HPQ) returns HPQ; #
# #
# sign(HPQ input) returns HPZ; #
# abs(HPQ input) returns HPQ; #
# ceil(HPQ input) returns HPZ; #
# floor(HPQ input) returns HPZ; #
# round(HPQ input) returns HPZ; #
# recip(HPQ input) returns HPQ; #
# pi(BIGINT precision) returns HPQ; #
# e(BIGINT precision) returns HPQ; #
# power(HPQ base, HPQ exponent) returns HPQ; #
# sqrt(HPQ input) returns HPQ; #
# nroot(HPZ theroot, HPQ input) returns HPQ; #
# log10(HPQ input) returns HPQ; #
# ln(HPQ input) returns HPQ; #
# log2(HPQ input) returns HPQ; #
# factorial(HPZ input) returns HPZ; #
# nCr(HPZ objects, HPZ selectionSize) returns HPZ; #
# nPr(HPZ objects, HPZ selectionSize) returns HPZ; #
# #
# degrees(HPQ input) returns HPQ; #
# radians(HPQ input) returns HPQ; #
# sind(HPQ input) returns HPQ; #
# cosd(HPQ input) returns HPQ; #
# tand(HPQ input) returns HPQ; #
# asind(HPQ input) returns HPQ; #
# acosd(HPQ input) returns HPQ; #
# atand(HPQ input) returns HPQ; #
# sinr(HPQ input) returns HPQ; #
# cosr(HPQ input) returns HPQ; #
# tanr(HPQ input) returns HPQ; #
# asinr(HPQ input) returns HPQ; #
# acosr(HPQ input) returns HPQ; #
# atanr(HPQ input) returns HPQ; #
# #
###################################################

-Informative articles on all these things exist at:

Comparison Operators: https://en.wikipedia.org/wiki/Relational_operator
Floor and Ceiling Functions: https://en.wikipedia.org/wiki/Floor_and_ceiling_functions
Arithmetic Operations: https://en.wikipedia.org/wiki/Arithmetic
Integer Division: https://en.wikipedia.org/wiki/Division_(mathematics)#Of_integers
Modulus Operation: https://en.wikipedia.org/wiki/Modulo_operation
Rounding (Commercial Rounding): https://en.wikipedia.org/wiki/Rounding
Factorial Operation: https://en.wikipedia.org/wiki/Factorial
Degrees: https://en.wikipedia.org/wiki/Degree_(angle)
Radians: https://en.wikipedia.org/wiki/Radian
Elementary Functions: https://en.wikipedia.org/wiki/Elementary_function

The following chart could be used to help test trigonometry outputs, under
Further Condsideration of the Unit Circle:
https://courses.lumenlearning.com/boundless-algebra/chapter/trigonometric-functions-and-the-unit-circle/

############
# #
# The End. #
# #
############