Difference between revisions of "Essential Algorithms and Data Structures for Computational Design"
Abel Maciel (talk  contribs) 
Abel Maciel (talk  contribs) (→Data operations tutorial) 

(13 intermediate revisions by the same user not shown)  
Line 336:  Line 336:  
Writing elegant algorithms that are efficient and easy to read and debug is hard. We explained in this chapter how to write algorithms with style using colorcoding and labeling. We also articulated a 4step process to help develop algorithms. Following these guides help minimize bugs and improve the readability of the scripts. We will list a few of the common issues that lead to an incorrect or unintended result.  Writing elegant algorithms that are efficient and easy to read and debug is hard. We explained in this chapter how to write algorithms with style using colorcoding and labeling. We also articulated a 4step process to help develop algorithms. Following these guides help minimize bugs and improve the readability of the scripts. We will list a few of the common issues that lead to an incorrect or unintended result.  
−  
===Invalid or wrong type input===  ===Invalid or wrong type input===  
If the input is of the wrong type or is invalid, GH changes the color of components to red or orange to indicate an error warning, with feedback about what the issue might be. This is helpful, but sometimes faulty input goes unnoticed if the components assign a default value, or calculate an alternative value to replace the input, that is not what was intended. It is a good practice to always doublecheck the input (hook to a panel or parameter viewer and label the input). To avoid using the wrong types, it is advisable to convert to the intended type to ensure accuracy.  If the input is of the wrong type or is invalid, GH changes the color of components to red or orange to indicate an error warning, with feedback about what the issue might be. This is helpful, but sometimes faulty input goes unnoticed if the components assign a default value, or calculate an alternative value to replace the input, that is not what was intended. It is a good practice to always doublecheck the input (hook to a panel or parameter viewer and label the input). To avoid using the wrong types, it is advisable to convert to the intended type to ensure accuracy.  
+  
+  [[File:EADSMcNeel_057_F26.pngcenterthumb550pxframe'''1.8.1: Figure 26:''' Error resulting from wrong input type]]  
+  
+  ===Incorrect input===  
+  Input is prone to unintended change via intermediate processes or when multiple users have writing access to the script. It is very useful to preview and verify all key input and output. The Panel component is very versatile and can help check all types of values. Also, you can set up guarding logic against out of range values or to trap undesired values.  
+  
+  [[File:EADSMcNeel_058_F27.pngcenterthumb600pxframe'''1.8.2.1: Figure 27:''' Error resulting from incorrect input. Cannot assume curve domain is 01 and use 0.5 to evaluate the midpoint.]]  
+  
+  [[File:EADSMcNeel_059_F28.pngcenterthumb600pxframe'''1.8.2.2: Figure 28:''' Example of a robust solution to evaluate the midpoint of a curve.]]  
+  
+  ===Incorrect order of operation===  
+  You should try to organize your solutions horizontally or vertically to clearly see the sequence of operations. You should also check the output from each step to make sure it is as expected before continuing on your code. There are also some techniques that help consolidate the script, for example, use Expression when multiple numeric and math operations are involved. The following highlights some unfavorable organization.  
+  
+  [[File:EADSMcNeel_060_F29.pngcenterthumb600pxframe'''1.8.3.3: Figure 29:''' Example of a robust solution to evaluate the midpoint of a curve.]]  
+  
+  The following shows how to rewrite the same code to make it less errorprone.  
+  
+  [[File:EADSMcNeel_061_F30.pngcenterthumb600pxframe'''1.8.3.4: Figure 30:''' Best practices to align input with processes, or use Expressions]]  
+  
+  ===Mismatched data structures===  
+  
+  Mismatched data structures as input to the same process or component are particularly tricky to guard against in GH, and has the potential to spiral the solution out of memory. It is essential to test the data structure of all input (except trivial ones) before feeding into any component. It is also important to examine the desired matching under different scenarios (data matching will be explained at length later).  
+  
+  [[File:EADSMcNeel_062_F31.pngcenterthumb600pxframe'''1.8.4: Figure 31:''' Mismatched data structures of input can cause errors in the output]]  
+  
+  
+  ===Long processing time===  
+  
+  Some algorithms are timeconsuming, and you simply have to wait for it to process, but there are ways to minimize the wait when it is unnecessary. For example, at the early cycles of development, you should try to use a smaller set of data to test your solution with before committing the time to process the full set of data. It is also a good practice to break the solution into stages when possible, so you can isolate and disable the timeconsuming parts. Also, it is often possible to rewrite your solution to be more optimized and consume less time. Use the GH Profiler to test processing time. When a solution takes far too long to process or crashes, you should do the following: before you reopen the solution, disable it, and disconnect the input that caused the crash.  
+  
+  [[File:EADSMcNeel_063_F32.pngcenterthumb600pxframe'''1.8.5: Figure 32:''' Grasshopper Profiler widget help observe processing time]]  
+  
+  ===Poor organization===  
+  Poorly organized definitions are not easy to debug, understand, reuse or modify. We can’t stress enough the importance of writing your definitions with styles, even if it costs extra time to start with.  
+  You should always color code, label everything, give meaningful names to variables, break repeated operations into modules and preview your input and output.  
+  
+  [[File:EADSMcNeel_064_F33.pngcenterthumb300pxframe'''1.8.6: Figure 33:''' Poor organization in visual programming make the code hard to read or debug]]  
+  
+  ==Algorithms tutorials==  
+  ===Unioned circles tutorial===  
+  Use the 4step process to design an algorithm that unions 2 circles, given the following: both are located on the XYPlane. The first circle (Cir1) has a center (C1) = (2,2,2) and radius (R1) = some random number between 3 and 6. The second circle (Cir2) has a center (C2) is shifted to the right of (Cir1) by an amount equal to R1 along positive XAxis. R2 = R1 * 1.2  
+  
+  { class="wikitable" style="width:100%;"  
+  colspan="2" style="backgroundcolor:#bfbfbf  '''Analyze the question and the flow of the solution'''  
+    
+  colspan="2" style="backgroundcolor:#ffffff  [[File:EADSMcNeel_065.pngcenter600px ]]  
+    
+  style="width: 30%" "backgroundcolor:#ffffff '''Output:'''  
+  Curve for the region union.  
+  style="backgroundcolor:#ffffff [[File:EADSMcNeel_066.pngright80px ]]  
+    
+  style="width: 30%" "backgroundcolor:#ffffff '''Key Proces: union of 2 circles:'''  
+  Use the ''Region Union'' component that takes curves and a plane.  
+  style="backgroundcolor:#ffffff [[File:EADSMcNeel_067.pngright250px ]]  
+    
+  style="width: 30%" "backgroundcolor:#ffffff '''Input to the region union:'''  
+  Identify the input needed and use given input when relevant.  
+  The plane for region union has been given. The 2 circles need their own plane and radius. The center of the plane is the center of the circle.  
+  style="backgroundcolor:#ffffff [[File:EADSMcNeel_068.pngright600px ]]  
+    
+  style="width: 30%" "backgroundcolor:#ffffff '''Intermediate process to generate the center and plane of the 1st circle:'''  
+  Construct a center from the given coordinates. Create a plane using ''Plane Origin'' component and use the constructed center and XYPlane  
+  The radius is from a random number between 3 and 6. Use ''Random'' component to create the radius  
+  style="backgroundcolor:#ffffff [[File:EADSMcNeel_069.pngright550px ]]  
+    
+  style="width: 30%" "backgroundcolor:#ffffff '''Intermediate process to generate the center and plane of the 2nd circle:'''  
+  Calculate the 2nd circle plane by moving the first circle plane along the xaxis by an amount = first radius  
+  
+  GCalculate the 2nd circle radius by multiplying the first radius by 1.2  
+  style="backgroundcolor:#ffffff [[File:EADSMcNeel_070.pngright450px ]]  
+    
+  colspan="2" style="backgroundcolor:#ffffff  [[File:EADSMcNeel_071.pngcenter1000px ]]  
+  }  
+  
+  ===Sphere with bounds tutorial===  
+  Use the 4step process to draw a sphere with a radius between 2 and 6. If the input is less than 2, then set the radius to 2, and if the input radius is greater than 6, set the radius to 6. Use a number slider to input the radius and set between 0 and 10 to test. Make sure your solution is well organized, colorcoded and labeled properly.  
+  
+  { class="wikitable" style="width:100%;"  
+  colspan="2" style="backgroundcolor:#bfbfbf  '''Use the 4step process to solve the algorithms'''  
+    
+  style="width: 30%" "backgroundcolor:#ffffff '''Output:'''  
+  The sphere as geometry.  
+  style="backgroundcolor:#ffffff [[File:EADSMcNeel_072.pngright70px ]]  
+    
+  style="width: 30%" "backgroundcolor:#ffffff '''Key Process: create a sphere:'''  
+  Map the coordinates list from its current domain to a new domain 3 to 9. Use ''ReMap'' component  
+  style="backgroundcolor:#ffffff [[File:EADSMcNeel_073.pngright250px ]]  
+    
+  style="width: 30%" "backgroundcolor:#ffffff '''Input:'''  
+  1 The radius parameter (0  10)  
+  
+  2 The bounds of the radius are 2 & 6  
+  style="backgroundcolor:#ffffff [[File:EADSMcNeel_074.pngright560px ]]  
+    
+  style="width: 30%" "backgroundcolor:#ffffff '''Intermediate processes #1:'''  
+  Construct a selection logic of radii and pattern. The radii is a list of the values from the slider, min and max.  
+  The list of pattern is generated to select the correct radius value.  
+  style="backgroundcolor:#ffffff [[File:EADSMcNeel_075.pngright800px ]]  
+    
+  style="width: 30%" "backgroundcolor:#ffffff '''Intermediate processes #2'''  
+  The selection logic checks if the radius from the slider is between the bounds, then set it to be selected, if less, then select the min, and if more select the max.  
+  style="backgroundcolor:#ffffff [[File:EADSMcNeel_076.pngright820px ]]  
+  }  
+  
+  ===Data operations tutorial===  
+  
+  Given the numbers embedded in the Number parameter below:  
+  
+  1 Analyze input in terms of bounds and distribution  
+  
+  2 View the data and how it is structured  
+  
+  3 Extract even numbers  
+  
+  4 Sort numbers descending  
+  
+  5 Remap sorted numbers to (100 to 200)  
+  
+  { class="wikitable" style="width:100%;"  
+  colspan="2" style="backgroundcolor:#bfbfbf  '''Solution'''  
+    
+  style="width: 30%" "backgroundcolor:#ffffff '''1 Analyze the input bounds and distribution'''  
+  Use the ''QuickGraph'' to show that the set of numbers are between 3 and 98 and are distributed randomly.  
+  style="backgroundcolor:#ffffff [[File:EADSMcNeel_077.pngright70px ]]  
+    
+  style="width: 30%" "backgroundcolor:#ffffff '''2 Analyze the input data structure and values'''  
+  Use the ''Panel'' and ''Parameter Viewer'' to show there are 16 elements organized in a list  
+  style="backgroundcolor:#ffffff [[File:EADSMcNeel_078.pngright250px ]]  
+    
+  style="width: 30%" "backgroundcolor:#ffffff '''3 Extract Even numbers:'''  
+  Create the logic to test if a number is even (divisible by 2 without a remainder) and use Dispatch to extract even numbers  
+  style="backgroundcolor:#ffffff [[File:EADSMcNeel_079.pngright560px ]]  
+    
+  style="width: 30%" "backgroundcolor:#ffffff '''Intermediate processes #1:'''  
+  Construct a selection logic of radii and pattern. The radii is a list of the values from the slider, min and max.  
+  The list of pattern is generated to select the correct radius value.  
+  style="backgroundcolor:#ffffff [[File:EADSMcNeel_080.pngright800px ]]  
+  }  
+  
+  ===Pitfalls tutorial===  
=Chapter Two: Introduction to Data Structures=  =Chapter Two: Introduction to Data Structures=  
=Chapter Three: Advanced Data Structures=  =Chapter Three: Advanced Data Structures= 
Revision as of 16:47, 25 March 2020
The Essential Algorithms and Data Structures for Computational Design, by Rajaa Issa, introduces effective methodologies to develop complex 3D modeling algorithms using Grasshopper. It also covers extensively the data structure adopted by Grasshopper and its core organization and management tools.
The full contents of the book are produced here with the authorization of the authors and are directed towards designers who are interested in parametric design and have little or no background in programming. All concepts are explained visually using Grasshopper® (GH), the generative modeling environment for Rhinoceros® (Rhino). This book is not intended as a beginner's guide to Grasshopper in terms of user interface or tools. Basic knowledge of the interface and workflow is assumed. For more resources and getting started guides, go to the learn section in [rhino3d.com]. The content is divided into three chapters. Chapter 1 discusses algorithms and data. It introduces a methodology to help create and manage parametric solutions. It also introduces basic data concepts such as data types, sources and common ways to process them. Chapter 2 reviews basic data structures in Grasshopper. That includes single items and lists. Chapter 3 includes an indepth review of the tree data structure in Grasshopper and practical applications in design problems. All Grasshopper examples and tutorials are written with Rhinoceros version 6 and are included in the download.
Contents
 1 Chapter 1: Algorithms and Data
 2 Chapter Two: Introduction to Data Structures
 3 Chapter Three: Advanced Data Structures
