a.
You can refer to a particular branch by its name, as in  hild ranches(“Win”). 
b.
Alternatively, you can use the Add method to add a new branch, as in 
hild ranches.Add(“Win”,PTFirst ranch). The first argument is the name you give to the 
branch, and the second argument (one of two optional arguments) indicates that this 
will be the top branch out of this node. 
4.
Each branch—technically a PTDecisionTreeBranch object—has a DestinationNode property that 
returns the node to the right of this branch. It also has a SourceNode property that returns the 
node from which the branch emanates. 
5.
Each node and branch has a Name property for labeling. Note: Many trees use the same name, 
such as Drill Decision, for multiple nodes or branches. If you plan to refer to these by name in 
your code, it is best to give them distinct names, such as Drill Decision 1, Drill Decision 2, and so 
on, to avoid ambiguity. 
6.
Each decision and chance branch has a BranchValueCell property, followed by a Value property. 
This specifies the value (usually monetary) on the branch, as in BranchValueCell.Value = 1000. 
7.
Each chance branch also has a BranchSelectorCell property, followed by a Value property. This 
specifies the probability on a chance branch, as in BranchSelectorCell.Value = 0.35. 
The following macro, taken from the example file PrecisionTree XDK – Creating Tree 1.xlsm, illustrates 
how these guidelines can be used to create a simple tree with one decision node (the root node), two 
decision branches, a chance node after the first decision branch, and two chance branches from the 
chance node. Again, if you visualize the tree, the code is quite straightforward. The resulting decision 
tree appears in Figure 6. 
Sub CreateTree() 
' Make a new tree starting at the cell B2 in the Tree worksheet 
With PrecisionTree.ModelWorkbook.DecisionTrees _ 
.Add(wsTree.Range("B2"), , "Simple Gamble") 
With .rootNode 
' Single decision node 
.ChangeNodeType PTTreeDecisionNode 
.Name = "Gamble?" 
' First decision: gamble 
With .ChildBranches.Add("Yes", PTFirstBranch) 
' Pay 100 to play 
.BranchValueCell.Value = -100 
' Two possible outcomes: win 5000 or lose 1000 
With .DestinationNode 
.ChangeNodeType PTTreeChanceNode 
.Name = "Win?" 
With .ChildBranches.Add("Yes", PTFirstBranch) 
.BranchSelectorCell.Value = 0.2 
.BranchValueCell = 5000 
End With 
With .ChildBranches.Add("No", PTLastBranch) 
.BranchSelectorCell.Value = 0.8 
.BranchValueCell = -1000 
End With 
End With 
End With 
' Second decision: don't gamble, no gain, no loss 
.ChildBranches.Add "No", PTLastBranch 
End With 
End With 
End Sub 
Pdf find text - search text inside PDF file in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Learn how to search text in PDF document and obtain text content and location information
how to make pdf text searchable; how to search text in pdf document
Pdf find text - VB.NET PDF Text Search Library: search text inside PDF file in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Learn How to Search Text in PDF Document and Obtain Text Content and Location Information in VB.NET application
can't select text in pdf file; pdf find and replace text
Figure 6 Simple Gamble 
You can also use VBA to change an existing tree. As an example, the following macro, also taken from 
the file PrecisionTree XDK – Creating Tree 1.xlsm, can be used to change the values and probabilities in 
the Simple Gamble tree shown in Figure 6. Note that the code tries to reference a “Simple Gamble” tree 
in the With line. If there is no such tree, the macro exits with a message to this effect. Otherwise, it 
makes changes to the existing tree. Also, note that there is a Nodes collection object for the entire tree, 
so that you can get to a particular node by referencing its name. However, there is no Branches 
collection object for the entire tree, so to get to any branch, you have to reference the node from which 
the branch emanates. (There are other ways to get to a branch, but this is probably the most 
straightforward.) 
Sub ChangeTree1() 
' Quit if there is no such tree 
On Error GoTo exitPoint 
With PrecisionTree.ModelWorkbook.DecisionTrees("Simple Gamble") 
' Change cost of playing 
.rootNode.ChildBranches("Yes").BranchValueCell.Value = -50 
' Change probabilities of winning and losing 
.Nodes("Win?").ChildBranches("Yes").BranchSelectorCell.Value = 0.1 
.Nodes("Win?").ChildBranches("No").BranchSelectorCell.Value = 0.9 
End With 
Exit Sub 
exitPoint: 
MsgBox "There is no tree to change.", vbInformation 
End Sub 
The following macro, again from the file PrecisionTree XDK – Creating Tree 1.xlsm, illustrates another 
possible change. Now the signs of all monetary values are changed, and the OptimumPath property of 
the tree is changed to PTMinimumPayoff. This creates a tree that is equivalent to the original tree, but 
with a “minimize expected cost” criterion. 
Sub ChangeTree2() 
' Quit if there is no such tree 
On Error GoTo exitPoint 
With PrecisionTree.ModelWorkbook.DecisionTrees("Simple Gamble") 
' Change so that expected cost is minimized 
.OptimumPath = PTMinimumPayoff 
' Change sign of cost of playing 
.rootNode.ChildBranches("Yes").BranchValueCell.Value = 100 
' Change signs of values from winning and losing 
.Nodes("Win?").ChildBranches("Yes").BranchValueCell.Value = -5000 
.Nodes("Win?").ChildBranches("No").BranchValueCell.Value = 1000 
End With 
Exit Sub 
C# Word - Search and Find Text in Word
C# Word - Search and Find Text in Word. Learn How to Search Text in PDF Document and Obtain Text Content and Location Information. Overview.
how to select text on pdf; how to search pdf files for text
C# PowerPoint - Search and Find Text in PowerPoint
C# PowerPoint - Search and Find Text in PowerPoint. Learn How to Search Text in PDF Document and Obtain Text Content and Location Information. Overview.
pdf make text searchable; pdf select text
exitPoint: 
MsgBox "There is no tree to change.", vbInformation 
End Sub 
Finally, the following macro, again from the file PrecisionTree XDK – Creating Tree 1.xlsm, illustrates 
how you can change the decision criterion to maximize expected utility, with an exponential utility 
function. In this case, you can display expected values, expected utilities, or certainty equivalents on the 
tree. The latter is chosen here. 
Sub ChangeTree3() 
' Quit if there is no such tree 
On Error GoTo exitPoint 
With PrecisionTree.ModelWorkbook.DecisionTrees("Simple Gamble") 
' Change to an exponential utility function and display certainty equivalents 
With .UtilityFunction 
.Enabled = True 
.FunctionType = PTExponential 
.RValue = 500 
.Display = PTDisplayCertaintyEquivalent 
End With 
End With 
Exit Sub 
exitPoint: 
MsgBox "There is no tree to change.", vbInformation 
End Sub  
The results of these three “change” macros, all applied to the original tree, appear in Figures 7, 8, and 9. 
Figure 7 Simple Gamble with Changed Data 
Figure 8 Simple Gamble with Expected Cost Minimization 
C# Excel - Search and Find Text in Excel
Easy to search and find text content and get its location details. Allow to search defined Excel file page or the whole document. C# PDF: Example of Finding Text
how to select text in pdf; select text in pdf reader
VB.NET PDF File Merge Library: Merge, append PDF files in vb.net
When you have downloaded the RasterEdge Image SDK for .NET, you can unzip the package to find the RasterEdge.Imaging.PDF.dll in the bin folder under the root
search pdf for text; search pdf documents for text
Figure 9 Simple Gamble with Expected Utility Maximization 
Technical Note: BranchSelectorCell 
You might wonder at the strange name for the BranchSelectorCell property. As stated earlier, when it is 
followed by Value, this specifies the probability on a branch emanating from a chance node. However, it 
can also be used for a branch emanating from a decision (or logic) node. Then it returns the YES or NO 
value that determines which branch is selected—that is, followed. Even with branches out of chance 
nodes, its value, the probability, indicates which branch is probabilistically selected—hence the word 
“Selector” in the name. 
Technical Note: InterfaceState 
If you have automated Excel with VBA, you might have turned screen updating off, and then turned it 
back on, as in the following lines: 
Application.ScreenUpdating = False 
' Do a lot of stuff 
Application.ScreenUpdating = True 
The effect is to avoid a lot of screen flickering and to speed up the process. The PrecisionTree XDK 
provides a similar capability for avoiding screen flicker and improving speed with the PTInterfaceState 
object and StartLongProcess method. Before doing a complex series of operations, like building a large 
tree, you can use the following lines, where the argument of the Set line is text that will appear in the 
status bar while the tree is being created. 
Dim interfaceState As PTInterfaceState 
On Error GoTo exitPoint 
Set interfaceState = PrecisionTree.StartLongProcess("Creating Tree...") 
' Code that creates the tree (might raise an error)…. 
On Error GoTo 0 
Among other things, the Set line turns off screen updating, it puts Excel into manual recalculation mode, 
and it turns off PrecisionTree calculations. However, after all the tree-creating code, you must restore 
everything to its original state with the following lines: 
exitPoint: 
If Not (interfaceState Is Nothing) Then interfaceState.Restore True 
The purpose of the On Error GoTo exitPoint line is to turn on error handling. This ensures that if any 
errors cause the program to stop unexpectedly, the Restore method will be called. Otherwise, Excel 
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit Excel
HTML5 Viewer for C# .NET, users can convert Excel to PDF document, export C#.NET RasterEdge HTML5 Viewer also enable users to quickly find text content by
search pdf files for text; select text pdf file
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
document. If you find certain page in your PDF document is unnecessary, you may want to delete this page directly. Moreover, when
searching pdf files for text; search multiple pdf files for text
would stay in an “unnatural” state—for example, it would stay in manual recalculation mode. The 
purpose of the On Error GoTo 0 line is to turn off error handling. 
The Boolean argument of the Restore method can be explained as follows. Imagine that the tree-
creating code, the part now commented out, raises an error, which sends it to the exitPoint and the 
Restore line. If the Boolean argument is False, the error will be ignored (and cleared), so that any 
subsequent code will run as if the error never happened. However, if this argument is True, the Restore 
line will immediately throw the same error that occurred in the earlier code. This would allow you to get 
the original error message and have the routine stop, facilitating the debugging process. 
Bayesian Revision 
eginning in PrecisionTree 6.0, you can “flip” a symmetric probability tree to implement  ayes’ rule. This 
ability is also available in the PrecisionTree XDK with the BayesRevision method of the RootNode object. 
The following macro, taken from the example file PrecisionTree XDK – Creating Tree with Bayesian 
Revision.xlsm, illustrates the process. The probability tree is first built with the given prior probabilities 
and likelihoods (which by then have been read from a Data sheet). Next, the tree is flipped with the 
BayesianRevision method. This uses the reordering array, which indicates that the second-stage nodes 
should be become the first-stage node, and vice versa. Finally, the probabilities required for the final 
decision tree (the testProb and posterior arrays) are read from the flipped tree. 
Sub CreateBayesTreeAndFlip() 
Dim i As Integer, j As Integer 
Dim reordering(1 To 2) As Long 
With PrecisionTree.ModelWorkbook.DecisionTrees _ 
.Add(wsBayesTree.Range("B2"), , "Tree to flip") 
With .rootNode 
.ChangeNodeType PTTreeChanceNode 
.Name = "Well type" 
For i = 1 To 3 
With .ChildBranches.Add(wellLabel(i), _ 
IIf(i = 1, PTFirstBranch, PTLastBranch)) 
.BranchSelectorCell.Value = prior(i) 
' The subtrees from each destination node, must be labeled 
' exactly the same or else Bayesian revision won't be allowed. 
With .DestinationNode 
.ChangeNodeType PTTreeChanceNode 
.Name = "Test result" 
For j = 1 To 3 
With .ChildBranches.Add(testLabel(j), _ 
IIf(j = 1, PTFirstBranch, PTLastBranch)) 
.BranchSelectorCell.Value = likelihood(i, j) 
End With 
Next 
End With 
End With 
Next 
' Flip the tree 
reordering(1) = 2 
reordering(2) = 1 
.BayesianRevision reordering 
' Get revised probabilities from flipped tree 
For i = 1 To 3 
With .ChildBranches(i) 
testProb(i) = .BranchSelectorCell.Value 
With .DestinationNode 
For j = 1 To 3 
posterior(i, j) = .ChildBranches(j).BranchSelectorCell.Value 
Next 
C# WPF Viewer: Load, View, Convert, Annotate and Edit Excel
function will help users to freely convert Excel document to PDF, Tiff and Text search and select functionalities and manipulate help to find text contents on
cannot select text in pdf; pdf text select tool
XDoc.Word for .NET, Support Processing Word document and Page in .
Able to view and edit Word rapidly. Convert. Convert Word to PDF. Convert Word to ODT. Text & Image Process. Search and find text in Word. Insert image to Word page
text select tool pdf; pdf searchable text converter
End With 
End With 
Next 
End With 
End With 
End Sub 
Creating Reports 
Once you have a decision tree, it is easy to create Policy Suggestion or Risk Profile reports. The following 
macro, taken from the example file PrecisionTree XDK – Creating Reports.xlsm, illustrates some 
possibilities. Here are several things to note: 
1.
Two report application settings are changed, but the original settings are stored in variables so 
that they can be restored at the end of the macro. Specifically, if you plan to create multiple 
reports, you should set the ReportOverwriteExisting property to False; otherwise, each report 
will overwrite the previous report. 
2.
Reports are created from the NewPolicySuggestion or NewRiskProfile methods of a 
PTModelWorkbook object. You then work with the resulting objects, PTPolicySuggestion and 
PTRiskProfile, created implicitly in the With lines. A model must be specified, in this case, an 
existing decision tree, the “Include” properties indicate which items to include in the report, and 
finally, the GenerateReport method creates the report. 
3.
By default, the starting node for the reports is the root node of the tree. However, you can 
specify another starting node if you want to base the report on a particular subtree of the entire 
tree.  
Sub CreateReports() 
Dim modelWB As PTModelWorkbook 
Dim rptPlacement As PTReportPlacement 
Dim rptOverwrite As Boolean 
With PrecisionTree.ApplicationSettings 
' Remember current settings 
rptPlacement = .ReportPlacement 
rptOverwrite = .ReportOverwriteExisting 
' Change settings 
.ReportPlacement = PTActiveWorkbook 
' The following must be set to False. Otherwise, each report 
' requested below will overwrite the previous report. 
.ReportOverwriteExisting = False 
End With 
Set modelWB = PrecisionTree.ModelWorkbook 
' Policy suggestion for entire tree 
With modelWB.NewPolicySuggestion 
Set .Model = modelWB.DecisionTrees("Oil Drilling Decisions") 
.IncludeDecisionTable = True 
.IncludeOptimalDecisionTree = True 
.GenerateReport 
End With 
' Policy suggestion assuming decision to NOT test has been made 
With modelWB.NewPolicySuggestion 
Set .startingNode = modelWB.DecisionTrees("Oil Drilling Decisions") _ 
.Nodes("Drill Decision 4") 
.IncludeDecisionTable = True 
.IncludeOptimalDecisionTree = True 
.GenerateReport 
End With 
' Risk profile for entire tree 
With modelWB.NewRiskProfile 
Set .Model = modelWB.DecisionTrees("Oil Drilling Decisions") 
.PathsToAnalyze = PTAnalyzeOptimumPath 
.IncludeCumulativeChart = False 
.IncludeProbabilityChart = True 
.IncludeStatisticalSummary = True 
.GenerateReport 
End With 
' Risk profile assuming decision to not test has been made 
With modelWB.NewRiskProfile 
Set .startingNode = modelWB.DecisionTrees("Oil Drilling Decisions") _ 
.Nodes("Drill Decision 4") 
.PathsToAnalyze = PTAnalyzeOptimumPath 
.IncludeCumulativeChart = False 
.IncludeProbabilityChart = True 
.IncludeStatisticalSummary = True 
.GenerateReport 
End With 
With PrecisionTree.ApplicationSettings 
' Restore original settings 
.ReportPlacement = rptPlacement 
.ReportOverwriteExisting = rptOverwrite 
End With 
End Sub  
Technical Note: Referring to Nodes by Cell Address 
There was a suggestion earlier in this guide that you should provide nodes with distinct names so that 
you can refer to them unambiguously in your code. For example, this enables the reference to “Drill 
Decision 4” in the above code, which wouldn’t be possible if all four decision nodes had the same “Drill 
Decision” name. However, there is another way to do it. You can refer to a node by its cell address. If 
you look closely at a PrecisionTree decision tree (with Excel gridlines turned on), you will notice that 
every node “straddles” two cells, one above and one below. When referring to the node, you can refer 
to either of these cells, using the ItemFromCell property. For example, because the Drill Decision 4 node 
straddles cells D50 and D51 in the example file, you could replace .Nodes(“Drill Decision 4”) with either 
.Nodes.ItemFromCell(Range(“D50”)) 
or 
.Nodes.ItemFromCell(Range(“D51”)) 
Of course, if either of these cells is range-named (probably for this specific purpose), you could instead 
reference the range name. 
Performing Sensitivity Analyses 
The VBA code required to perform one or more sensitivity analyses is also fairly straightforward. This is 
illustrated in the following macro, taken from the example file PrecisionTree XDK – Sensitivity 
Analyses.xlsm. In addition to the guidelines for reports (not repeated here), the following guidelines 
apply: 
1.
A new sensitivity analysis—technically a PTSensitivityAnalysis object—is created implicitly in the 
With lines with the NewSensitivityAnalysis method of a PTModelWorkbook object. 
2.
The AnalysisType property must be set to PTOneWayAnalysis or PTTwoWayAnalysis. 
3.
The starting node of the Output property should be set, either to the root node or some other 
node. 
4.
You then add one or more input cells and specify how you want them to vary. Also, for a two-
way analysis, two inputs should be specified as the X-axis and Y-axis variables. 
5.
The “Include” properties depend on the type of analysis. For example, tornado and spider 
graphs are not applicable for a one-way analysis with a single input or a two-way analysis. 
Sub PerformSensitivityAnalyses() 
Dim modelWB As PTModelWorkbook 
Dim rptPlacement As PTReportPlacement 
Dim rptOverwrite As Boolean 
With PrecisionTree.ApplicationSettings 
' Remember current settings 
rptPlacement = .ReportPlacement 
rptOverwrite = .ReportOverwriteExisting 
' Change settings 
.ReportPlacement = PTActiveWorkbook 
' The following must be set to False. Otherwise, each report 
' requested below will overwrite the previous report. 
.ReportOverwriteExisting = False 
End With 
Set modelWB = PrecisionTree.ModelWorkbook 
' One-way sensitivity analysis from root node on a single input 
With modelWB.NewSensitivityAnalysis 
.analysisType = PTOneWayAnalysis 
.IncludeStrategyRegion = True 
.IncludeSensitivityGraph = True 
.GraphsDisplayPercentageChange = False 
Set .Output.startingNode = modelWB.DecisionTrees("Oil Drilling Decisions").rootNode 
With .Inputs.Add 
Set .VaryCell = Range("Cost_of_test") 
.VariationMethod = PTActualMinMaxValues 
.BaseValue = Range("Cost_of_test").Value 
.Minimum = .BaseValue - 10000 
.Maximum = .BaseValue + 50000 
.Steps = 7 
End With 
.GenerateReport 
End With 
' One-way sensitivity analysis from an interior node on a single input 
With modelWB.NewSensitivityAnalysis 
.analysisType = PTOneWayAnalysis 
.IncludeStrategyRegion = True 
.IncludeSensitivityGraph = True 
.GraphsDisplayPercentageChange = False 
Set .Output.startingNode = modelWB.DecisionTrees("Oil Drilling Decisions") _ 
.Nodes("Drill Decision 1") 
With .Inputs.Add 
Set .VaryCell = Range("Cost_of_drilling") 
.VariationMethod = PTActualMinMaxValues 
.BaseValue = Range("Cost_of_drilling").Value 
.Minimum = .BaseValue - 500000 
.Maximum = .BaseValue + 100000 
.Steps = 7 
End With 
.GenerateReport 
End With 
' One-way sensitivity analysis from root node on several inputs 
With modelWB.NewSensitivityAnalysis 
.analysisType = PTOneWayAnalysis 
.IncludeStrategyRegion = False 
.IncludeSensitivityGraph = False 
.IncludeTornadoGraph = True 
.IncludeSpiderGraph = True 
.GraphsDisplayPercentageChange = False 
Set .Output.startingNode = modelWB.DecisionTrees("Oil Drilling Decisions").rootNode 
With .Inputs.Add 
Set .VaryCell = Range("Cost_of_test") 
.VariationMethod = PTActualMinMaxValues 
.BaseValue = Range("Cost_of_test").Value 
.Minimum = .BaseValue - 10000 
.Maximum = .BaseValue + 50000 
.Steps = 7 
End With 
With .Inputs.Add 
Set .VaryCell = Range("Cost_of_drilling") 
.VariationMethod = PTActualMinMaxValues 
.BaseValue = Range("Cost_of_drilling").Value 
.Minimum = .BaseValue - 500000 
.Maximum = .BaseValue + 100000 
.Steps = 7 
End With 
With .Inputs.Add 
Set .VaryCell = Range("Small_well_value") 
.VariationMethod = PTPercentageChangeFromBase 
.BaseValue = Range("Small_well_value").Value 
.Minimum = -20 
.Maximum = 40 
.Steps = 7 
End With 
With .Inputs.Add 
Set .VaryCell = Range("Large_well_value") 
.VariationMethod = PTPercentageChangeFromBase 
.BaseValue = Range("Large_well_value").Value 
.Minimum = -20 
.Maximum = 40 
.Steps = 7 
End With 
.GenerateReport 
End With 
' Two-way sensitivity analysis from root node 
With modelWB.NewSensitivityAnalysis 
.analysisType = PTTwoWayAnalysis 
.IncludeStrategyRegion = True 
.IncludeSensitivityGraph = True 
.GraphsDisplayPercentageChange = False 
Set .Output.startingNode = modelWB.DecisionTrees("Oil Drilling Decisions").rootNode 
With .Inputs.Add 
' Each input must be designated for the X-axis or the Y-axis 
.TwoWayAnalysis = PTTwoWaySensitivityXAxis 
Set .VaryCell = Range("Small_well_value") 
.VariationMethod = PTPercentageChangeFromBase 
.BaseValue = Range("Small_well_value").Value 
.Minimum = -20 
.Maximum = 40 
.Steps = 7 
End With 
With .Inputs.Add 
.TwoWayAnalysis = PTTwoWaySensitivityYAxis 
Set .VaryCell = Range("Large_well_value") 
.VariationMethod = PTPercentageChangeFromBase 
.BaseValue = Range("Large_well_value").Value 
.Minimum = -20 
.Maximum = 40 
.Steps = 7 
End With 
.GenerateReport 
End With 
With PrecisionTree.ApplicationSettings 
' Restore original settings 
.ReportPlacement = rptPlacement 
.ReportOverwriteExisting = rptOverwrite 
End With 
End Sub 
Some General VBA Tips 
This guide concludes with a few VBA tips that you should know regardless of whether you are 
automating PrecisionTree or Excel. 
File Format (xlsm) 
If you save a workbook that includes VBA code, you must save it as a macro-enabled (.xlsm) file. This is 
true for any Excel file that contains VBA code; it is not specific to PrecisionTree files. Then if you open 
this .xlsm file later on, you will be warned that it contains macros. Make sure you elect to enable the 
macros; otherwise the V A macros won’t work. 
Running a Macro 
If you develop a V A program for nontechnical users, you probably won’t want them to see your code, 
either for proprietary reasons or because it would be too intimidating. However, it is easy to create a 
simple user interface for running the program. To do so, activate a worksheet, insert a shape such as a 
rectangle, right-click it, select Assign Macro, and select your macro. You can also insert descriptive text, 
such as Run Program, in the shape. From then on, a user can simply click the shape to run the program. 
ThisWorkbook 
You can always reference a workbook by name, as in Workbooks(“My Example File.xlsm”). Alternatively, 
you can refer to the active workbook with the built-in object ActiveWorkbook. However, an even safer 
reference is to ThisWorkbook, which always references the workbook containing the VBA code. (It is 
safer than ActiveWorkbook because the workbook containing the code might not be active when you 
run your program.) 
Worksheet Code Names 
The code in the example files sometimes references worksheets by their “code” names. A worksheet 
actually has two names, the name you see on its tab, and a code name, which can be set only in the 
Visual Basic Editor. This is illustrated in Figure 10 (see the highlighted line in the Properties section). In 
this example, the notation wsTree (Tree) in the Project section indicates that Tree is the name on the 
tab and wsTree is the code name. (Any names can be used for code names, but a common practice is to 
use the prefix ws.) One reason for using code names in V A programs is that you don’t need to create a 
Worksheet object variable; you can simply write wsTree.Range(“A1”), for example. A second reason is 
that if your code refers to the worksheet by name, as in Worksheets(“Tree”), and someone changes the 
name on the worksheet tab, an innocent enough change to make, this will break your program. 
However, because code names can be changed only through the Visual Basic Editor, it is much less likely 
that anyone will change them. 
Documents you may be interested
Documents you may be interested