Visualizing matrix transformations i pyplot

2012-01-21T10:34:00.002+01:00

I was playing around with some matrix transformations and trying to visualize them using python and pyplot. Run for example as: 'ipython -pylab pyplot_matrix_transformations.py' (-pylab not really needed).

# Visualizing some vector/matrix-transformations using pylab and pyplot
# Thomas Lundqvist, 2012-01-21
# Public Domain. Use freely!

from pylab import *
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure()
# ax = fig.add_subplot(111)
ax = Axes3D(fig)

# Draws lines between all points defined as column 
# vectors in matrix a. pyplot makes each call to plot
# use a different color

def p(a):
   ax.plot(a[0].tolist()[0], a[1].tolist()[0], zs=a[2].tolist()[0])

# Original set of points

a = mat(
 [[0,0,0,1],
  [1,0,0,1],
  [1,1,0,1],
  [0,1,0,1],
  [0,0,0,1]]).T
p(a)

# Shear, new x depends on 1 * old y
# Translate z-coord +0.2
m = mat(
 [[1,1,0,  0],
  [0,1,0,  0],
  [0,0,1,0.2],
  [0,0,0,  1]])
b = m*a
p(b)

# Scale y 2 times and translate +1 in z
m2 = mat(
 [[1,0,0,0],
  [0,2,0,0],
  [0,0,1,1],
  [0,0,0,1]])
c = m2*a
p(c)

# Do both transformations (m and m2)
p(m2*b)

# Rotate the 'a' and 'c' shapes 5 degrees 20 times
# around the z-axis
for i in range(20):
   r = deg2rad((i+1)*5)
   mr = mat(
 [[cos(r), -sin(r), 0, 0],
  [sin(r),  cos(r), 0, 0],
  [     0,       0, 1, 0],
  [     0,       0, 0, 1]])
   p(mr*a)
   p(mr*c)

# Display everything
fig.show()

The result should look like this. pyplot lets me rotate the graph using the mouse:

Go language reflection examples

2010-05-20T08:43:00.003+02:00

I have played around a bit with the new Go language (go, golang, go-lang). I couldn't find any good examples of how the reflection library worked so I made some brief examples below summarizing my findings.

Functions with variable number of arguments

First, it is possible to do many things without the reflect-package. For example, the following code shows how to distinguish between different types in a function using a variable number of parameters. The function split_into() splits a string into fields and put them all into different variables. The type of a variable determines how a field is converted (maybe a beginning of the c-language scanf).

// Split line at ',' and put into variables if
// number of fields match number of arguments.
// Handles string, int, and float.

func split_into(line string, a ...interface{}) bool {
    fa := strings.Split(line, ",", -1)
    if len(fa) == len(a) {
        for i, field := range a {
            switch f := field.(type) {
            case *string:
                *f = fa[i]
            case *int:
                *f, _ = strconv.Atoi(fa[i])
            case *float:
                *f, _ = strconv.Atof(fa[i])
            }
        }
        return true
    }
    return false
}

func testsplit() {
    var a int
    var b string
    var c float
    ok := split_into("12,This is some text,3.14", &a, &b, &c)
    fmt.Println(ok, a, b, c)
}
// testsplit() prints: "true 12 This is some text 3.14"

The example above shows how to unpack a variable number of arguments to a function and how to use a the special type switch statement. The declaration a ...interface{} is used instead of the simpler a ... to get all the arguments as a vector which seems to be more convenient than just "..." which gives a struct (a struct would require the reflect package I believe). The type of variable a inside the function is []interface{}, that is, a vector containing unknown objects.

Reflection example

For a reflection example, I tried to create a struct and then using reflection to modify its members. Due to a silly mistake my first attempt (below) failed:

type My_struct struct {
    I int
    S string
}

func reflect_test_1() {
    // First attempt. Didn't work:
    a := My_struct{1, "alpha"}
    aValue := reflect.NewValue(a).(*reflect.StructValue)
    fmt.Println(reflect.Typeof(aValue).String()) // Convenient way to check type
    i := aValue.Field(0).(*reflect.IntValue)
    i.Set(2)
    s := aValue.Field(1).(*reflect.StringValue)
    s.Set("beta")
    fmt.Println("I =", i.Get(), ", S =", s.Get())
    fmt.Println("I =", a.I, ", S =", a.S)
}
// Prints:
// *reflect.StructValue
// I = 2 , S = beta
// I = 1 , S = alpha

In the example above, the function reflect.NewValue() is first called to create a Value object. The Value object is used by the reflect package as an interface to the real data. It mainly contains a pointer to the actual data stored in the struct a. Since the actual data is a struct, NewValue() automatically creates a StructValue to refer to the data. The type assertion .(*reflect.StructValue) makes sure that aValue is a StructValue. Using the function Field() on our StructValue it is possible to refer to the fields of the struct and then Set() and Get() field values.

But, what was my problem with the example above? The final content in a is untouched. Clearly, when the fields are set to different values, the new values end up in a copy of the original struct, not in the original struct. The change below fixes the problem:

func reflect_test_2() {
    // Second attempt, success!
    a := My_struct{1, "alpha"}
    pValue := reflect.NewValue(&a).(*reflect.PtrValue)
    fmt.Println(reflect.Typeof(pValue).String())
    aValue = reflect.Indirect(pValue).(*reflect.StructValue)
    i := aValue.Field(0).(*reflect.IntValue)
    i.Set(2)
    s := aValue.Field(1).(*reflect.StringValue)
    s.Set("beta")
    fmt.Println("I =", i.Get(), ", S =", s.Get())
    fmt.Println("I =", a.I, ", S =", a.S)
}
// Prints:
// *reflect.PtrValue
// I = 2 , S = beta
// I = 2 , S = beta

The mistake in the first example was to pass the array a by-value instead of by-reference. Without the &-sign, a copy of the struct is created when NewValue() is called. We must pass a pointer to avoid the copying. However, the reflection gets a bit more complex since we need to traverse the pointer first before we find the struct.

A final note. If we make the fields in the struct private (non-exported) it will not work. The Set() operation seems to work only on exported fields:

type My_struct struct {
    i int
    s string
}
// reflect_test_1() or reflect_test_2() will now cause:
// panic: cannot set value obtained via unexported struct field

Ruby hexdigest to digest

2007-09-06T09:11:00.000+02:00


# Translating back from hexdigest to digest. Useful when you
# have used Digest::SHA1.hexdigest and change your mind.

def hexdigest_to_digest(h)
  h.unpack('a2'*(h.size/2)).collect {|i| i.hex.chr }.join
end

Bits from Thomas

Visualizing matrix transformations i pyplot

Go language reflection examples

Functions with variable number of arguments

Reflection example

Ruby hexdigest to digest