Chapter 1: Algorithms and Data
Algorithms and data are the two essential parts of any parametric design solution, but writing algorithms is not trivial and requires a skill that does not come easy to intuitive designers. The algorithmic design process is highly logical and requires an explicit statement of the design intention and the steps to achieve them. This chapter introduces a methodology to help creative designers develop new algorithmic solutions. All algorithms involve manipulating data and hence Algorithms and Data are tightly connected. We will introduce the basic concepts of data types and processes.
Algorithmic design
We can define algorithmic design as a design method where the output is achieved through welldefined steps. In that sense, many human activities are algorithmic. Take, for example, baking a cake. You get the cake (output) by using a recipe (welldefined steps). Any change in the ingredients (input) or the baking process results in a different cake. We will analyze the parts of typical algorithms, and identify a strategy to build algorithmic solutions from scratch. Regardless of its complexity, all algorithmic solutions have 3 building blocks: input, key process, and output. Note that the key process may require additional input and processes.
Throughout this text, we will organize and label the solutions to identify the three blocks clearly. We will also use consistent color coding to visually distinguish between the parts. This will help us become more comfortable with reading algorithms and quickly identify input, key processing steps, and properly collect and display output. Visual cues are important to develop fluency in algorithmic thinking.
In general, reading existing algorithmic solutions is relatively easy, but building new ones from scratch is much harder and requires a new set of skills. While it is useful to know how to read and modify existing solutions, it is essential to develop algorithmic design skills to build new solutions from scratch.
Algorithms parts
In Grasshopper, a solution flows from left to right. At the far left are input values and parameters, and the farright has the output. In between are one or more key processes, and sometimes additional input and output. Let’s take a simple example to help identify the three parts of any algorithm (input, key process, output). The simple addition algorithm includes two numbers (input), the sum (output) and one key process that takes the numbers and gives the result. We will use purple for the input, maroon for the key processes and light blue for the output. We will also group and label the different parts and adhere to organizing the Grasshopper solutions from left to right.
Algorithms may involve intermediate processes. For example, suppose we need to create a circle (output) using a center and a radius (input). Notice that the input is not sufficient because we do not know the plane on which the circle should be created. In this case, we need to generate additional information, namely the plane of the circle. We will call this an intermediate process and use brown color to label it.
Some solutions are not written with styles and hence are hard to read and build on. It is very important that you take the time to organize and label your solutions to make it easier to understand, debug and use by others.
Solution
In order to figure out what the algorithm is meant to do, we need to group the input on the left side, and collect the output on the right side, then organize the processes in the order or execution. We then step through the solution from left to right to deduce what it does. We can examine and preview the output in each step.
The example of the tutorial is meant to create a circle that is twice as large as another circle that goes through three given points. One of the points is constructed out of its 3 coordinates.
Designing algorithms: the 4step process
Before we generalize a method to design algorithms, let’s examine an algorithm we commonly use in real life such as baking a cake. If you already have a recipe for a cake, you simply get the recommended ingredients, mix them, pour in a pan, put in preheated oven for a certain amount of time, then serve. If the recipe is well documented, then it is relatively straightforward to use.
As you become more proficient in baking cakes, you may start to modify the recipe. Perhaps add new ingredients (chocolate or nuts) or use different tools (cupcake container).
When designers write algorithms, they typically try to search for existing solutions and modify to fit their purposes. While this is a good entry point, using existing solutions can be frustrating and timeconsuming.
Also, existing solutions have their own flavor and that may influence design decisions and limit creativity. If designers have unique problems, and they often do, they have no choice but to create new solutions from scratch; albeit a much harder endeavor.
Back to our example, the task of baking a cake is much harder if you don’t have a recipe to follow and have not baked one before. You will have to guess the ingredients and the process. You will likely end up with bad results in the first few attempts, until you figure it out! In general, when you create a new recipe, you have to follow the process in reverse. You start with an image of the desired cake, you then guess the ingredients, tools and steps. Your thinking goes along the following lines:
 The cake needs to be baked, so I need an oven and time;
 What goes in the oven is a cake batter held by a container;
 The batter is a mix of ingredients;
