﻿
The simple macro in Listing 70 demonstrates this problem. The value 0.2 is repeatedly added to the variable
num until the value is equal to 5. If infinite precision were used, or if the number 0.2 were exactly
represented inside the computer, the loop would stop with the variable num containing the value 5. The
variable never precisely equals the value 5, however, so the loop never stops. The value 5 is printed, but this
is only because the Print statement rounds 4.9999999 to the value 5 when it prints the number.
Listing 70. Rounding errors and finite precision prevent this from stopping.
Dim num As Single
Do
num = num + 0.2
If num > 4.5 Then Print num  'prints 4.6, 4.8, 5, 5.199999...
Loop Until num = 5.0
Print num
Computers use complex rounding algorithms in an attempt to reduce the impact of finite precision — finite
precision means that a finite number of digits and storage are used to represent a number. Although this
helps, Listing 70 clearly demonstrates that the internal complex rounding algorithms do not solve the
problem. When you compare two floating-point numbers to see if they are equal, it is safer to compare them
to a range of values. The code in Listing 71 stops when the variable is greater than or equal to 5.
Listing 71. Avoid rounding errors by using >= (greater than or equal to).
Dim num As Single
Do
num = num + 0.2
Loop Until num >= 5.0
Print num  '5.199999
The code in Listing 71 works to some extent, but you probably want the loop to exit when the variable num
is 4.9999999 rather than when it is 5.199999. You can do this by checking to see if two numbers are close
rather than equal. The big question is, How close must two numbers be before they are considered equal?
You can usually make a simple guess based on what you know about the problem. Single-precision variables
can represent about eight digits of precision. Double-precision variables can represent about 16 digits of
precision. Don’t try to demand more precision from the variables than they support. The code in Listing 71
uses single-precision variables so you can expect roughly seven digits of precision. The code in Listing 72
prints the difference between 5 and num — notice that about six digits are correct.
Listing 72. Compare the variable to a range.
Dim num As Single
Do
num = num + 0.2
Loop Until 4.99999 < num AND num < 5.00001
Print 5 - num  '4.76837158203125E-07  = 0.000000476837158203125
The ABS function returns the absolute value of a number. You can use it to simplify the process of checking
to see how close one number is to another.
If ABS(num - 5) < 0.00001 Then
Using ABS and subtraction indicates how close two numbers are to each other, but it may not be sufficient.
For example, light travels at about 299,792,458 meters each second. This number contains nine digits. A
single-precision number is  accurate to about seven digits. See Listing 73.
Listing 73. Single-precision variables have only seven or eight digits of accuracy.
Dim c1 As Single  'Scientists usually use the letter c to represent
Dim c2 As Single  'the speed of light.
98
Pdf secure - C# PDF Digital Signature Library: add, remove, update PDF digital signatures in C#.net, ASP.NET, MVC, WPF
Help to Improve the Security of Your PDF File by Adding Digital Signatures
Pdf secure - VB.NET PDF Digital Signature Library: add, remove, update PDF digital signatures in vb.net, ASP.NET, MVC, WPF
Guide VB.NET Programmers to Improve the Security of Your PDF File by Adding Digital Signatures
c1 = 299792458    'Speed of light in meters per second to nine digits
c2 = c1 + 16      'Add 16 to the speed of light
If c1 = c2 Then   'These are equal because only the first seven
Print "Equal"   'or eight digits are significant
End If
The code in Listing 73 adds 16 to the speed of light, but this does not change the value. This is because only
the first seven or eight digits are significant. The code in Listing 74 uses a number that is smaller in
magnitude but uses the same number of digits. Adding 1 to the number would change a significant digit, but
adding a smaller number still leaves the numbers equal.
Listing 74. Single-precision variables have only seven or eight digits of accuracy.
Dim c1 As Single   'Scientists usually use the letter c to represent
Dim c2 As Single   'the speed of light.
c1 = 299.792458    'This is nine digits but it is not the speed of light
c2 = c1 + .0000016 'Must add a smaller number for them to still be equal
If c1 = c2 Then    'These are equal because only the first seven
Print "Equal"    'or eight digits are significant
End If
Floating-point numbers can have different magnitudes — magnitude refers to the size of the number — and
it doesn’t significantly affect the number of digits that are relevant. To check if two numbers are about the
same value, large numbers can differ by a greater amount than small numbers. The greatest allowed
difference is dependent upon the magnitude (size) of the numbers; a mathematician calls this the “relative
error.” See Listing 75.
Listing 75. Compare two numbers.
REM This uses n1 as the primary number of interest
REM n2 is compared to n1 in a relative way
REM rel_diff is the desired relative difference
REM rel_diff is assumed non-negative
Function AreSameNumber(n1, n2, rel_diff) As Boolean
AreSameNumber = False                 'Assume that they are different
If n1 <> 0 Then                       'Cannot divide by n1 if it is zero
If ABS((n1-n2)/n1) <= rel_diff Then 'Divide difference by n1 for relative
End If                              'If n1, the number of interest, is
ElseIf ABS(n2) <= rel_diff Then       'zero, then compare n2 for size.
End If
End Function
The code in Listing 75 divides the difference of two numbers by one of the numbers. The code in Listing 76
checks numbers of different sizes to see if they are the same number.
Listing 76. Test if same number.
Dim s1 As Single
Dim s2 As Single
Print AreSameNumber(299792458, 299790000, 1e-5)  'True: five digits same
Print AreSameNumber(299792458, 299700000, 1e-5)  'False: four digits same
s1 = 299792458                                   's1 assigned different value
s2 = 299792448                                   'than s2 but same number.
Print AreSameNumber(s1, s2, 0.0)     'True: Same number in single precision.
Print AreSameNumber(299.792458, 299.790000, 1e-5)'True: five digits same
99
Online Remove password from protected PDF file
can receive the unlocked PDF by simply clicking download and you are good to go! Web Security. When you upload a file it is transmitted using a secure connection
pdf security remover; convert locked pdf to word online
Online Change your PDF file Permission Settings
can receive the locked PDF by simply clicking download and you are good to go!. Web Security. When you upload a file it is transmitted using a secure connection
pdf password encryption; change pdf security settings
Print AreSameNumber(2.99792458, 2.99700000, 1e-5)'False: four digits same
End Sub
A large quantity of literature and research is available on the negative issues associated with floating-point
numbers. A complete discussion is therefore well beyond the scope of this book. In general usage, the
problems typically aren’t that troublesome, but, when they arise, they can be most perplexing if you aren’t
aware of the issues.
4.3. Mathematical functions
The mathematical functions in OOo Basic take a numeric argument. All of the standard types are converted
to a Double before they are used. Strings may include hexadecimal and octal numbers. The functions are the
same as those available in Visual Basic (see Table 26).
Table 26. Mathematical functions supported by OOo Basic.
OOo Basic
VB
VB .NET
Return Value
ABS
ABS
Math.Abs
The absolute value of a specified number.
Exp
Exp
Math.Exp
The base of natural logarithms raised to a power.
Log
Log
Math.Log
The logarithm of a number. In VB .NET you can overload this method
to return either the natural (base e) logarithm or that of a specified base.
Sgn
Sgn
Math.Sign
Integer value indicating the sign of a number.
Sqr
Sqr
Math.Sqrt
The square root of a number.
Use the ABS function to determine the absolute value of a number, which you can think of as simply
throwing away the leading + or - sign from the front of the number. The geometrical definition of ABS(x) is
the distance from x to 0 along a straight line.
ABS(23.33) = 23.33
ABS(-3)    = 3
ABS("-1")  = 1  'Notice that the string value "-1" is converted to a Double
Use the Sgn function to determine the sign of a number. An integer with the value -1, 0, or 1 is returned if
the number is negative, zero, or positive.
Sgn(-37.4) = -1
Sgn(0)     =  0
Sgn("4")   =  1
The square root of 9 is 3, because 3 multiplied by 3 is 9. Use the Sqr function to get the square root of a
number. The Sqr function can’t calculate the square root of a negative number — attempting to do so causes
a run-time error.
Sqr(100) = 10
Sqr(16)  = 4
Sqr(2)   = 1.414213562371
Logarithms were devised by John Napier, who lived from 1550 through 1617. Napier devised logarithms to
simplify arithmetic calculations, by substituting addition and subtraction for multiplication and division.
Logarithms have the following properties:
Log(x*y) = Log(x) + Log(y)
Log(x/y) = Log(x) - Log(y)
Log(x^y) = y * Log(x)
100
C# PDF Library SDK to view, edit, convert, process PDF file for C#
XDoc.PDF SDK provides users secure methods to protect PDF document. C# users can set password to PDF and set PDF file permissions to protect PDF document.
copy text from locked pdf; change pdf document security properties
C# HTML5 PDF Viewer SDK to view, annotate, create and convert PDF
C#.NET: Edit PDF Password in ASP.NET. RaterEdge HTML5 PDF Editor also provides C#.NET users secure solutions for PDF document protection.
decrypt pdf file; create pdf the security level is set to high
The Exp function is the inverse of the Log function. For example, Exp(Log(4)) = 4 and Log(Exp(2)) = 2. By
design, logarithms turn multiplication problems into addition problems. This allows the use of logarithms as
they were originally designed.
Print Exp(Log(12) + Log(3)) '36 = 12 * 3
Print Exp(Log(12) - Log(3)) ' 4 = 12 / 3
Logarithms are defined by the equation y=b^x. It is then said that the logarithm, base b, of y is x. For
example, the logarithm base 10, 10^2 = 100 so the logarithm, base 10, of 100 is 2. The natural logarithm,
with a base approximated by e=2.71828182845904523536, is frequently used because it has some nice
mathematical properties. This is called the “natural logarithm” and is used in OOo Basic. Visual Basic .NET
allows you to calculate logarithms of other bases. This is easily done using the formula that the logarithm
base b is given by Log(x)/Log(b), regardless of the base of the logarithm that is used.
Logarithms are not as useful as a general shortcut for calculations today, when lots of computing power is
available. However, the logarithmic relationship describes the behavior of many natural phenomena. For
example, the growth of populations is often described using logarithms, because geometric growth
expressed on a logarithmic graph displays as a straight line. Exponentials and logarithms are also used
extensively in engineering computations that describe the dynamic behavior of electrical, mechanical, and
chemical systems.
The macro in Listing 77 calculates the logarithm of the number x (first argument) to the specified base b
(second argument). For example, use LogBase(8, 2) to calculate the log, base 2, of 8 (the answer is 3).
Listing 77. LogBase.
Function LogBase(x, b) As Double
LogBase = Log(x) / Log(b)
End Function
4.4. Numeric conversions
OOo Basic tries to convert arguments to an appropriate type before performing an operation. However, it is
safer to explicitly convert data types using conversion functions, as presented in this chapter, than to rely on
the default behavior, which may not be what you want. When an Integer argument is required and a floating-
point number is provided, the default behavior is to round the number. For example, 16.8 MOD 7 rounds
16.8 to 17 before performing the operation. The Integer division operator, however, truncates the operands.
For example, “Print 4 \ 0.999” truncates 0.999 to 0, causing a division-by-zero error.
There are many different methods and functions to convert to numeric types. The primary conversion
functions convert numbers represented as strings based on the computer’s locale. The conversion functions
in Table 27 convert any string or numeric expression to a number. String expressions containing
hexadecimal or octal numbers must represent them using the standard OOo Basic notation. For example, the
hexadecimal number 2A must be represented as “&H2A”.
Table 27. Convert to a numerical type.
Function
Type
Description
CByte(expression)
Byte
Round the String or numeric expression to a Byte.
CCur(expression)
Currency
Convert the String or numeric expression to a Currency. The locale settings are
used for decimal separators and currency symbols.
CDec(expression)
Decimal
Generate a Decimal type; implemented only on Windows.
CInt(expression)
Integer
Round the String or numeric expression to the nearest Integer.
CLng(expression)
Long
Round the String or numeric expression to the nearest Long.
101
C# Create PDF Library SDK to convert PDF from other file formats
& thread-safe .NET solution which provides a reliable and quick approach for C# developers to create a highly-secure and industry-standard PDF document file.
cannot print pdf security; decrypt pdf
PDF Image Viewer| What is PDF
information; Royalty-free to develop PDF compatible software; Open standard for more secure, dependable electronic information exchange.
change pdf document security; create encrypted pdf
Function
Type
Description
CDbl(expression)
Double
Convert a String or numeric expression to a Double.
CSng(expression)
Single
Convert a String or numeric expression to a Single.
The functions that return a whole number all have similar behavior. Numeric expressions are rounded rather
than truncated. A string expression that does not contain a number evaluates to zero. Only the portion of the
string that contains a number is evaluated, as shown in Listing 78.
Listing 78. CInt and CLng ignore non-numeric values.
Print CInt(12.2)      ' 12
Print CLng("12.5")    ' 13
Print CInt("xxyy")    '  0
Print CLng("12.1xx")  ' 12
Print CInt(-12.2)     '-12
Print CInt("-12.5")   '-13
Print CLng("-12.5xx") '-13
CLng and CInt have similar, but not identical, behavior for different types of overflow conditions. Decimal
numbers in strings that are too large cause a run-time error. For example, CInt("40000") and
CLng("999999999999") cause a run-time error, but CLng("40000") does not. CLng never causes an
overflow if a hexadecimal or octal number is too large; it silently returns zero without complaint. CInt,
however, interprets hexadecimal and octal numbers as a Long and then converts them to an Integer. The
result is that a valid Long generates a run-time error when it is converted to an Integer. A hexadecimal value
that is too large to be valid returns zero with no complaints and then is cast to an Integer (see Listing 79).
Listing 79. CInt interprets the number as a Long, then converts to an Integer.
Print CLng("&HFFFFFFFFFFE")  '0  Overflow on a Long
Print CInt("&HFFFFFFFFFFE")  '0  Overflow on a Long then convert to Integer
Print CLng("&HFFFFE")        '1048574
Print CInt("&HFFFFE")        'Run-time error, convert to Long then overflow
The code in Listing 80 converts numerous hexadecimal numbers to a Long using CLng. See Table 28 for an
explanation of the output in Listing 80.
Listing 80. ExampleCLngWithHex.
Sub ExampleCLngWithHex
On Error Resume Next
Dim s\$, i%
Dim v()
v() = Array("&HF",     "&HFF",     "&HFFF",     "&HFFFF",_
"&HFFFFF", "&HFFFFFF", "&HFFFFFFF", "&HFFFFFFFF",_
"&HFFFFFFFFF",_
"&HE",      "&HFE",     "&HFFE",     "&HFFFE",_
"&HFFFFE",  "&HFFFFFE", "&HFFFFFFE", "&HFFFFFFFE",_
"&HFFFFFFFFE")
For i = LBound(v()) To UBound(v())
s = s & i & " CLng(" & v(i) & ") = "
s = s & CLng(v(i))
s = s & CHR\$(10)
Next
MsgBox s
End Sub
102
C# PowerPoint - PowerPoint Creating in C#.NET
SDK for .NET, is a robust & thread-safe .NET solution which provides a reliable and quick approach for C# developers to create a highly-secure and industry
add security to pdf document; change security on pdf
C# Word - Word Creating in C#.NET
Word SDK for .NET, is a robust & thread-safe .NET solution which provides a reliable and quick approach for C# developers to create a highly-secure and industry
decrypt pdf with password; decrypt pdf online
Table 28. Output from Listing 80 with explanatory text.
Input
CLng
Explanation
F
15
FF
255
FFF
4095
FFFF
65535
FFFFF
1048575
FFFFFF
16777215
FFFFFFF
268435455
FFFFFFFF
??
Should return -1, but may cause a run time error on 64-bit versions.
FFFFFFFFF
0
Overflow returns zero; this is nine hexadecimal digits.
E
14
FE
254
FFE
4094
FFFE
65534
FFFFE
1048574
FFFFFE
16777214
FFFFFFE
268435454
FFFFFFFE
ERROR
Run time error, used to return -2.
FFFFFFFFE
0
Overflow returns zero; this is nine hexadecimal digits.
When writing numbers, you don’t need to include leading zeros. For example, 3 and 003 are the same
number. A Long Integer can contain eight hexadecimal digits. If only four digits are written, you can assume
there are leading zeros. When the hexadecimal number is too large for a Long, a zero is returned. The
negative numbers are just as easily explained. The computer’s internal binary representation of a negative
number has the first bit set. The hexadecimal digits 8, 9, A, B, C, D, E, and F all have the high bit set when
represented as a binary number. If the first hexadecimal digit has the high bit set, the returned Long is
negative. A hexadecimal number is positive if it contains fewer than eight hexadecimal digits, and it is
negative if it contains eight hexadecimal digits and the first digit is 8, 9, A, B, C, D, E, or F. Well, this used
to be true.
TIP
In 64-bit versions of OOo, CLng generate an error for negative numbers represented as Hexadecimal!
Hopefully this will be fixed. Here are two tests that I expect to print -1. Note: I last tested with OOo
version 3.3.0 and LO 4.0.1.2.
print &HFFFFFFFF
print CLng("&HFFFFFFFF")  ' Generates an error
The CByte function has the same behavior as CInt and CLng, albeit with a few caveats. The return type,
Byte, is interpreted as a character unless it is explicitly converted to a number. A Byte is a Short Integer that
uses only eight bits rather than the 16 used by an Integer.
Print CByte("65")         'A has ASCII value 65
Print CInt(CByte("65xx")) '65 directly converted to a number.
103
C# Word - Word Create or Build in C#.NET
a robust & thread-safe .NET solution which provides a reliable and quick approach for C# developers to create a highly-secure and industry Create Word From PDF.
decrypt pdf file online; pdf encryption
RasterEdge.com General FAQs for Products
not the product end user, please copy and email the secure download link are dedicated to provide powerful & profession imaging controls, PDF document, image
pdf security password; convert secure pdf to word
TIP
An integer in VB .NET is equivalent to an OOo Basic Long.
VB uses different rounding rules. Numbers are rounded to the nearest even number when the decimal point
is exactly 0.5; this is called IEEE rounding.
The functions that return a floating-point number all have similar behavior. Numeric expressions are
converted to the closest representable value. Strings that contain non-numeric components generate a run-
time error. For example, CDbl(“13.4e2xx”) causes a run-time error. CDbl and CSng both generate a run-
time error for hexadecimal and octal numbers that are too large.
Listing 81. CSng and CDbl handle string input.
Print CDbl(12.2)      ' 12.2
Print CSng("12.55e1") ' 125.5
Print CDbl("-12.2e-1")'-1.22
Print CSng("-12.5")   '-12.5
Print CDbl("xxyy")    ' run-time error
Print CSng("12.1xx")  ' run-time error
The functions CDbl and CSng both fail for string input that contains non-numeric data; the Val function does
not. Use the Val function to convert a string to a Double that may contain other characters. The Val function
looks at each character in the string, ignoring spaces, tabs, and new lines, stopping at the first character that
isn’t part of a number. Symbols and characters often considered to be parts of numeric values, such as dollar
signs and commas, are not recognized. The function does, however, recognize octal and hexadecimal
numbers prefixed by &O (for octal) and &H (for hexadecimal).
The Val function treats spaces differently than other functions treat spaces; for example, Val(“  12    34”)
returns the number 1234; CDbl and CSng generate a run-time error, and CInt returns 12 for the same input.
Listing 82. Treatment of spaces is different.
Sub NumsAreDifferent
On Error GoTo ErrorHandler:
Dim s\$
s = "Val(""  12  34"") = "
s = s & Val( 12    34")
s = s & CHR\$(10) & "CInt(""  12  34"") = "
s = s & CInt("  12    34")
s = s & CHR\$(10) & "CLng(""  12  34"") = "
s = s & CLng("  12    34")
s = s & CHR\$(10) & "CSng(""  12  34"") = "
s = s & CSng("  12    34")
s = s & CHR\$(10) & "CDbl(""  12  34"") = "
s = s & CDbl("  12    34")
MsgBox s
Exit Sub
ErrorHandler:
s = s & " Error: " & Error
Resume Next
End Sub
TIP
The Val function does not use localization while converting a number so the only recognized decimal
separator is the period; the comma can be used as a group separator but is not valid to the right of the
decimal. Use CDbl or CLng to convert numbers based on the current locale. In case you forgot, the locale
is another way to refer to the settings that affect formatting based on a specific country. See Listing 83.
104
Listing 83. The Val function is the inverse of the Str function.
Sub ExampleVal
Print Val(" 12 34")  '1234
Print Val("12 + 34") '12
Print Val("-1.23e4") '-12300
Print Val(" &FF")    '0
Print Val(" &HFF")   '255
Print Val("&HFFFF")  '-1
Print Val("&HFFFE")  '-2
Print Val("&H3FFFE") '-2, yes, it really converts this to -2
Print Val("&HFFFFFFFFFFFFF") '-1
End Sub
As of version 1.1.1, the behavior of the Val function while recognizing hexadecimal or octal numbers is
strange enough that I call it a bug. Internally, hexadecimal and octal numbers are converted to a 32-bit Long
Integer and then the least significant 16 bits are converted to an Integer. This explains why in Listing 83 the
number H3FFFE is converted to -2, because only the least significant 16 bits are recognized — in case you
forgot, this means the rightmost four hexadecimal digits. This strange behavior is demonstrated in Listing
84. The output is explained in Table 29.
Listing 84. ExampleValWithHex.
Sub ExampleValWithHex
Dim s\$, i%
Dim l As Long
Dim v()
v() = Array("&HF",     "&HFF",     "&HFFF",     "&HFFFF",_
"&HFFFFF", "&HFFFFFF", "&HFFFFFFF", "&HFFFFFFFF",_
"&HFFFFFFFFF",_
"&HE",      "&HFE",     "&HFFE",     "&HFFFE",_
"&HFFFFE",  "&HFFFFFE", "&HFFFFFFE", "&HFFFFFFFE",_
"&HFFFFFFFFE", "&H111111111", "&H1111")
For i = LBound(v()) To UBound(v())
s = s & "Val(" & v(i) & ") = " & Val(v(i)) & CHR\$(10)
Next
'This worked in OOo 2.x, but, it
' fails in OOo 3.2.1
'l = "&H" & Hex(-2)
s = s & CHR\$(10) & "Hex(-1) = " & Hex(-1) & CHR\$(10)
s = s & "Hex(-2) = " & Hex(-2) & CHR\$(10)
's = s & "l = &H" & Hex(-2) & " ==> " & l & CHR\$(10)
MsgBox s
End Sub
Table 29. Output from Listing 84 with explanatory text.
Input
Output
Explanation
F
15
FF
255
FFF
4095
FFFF
-1
Hexadecimal FFFF is -1 for a 16-bit (two-byte) integer.
FFFFF
-1
Only the rightmost two bytes (four characters) are recognized.
E
14
105
Input
Output
Explanation
FE
254
FFE
4094
FFFE
-2
Hexadecimal FFFE is -2 for a 16-bit (two-byte) integer.
FFFFE
-2
Only the rightmost two bytes are recognized.
FFFFFE
-2
Only the rightmost two bytes are recognized.
FFFFFFE
-2
Only the rightmost two bytes are recognized.
FFFFFFFE
-2
Only the rightmost two bytes are recognized.
HFFFFFFFFE
-2
Only the rightmost two bytes are recognized.
111111111
4639
Correct value, right most two bytes only.
1111
4639
Correct value
Val converts hexadecimal numbers, but, it only uses the rightmost two bytes.
Use the functions CByte, CInt, CLng, CSng, and CDbl to convert a number, string, or expression to a
specific numeric type. Use the functions Int and Fix to remove the decimal portion and return a Double. A
string expression that does not contain a number evaluates to zero. Only the portion of the string that
contains a number is evaluated. See Table 30.
Table 30. Remove the decimal portion of a floating-point number.
Function
Type
Description
Int
Double
Round the number toward negative infinity.
Fix
Double
Chop off the decimal portion.
The functions Int and Fix differ only in their treatment of negative numbers. Fix always discards the
decimal, which is equivalent to rounding toward zero. Int, on the other hand, rounds toward negative
infinity. In other words, “Int(12.3)” is 12 and “Int(-12.3)” is -13.
Print Int(12.2)     ' 12
Print Fix(12.2)     ' 12
Print Int("12.5")   ' 12
Print Fix("12.5")   ' 12
Print Int("xxyy")   '  0
Print Fix("xxyy")   '  0
Print Int(-12.4)    '-13
Print Fix(-12.4)    '-12
Print Fix("-12.1xx")'-12
Print Int("-12.1xx")'-13
The CCur function converts a numerical expression to a currency object. Visual Basic .NET removed
support for the CCur function as well as the Currency data type. OOo Basic still supports the Currency data
type.
106