Getting Started | Documentation | Glish | Learn More | Programming | Contact Us |
Version 1.9 Build 1556 |
|
A reference is an alias to another variable, record field, or, for some types, a portion of a variable or record field. It provides a mechanism to allow two or more variables to refer to the same value. References are created using the ref operator.
a := 1:5 b := ref a b[2] := 9 print aprints [1 9 3 4 5] and not [1 2 3 4 5]. If you now execute:
a[3] := 121b will equal [1 9 121 4 5] (as will a). References to record field are created in the the same way:
rxd := [a = 3:1, b = "hello there"] sxd := [x = ref rxd.a, y = ref rxd.b] sxd.x[2] := -4 # changes rxd.a[2], too print rxd.a[2]prints -4.
A very important point to keep in mind when using reference is the way references can be broken through assignment. This can be a source of unexpected problems. A reference allows two variables to refer to the same value, but assigning to either of the variables, as opposed to their elements, breaks the link. In the following,
x := 1:3 y := ref x x[3] := 9 # changes y[3], too y[1] := 10 # changes x[1], too x := 3:1 # !! breaks the reference !! x[2] := 121 # does NOT modify ythe next to last assignment of 3:1 to x, instead of subscripted elements of x, breaks the reference, and as a result, the final assignment does not modify y. After the last assignment, x equals [3, 121, 1], and y equals [10, 2, 9]. References to record fields behave in the same way.
The reference connection is maintained across assignment by explicitly using the val operator. For example, after executing:
c := [1, 3, 7, 12] d := ref c val c := "hello there"the value of d (and of course c) is the two-element string "hello there". Assigning to val d will similarly change the value of c.
The behavior of record fields are identical to other variables. For example,
r := [foo = 1:3, bar = "hello there"] s := [a = ref r.foo, b = ref r.bar] s.a[2] := -4 # changes r.foo[2], too s.a := [T, T, T, T, T] # doesn't change r.foo val r.bar := 1:7 ^ 2 # changes s.b, too print r.foo[2], s.b[5]prints -4 followed by 25.
The second assignment makes s a record with two fields, a and b, which are references to r.foo and r.bar.
The third assignment changes s.a[2] and r.foo[2] to be -4.
The fourth assignment breaks the link between s.a and r.foo, because s.a is assigned to the entire variable and not just some of its elements.
The fifth assignment modifies both r.bar and s.b to be a vector of the first 7 integers squared. Without the val operator, only r.bar changes, and the link between r.bar and s.b is broken.
It is also possible, though not recommended, to make the value referred to by a reference constant. This is done as follows:
c := 1 d := ref c const val d := 2The last assignment changes c to a constant value, and d is a reference to c. After this, c cannot be modified.
Partial value references can be created for any of the vector types. These references are created much like whole value references, but partial value references reference only a portion of the value. They also have more restrictions on their use than whole value references.
Partial value references are also created with the ref operator. Unlike whole value references, partial value references create an alias to a ``sub-vector'' or ``sub-array''. That is, they reference a portion of another vector or array. So for example,
vec := [1:10] svec := ref vec[5:9] svec[4] := 20 # modifies vec[8], tooHere a vector with ten elements, vec, is created, and then a reference to a portion of that vector is created, svec. Modification to any of svec elements changes the respective elements in vec. In this case, modifying the forth element in svec also changes the eighth element of vec. The length of svec is 5 not 10.
Partial value references are created for vector or array valued fields in the same way. For example,
xle := [x=1:10, l=10:1, e=[2,7]] m := [t=ref xle.x[9:10], u=ref xle.l[9:10], v=ref xle.e] m.u[2] := m.t[2] # modifies xle.l[10] as wellThis example shows how sub-vector references of fields are similar to whole value references of fields. It is important to note, however, that you cannot take a partial value reference of a record. So,
mz := ref xle["x e"]is not valid.
Partial value references can also be created for arrays, and this is probably where they prove most useful. In the following,
base := array(0,5,5) diag := ref base[array(1:5,5,2)] # a vector lower := ref base[4:5,] # a 2x5 array diag[3] := 1 # modifies base[3,3], too lower[1:2,[1,5]] := 5 # modifies base[4:5,[1,5]], # AND diag[5], as wellIn this example, an array, base, is created. Then two partial value references, diag and lower, are created. The partial reference diag references elements along the diagonal of base, and the partial reference lower references the fourth and fifth rows of base. Modifying elements of either of the references modifies the corresponding elements of base.
It is important to realize that partial value references are broken the same way as whole value references. Continuing with the previous example,
diag := 5:9 # !! breaks reference !! lower[2,2] := 22 # modifies base[5,2], alsothe assignment to diag does not modify base. It breaks the reference link, and sets diag equal to 5:9. Assignments to lower elements, e.g. the second one, still modify base because that link remains intact.
Breaking partial value references to record fields happens identically.
There are more restrictions maintaining partial element references than there are with whole value references. The val operator is used to explicitly maintain partial value references. For example,
a := 1:10 b := ref a[6:10] val a := 10:1 # modifies b as wellHere a vector, a , and a partial value reference, b are set up. Modifying the entirety of a changes the elements which b references. This type of manipulation must be done very cautiously, however, because if the referenced vector, a, is shortened the reference vector may become invalid. In the following,
val a := 6:10 # b is now INVALID!a is assigned a shorter vector. At this point, b is now invalid, and subsequent indexing into b will generate error messages.
The partial value reference can also be assigned to, but with restrictions. The length of the new value must match the length of the reference. So,
a := 1:10 b := ref a[6:10] val b := 11:15 # modifies a as wellhere b is used in a val assignment, but because the length of b and the length of the value being assigned are equal, all of b and the selected portion of a changes. If the lengths were not equal, an error message would be reported. Continuing this example,
val b := 1:15 # ERROR!An assignment such as this generates an error message.