We can use a similar methodology to design parametric algorithm from scratch. Keep in mind that creating new algorithms is a “skill” and it requires patience, practice and time to develop.
Algorithmic thinking in 3D modeling vs parametric design
3D modeling involves certain level of algorithmic thinking, but it has many implicit steps and data. For example, designing a mass model using a 3D modeler may involve the following steps:
 1 Think about the output (e.g. a mass out of few intersecting boxes)
 2 Identify a command or series of commands to achieve the output ( e.g. run Box command few times, Move, Scale or Rotate one or more boxes, then BooleanUnion the geometry).
At that point, you are done!
Data such as the base point for your initial box, width, height, scale factor, move direction, rotation angle, etc. are requested by the commands, and the designer does not need to prepare ahead of time. Also, the final output (the boolean mass) becomes directly available and visible as an object in your document.
Algorithmic solutions are not interactive and require explicit articulation of data and processes. In the box example, you need to define the box orientation and dimensions. When copy, you need a vector and when rotate you need to define the plane and angle or rotation.
Designing algorithms
Designing algorithms requires knowledge in geometry, mathematics and programming. Knowledge in geometry and mathematics is covered in the Essential Mathematics for Computational Design. As for programming skills, it takes time and practice to build the ability to formulate design intentions into logical steps to process and manage geometric data. To help get started, it is useful to think of any algorithm as a 4step process as in the following:
1 Clearly identify the desired outcome  Output 
2 Identify key steps to reach the outcome  Key processes 
3 Examine initial data and parameters  Input 
4 Define intermediate steps to generate missing data  Intermediate input + processes 
Thinking in terms of these 4 steps is key to developing the skill of algorithmic design. We will start with simple examples to illustrate the methodology, and gradually apply on more complex examples.
Step 1: Output: The sum of the 2 numbers. Use a Panel to collect the sum.  
Step 2: Key process: Addition. Use the Addition component that takes 2 numbers and gives the sum.  
Step 3: Input: 2 numbers. Use a Panel to hold the values of input numbers. 
Step 1: Output: Circle. Use the Circle parameter to collect the output.  
Step 2: Key process: Identify a key process that generates a circle from a radius. Use the Circle component in Grasshopper.  
Step 3: Input: Use the given input (center and radius). Feed the radius to the Circle component.  
Step 4: Intermediate process: The circle needs the center, and also the plane on which the circle is located. Assume the circle is on a plane parallel to the XYPlane and use the circle center as the origin of the plane. 
Step 1: Output: The line geometry. Use the Geometry parameter to collect the output.  
Step 2: Key process: Identify a key process that generates a line from 2 points. Use the Line component in Grasshopper.  
Step 3: Input: Use the given input (referenced point and 3 coordinates). Feed one point to one of the ends of the line.  
Step 4: Intermediate process: Before we can use the coordinates as a point, we need to construct a point. 
Data
Data is information stored in a computer and processed by a program. Data can be collected from different sources, it has many types and is stored in welldefined structures so that it can be used efficiently. While there are commonalities when it comes to data across all scripting languages, there are also some differences. This book explores data and data structures specific to Grasshopper.
Data sources
In Grasshopper, there are three main ways to supply data to processes (or what is called components): internal, referenced and external.
1 Internally set data: Data can be set inside any instance of a parameter. Once set, it remains constant, unless manually changed or overridden by external input. This is a good way when you do not generally need to change the data after it is set (constant). Data is stored inside the GH file.  
2 Referenced data: Data can be referenced from Rhino or some external document. For example, you can reference a point created in a Rhino document. When you move the point in Rhino, its reference in Grasshopper updates as well. Grasshopper files are saved separately from Rhino files, and hence if the GH file has referenced data, the Rhino file needs to be saved and passed along with the GH file to avoid any loss of data.  
3 Externally supplied data: Data can be supplied from previous processes. This method is best suited for dynamic data or data controlled parametrically. Externally supplied data to a parameter takes precedent over the internal or referenced values (when both exist). 
Data types
All programming languages identify the kind of data used in terms of the values that can be assigned to and the operations and processes it can participate in. There are common data types such as Integer, Number, Text, Bool (true or false), and others. Grasshopper lists those under the Params > Primitives tab.
Grasshopper supports geometry types that are useful in the context of 3D modeling such as Point (3 numbers for coordinates), Line (2 points), NURBS Curve, NURBS Surface, Brep, and others. All geometry types are included under the Param> Geometry tab in GH.
There are other mathematics types that designers do not usually use in 3D modeling, but are very common in a parametric design such as Domains, Vectors, Planes, and Transformation Matrices. GH provides a rich set of tools to help create, analyze and use these types. To fully understand the mathematical as well as geometry types such as NURBS curves and surfaces, you can refer to the Essential Mathematics for Computational Design book by the author.
The parameters in GH can be used to convert data from one type to another (cast). For example, if you need to turn a text into a number, you can feed your text into a Number parameter. If the text cannot be converted, you’ll get an error.
Grasshopper components internally convert the input to suitable types when possible. For example, if you feed a “text” to the Addition component, GH tries to read the text as a number. If a component can process more than one type, it uses the input type without conversion. For example, equality in an expression can compare text as well as numbers. In such a case, make sure you use the intended type to avoid confusion.
It is worth noting that sometimes GH components simply ignore invalid input (null or wrong type). In such cases, you are likely to end up with an unexpected result and hard to find the bug. It is very important to verify the output from each component before using it.
Processing data
Algorithmic designs use many data operations and processes. In the context of this book, we will focus on five categories: numeric and logical operations, analysis, sorting, and selection.
Numeric operations
Numeric operations include operations such as arithmetic, trigonometry, polynomials, and complex numbers. GH has a rich set of numeric operations, and they are mostly found under the Math tab.
There are two main ways to perform operations in GH. First by using designated components for specific operations such as Addition, Subtraction, and Multiplication.
Second, use an Expression component where you can combine multiple operations and perform a rich set of math and trigonometry operations, all in one expression.
The Expression component is more robust and readable when you have multiple operations.
Input to Expressions can be treated as text depending on the context.
It is worth mentioning that most numeric input to components allow writing an expression to modify the input inline. For example, the Range component has N (number of steps) input. If you rightmouse click on “N”, you can set an expression. You always use “x” to represent the supplied input regardless of the name.
Logical operations
Main logical operations in GH include equalities, sets and logical operations.
Logical operations are used to create conditional flows of data. For example, if you like to draw a sphere only when the radius is between two values, then you need to create a logic that blocks the radius when it is not within your limits.
Data analysis
There are many tools in GH to examine and preview data. Panel is used to show the full details of the data and its structure, while the Parameter Viewer shows the data structure only. Other analysis components include Quick Graph that plots data in a graph, and Bounds to find the limits in a given set of numbers (the min and max values in the set).
Sorting
GH has designated components to sort numeric and geometry data. The Sort List component can sort a list of numeric keys. It can sort a list of numbers in ascending order or reverse the order. You can also use the Sort List component to sort geometry by some numeric keys, for example sort curves by length. GH has components designated to sort geometry sets such as Sort Points to sort points by their coordinates.
Selection
3D modeling allows picking specific or a group of objects interactively, but this is not possible in algorithmic design. Data is selected in GH based on the location within the data structure, or by a selection pattern. For example, the List Item component allows selecting elements based on their indices.
The Cull Pattern component allows using some repeated pattern to select a subset of the data.
As you can see from the examples, selecting specific items or using cull components yield a subset of the data, and the rest is thrown away. Many times you only need to isolate a subset to operate on, then recombine back with the original set. This is possible in GH, but involves more advanced operations. We will get into the details of these operations when we talk about advanced data structures in Chapter 3.
Mapping
That refers to the linear mapping of a range of numbers where each number in a set is mapped to exactly one value in the new set. GH has a component to perform linear mapping called ReMap. You can use it to scale a set of numbers from its original range to a new one. This is useful to scale your range to a domain that suits your algorithm’s needs and limitations.
Converting data involves mapping. For example, you may need to convert an angle unit from degrees to radians ( GH components accept angles in radians only).
As you know, parametric curves have “domains” (the range of parameters that evaluate to points on the curve). For example, if the domain of a given curve is between 12.5 to 51.3, evaluating the curve at 12.5 gives the point at the start of the curve. Many times you need to evaluate multiple curves using consistent parameters. Reparameterizing the domain of curves to some unified range helps solve this problem. One common domain to use is “0 To 1”. At the input of each curve in any GH component, there is the option to Reparameterize which resets the domain of the curve to be “0 to 1”.
Flow control tutorial
What is the purpose of the following algorithm? Notate and color code to describe the purpose of each part.
Analyze the algorithm 
The algorithm has an output that is a sphere, a radius input and some conditional logic to process the radius. 
Notate and colorcode the solution 
From testing the output and following the steps of the solution it becomes apparent that the intention is to make sure that the radius of the sphere cannot be less than 1 unit. 
Test with radius < 1 
Data processing tutorial
Given a list of point coordinates, do the following:
 1 Analyze the list to understand the data.
 3 Write an algorithm to use the input to construct a list of type Point with coordinates mapped to a domain between 3 and 9.
