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
decrypt pdf password; pdf password security
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
decrypt pdf password online; decrypt pdf without password
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
AreSameNumber = True              'comparison.
End If                              'If n1, the number of interest, is
ElseIf ABS(n2) <= rel_diff Then       'zero, then compare n2 for size.
AreSameNumber = True
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.
Sub CheckSameNumber
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
Correct hexadecimal value.
FF
255
Correct hexadecimal value.
FFF
4095
Correct hexadecimal value.
FFFF
65535
Correct hexadecimal value.
FFFFF
1048575
Correct hexadecimal value.
FFFFFF
16777215
Correct hexadecimal value.
FFFFFFF
268435455
Correct hexadecimal value.
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
Correct hexadecimal value.
FE
254
Correct hexadecimal value.
FFE
4094
Correct hexadecimal value.
FFFE
65534
Correct hexadecimal value.
FFFFE
1048574
Correct hexadecimal value.
FFFFFE
16777214
Correct hexadecimal value.
FFFFFFE
268435454
Correct hexadecimal value.
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
Hexadecimal F is 15.
FF
255
Hexadecimal FF is 255.
FFF
4095
Hexadecimal FFF is 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
Hexadecimal E is 14.
105
Input
Output
Explanation
FE
254
Hexadecimal FE is 254.
FFE
4094
Hexadecimal FFE is 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
4.5. Number to string conversions
String conversion functions, shown in Table 31, change non-string data into strings. In OOo, text is stored as
Unicode version 2.0 values, providing good support for multiple languages. Each String variable can hold 
up to 65,535 characters. 
Table 31. String conversion functions.
Function
Description
Str
Convert from a number to a String with no localization.
CStr
Convert anything to a String. Numbers and dates are formatted based on locale.
Hex
Return the hexadecimal representation of a number as a String.
Oct
Return the octal representation of a number as a String.
4.6. Simple formatting
Use the CStr function to generally convert any type to a String. The returned value is dependent upon the 
input data type. Boolean values convert to the text “True” or “False.” Dates convert to the short date format 
used by the system. Numbers are converted to a string representation of the number. See Listing 85.
Listing 85. Output from CStr is locale specific; this is English (USA).
Dim n As Long, d As Double, b As Boolean
n = 999999999 : d = EXP(1.0) : b = False
Print "X" & CStr(b)  'XFalse
Print "X" & CStr(n)  'X999999999
Print "X" & CStr(d)  'X2.71828182845904
Print "X" & CStr(Now)'X06/09/2010 20:24:24 (almost exactly 7 years after 1
st
edition)
The CStr function performs simple number formatting with knowledge of the current locale. Simple 
conversion of a number to a string is done with Str. Although the Str function is designed to deal specifically
with numeric values, the output is very similar to CStr. When the Str function converts a number to a string, 
a leading space is always included for the sign of the number. A negative number includes the minus sign, 
and no leading empty space is present. A non-negative number, on the other hand, includes a leading empty 
space. The output of Str is not locale specific; a period is always used as the decimal separator. See Listing 
86.
Listing 86. Output from Str is not dependent upon locale.
Dim n As Long, d As Double, b As Boolean
n = 999999999 : d = EXP(1.0) : b = False
Print "X" & Str(b)  'XFalse
Print "X" & Str(n)  'X 999999999
Print "X" & Str(d)  'X 2.71828182845904
Print "X" & Str(Now)'X06/09/2010 20:28:48 (almost exactly 7 years after 1
st
edition)
The output from the code in Listing 85 and Listing 86 is the same except for a leading space in front of the 
non-negative numbers. If you run the code using a different locale, such as Germany, the output changes for
Listing 85 but not Listing 86.
TIP
There is little reason to use Str rather than CStr. Str may run a bit faster, but CStr knows about your current 
locale.
107
Documents you may be interested
Documents you may be interested