how to display pdf file in c# : Export highlighted text from pdf Library control component .net web page windows mvc Excel39-part211

name Module1. Once a module exists, you can effortlessly switch between
spreadsheet and module, simply by clicking on their tabs. To summarize the
procedure for Excel 5 and Excel 95:
1 Open a new spreadsheet.
2 Make a new Module sheet with the regular menu sequence I
nsert M
acro
M
odule. An Insert dialog box will appear.
3 Alternatively, right-click on the tab at the bottom of your spreadsheet (most
likely labeled Sheet1) and in the resulting sub-menu click on Insert, on
Module, then on OK.
4 In either case you will see a blank sheet labeled Module1.
5 Verify that you can readily switch between Module1 and Sheet1 by clicking
on their tabs.
Starting with Excel 97, the modules are also stored together with the work-
book, but they are not as readily visible. To generate a new module in Excel
97, Excel 98, or Excel 2000 requires the command sequence T
ools M
acro
V
isual Basic Editor, followed by I
nsert M
odule. From then on, you can
switch between spreadsheet and module with Alt+F11 if your keyboard has
an F11 key. Otherwise, use F
ile C
lose and Return to Microsoft Excel (or Alt
+Q) to move from module to spreadsheet, and T
ools M
acro  V
isual
Basic Editor to get from spreadsheet to module. Unfortunately, you can no
longer use the spreadsheet tab to create or switch to a module. In summary,
starting with Excel 97 the corresponding procedure is as follows:
1 Open a new spreadsheet.
2 Select the VBA Editor with T
ools M
acro V
isual Basic Editor, which will
show you a screen with its left-hand side not just empty but dark, and with
its own menu bar.
3 Using that menu bar, select I
nsert M
odule. The dark space will become
white, and will be your module.
4 If your keyboard has an F11 key, verify that you can readily switch between
the module and the spreadsheet by clicking Alt+F11.
5 Also verify that you can switch from module1 to spreadsheet with
F
ileC
lose and Return to Microsoft Excel (or Alt+Q).
6 Once you have written a macro, you can also switch from the spreadsheet to
the macro module with T
ools M
acro M
acros (or Alt+F8), selecting the
macro by clicking on its name, and then depressing the E
dit key.
7 While testing and debugging a macro, it is convenient to use the function
key F5 to switch directly to the Macro dialog box, without leaving the VBA
editor.]
Writing macros usually involves making and correcting mistakes. The VBA
editor will catch quite a few syntax errorsas you write or modify the macro.
However, there are many errors the VBA editor cannot foresee, because they
depend on particular parameter values that are yet to be computed, such as
10.1 What is a macro?
377
Export highlighted text from pdf - extract text content from PDF file in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Feel Free to Extract Text from PDF Page, Page Region or the Whole PDF File
can't copy and paste text from pdf; cut and paste text from pdf document
Export highlighted text from pdf - VB.NET PDF Text Extract Library: extract text content from PDF file in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
How to Extract Text from PDF with VB.NET Sample Codes in .NET Application
copy paste text pdf file; extracting text from pdf
sqr(a) when abecomes negative. Such run-time errorstypically will throw
you back to the macro, where you can correct them if you can guess what the
(often rather cryptic) error message is trying to tell you.
But that is not all. Often, the corrected macro will refuse to run, and even
the macro icon will look funny. In that case, you may first need to resetthe
macro. You do this, in the VBA editor, with the command sequence R
un ⇒
R
eset or its shortcut, Alt+r, Alt+r. In order to simplify matters and save
time, it is often useful during testing and debugging to reset the macro rou-
tinely with the sequence Alt+r, Alt+r, F5.
This chapter will deal only with modules. Dialog sheets allows you to
design your own dialog boxes, which can give your macros a slick, profes-
sional-looking user interface. However, learning to construct functional
dialog  boxes  requires  a  substantial  investment  of  time  and  effort.
Fortunately, almost the same functionality can be obtained with simple
message and input boxes, which are much easier to program, and do not
require the use of dialog sheets. In the physical sciences, the emphasis is
usually on what a macro can do in terms of its mathematical prowess rather
than on its convenience of data entry, or on controlling data access. In this
book we will therefore leave dialog sheets alone. You, my reader, will judge
for yourself whether the worked-out macros described in this chapter would
have benefited from a more elaborate user interface. And if you feel strongly
about it, by all means learn how to design dialog boxes, and incorporate
them in your macros.
10.1b
Reading and modifying the contents of a single cell
As our introduction to using a macro we will write several macros and see
how they operate. As our first example we will take a highlighted cell and
readthe valueit contains. Open a new spreadsheet, open the Visual Basic
editor, insert a new module, and in it type:
'Read a cell value
Sub read()
myvalue = Selection.Value
MsgBox "The cell value is " & myvalue
End Sub
1 First we will explain, line-by-line, what these various instructions mean.
The first line (starting with an apostrophe) is a commentline; it is ignored
by the computer, and is purely for human consumption. In this case it
summarizes what the macro will do. The apostrophe always identifies that
what follows on that line (i.e., to the right of the apostrophe) is merely
comment, and should not be executed by the computer.
VBA will show comments in dark green, which on some monitor screens
may not show as significantly different from black. In that case you may
want to select bright green instead. Do this in the VBA editor with T
ools ⇒
378
Some useful macros
C# PDF Text Highlight Library: add, delete, update PDF text
etc. Able to remove highlighted text in PDF document in C#.NET. Support to change PDF highlight color in Visual C# .NET class. Able
a pdf text extractor; copying text from pdf into word
C# PDF Convert to Text SDK: Convert PDF to txt files in C#.net
Text in any fonts, colors and sizes, or highlighted characters are easy to be converted to plain text. Text can be extracted from scanned PDF image with OCR
copy text from encrypted pdf; copy text from pdf to word with formatting
O
ptions, in the Options dialog box select the Editor Format tab, C
ode
Colors, Comment Test, then select as Fo
reground the bright green strip.
Also select bright blue for the Keyword Text, then exit with OK.
2 The second line indicates the actual beginning of the macro. It always
starts with the word Sub, short for subroutine(a stand-alone program that
can beused as a module), and then gives it a name (here: “read”) to call it
by. The brackets are to specify any information that must be passed into
and out of the subroutine. A macro, which is a special type of subroutine,
has no such arguments, so the brackets enclose nothing, but they are
nonetheless required, as is the name.
3 The next line defines that myvalue(or any other name you might want to
give it) should contain the value shown in whatever cell you will select in
the spreadsheet. (This is merely a name, just as an unknown parameter
might be given the symbol xin an algebra problem, or a concentration the
symbol cor the name conc. In VBA one can use long, self-explanatory
names, algebra-like single-letter symbols, or anything in-between, as long
as the name starts with a letter, and contains neither empty spaces nor any
of the special characters ., !, #, $, %, or &. Long, composite names can be
made more easily readable with interspersed capitals, as in my Value, or
with underscores, as in my_value.
Whentheprogramencountersthelinemyvalue = Selection.Value,
itwillassigntotheparametercalledmyvaluethevalueitfindsinthehigh-
lightedcell.Youcanreadthelineas:assigntomyvaluetheValueproperty
fromtheSelection.ValueandSelectionaretermsthatVBArecognizes,
andassuchwillbeshownindarkblueonthemonitorscreen.Theywillalso
becapitalizedautomatically,evenifyoudon’t.
Next comes a check: the message box (which VBA spells as MsgBox) will
display the value to verify that it has been read correctly. Message boxes
are very useful for this purpose, especially during the debugging stage;
they can be removed (by deleting the entire line or, simpler, by preceding
them with an apostrophe ) after testing has shown that that particular
program segment works.
5 The final line lets the computer know that this is the end of the subroutine.
6 Now switch to the spreadsheet, fill several cells with numbers, or with for-
mulas that produce numerical values, and highlight one of them.
7 Select T
ools M
acro
8 In the resulting Macro dialog box you should see the macro name in the
large window. When you select it by clicking on it, the name of the macro
will also appear in the top window labeled M
acro Name/Reference. Then
click on the R
un button.
9 You should now see a message box that contains the text “The cell value is”
followed by the value read. For example, if you highlight a cell that con-
tains the value 3.456, then the message should read “The cell value is
3.456”. If you select a cell containing the formula=SQRT(9)+1.7 you
should see “The cell value is 4.7”, and so on.
10.1 What is a macro?
379
VB.NET PDF Convert to Text SDK: Convert PDF to txt files in vb.net
Plain text can get from any fonts, colors and sizes, or highlighted characters. Text extraction from scanned PDF image with OCR component in VB.NET.
extract text from pdf file; c# get text from pdf
10 The message box insists on being acknowledged, i.e., you mustclick on its
OK button before you can do anything else in the spreadsheet.
11 Try several cells, of varying content, and verify that the program works.
12 By assigning a function key to the macro you can avoid the rather labori-
ous procedure of steps 7 and 8 for calling it. In order to do so, again select
T
ools M
acro, and in the Macro dialog box click on “read” to select this
particular macro. (If a macro has already been selected, and you want
another macro, click on that one.) Now click on O
ptions; in the resulting
dialog box click in the small window for the Shortcut key, which should
now show a tick mark, then click in the window for Ct
rl+and enter the
letter z. (Any letter will do. However, in assigning letters to macros, avoid
those Ctrl-letter combinations that you may want to use for editing pur-
poses, such as Ctrl+x for cut, Ctrl+c for copy, and Ctrl+v for paste.)
Return to the main dialog box by clicking on the OK button, and execute
the macro by clicking on R
un. From now on, you can call the macro merely
by depressing the Ctrl key and, simultaneously, the z key (or whatever
other letter you assigned to the macro). Try it.
13 A macro can not only read information, it can also manipulate it. We will
demonstrate this by changing the value of the cell we have just read. To do
so, return to Module1, and modify the macro as shown below. For your
convenience, all new or modified lines are printed here in bold. (Such
boldfacing should not be entered in the macro; fortunately, it can’t.)
'Read and change a cell value
Sub read()
myvalue = Selection.Value
MsgBox "The cell value is " & myvalue
myvalue = myvalue + 4
Selection.Value = myvalue
End Sub
14 The line myvalue = myvalue + 4should not be taken literally, as in an
algebraic equation. Instead, it should be read as an assignment, in which
the value of the right-hand side is assigned to the parameter specified in
the left-hand part.
15 It clearly would have been preferable to write this line as myvalue⇐
myvalue + 4, i.e., with ⇐instead of an equal sign, but no corresponding
character was available on the teletypewriter keyboards for which the
early computer languages, including BASIC, were developed. A few
recently created computer languages indeed use the symbol :=which
somewhat resembles the back arrow ⇐and explicitly shows a directional-
ity. A few recent VBA instructions also use this symbol (which you will
encounter in, e.g., the syntax of input boxes), but most still employ the tra-
ditional BASIC assignment symbol=.
16 The next line again illustrates the directionality of the assignment. Unlike
an equality, which can be read from either side, Selection.Value =
myvaluewrites the value of myvalueover the earlier value, quite the
380
Some useful macros
opposite from the line myvalue = Selection.Value, which reads that
value but does not change anything. Again, the line should be read as if it
were printed as Selection.Value ⇐ myvalue, and the earlier line as
myvalue⇐Selection.Value.
17 Try the modified macro. When you select an empty cell, the message box
will report that it is empty, and thereafter the macro will add 4 to that value,
to give the cell the value 4; when you repeat the process with the same cell,
the macro will up the ante to 8, then to 12, and so on.
18 Modify the macro to perform another operation, such as a multiplication,
or whatever. Experiment with it.
19 It is often undesirable to overwrite an existing answer. We need not do that,
but instead can write the modified result somewhere else in the spread-
sheet, say immediately to the right of the highlighted cell, or just below it.
(Of course, if the latter cell already contains something, that will now be
overwritten, so be careful where you deposit the output of your macro.)
Modify the macro as follows, then test it.
'Read and change a cell value
Sub read()
myvalue = Selection.Value
MsgBox "The cell value is " & myvalue
myvalue = myvalue + 4
Selection.Offset(0,1).Select
Selection.Value = myvalue
End Sub
20 Thefirstnumberintheoffsetspecifiesthenumberofrowstobeshifted
(down),thesecondthenumberofcolumns(totheright).Wecanmovetwo
cellstotheleftwith,say,Offset(0,-2),onecelldownandtwototheleft
withOffset(1,-2),andsoon,providedthatthereisspacetogoto.Tryitout.
21 When the offset directs the result to a cell outside the spreadsheet, an error
message appears, warning you of a run-time error, i.e., of an error that
could not have been foreseen by the computer when it checked the
program (because, in this example, the program could not know at that
time what cell you were going to select) but that only occurred during the
executionof the macro. The message box that you will see actually
describes the error, albeit somewhat cryptically, as “Offset method of
Range class failed”. So now you know! Pressing G
oto will get you back to
Module1, and will highlight the offending instruction. Modify it to move to
the right and down, and verify that it is now working smoothly again. As
you can see from this example, program crashes in VBA are almost as
gentle as those in Excel, and the error messages only barely more informa-
tive.
Before you leave the VBA editor, you must 'reset' it. You can do this with
R
un ⇒R
eset, or with Alt+R, Alt+R. Only after that is done should you
return to the spreadsheet with Alt+F11. If you forget to reset the editor,
you can return to the spreadsheet but you cannot rerun the macro; in that
10.1 What is a macro?
381
case, go back to the VBA editor with Alt+F11, reset it, and return to the
spreadsheet.
22 We will now return to our rather simple first macro, and extend its useful-
ness by letting it read and display several self-explanatory properties of a
highlighted cell.
'Read the cell address, value and formula
Sub read()
myaddress = Selection.Address
MsgBox "The cell address is " & myaddress
myvalue = Selection.Value
MsgBox "The value is " & myvalue
myformula = Selection.Formula
MsgBox "The formula is " & myformula
End Sub
Return to the spreadsheet, select a cell, enter a formula in it, such as=
3.4+2*LOG(7) or whatever else suits your fancy, and test it.
23 This brings up a point worth mentioning here. Excel and Visual BASIC
grew up separately, and have only recently been linked. Some aspects of
the marriage still need to be ironed out. This is evident in the VBA math
functions. While most of these are the same in Excel and VBA, there are a
number of differences.
All VBA math functions are coded with three letters, while Excel func-
tions have no such constraints. Consequently, the sign of xis given by
sgn(x) in VBA, but by sign(x) in Excel; √xis sqr(x) in VBA, sqrt(x) in Excel; a
random number is generated in VBA with rnd(x), in Excel with rand( ); and
arctan(x) is specified by atn(x) in VBA but in Excel by atan(x). It is annoying
that the macro editor of Excel does not (also) accept the Excel functions, or
at least alerts the user to these spelling differences. It is outright confusing
when the meaning is changed: fix(x) in VBA does not always give the same
result as fixed(x,0) in Excel. The worst offender is log(x) which, in VBA, rep-
resents the natural, e-based logarithm, whereas in Excel (and in almost
everyone else's nomenclature) it is written as ln(x). VBA does not even
have a symbol for the 10-based logarithm, so that the 10-based
log(x)=ln(x)/ln(10) in Excel must be written in VBA as log(x)/log(10).
Sorry, even Bill Gates naps sometimes.
24 Try to fool the macro by entering a letter, word or sentence. The message
box will return the correct address, but will not be able to distinguish
between a value and a formula. Instead, in both cases it will merely repeat
the text it finds.
25 Note that, in reading a cell address, the macro editor automatically adds
dollar signs for absolute addressing.
10.1c
Reading and modifying the contents of a block of cells
We now extend the macro to read not just the contents of a single cell, but of
an entire, rectangular block of cells. Such a block constitutes an array, which
382
Some useful macros
can contain many different values and formulas. To test it we therefore
specify a particular cell in that array, as shown here.
'Read an array
Sub ReadArray1()
Dim myaddress As Variant, myvalue As Variant, myformula As Variant
myaddress = Selection.Address
MsgBox "The array covers the range " & myaddress
myvalue = Selection.Value
MsgBox "The value of cell (1,1) is " & myvalue(1,1)
MsgBox "The value of cell (3,2) is " & myvalue(3,2)
myformula = Selection.Formula
MsgBox "The formula in cell (1,1) is " & myformula(1,1)
MsgBox "The formula in cell (3,2) is " & myformula(3,2)
End Sub
1 This latest extension illustrates how a macro handles arrays. The array must
be dimensioned, i.e., the computer must be told to expect a multi-valued
parameterthat is organized in rows and/or columns. In VBA it is easiest to
dimension an array As Variant, which leaves its precise size and nature
unspecified. (The only disadvantage of always using As Variantis that it
is inefficient in terms of computer memory and execution speed.
Fortunately, with modern computers,we only need to consider those
factors in programs that involve rather large data arrays.)
2 Test this macro on an array of formulas, numbers, or text (i.e., one or more
letters, words, or sentences). Observe that it will return the address range
whether the cells involved are empty or not. It will return no information for
the value or formula of an empty cell (but that it comes up empty-handed
will stop neither the program nor the computer), and it obviously will not be
able to distinguish between a value and a formula when a cell merely con-
tains a number, or text. Still, where there is valid information to be had, the
macro will read it properly, and the message boxes will report it.
3 An array is always assumed to have two dimensions: rows, and columns.
Therefore, when you select a column, and want to read, say, the value in its
second cell, you must specify this cell as cell (2,1), even though there is
only one column. Likewise, in a single row, the fifth cell is identified as cell
(1,5)because this cell has the row index 1, and the column index 5.
The following macro demonstrates an even more extensive use of
messageboxes,and asimplificationinthatonlyoneArrayis used,which
canthenbeexaminedItembyItem.(NoteagainthatVBAconsidersevery-
thingtotherightofanapostropheasacomment.Forshortinstructionsand
comments, writing the comments tothe right of theinstructionleads to
compact yetvery readable code.) Enter this macro and testit ona small
samplearray.
Sub ReadArray2()
' defines macro and names it 
Dim Array As Variant
' dimensions the array
nr = Selection.Rows.Count
' counts the number of rows
MsgBox "The number of rows is " & nr 
' displays nr
10.1 What is a macro?
383
nc = Selection.Columns.Count
' counts the number of columns
MsgBox "The number of columns is " & nc ' displays nc
Array = Selection.Value
' selects highlighted array
MsgBox "The highlighted range is " & Selection.Address
MsgBox "The top left cell has the address " & 
Selection.Item(1, 1).Address
MsgBox "The top left cell contains the value " & 
Selection.Item(1, 1).Value
MsgBox "The top left cell contains the formula " & 
Selection.Item(1, 1).Formula
MsgBox "The bottom left cell has the address " & 
Selection.Item(nr, 1).Address
MsgBox "The bottom left cell contains the value " & 
Selection.Item(nr, 1).Value
MsgBox "The bottom left cell contains the formula " & 
Selection.Item(nr, 1).Formula
MsgBox "The bottom right cell has the address " & 
Selection.Item(nr, nc).Address
MsgBox "The bottom right cell contains the value " & 
Selection.Item(nr, nc).Value
MsgBox "The bottom right cell contains the formula " & 
Selection.Item(nr, nc).Formula
End Sub
In VBA, a space followed by an underscore indicates that the line is to be
continued. VBA can accommodate lines with up to 256 characters (includ-
ing spaces), but such long lines are difficult to print, or to read on a monitor
screen.
10.1d
Two di≈erent approaches to modifying a block of cells
As our last example in this section we will take a highlighted block of data,
and raise all of its elements to some power, for which we will here select 3.
(With an integer power it is somewhat easier to verify by simple inspection
that the macro works properly. However, you are free to pick any other
number, not necessarily either positive or integer.) Type the following
macro, give it a shortcut key, and test it.
'Cube all elements of an array
Sub Power()
For Each cell In Selection.Cells
cell.Value = cell.Value ^ 3
Next cell
End Sub
This example illustrates how easy it is to use a For Each … Next loopto
address all cells in a given, highlighted block, even without ever specifying it
as an array. The name 'cell' specifies the individual cells in the highlighted
block, and the loop addresses each of them in turn. (Any other name instead
of 'cell' would have worked just as well. You can see that 'cell' is not recog-
nized by the VBA compiler because it is not capitalized. (But “Cells” in
384
Some useful macros
“Selection.Cells” at the end of the third line is both required and recognized
by the compiler.)
For readers familiar with the way arrays are addressed in more traditional
languages such as FORTRAN or BASIC, the following, more conventional
macro would have achieved the same objective:
'Cube all elements of an array
Sub Power1()
Dim myArray As Variant
Dim rn As Integer, cn As Integer
myArray = Selection.Value
For rn = LBound(myArray, 1) To UBound(myArray, 1)
For cn = LBound(myArray, 2) To UBound(myArray, 2)
myArray(rn, cn) = myArray(rn, cn) ^ 3
Next cn
Next rn
Selection.Value = myArray
End Sub
1 The second dimension statement, “Dim rn As Integer, cn As Integer”, spec-
ifies that the parameters called rn and cn (for row number and column
number respectively) are integers. It is useful to dimension them as such,
because VBA treats integers quite differently from general numbers. When
no dimension is specified, VBA assumes by default that the parameter is As
Variant, its most flexible dimension. Note that a statement such as "Dim
rn, cn As Integer" might be misleading, because it is interpreted by VBA as
"Dim rn" followed by "Dim cn As Integer", so that it dimensions rn simply
by name (and therefore assigns it by default the dimension As Variant),
whereas it dimensions cn as an integer.
A parameter involved in specifying the cell coordinates in an array is
called an index; if there is any ambiguity about their nature, indices should
be declared as integers. (Special VBA functions such as LBound and
UBound, for lower bound and upper bound respectively, always specify
integers, and therefore need not be dimensioned as such.)
2 Below the assignment “Array=Selection.Value” we encounter two nested
For Next loops. In each loop a calculation is repeated a specified number of
times. In this example, each numerical value in the array is in turn raised to
its cube power (or to any other power we might have specified instead of
3). Incidentally, note that the indentation used facilitates our reading of
the macro, by showing what lines are involved in the two different loops.
3 In order to keep track of the various numbers to be cubed in the high-
lighted block, the inner loop (the three lines starting with “For cn=” and
ending with “Next cn”) calculates the cube of all numbers on a given row of
the highlighted area. The program determines the first and last column of
the array as LBound(Array, 2) and UBound(Array, 2) respectively, where
the 2 denotes that these are the Lower and Upper bounds of the columns.
(Array notation specifies rows first, then columns, so that rows are the first
array dimension, and columns its second dimension.)
10.1 What is a macro?
385
4 The outer loop (starting with “For rn=” and ending with “Next rn”) makes
sure that the calculation is then repeated for all elements of a given
column in the highlighted area, their row indices being specified by
LBound(Array, 1) To UBound(Array, 1), where 1 denotes the rows. Again,
the macro automatically determines the lower and upper bounds of the
highlighted area, so that you need not supply that information.
5 The next line, between “Next rn” and “End Sub”, assigns the (now altered)
values of Array to the Values of the Selection. In other words, this line
writes the results of the macro calculation back into the highlighted area,
thereby overwriting the original data.
6 It may be useful to dissect the macro Power1, because it contains five
common, distinctive parts of a well-written Excel macro:
a The first and last lines define the macro as such, and specify its name.
b Lines 2 and 3 specify the dimensions used.
c The fourth line assigns the values in the highlighted block to the array
called Array, i.e., it reads the selected data.
d The next five lines constitute the heart of the macro, because they are
the lines that specify the actual calculation. In fact, only the third one of
these five does the actual calculation; the others are needed to specify
which data should be cubed. Note that there is nothing special about
the particular mathematical operation (cubing) used here: any other
operation that can be coded in BASIC could have been used instead.
e Finally, the penultimate line writesthe results, in this case back into the
active block.
7 On the other hand, the macro Power dispenses with much of this, and
simply condenses steps (b) through (e) into a simple, single For Each …
Next loop.
8 Why discuss these two macros here, when they achieve the same purpose,
while one is so much simpler than the other? The reason is that they are
not quite equivalent. For an array of numbers, defined and stored as their
values, macros such as Power and Root are our first choice, since they are
indeed simpler to read as well as faster to execute. However, they have an
Achilles heel: since they modify one cell at the time, in an unspecified
order, they are not reliable when the cell values are mutually dependent.
9 For example, use two columns, A and B. Enter the value 1 in both cells A1
and B1. Enter the number 2 in cell A2, highlight cells A1 and A2, and drag
the cells down by their common handle to, say A10. On the other hand, in
cell B2 we deposit the instruction=B1+1, and then copy and paste this
into cells B3:B10. In both columns we will now see the sequence 1, 2, 3, …,
9, 10.
10 When we use Power on A1:A10 we will obtain 1, 8, 27, 64, 125, 216, 343, 512,
729, and 1000. However, when we use Power on B1:B10, we will instead get
the sequence 1, 8, 729, 3.89E+08, 5.89E+25, 2.04E+77, 8.49E+231 or
########, and from there on nonsense. Clearly, the macro calculates B2 as
23before it starts to compute the cube of B3, so that B3 at that time reads
386
Some useful macros
Documents you may be interested
Documents you may be interested