c# parse pdf data : Read pdf metadata java SDK control project wpf web page winforms UWP xnumbers-tutorial13-part883

Xnumbers Tutorial 
30 
number to round 
dec 
number rounded 
6.2831853071795864769 
6.2831853071795864769 
6.3 
6.2831853071795864769 
6.28 
6.2831853071795864769 
6.283 
6.2831853071795864769 
6.2832 
100352934.23345 
100352934 
100352934.23345 
-1 
100352930 
100352934.23345 
-2 
100352900 
When the number is in exponential format, it is internally converted into decimal before the 
rounding. 
number to round 
Decimal format 
Dec 
number rounded 
1.238521E-17 
0.00000000000000001238521 
16 
1.238521E-17 
0.00000000000000001238521 
17 
1.E-17 
1.238521E-17 
0.00000000000000001238521 
18 
1.2E-17 
1.238521E-17 
0.00000000000000001238521 
19 
1.24E-17 
Relative Rounding 
=xroundr(x, [dgt])  
Returns the relative round of a number. The optional parameter Dec sets the significant digits 
to keep. (default = 15) 
This function always rounds the decimal place no matter what the exponent is 
number to round 
dgt 
number rounded 
1.23423311238765E+44 
15 
1.23423311238765E+44 
1.23423311238765E+44 
14 
1.2342331123876E+44 
1.23423311238765E+44 
13 
1.234233112388E+44 
1.23423311238765E+44 
12 
1.23423311239E+44 
1.23423311238765E+44 
11 
1.2342331124E+44 
1.23423311238765E+44 
10 
1.234233112E+44 
Read pdf metadata java - add, remove, update PDF metadata in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Allow C# Developers to Read, Add, Edit, Update and Delete PDF Metadata
pdf metadata viewer online; acrobat pdf additional metadata
Read pdf metadata java - VB.NET PDF metadata library: add, remove, update PDF metadata in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Enable VB.NET Users to Read, Write, Edit, Delete and Update PDF Document Metadata
get pdf metadata; bulk edit pdf metadata
Xnumbers Tutorial 
31 
Extended Numbers manipulation 
Digits count 
xdgt(x) 
Returns the number of digits, significant or not, of an extended number. 
It is useful for counting the digits of long numbers 
xdgt(4.47213595499957939281834733746) = 30 
xdgt(3.99999999999999999999999990000) = 30 
xdgt(100000) = 6 
xdgt(5856.51311933374) = 15 
xdgt(1.2345678E-12) = 8 
Significant Digits count 
xdgts(x) 
Returns the number of significant digits of a number( trailing zeros are not significant). 
xdgts("1240100000") = 5 
xdgts(3.99999999999999999999999990000) = 26 
xdgts(100000) = 1 
xdgt(1.2345678E-12) = 8 
Numbers comparison 
xcomp(a [b]) 
Compares two extended numbers. It returns the value y defined by: 
<
− ⇒
=
>
=
a b
a b
a b
y
1
  0
  1 