Note that the input list is organized so that the first 3 numbers refer to the x,y,z of the first point, the second 3 numbers belong to the second point and so on.
Analyze the algorithm  
There is a list of 51 numbers (3 coordinates for each point implies the list includes 17 points) Using a QuickGraph, we can see that the range of values are between 2.60 and 15.89. We can also see that the values are distributed randomly. One other input is the target domain:  
Use the 4step process to solve the algorithms  
Output: List of points.  
Key Process #1 Remap Coordinates: Map the coordinates list from its current domain to a new domain 3 to 9 Use ReMap component.  
Intermediate processes #1 The input domain is missing and can be extracted using Bounds component  
Key Process #2 Construct Points: Construct points from coordinates. Use Construct Point (Pt) component  
Intermediate processes #2 Extract all X coordinates as one list, Y in another and Z in the third. Use Cull Pattern component with appropriate pattern to extract each coordinate as a separate list. The input to Cull is the remapped points from process #1  
Putting it all together  
Pitfalls of algorithmic design
Writing elegant algorithms that are efficient and easy to read and debug is hard. We explained in this chapter how to write algorithms with style using colorcoding and labeling. We also articulated a 4step process to help develop algorithms. Following these guides help minimize bugs and improve the readability of the scripts. We will list a few of the common issues that lead to an incorrect or unintended result.
Invalid or wrong type input
If the input is of the wrong type or is invalid, GH changes the color of components to red or orange to indicate an error warning, with feedback about what the issue might be. This is helpful, but sometimes faulty input goes unnoticed if the components assign a default value, or calculate an alternative value to replace the input, that is not what was intended. It is a good practice to always doublecheck the input (hook to a panel or parameter viewer and label the input). To avoid using the wrong types, it is advisable to convert to the intended type to ensure accuracy.
Incorrect input
Input is prone to unintended change via intermediate processes or when multiple users have writing access to the script. It is very useful to preview and verify all key input and output. The Panel component is very versatile and can help check all types of values. Also, you can set up guarding logic against out of range values or to trap undesired values.
Incorrect order of operation
You should try to organize your solutions horizontally or vertically to clearly see the sequence of operations. You should also check the output from each step to make sure it is as expected before continuing on your code. There are also some techniques that help consolidate the script, for example, use Expression when multiple numeric and math operations are involved. The following highlights some unfavorable organization.
The following shows how to rewrite the same code to make it less errorprone.
Mismatched data structures
Mismatched data structures as input to the same process or component are particularly tricky to guard against in GH, and has the potential to spiral the solution out of memory. It is essential to test the data structure of all input (except trivial ones) before feeding into any component. It is also important to examine the desired matching under different scenarios (data matching will be explained at length later).
Long processing time
Some algorithms are timeconsuming, and you simply have to wait for it to process, but there are ways to minimize the wait when it is unnecessary. For example, at the early cycles of development, you should try to use a smaller set of data to test your solution with before committing the time to process the full set of data. It is also a good practice to break the solution into stages when possible, so you can isolate and disable the timeconsuming parts. Also, it is often possible to rewrite your solution to be more optimized and consume less time. Use the GH Profiler to test processing time. When a solution takes far too long to process or crashes, you should do the following: before you reopen the solution, disable it, and disconnect the input that caused the crash.
Poor organization
Poorly organized definitions are not easy to debug, understand, reuse or modify. We can’t stress enough the importance of writing your definitions with styles, even if it costs extra time to start with. You should always color code, label everything, give meaningful names to variables, break repeated operations into modules and preview your input and output.
Algorithms tutorials
Unioned circles tutorial
Use the 4step process to design an algorithm that unions 2 circles, given the following: both are located on the XYPlane. The first circle (Cir1) has a center (C1) = (2,2,2) and radius (R1) = some random number between 3 and 6. The second circle (Cir2) has a center (C2) is shifted to the right of (Cir1) by an amount equal to R1 along positive XAxis. R2 = R1 * 1.2
Analyze the question and the flow of the solution  
Output:
Curve for the region union. 

