DesignScript summary:

Transcription

1 DesignScript summary: This manual is designed fr thse readers wh have sme experience with prgramming and scripting languages and want t quickly understand hw DesignScript implements typical prgramming cncepts and the new cncepts which DesignScript intrduces. [Fr thse readers wh prefer an initial step-by-step intrductin t prgramming and basic cmputatinal gemetry, please refer t the DesignScript User manual. This can be fund at DesignScript supprt tw styles f prgramming: Imperative and Assciative and has functinality which is cmmn t bth styles. Imperative prgramming is characterized by explicit 'flw cntrl' using fr lps (fr iteratin) and if statements (fr cnditinals) as fund in familiar scripting and prgramming languages such as Pythn. Imperative prgramming is useful t perfrm iteratin, either stepping thrugh a cllectin r t perfrm sme iterative feedback r ptimisatin lp. Assciative prgramming uses the cncept f graph dependencies t establish 'flw cntrl and is useful fr mdeling cmplex peratins (such as gemetric prcesses) applied t cllectin f bjects, in a very succinct prgramming style with autmatic change prpagatin. The tw styles f prgramming address different cmputatinal tasks and essentially cmplement each ther. The different styles f prgramming share a cmmn ntatin which means that in sme case the same cde can be executed either assciatively r imperatively. In additin there are certain cmputatinal tasks that benefit frm a cmbinatin f prgramming styles within the same prgram r indeed within the same functin r methd. DesignScript supprts this flexibility by allwing Imperative cde t be nested within Assciative cde and vice versa. Aspects f DesignScript that are cmmn t bth Assciative and Imperative prgramming: Imprt statement: allws the use within a primary script f ther scripts r external DLL s imprt("prtgemetry.dll"); imprt("math.dll"); imprt("myclass.ds") // use the standard DesignScript gemetry library // use the standard DesignScript math library // use a previusly defined script All imprt statements must cme at the tp f the script. Scripts and referenced DLL s shuld be installed either in the default DesignScript directry r shuld be lcated in the directry frm which the primary script is being accessed. Print functin allws strings and the value f variables t be printed t the DesignScript IDE utput windw Print("hell wrld"); Print("a = " + a + "mm"); // typical first statement in any prgramming language // different 'quted string' and variable can be 'cncatenated' // with the '=' sign t frm a single utput 'a = 25mm' DesignScript is a blck structured language: Blcks are defined with and may have anntatins in [] The uter blck in a DesignScript prgram is interpreted as being Assciative. Scpe f variables: The scpe f a variable is cntrlled by the blck in which it is defined. Variables defined within ne blck can be used within inner blcks, but nt within uter blcks. a = 5; b = a +7; c = b; // define variable 'a' at the glbal scpe (utside any blck) // variable 'a' can be reference within a nested blck // it is nt allwed t reference the variable 'b' // utside the blck in which it is defined Only gemetric variables defined within the utermst blck ( glbal scpe ) will be generated and displayed in the DesignScript hst applicatin (currently AutCAD). It is therefre pssible t cnstruct, use and dispse f gemetric variables withut the cst f displaying these by nt defining these in the utermst blck. [Nte: the utermst blck is by default Assciative]

2 Types: In DesignScript the explicit typing f variables during declaratin is ptinal. Hwever there are certain peratins where a particular type f variable is expected. Als different functins and methds may expect arguments f a defined type. S while variables d nt have t be explicitly typed, the type they have at runtime may affect the behaviur f the prgram. At the start f writing a prgram it may be a helpful strategy t use untyped variables, particularly when the prgrammer is in an explratry mde and when flexibility is required t explre the ptin fr variables t have different types f values. Predefining the type f a variable reduces this flexibility and may inhibit explratin. Hwever as the prgram matures, the prgrammer may want t be mre explicit abut the type f different variables and t use explicit typing as part f the errr checking prcess in his prgram. Built-in types: DesignScript supprts the fllwing built-in types: int, duble, bl, string a : int = 10; // whle numbers, typically used fr cunters, indices, etc b : duble = 5.1; // with a decimal flating pint c : bl = true; // r false d : string = "hell wrld"; e = null; // undefined Optinal use f type : DesignScript supprt bth typed and un-typed variables The type f a variable can be defined using the syntax variablename : type; variablename : type = expressin; // initialize a variable with a value In the absence f the type f a variable being explicitly defined, the type f a variable takes the type f the value assigned t it a = 10; // variable 'a' has n predefined type, // but assumes the 'int' type by having an int (the value 10) assigned t it Default type: DesignScript has a default type called var. a : var; // the variable a is declared, but f an undefined type User defined types: these are types defined as classes within DesignScript r via imprted DLL s. DesignScript is an bjectriented language and uses the standard terminlgy f class, subclass, superclass, cnstructr, methd, arguments and instance, as in: instance = Class.Cnstructr(arg1, arg2, argn); A variable is an instance f a class using a particular named cnstructr r methd with varius input arguments. Optinal typing and the ability f a variable t change type: We have seen that variables need nt be explicitly typed and that they can take n the type f the value assigned t them. It is therefre pssible fr a variable t change its type, and this may affect the validity f hw it is referenced in subsequent language statements, as illustrated by this example: imprt("prtgemetry.dll"); WCS = CrdinateSystem.WCS; // use the standard DesignScript gemetry library // define the wrld crdinate system a = Line.ByStartPintEndPint (Pint.ByCartesianCrdinates(WCS, 5, 5, 0), Pint.ByCartesianCrdinates(WCS, 10, 5,0)); // create variable a as instance f the Line class b = a.pintatparameter(0.5); // referencing variable a t make variable b [pint n the line] a = Arc.ByPintsOnCurve(Pint.ByCartesianCrdinates(WCS, 5, 5, 0), Pint.ByCartesianCrdinates(WCS, 10, 5, 0), Pint.ByCartesianCrdinates(WCS, 10, 10, 0)); // switch variable a t be an instance f the Arc class // variable b is still valid In this example, variable b is still valid because the.pintatparameter() methd is defined in the Curve class and Line and Arc are bth subclasses f Curve. S it is pssible fr a variable t be defined withut a type r t change its type. Hwever, when it is referenced (either as an instance used with a methd r as an argument) then it may be required t be f specific type. Therefre (mre generally) the users shuld check the class hierarchy f the libraries he is using t ensure that such type changes are valid.

3 Prperties: user defined types (r classes) can have prperties which are accessed via the. peratr [the dt peratr] Prperties may have a defined type. imprt("prtgemetry.dll"); a = Pint.ByCrdinates(5,5,0); b = a.x; // b = 5.. access the X crdinate prperty f the Pint variable 'a' Nte: mst prperties f the gemetry bjects in PrtGemetry are read nly and cannt be assigned t. A cnstructr [such as Pint.ByCrdinates(5,5,0);] is effectively setting a set f related (and sufficient) prperties in ne g. DesignScript intentinally restricts the change f a single prperty [such as the X crdinate f a pint] in islatin, utside the knwn cntext prvided by such methd. a.x = 10; // nt allwed, instead a methd shuld be used t define a.x in the cntext f ther prperties There are sme prperties that are writeable and can be assigned t, specifically in the DesignScript PrtGemetry library: imprt("prtgemetry.dll"); a = Line.ByStartPintEndPint (Pint.ByCartesianCrdinates(WCS, 5, 5, 0), Pint.ByCartesianCrdinates(WCS, 10, 5,0)); a.clr = Clr.Red; // assign a clr t a gemetric variable a.visible = true; // cntrl a variable s visibility The users shuld check the prperties f the class he is using t determine which prperties are read nly r writable. Guaranteed Prperties: Each class in the gemetry library has a set f guaranteed prperties that are always defined n matter which cnstructr is used t create an instance f the class. Therefre these guaranteed prperties can always be referenced. There may als be ther prperties, which are nt guaranteed and which are unique t specific cnstructrs being currently used. These prperties may nt be available t be referenced if the cnstructr fr this instance is changed. Cllectins: can be defined with the ntatin and evaluated by the Cunt() and Rank() functins a = 1, 2, 3, 4; // a 1D cllectin defined using the ntatin, with a list f values b = Rank(a); // b = 1 c = Cunt(a); // c = 4 d = 1, 2, 3, 4 ; // d is a 2D cllectin e = Rank(d); // d = 2 f = Cunt(d); // f = 2 Range Expressin: range expressin can be used t generate numeric cllectins, in the frm start..end..inc a = 1..5; // a = 1,2,3,4,5 f n increment is specified use the default increment f '1' b = ; // b = 1,3,5,7,9 using the defined increment '2' c = ~3; // c = 1.0, , , 9.0 using the 'apprximate' increment '~3' d = #3; // d = 1, 5, 9 using the 'number f cases' '#3' Indexing: the members f a cllectin can be accessed using indices and the [] ntatin a = 1..9; // a = 1,2,3,...7, 8, 9.. using the default increment f '1' b = a[0]; // b = 1 in DesignScript as with ther languages, indexing starts frm zer c = a[-1] ; // c = 9 negative indexing cunts back frm the end f the cllectin d = a[ ]; // d = 2, 4, 6 a cllectin f int s can be used t select a sub cllectin, // via a range expressin e = a[ 2, 3, 0 ]; // d = 3,4,1 a cllectin f int s can be used t select a sub cllectin, // via sme arbitrary cllectin f = Cunt(a); // f = 9 using the Cunt() functin Nte: the fllwing cde will fail g = a[cunt(a)]; // because indexing starts at zer, the last member f a cllectin is a[cunt(a)-1].. This prvides the mtivatin fr negative indexing where: a[cunt(a)-1] is equivalent t a[-1] (the cunt f a is applied autmatically) Rectangular Cllectin: is a cllectin where all sub cllectins are the same dimensin and length a = 1, 2, 3, 4 ; // a rectangular 2D cllectin b = Cunt(a[0]); // b = 2 bth the a[0] and a[1] subcllectins and have the same length c = Cunt(a[1]); // c = 2

4 Ragged Cllectin: is a cllectin where sub cllectins may have different dimensins and lengths a = 1, 2, 3, 4, 5, 6 ; // a ragged 2D cllectin b = Cunt(a[0]); // b = 2 a[0], a[1] and a[2] are subcllectins f different lengths c = Cunt(a[1]); // c = 3 d = Cunt(a[2]); // d = 1 Declaring variables: DesignScript gives cmplete freedm t the prgrammer, as fllws: a; // the variable is untyped and can have any value assigned t it b = null; // the variable is untyped and can have any value assigned t it c : var; // the variable is untyped and can have any value assigned t it d : int; // the variable is declared as a single int e : int[]; // the variable is declared as a 1D cllectin f int's: all member must be int's f : int[][]; // the variable is declared as a 2D cllectin f int's: all member must be int's g : int[]..[]; // the variable can be a single int r a cllectin f int's f any dimensin h = ; // the variable is an empty cllectin f any type and can als be a single value *Nte: the use f the int type (abve) is purely illustrative. Any type can be used, as apprpriate.] In summary: A variable can be untyped and therefre can be a single value f any type r a cllectin f any dimensin f any type. Or a variable can be declared as a single value r as a cllectin f a specified dimensin, r as a cllectin f any dimensin; and the variable can be typed r untyped. If it is imprtant t declare the type f the variable and it is anticipated that a variable may be a single value r a cllectin f values, then the declaratin variable : type[]..[]; shuld be used. If it is imprtant t declare the type f the variable and it is anticipated that a variable culd be f mre than ne type, then the type declared shuld be the mst specialised cmmn super type f the anticipated values fr this variable. Fr example, if a variable culd be a Line r an Arc, then it shuld be declared as variable : Curve; [as the cmmn super type] Similarly, if it is imprtant t declare the type f a cllectin variable and it is anticipated that the variable will be a hetergeneus cllectin, then the type f the cllectin shuld the mst specialised cmmn super type f the anticipated members. Fr example, if a variable cllectin culd cntain members that are Line r Arc, then the cllectin shuld be declared as variable : Curve[]; [as the cmmn super type] r variable : Curve[]..[]; if it is anticipated that the dimensin f the cllectin may change. Therefre (mre generally) the users shuld check the class hierarchy f the libraries he is using t ensure that he has selected the apprpriate cmmn super type. Flexible cllectin building: DesignScript supprts flexible and direct ways t build cllectins h[2] = 5; // h = null, null, 5 here, a variable can be defied as a member f a cllectin, // withut that cllectin having been previus defined. The values f the // members f the cllectin prir t member which is explicitly defined will be null h[1] = 4,5,6; // h = null 4, 5, 6, 5 here, a member f cllectin that was riginally a single value // (r a sub cllectin f a particular dimensin) can be directly replaced by a different // single value r by a cllectin f a different dimensin In additin there are a number f functins available t build and manipulate cllectins, including t Insert, Remve and test fr the presence f members in a cllectin *see the Language Functin tab in the DesignScript class library dcumentatin]

5 Imperative Prgramming: accessed via the [Imperative]directive applied t a blck: Imperative prgramming is useful t perfrm iteratin, either stepping thrugh a cllectin r t perfrm sme iterative feedback r ptimisatin lp. Imperative prgramming uses cnventinal fr and while lps and if.. else statements t explicitly define flw cntrl. Prgram executin: In the absence f such flw cntrl the next statement in the prgram is executed, fr example: 1 a; b; // define the variables t be utput at the tp r uter scpe 2 [Imperative] 3 4 a = 10; // riginal value f 'a' 5 b = a * 2; // calculating b based n the current value f a.. b = 20 6 a = 15; // changing the value f 'a' will NOT cause the value f 'b' t change 7 If this cde fragment is executed in single step debug, the fllwing sequence f statements will be executed: 4, 5, 6. Iteratin: defined by a fr lp, as: fr (variable in cllectin) defined by a while lp, as: while(cnditin_is_true).. An example f a fr lp: a= ; // declare an empty cllectin at the glbal scpe [Imperative] fr(i in 0..5) // fr lp a[i] = i; b = a; // b = 0, 1, 2, 3, 4, 5 An example f a while lp: a= ; // declare an empty cllectin at the glbal scpe i = 0; // define the initial value fr i [Imperative] while(i <=5) // test if I satisfies the defined cnditin a[i] = i; i = i+1; // increment i b = a; // b = 0, 1, 2, 3, 4, 5

6 Cnditinal: defined by an if..else statement as: if (cnditin_is_true) single_statement_if_true if (cnditin_is_true) statements_if_true if (cnditin_is_true) statements_if_true else statements_if_false An example f a if..else cnditinal embedded in a duble fr lp imprt("prtgemetry.dll"); icunt = 4; jcunt = 5; resultpints = ; // define an empty cllectin [Imperative] fr(i in 0..iCunt) fr(j in 0..jCunt) if ((i == 0) (i == icunt) (j == 0) (j == jcunt)) // pints are the periphery f the array t mve dwn resultpints[i][j] = Pint.ByCrdinates(i, j, -1); else // pints are the periphery f the array t mve up resultpints[i][j] = Pint.ByCrdinates(i, j, 1);

7 A mre cmplex example f iteratin: imprt("prtgemetry.dll"); imprt("math.dll"); // use the standard DesignScript gemetry library // use the standard DesignScript math library surfacepints_2d_array : Pint[][]; // define a 2D array f Pints surface : BSplineSurface; // define a surface [Imperative] xsize = 10; ysize = 15; xheight = 2; yheight = 4; numclsx = 8; numclsy = 6; fr(i in 0..numClsX) fr(j in 0..numClsY) surfacepints_2d_array[i][j] = Pint.ByCrdinates( i * (xsize / numclsx), // x crdinates j * (ysize / numclsy), // y crdinates (Math.Sin(i * (180 / numclsx)) * xheight) + (Math.Sin(j * (180 / numclsy)) * yheight) ); // z crdinates surface = BSplineSurface.ByPints(surfacePints_2D_array).SetClr(Clr.Cyan); // create a surface Cmpare this script with the same gemetry created Assciatively n Page 9.

8 Assciative Prgramming: accessed via the [Assciative]directive: Assciative prgramming uses the cncept f graph dependencies t establish 'flw cntrl.' Changes t 'upstream' variables are autmatically prpagated t dwnstream variables. Assciative prgramming in DesignScript als implements tw additinal cncepts: replicatin and mdifiers. With replicatin, anywhere a single value is expected a cllectin may be used instead and the executin is autmatically replicated ver each element. The cmbined result f dependencies and replicatin is that is easy t prgram cmplex data flws (including gemetric peratins) invlving cllectins. An upstream variable may change frm being a single value t a cllectin r frm a cllectin t anther cllectin f different dimensins r size, s the dwnstream dependent variables will autmatically fllw suit and als becme cllectins f the apprpriate dimensin and size. This makes Assciative prgramming incredibly pwerful, particularly in the cntext f generating and cntrlling design gemetry. With mdifiers, each variable can have multiple states, which might reflect the gemetric mdeling sequence. Fr example a gemetric variable might be created (say as a curve) and then it can be mdified by being trimmed, prjected, extended, transfrmed r translated. Withut the cncept f mdifiers each state r mdeling peratin wuld require t be a separate variable and this wuld frce the user t have t make up the names f all these intermediate variables. Mdifiers avid impsing this naming prcess n the user. Dependencies, replicatin and mdifiers can all be cmbined t represent the typical mdeling peratins fund in architecture and cnstructins. Buildings are cmpsed f cllectins f cmpnents. Typically these cllectins are ften the prduct f a series f standard peratins acrss all members. On the ther hand, within such cllectins there may be special cnditins where different r additinal mdeling peratins are required t be applied t a sub cllectin f members. Mdifiers enable these special cnditins t be identified and fr additinal mdeling peratin applied. Assciative prgramming invlves the fllwing cncepts: Assignments and Dependencies In assciative mde, except where therwise nted, all DesignScript statement are f the frm: variable = expressin; fr example: a = 10; // a is defines as int with the value 10; b = a * 2; // b is defined by the expressin 'a * 2' These statements define relatinships between the variable (n the left hand side f the statement) and references t ther variables within the expressin (n the right hand side f the statement). These relatinships define a graph. [Nte: In the fllwing cde fragment, we have added line numbers s as t be able t describe the executin rder. These line numbers shuld be remved befre executing these fragments in DesignScript] 1 a; b; // define the variables t be utput at the tp r uter scpe 2 [Assciative] 3 4 a = 10; // riginal value f 'a' 5 b = a * 2; // define b as dependent n a.. b initially = 10, then = 30 6 a = 15; // changing the value f 'a' will change the value f 'b' (nw = 30) 7 If this cde fragment is executed in single step debug, the fllwing sequence f statements will be executed: 4, 5, 6, 5. In assciative prgramming, statement 5 is nt just executed nce (in sequence, after statement 3). In assciative prgramming, statement 5 establishes a persistent relatinship between the variable b and variable a. When the value f variable a is re-defined in statement 6, the Assciative update mechanism in DesignScript will execute all statements that depend n variable a, which (in this example) includes statement 5. Hence the executin sequence: 4, 5, 6, 5. This can be cmpared t the exact same cde fragment executed imperatively, as fllws: 1 a; b; // define the variables t be utput at the tp r uter scpe 2 [Imperative] 3 4 a = 10; // riginal value f 'a' 5 b = a * 2; // calculating b based n the current value f a.. b = 10 6 a = 15; // changing the value f 'a' will NOT cause the value f 'b' t change 7 If this cde fragment is executed in single step debug, the fllwing sequence f statements will be executed: 4, 5, 6. In imperative prgramming, statement 5 is just executed nce (in sequence, after statement 3). In imperative prgramming, statement 5 des nt establish a persistent relatinship between the variable b and variable a.

9 Cllectins and Replicatin: a cllectin can be used where a single value is expected 1 a; b; // define the variables t be utput at the tp r uter scpe 2 [Assciative] 3 4 a = 10; // riginal value f a 5 b = a * 2; // define b as dependent n a 6 a = 5, 10, 15 ; // redefine a as a cllectin.. the value f b is nw = 10, 20, 30 7 In this example, when a becmes a cllectin f values, the expressin a * 2 is executed fr every member f a and the resulting cllectin f values are assigned t b. In assciative prgramming, the existence f variable as a cllectin is prpagated t all dependent variables, in this example b. This prpagatin f cllectins is called replicatin. If this cde fragment is executed in single step debug, the fllwing sequence f statements will be executed: 4, 5, 6, 5. Nte that variables can be untyped, but if they are declared as typed then DesignScript assumes that the user wants t restrict the values that can be assigned t that variable and will reprt errrs if an errneus assignment is attempted. Fr example, if a and b are defined as single int s, belw: a : int; // explicitly defined as a single int b : int; // explicitly defined as a single int [Assciative] a = 10; b = a * 2; a = 5, 10, 15 ; // changed int an array f int's this will fail T vercme this, there are tw strategies: a : int[]..[]; // explicitly defined a variable as a type which culd be a single value r a cllectin b; // declare the variable as untyped Zipped replicatin: When there are multiple cllectins within the same expressin, we need t cntrl hw these are cmbined. With zipped replicatin, when there are multiple cllectins, the crrespnding member f each cllectin is used fr each evaluatin f the expressin. This wrks well when all cllectins are the same dimensin and length. If cllectins are f different lengths, then the shrtest cllectins determines the number f times the expressin is evaluated, and hence the size f the resulting cllectin. a; b; c; // define the variables t be utput at the tp r uter scpe [Assciative] a = 1, 5,9; b = 2, 4,6; c = a + b; // zipped replicatin peratin.. c = 3, 9, 15 Nte: replicatin wrks well with rectangular cllectin, but the results may be undefined when used with ragged cllectins.

10 Cartesian replicatin cntrlled by Replicatin Guides When there are multiple cllectins, we need t cntrl hw these are cmbined. With cartesian replicatin, each member f ne cllectin is evaluated with every member f the ther cllectins, s that resulting cllectin is the cartesian prduct f the input cllectins. The rder in which the cartesian prduct is created is cntrlled by replicatin guides in the frm <n>, which define the sequence f the replicatin peratins. This must be a cntinuusly increasing sequence f int s starting at 1. This sequence is equivalent t the rder f the nested fr lps that wuld have had t be written in an Imperative script a; b; c; d; // define the variables t be utput at the tp r uter scpe [Assciative] a = 1, 5,9; b = 2, 4 ; c = a<1> + b<2>; // cartesian replicatin c = 3, 5, 7, 9, 11, 13 d = a<2> + b<1>; // changing the sequence f replicatin guides changes the resulting cllectin // d = 3, 7, 11, 5, 9, 13 Cmbining zipped and cartesian replicatin In the fllwing example, we are taking the cartesian prduct f ne 1D array and anther 1D array [t create an intermediate 2D array) and then 'zipping' this intermediate 2D array with anther 2D array imprt("prtgemetry.dll"); imprt("math.dll"); // use the standard DesignScript gemetry library // use the standard DesignScript math library surfacepints_2d_array : Pint[][]; // define a 2D array f Pints surface : BSplineSurface; // define surface [Assciative] xsize = 10; ysize = 15; xheight = 2; yheight = 4; numclsx = 8; numclsy = 6; xcrds_1d_array ycrds_1d_array = 0..xSize..#numClsX; // 1D array = 0..ySize..#numClsY; // 1D array xsinewave_1d_array = (Math.Sin( #numClsX) * xheight); ysinewave_1d_array = (Math.Sin( #numClsY) * yheight); // 1D array // 1D array zheight_2d_array = xsinewave_1d_array<1> + ysinewave_1d_array<2>; // using cartesian replicatin // adding a 1D array t anther 1D array creates a 2D array surfacepints_2d_array = Pint.ByCrdinates(xCrds_1D_array<1>, ycrds_1d_array<2>, zheight_2d_array<1><2>); // this peratin is taking the cartesian prduct f xcrds_1d_array and ycrds_1d_array // [t create a 2D array) and then 'zipping' this 2D array with zheight_2d_array surface = BSplineSurface.ByPints(surfacePints_2D_array).SetClr(Clr.Cyan); // create a surface Cmpare this script with the same gemetry created Imperatively n Page 6.

11 Mdifiers: a variable can have a sequence f states As we have seen, a variable may be defined in ne statement (where it is n the left hand side f the = sign and has a value assigned t it) and a variable may be referenced in a subsequent expressin (n the right hand side f the = sign). a = 10; // a is defines as int with the value 10; b = a * 2; // b is defined by the expressin 'a * 2' We nw intrduce the cncept in Assciative prgramming f a mdifier in which a previusly defined variable appears n bth left and right hand side f statement, s as t have its riginal value mdified. a; b; // define the variables t be utput at the tp r uter scpe [Assciative] a = 10; // riginal value f a b = a *2; // define b as dependent n a a = a + 1; // mdify a t be 1 mre than its riginal value. nw a = 11 // the value f b is nw = 22 Essentially, the variable a has multiple states state 1: a = 10; // riginal value f a state 2: a = a+1; // mdify a t be 1 mre than its riginal value. nw a = 11 when a variable is referenced, the value f its final state is used. In this case, when the statement b = a *2; is evaluated, the value f the secnd (and final) state f a is used (i.e. 11) Mdifiers are extremely useful t represent cmpund mdeling peratins, fr example: imprt("prtgemetry.dll"); // use the standard DesignScript gemetry library a; // define the variables t be utput at the tp r uter scpe [Assciative] a = Line.ByStartPintEndPint(Pint.ByCrdinates(10, 0, 0), Pint.ByCrdinates(10, 5, 0)); a = a.trim(0.2, 0.8, false); // trim the line a = a.translate(1, 1, 0); // mve the trimmed line Mdifiers avid having t give a separated variable name t each peratin. Mdifying a member f cllectin: A member f a cllectin can be mdified, withut breaking the integrity f the cllectin. imprt("prtgemetry.dll"); // use the standard DesignScript gemetry library a; b; // define the variables t be utput at the tp r uter scpe [Assciative] a = ; // initially a = 1,5,9 b = a *2; // define b as dependent n a, b initially = 2, 10, 18 // subsequently b = 2, 10, 2 a[-1] = a[-1] + 1; // mdify a member f the cllectin // a = 1,5,10 nte: use f negative indexing frm the end f the cllectin Because a member f the cllectin a has been mdified, this will trigger a re-cmputatin f dependent statement b = a *2; Hwever, this re-cmputatin will use the cllectin a including the mdificatin t a[-1] The use f mdifier saves having t use explicit names fr the intermediate states in a sequence f mdelling peratins. Summary: A statement where the variable n the left hand side is als referenced within the expressin n the right hand side is effectively a mdifier f that variable, e.g. a = a + 1;

12 Mdifier blcks: The statements that define and mdify a variable d nt have t be cntiguus statements in a prgram. But this flexibility f separating the statements relating t same variable may eventually lead t a cnsiderable lss f clarity. It may be advantageus t grup all the statements which define and mdify a specific variable int a single prgram blck, as fllws: imprt("prtgemetry.dll"); // use the standard DesignScript gemetry library a; // define the variable t be utput at the tp r uter scpe [Assciative] a = // create the line Line.ByStartPintEndPint(Pint.ByCrdinates(10, 0, 0), Pint.ByCrdinates(10, 5, 0)); Trim(0.2, 0.8, false); // trim the line Translate(1, 1, 0); // mve the trimmed line Anther advantage f the Mdifier blck is that the name f the variable des nt have t be repeated n the left and right hand side f each mdifier statement. If the variable name is lng, this remves a surce f typing errrs and imprves readability. Right Assign: allws the labeling and referencing f intermediate states within a mdifier blck using the => ntatin. imprt("prtgemetry.dll"); // use the standard DesignScript gemetry library a; b; c; d; // define the variables t be utput at the tp r uter scpe [Assciative] a = Line.ByStartPintEndPint(Pint.ByCrdinates(10, 0, 0), Pint.ByCrdinates(10, 5, 0)) => a@initial; //'right assign' the initial state f a t a new variable Trim(0.2, 0.8, false) => a@trim; // trim the line and 'right assign' the intermediate state // f a t a new variable Translate(1, 1, 0); // mve the trimmed line b = a; c = a@initial.translate(-1, 1, 0); d = a@trim.translate(-1, -1, 0); // 'b' will be the final state f 'a' // 'c' is a mdificatin f an intermediate state f 'a'; // similarly fr 'd' In-line cnditinal: an in-line cnditinal is defined as: variable = blean_expressin? expressin_if_true : expressin_if_false; fr example: a; b; // define the variables t be utput at the tp r uter scpe [Assciative] a = 4; // variable a as a single value b = a<2?10:20; // make the value f 'b' depend cnditinally n the value a : b = 20; //

13 In-line cnditinal with a cllectin: a new cllectin can be built frm an existing cllectin, using replicatin, where the individual members f the existing cllectins are evaluated, and the expressin_if_true and the expressin_if_false are used t build the new cllectin, fr example: a; b; // define the variables t be utput at the tp r uter scpe [Assciative] a = 0..5; // 'a' = 0, 1, 2, 3, 4, 5 b = a<2?10:20; // 'b' = 10, 10, 20, 20, 20, 20; // build cllectin 'b' by evaluating // each member f the cllectin 'a' In-line cnditinal where the value f ne prperty is used t set the value f anther (writable) prperty: In the fllwing example the blean expressin within the in-line cnditinal is evaluated fr each member f the cllectin and the value f the expressin_if_true r value f the expressin_if_false is assigned t the writable prperty f that member f the cllectin. imprt("prtgemetry.dll"); curve : Curve[]..[]; // define the utput variable as a cllectin f Curves [Assciative] start = Pint.ByCrdinates(0..10, 0, 0); // a 1D array f pint end = Pint.ByCrdinates(5, 5, 0); // a single pint curve = Line.ByStartPintEndPint(start, end); // a 1D array f lines curve.clr = curve.length > 6? Clr.Red : Clr.Blue; // use length t determine clr (replicated) The length f each member f the array f curves will be individual evaluated t determine its clr. This demnstrates a replicated in-line cnditinal assigning the value f a writable prperty. Understanding the differences between Assciative and Imperative prgramming: Assciative prgramming supprts graph based dependencies and uses: replicatin and replicatin guides, mdifiers and mdifier blcks in assciative prgramming a prgram statement nt nly defines that the value f a variable will be calculated based n references t ther variables, but als defines a persistent dependency relatinship between the variable whse value is being cmputed and the references t the ther variables. nce a dependencies has been established, a subsequent change t these ther variables in successive statements will cause the variable t be recmputed. In single-step debug mde the executin cursr may apparently mve backwards thrugh the surce cde as statements are executed and the value f variables are recmputed based n these dependencies. in the absence f graph based dependencies, statements are executed in lexical rder Imperative prgramming supprts explicit flw cntrl : iteratin with fr and while lps cnditinals with if..else statements in the absence f such flw explicit cntrl statements are executed in lexical rder in imperative prgramming a prgram statement defines the value f a variable t be calculated based n references t ther variables, but this is a ne-time peratin. A subsequent change t these ther variables in successive statements des nt cause the variable t be recmputed. frward references are nt allwed: a variable cannt be cmputed frm variables which have yet t been defined

14 Additinal functinality cmmn t bth Assciative and Imperative language interpretatin: Functins are first class elements f the language, Functin must be defined in the glbal scpe (the utermst blck) Functins are defined using the def key wrd as: def functin_name (argument_list) prgram statements def functin_name : return_type (argument_list) prgram statements The argument_list is a cmma separated list, with ptinal types By cnventin functin names start with an uppercase letter and argument names start with a lwer case letter. Fr example, with untyped arguments def f(x) = x * 5; // x is untyped, but the functin will fail if it is nt an int r a duble The functin can be called with different arguments.. sme which wrk and thers which fail: a = f(10); // a = 50.. with an int b = f(10.1); // b = with a duble c = f(mypint); // c = null.. representing failure Functin Overlading it is pssible t have multiple definitins f the same functin with different types f arguments, fr example: def f(x : int) = x * 5; // x as an int def f(x : duble) = x * 4.0; // x as an duble def f(x : Pint) = x.translate( 6.0, 0, 0); // x as a Pint In additin the type f the return argument can be explicitly defined, fr example: def f : int (x : int) = x * 5; // x as an int def f : duble (x : duble) = x * 4.0; // x as an duble def f : Pint (x : Pint) = x.translate( 6.0, 0, 0); // x as a Pint The functin can be called with different arguments and the apprpriate versin f the functin will autmatically be called fr arguments f the specific type, but if an argument is prvided fr which there is n verladed methd, then this will fail. a = f(10); // a = 50.. with an int: DesignScript will call: def f:int (x : int) b = f(10.1); // b = with a duble: DesignScript will call: def f:duble(x : duble) c = f(mypint); // c = mypint translated : DesignScript will call: def f:pint(x : Pint) d = f(yurline); // d = null.. DesignScript will call: def f(x) which will fail A functin may have a single statement, f the fllwing frm: def f(x) = x * 5; Or alternatively a functin may have multiple statements, in which the last must be a return statement defined using the return keywrd, in the frm: return = expressin; A functin can return any type. The return statement shuld be the last statement f the functin and nt nested within a blck, fr example: def f : int (x) y : int; y = x * 5; return = y + 1; // define a lcal variable // use the lcal variable tgether with arguments // define a return value Scping issues with functins. If we cnsider the functin definitin f, abve and within the same script have the statements y = 1; z = f(y+10); then because the variable y is defined bth in the uter scpe f the functin and within the functin, the executin f f will change the value f y in the uter scpe. This kind f side effect is ptentially a surce f errrs.

15 In the case abve, a variable was being assigned t within a functin and had the same name as a variable in the main script, but whether r nt the variable was present in the main script the functin wuld still execute. In the next example, a variable in the uter scpe is referenced in a functin def f (x) return = y * x; // define a return value y = 2; z = f(10); // z = 20 If y is cmmented ut then it will nt be available within f and the functin will fail, belw: def f (x) return = y * x; // this will fail // y = 2; cmment ut y s that it is nt available within f z = f(10); // z = null This means that functin f can nly perate in the cntext where the variable y is defined in the uter scpe. One f the mtivatins fr creating a functin is that it can eventually be mved t a functin library and used mre generally. Fr the functin t fulfill this rle, it cannt reference variables in its uter scpe. As such when the cde is maturing it is ften helpful t ensure that all variables within a functin are defined lcally r be arguments. Prgramming with Functins: Functins are first class features f the DesignScript language and as such they can be assigned t variables and passed arguments, fr example: def innerf_1 (x : int) return = x * 5; def innerf_2 (x : int) return = x + 5; // define a return value // define a return value def uterf ( func : var, x : int) return = func(x); // call the functin y = uterf(innerf_1, 10); // y = 50.. call uterf with innerf1 z = uterf(innerf_2, 10); // z = 15.. call uterf with innerf2

16 Object riented prgramming: Classes can be defined using the class keywrd and define new types, as class class_name class_statements class class_name extend base_class_name class_statements where class_statements can be prperty_definitins, cnstructrs r instance methds. All these must be defined within the scpe f the class definitin, i.e. within. By cnventin class names start with an uppercase letter. Inheritance: classes can be defined: by inheritance, by using the extend key wrd and specifying a base_class_name Classes need nt have a specified base class (the class will assume t be derived frm the universal base class, var). In this case a class can be defined by cmpsitin, by including existing classes as prperties Prperties: prperty_definitins may ptinally be typed and ptinally be given an initial value, fr example: Origin; Origin : Pint; // specify an untyped prperty withut an initial value // specify a prperty f a defined type withut a value Origin : Pint = Pint.ByCrdinates(0,0,0); // specify a prperty f a defined type and initial value By cnventin prperty names start with an uppercase letter. Cnstructrs: are define within the scpe f the class using the cnstructr key wrd with an ptinal cnstructr name, as: cnstructr (argument_list) prgram statements cnstructr cnstructr_name prgram statements Cnstructrs always return an instance f the class and therefre d nt need a return statement. The prgram statements within a cnstructr can use any cmbinatin f Assciative and Imperative prgramming. By cnventin cnstructr names start with an uppercase letter and argument names start with a lwer case letter. Methds: must be defined in the scpe f the class using the def key wrd as: def methd_name (argument_list) prgram statements def methd_name : return_type (argument_list) prgram statements Methds are similar t functin but are assciated with an instance f the class which can be referenced by the this keywrd. There can be multiple verlads fr the same methd name, but with different arguments. By cnventin methd names start with an uppercase letter and argument names start with a lwer case letter.

17 An example f a class definitin, with multiple prperties, a cnstructr and instance methds imprt("prtgemetry.dll"); imprt("math.dll"); class FixitySymbl // this class is implicitly extended frm var Origin : Pint; // prperties.. Size : duble; IsFixed : bl; Symbl : var[]..[]; //defined 'by cmpsitin', by ne r mre Slids cnstructr FrmOriginSize(rigin : Pint, size : duble, isfixed : bl) //example cnstructr Origin = rigin; // by cnventin prperties f the class (with uppercase names) Size = size; // are ppulated frm the crrespnding arguments (with lwercase names) IsFixed = isfixed; lcalwcs = CrdinateSystem.WCS; Symbl = isfixed? // cnditinal Cubid.ByLengths(CrdinateSystem.ByOriginVectrs(Origin, // if true lcalwcs.xaxis, lcalwcs.yaxis), Size, Size, Size) : Sphere.ByCenterPintRadius(Origin, Size * 0.25), // if false Cne.ByCenterLineRadius(Line.ByStartPintDirectinLength(Origin, lcalwcs.zaxis, -Size), Size * 0.01, Size * 0.5) ; def Mve : FixitySymbl(x : duble, y : duble, z : duble) // an instance methd return = FixitySymbl.FrmOriginSize(this.Origin.Translate(x, y, z), this.size, this.isfixed); // nte: the use f 'this' key wrd t refer t the instance // in general instances f DesignScript class are immutable, and cannt be changed // t give the illusin f change, this instance methd actually calls a cnstructr // and creates a new instance, but using sme f the prperties f the previus instance def SetClr (clr : Clr) this.symbl = this.symbl.setclr(clr); // call SetClr n cnstituent gemetric prperties return = null; rigin1 = Pint.ByCrdinates(5, 5, 0); rigin2 = Pint.ByCrdinates( , 10, 0); // define sme apprpriate input arguments // including a cllectin f pints firstfixitysymbl = FixitySymbl.FrmOriginSize(rigin1, 2, true); // initially cnstructed firstfixitysymbl.setclr(clr.cyan); firstfixitysymbl = firstfixitysymbl.mve(0, -4, 0); // set clr // mdified by the instance methd secndfixitysymbl = FixitySymbl.FrmOriginSize(rigin2, 2, false); // replicated cllectin secndfixitysymbl[2] = secndfixitysymbl[2].mve(0, -3, 0); // ne member mdified

18 Cmbining Imperative and Assciative styles prgramming: There are sme interesting scenaris where bth Imperative and Assciate prgramming can be cmbined. Cnsider the fllwing example f a simple design ptimisatin, where an Assciative mdel is nested within an Imperative while lp (in this case t find the highest peak f a sine wave surface with a defined area. imprt("prtgemetry.dll"); imprt("math.dll"); // use the standard DesignScript gemetry library // use the standard DesignScript math library surfacepints_2d_array : Pint[][]; // define a 2D array f Pints surface : BSplineSurface; // define surface area = 0; height = 0; heightinc = 0.1; [Imperative] while((area < 190)&&(height<10)) // increase height while the area < 190 and the height < 10 [Assciative] xsize = 10; ysize = 15; numclsx = 8; numclsy = 6; xcrds_1d_array ycrds_1d_array = 0..xSize..#numClsX; // 1D array = 0..ySize..#numClsY; // 1D array xsinewave_1d_array = (Math.Sin(( #numClsX)) * height); // 1D array ysinewave_1d_array = (Math.Sin(( #numClsY)) * height); // 1D array zheight_2d_array = xsinewave_1d_array<1> + ysinewave_1d_array<2>; // using cartesian replicatin // adding a 1D array t anther 1D array creates a 2D array pints = Pint.ByCrdinates(xCrds_1D_array<1>, ycrds_1d_array<2>, zheight_2d_array<1><2>); surface = BSplineSurface.ByPints(pints).SetClr(Clr.Cyan); // create the surface area = surface.area; // measure the surface area height = height + heightinc; // increase the height

19 Gemetry Library

20 IDE IDE cmmands and equivalent cntrl characters "New script" "ctrl + n" "Open script" "ctrl + " "Save" "ctrl + s" "Save as" "ctrl + alt + s" "Clse script " "ctrl + w" "Open slutin" "ctrl + shift + " "Save slutin" "ctrl + shift + s" "Clse slutin" "ctrl + shift + q" "Und" "ctrl + z" "Red" "ctrl + y" "Cut" "ctrl + x" "Cpy" "ctrl + c" "Paste" "ctrl + v" "Cmment" "ctrl + k" "Uncmment" "ctrl + u" "Run" "ctrl + F5" "Debug" "F5" "Next" "F10" "Step in" "F11" "Step ut" "shift + F11" "Stp" "shift + F5" change text size ctl + muse scrll in editr windw