The number b is optional (default b=0) 
If the second argument is omitted, the function returns the sign(a) 
xcomp(300, 299)= 1 
xcomp(298, 299)= -1 
xcomp(300, 300)= 0 
if b is missing, the function assumes b = 0 for default and then it returns the sign(a) 
xcomp(3.58E-12)=  1 
xcomp(0)= 0 
xcomp(-0.0023)=  -1 
.NET PDF SDK | Read & Processing PDF files
of text, hyperlinks, bookmarks and metadata; Advanced document provides royalty-free .NET Imaging PDF Reader SDK Document Imaging SDK and Java Document Imaging
batch edit pdf metadata; analyze pdf metadata
DocImage SDK for .NET: Document Imaging Features
viewer application Enable users to add metadata in the TIFF Type 6 (OJPEG) encoding Image only PDF encoding support. Add-on: Able to decode and read 20+ barcode
c# read pdf metadata; pdf metadata extract
Xnumbers Tutorial 
32 
Extended number check  
xIsXnumber(x)    
Returns TRUE if x is a true extended number.  
That is, x cannot be converted into double precision without losing of significant digits. It 
happens if a number has more than 15 significant digits. 
xIsXnuber(1641915798169656809371) = TRUE 
xIsXnuber(1200000000000000000000) = FALSE 
Format extended number 
=xFormat(str, [Digit_Sep]) 
=xUnformat(str)   
This function
1
separates an extended number in groups of digits by the separator character of 
you local system ( e.g. a comma "," for USA, a dot "." for Italy). Parameter "str" is the string 
number to format, Digit_Sep sets the group of digits ( default is 3) 
The second function removes any separator character from the string 
Example (on Italian standard): 
x = 1230000012,00002345678 
xFormat(x,3) = 1.230.000.012,000.023.456.79 
xFormat(x,6) = 1230.000012,000023.45679 
Example (on USA standard): 
xFormat(x,3)= 1,230,000,012.000,023,456,78 
xFormat(x,6)= 1230,000012.000023,45678 
Check digits  
DigitsAllDiff(number)   
This function
2
return TRUE  if a number has all digits different.  
DigitsAllDiff(12345) = TRUE 
DigitsAllDiff(123452) = FALSE 
Argument can be also a string. Example 
DigitsAllDiff(12345ABCDEFGHIM) = TRUE 
DigitsAllDiff(ABCDA) = FALSE 
1
These functions were original developed by Ton Jeursen for his add-in XNUMBER95, the downgrade version of 
XNUMBERS for Excel 5. 
Because it works well and it is very useful for examining long string of number, I have imported it in this package. 
2
This function appears by the courtesy of Richard Huxtable 
PDF Image Viewer| What is PDF
Promote use of metadata; Used on independent devices and processing SDK, allowing developers to read, write, view and convert word document without need for PDF.
batch pdf metadata; edit pdf metadata
.NET DICOM SDK | DICOM Image Viewing
new style; Ability to read patient metadata from the guide and sample codings; Ability to read DICOM images NET Document Imaging SDK and Java Document Imaging
change pdf metadata; add metadata to pdf programmatically
Xnumbers Tutorial 
33 
SortRange 
=SortRange (ArrayToSort, [IndexCol], [Order], [CaseSensitive]) 
This function returns an array sorted along a specified column 
ArrayToSort: is the (N x M ) array to sort  
IndexCol: is the index column for sorting (1 default) 
Order: can be "A" ascending (default) or "D" descending 
CaseSensitive: True (default) or False. It is useful for alphanumeric string sorting 
Example: The left table contains same points of a function f(x,y). The right table is ordered from 
low to high function values (the 3-th column)  
Digits sum 
sumDigits(number) 
This useful
1
function returns the digits sum of an integer number (extended or not) 
sumDigits(1234569888674326778876543) = 137 
Vector flip 
Flip(v) 
This function returns a vector in inverse order [a
1
, a
2
, a
3
, a
4
] ⇒ [a
4
, a
3
, a
2
, a
1
1
This function appears by the courtesy of Richard Huxtable
.NET PDF Generator | Generate & Manipulate PDF files
delete any pages in PDFs; Add metadata of a RasterEdge provides royalty-free .NET Imaging PDF Generator of NET Document Imaging SDK and Java Document Imaging
batch edit pdf metadata; batch pdf metadata
.NET JPEG 2000 SDK | Encode & Decode JPEG 2000 Images
Able to customize compression ratios (0 - 100); Support metadata encoding and decoding com is professional .NET Document Imaging SDK and Java Document Imaging
metadata in pdf documents; acrobat pdf additional metadata
Xnumbers Tutorial 
34 
Scientific format 
xcvexp(mantissa, [exponent])   
This function converts a number into scientific format. Useful for extended numbers that, being 
string, Excel cannot format. 
xcvexp(-6.364758987642234, 934) = -6.364758987642234E+934 
xcvexp(1.2334567890122786, ) = 1.2334567890122786E-807 
This function is useful also to convert any xnumbers into scientific notation, simply setting 
exponent = 0 (default) 
xcvexp(12342330100876523, 0) = 1.2342330100876523E+16 
xcvexp(0.000023494756398348) = 2.3494756398348E-5 
Split scientific format  
xsplit(x) 
This function returns an array containing the mantissa and exponent of a scientific notation.  
If you press Enter this function returns only the mantissa. If you select two cells and give the 
CTRL+SHIFT+ENTER sequence, you get both mantissa and exponent 
Note that, in the last case, you cannot convert directly into double (for example, using the 
VALUE function), even if the number of digits is less than 15. The exponent is too large for the 
standard double precision. 
Converting multiprecision into double 
=xcdbl(x)   
This function converts an extended number into standard double precision  
It can be nested with other functions and/or array-functions. 
Usually the extended numbers are too long for a compact visualization. So, after, the 
multiprecision computation, we would like to convert the result in a compact standard precision.  
For example, if you invert the matrix 
12 
-4 
using the multiprecision xMatInv function, you will get a matrix like the following 
0.3076923076923076923076923 
-0.02564102564102564102564103 
-0.1410256410256410256410256 
-0.2307692307692307692307692 
0.1025641025641025641025641 
0.06410256410256410256410256 
0.1538461538461538461538462 
-0.01282051282051282051282051 
0.05448717948717948717948718 
.NET Multipage TIFF SDK| Process Multipage TIFF Files
upload to SharePoint and save to PDF documents. Support for metadata reading & writing. com is professional .NET Document Imaging SDK and Java Document Imaging
pdf metadata editor; get pdf metadata
.NET Annotation SDK| Annotate, Redact Images
Automatically save annotations as the metadata of the document. Want to Try RasterEdge.com is professional .NET Document Imaging SDK and Java Document Imaging
extract pdf metadata; remove metadata from pdf online
Xnumbers Tutorial 
35 
If you use the functions xcdbl nested with the multiprecision function, the matrix will be 
rounded in standard precision and the output will have a more compact format 
Note that xcdbl affects only the output. The internal computing is always performed in 
multiprecision. 
Macros X-Edit 
These simple macros are very useful for manipulating extended numbers in the Excel 
worksheet. They perform the following operations: 
Format   
Separates groups of digits 
Unformat  
Removes the separator character 
Double Conversion 
Converts multiprecision numbers into standard double precision 
Round 
Rounding multiprecision numbers 
Relative Round 
Relative rounding multiprecision numbers 
Mop-Up 
Converts small numbers into 0 
From this menu you can also change the default Digit_Max parameter   
Using these macros is very simple. Select the range where you want to operate and then start 
the relative macro. They work only over cells containing only numeric values, extended or 
standard. Cells containing function are ignored 
Tip.  For stripping-out a formula from a cell and leaving its value, you can select the cell and 
then click in sequence   
(copy + paste values) 
Here are same little examples: 
Format - group 6
31415926.53589793238462643 
31,415926.535897,932384,62643 
19831415926.53589793238462 
⇒ 
19831,415926.535897,932384,62 
0.535897932384626433832734 
0.535897,932384,626433,832734 
Double Conversion
31415926.53589793238462643 
31415926.5358979 
19831415926.53589793238462 
⇒ 
19831415926.5358 
0.535897932384626433832734 
0.535897932384626 
Rounding  3 decimals.
31415926.53589793238462643 
31415926.536 
19831415926.53589793238462 
⇒ 
19831415926.536 
0.535897932384626433832734 
0.536 
Xnumbers Tutorial 
36 
Relative rounding - significant digits 15.
4.5399929762484851535591E-5 
4.53999297624849E-05 
1.0015629762484851535591E-6 
⇒ 
1.00156297624849E-06 
0.539929762484851535591E-12 
5.39929762484852E-13 
Mop-Up - Error limit 1E-15.
31415926.53589793238462643
31415926.53589793238462643 
-1.00E-15
⇒ 
0
5.78E-16
0
-1.40E-18
0
Note that the function mopup is used overall for improving the readability. The cells having 
values greater than the limit are not modified. 
Macro X-Converter 
This macro
1
(*) converts a well formed Excel formula to the equivalent  in terms of Xnumber 
multiprecision functions (xadd, xmult, etc.). 
The advantage over x-evaluate is that  the code can be debugged in normal excel using small 
values 
and in a familiar form. When the spreadsheet works it is ' converted to using nested x-calls for 
the precision work. The intention is to tag the conversion onto the copy worksheet function ' so 
that you end up with a multi-precision copy of the original. 
Its main features are: 
•  converts a range of cells directly on site or in a new worksheet. 
•  skips cells having functions not convertible.  
•  skips array functions except MINVERSE and MMULT that are substituted with the  
correspondent x-functions  xMatInv and xMatMult. 
•  Errors (if any ) are shown on the panel 
The digits parameter can be set in 4 different ways: 
1) an integer number i.e. 30  
2) a fixed reference of a cell, i.e. $A$1 
3) a name of a cell, i.e. "digits" 
4) simply nothing. In that case all the x-functions use the internal default = 30 
Of course not all the Excel Functions can be converted. The list of the Excel functions
2
converted is: 
* , / , + , - , ^ , ABS , ACOS , ACOSH , ASIN , ASINH , ATAN , ATANH , AVERAGE 
, COMBIN , COS , COSH , EXP , FACT , INT , LN , LOG , MDETERM , MINVERSE , 
MMULT , MOD , PI , PRODUCT , ROUND , SIN , SINH , SQRT , STDEV , STDEVP , SUM 
, TAN , TANH , TRUNC , VAR , VARP  
1
The conversion engine of this macro was originally developed by John Jones in an smart m4 macro language which 
makes the VB native j-code more simple (!) to write. It appears in this package thanks to his courtesy 
2
The functions are indicated with their original English names, that usually are different from the local names. 
Xnumbers Tutorial 
37 
Example. Assume to have an Excel formula in the cell B6 calculating the norm of a 3dim vector 
like the following worksheet. 
We would transform this formula into a multiprecision one using the x-functions of the 
Xnumbers add-in 
Select the cell B6 and start the macro X-Converter from the menu X-Edit 
Range to convert: the range containing the one or more formulas to convert 
Digit Parameter: specifies the global precision digits for all the functions under conversion. 
You can leave "(Default)" or blank meaning that all the function will use the internal default 
precision (usually 30 digits). But you can set a reference cell (example $A$1) where you have 
set your own precision. Or you can insert a name of a cell (example "mydigits") that you have 
defined. You can also insert directly a number (example 25) 
Output Option: sets the output where the multiprecision function will be copied. Select "on 
site" if we want to convert the formula directly in the selected cell. Select "new sheet" if we want 
to perform the conversion in a new worksheet. The original formula will be preserved. 
Let's select "on site" and click "run". The worksheet look will look like as the following 
As we can see the original standard formula 
=SQRT(B2+B3+B4)  
in cell B6 has been substituted with the multiprecision formula   
Xnumbers Tutorial 
38 
=xsqr(xadd(xadd(B2,B3),B4)).  
working with the default precision digits (30) 
Note that there are 3 nested functions in the converted formula.  
The maximum number of nested functions in Excel is 8. 
If an error raises during the cell conversion, the formula is left unchanged and the text is turned 
in red. The macro always shows a short list of the errors encountered during the conversion. 
The macro works also with a range selection  
Example. In the following worksheet we have same functions in the range A3:A18 
Note that the cell A18 contains the 
function COUNTA that are not the 
similar x-function 
Note that the range A14:A15 
contains an array function { ... }, 
thus the cells  A14 and A15 are 
inseparable. 
The cells A7 contain a simple 
constant 
We want to convert them, where possible, in a new worksheet without affect the original 
worksheet. 
For that, select all the range A3:A18 and start the X-Converter 
Select "new sheet" and click "run". The new worksheet look like as the following 
Note that the cell A7, A14, A15, A18 are unchanged 
Note that the original cells A9 = B7^12 and A13 =A11^2.6 having the same operator symbol 
"^", are substituted with two different x-functions: xpow for integer power and xexpa for float 
power. 
Xnumbers Tutorial 
39 
Statistical Functions 
Factorial 
xfact(n, [Digit_Max]) 
Returns the factorial of an integer number  xfact(n)= n!  
This example shows all 99 digits of 69! 
xfact(69, 100) = 711224524281413113724683388812728390922705448935203693936480-  
40923257279754140647424000000000000000 
If the parameter Digit_Max is less than 99, the function returns the approximate result in 
exponential format: 
xfact(69) = 1.71122452428141311372468338881E+98 
For large number (n>> 1000) you can use the faster function xGamma(x). The relation between 
the factorial and the gama function is: 
Γ(n)  =  (n-1)! 
Factorial with double-step 
xfact2(n, [Digit_Max])   
Returns the factorial with double step.   
if n is odd    ⇒  xfact2(n) = 1⋅3⋅5⋅7⋅9...n 
if n is even  ⇒  xfact2(n) = 2⋅4⋅6⋅8⋅ ...n 
Note: In many books, this function is indicate improperly as "double factorial", or - even worse - with the 
confusing symbol "!!".  
Combinations 
xComb(n, k, [Digit_Max])  
Returns the binomial coefficients, a combination of n, class k.  xcomb = C
n,k
The example below shows all the 29 digits of the combination of 100 objects grouped in class 
of 49 elements: 
xComb(100,49) = 98913082887808032681188722800 
Combinations of N = 100 
objects in class of 10, 20, … 
90 
Note the typical parabolic 
outline of the binomial 
coefficients 
For large argument (n and k >>1000) use the faster function xcomb_big(n,k) .  
Documents you may be interested
Documents you may be interested