Key Proces: union of 2 circles:
Use the Region Union component that takes curves and a plane. 

Input to the region union:
Identify the input needed and use given input when relevant. The plane for region union has been given. The 2 circles need their own plane and radius. The center of the plane is the center of the circle. 

Intermediate process to generate the center and plane of the 1st circle:
Construct a center from the given coordinates. Create a plane using Plane Origin component and use the constructed center and XYPlane The radius is from a random number between 3 and 6. Use Random component to create the radius 

Intermediate process to generate the center and plane of the 2nd circle:
Calculate the 2nd circle plane by moving the first circle plane along the xaxis by an amount = first radius GCalculate the 2nd circle radius by multiplying the first radius by 1.2 

Sphere with bounds tutorial
Use the 4step process to draw a sphere with a radius between 2 and 6. If the input is less than 2, then set the radius to 2, and if the input radius is greater than 6, set the radius to 6. Use a number slider to input the radius and set between 0 and 10 to test. Make sure your solution is well organized, colorcoded and labeled properly.
Use the 4step process to solve the algorithms  
Output:
The sphere as geometry. 

Key Process: create a sphere:
Map the coordinates list from its current domain to a new domain 3 to 9. Use ReMap component 

Input:
1 The radius parameter (0  10) 2 The bounds of the radius are 2 & 6 

Intermediate processes #1:
Construct a selection logic of radii and pattern. The radii is a list of the values from the slider, min and max. The list of pattern is generated to select the correct radius value. 

Intermediate processes #2
The selection logic checks if the radius from the slider is between the bounds, then set it to be selected, if less, then select the min, and if more select the max. 
Data operations tutorial
Given the numbers embedded in the Number parameter below:
1 Analyze input in terms of bounds and distribution
2 View the data and how it is structured
3 Extract even numbers
4 Sort numbers descending
5 Remap sorted numbers to (100 to 200)
Solution  
1 Analyze the input bounds and distribution
Use the QuickGraph to show that the set of numbers are between 3 and 98 and are distributed randomly. 

2 Analyze the input data structure and values
Use the Panel and Parameter Viewer to show there are 16 elements organized in a list 

3 Extract Even numbers:
Create the logic to test if a number is even (divisible by 2 without a remainder) and use Dispatch to extract even numbers 

Intermediate processes #1:
Construct a selection logic of radii and pattern. The radii is a list of the values from the slider, min and max. The list of pattern is generated to select the correct radius value. 