Column major and row major are irrespective of the data stored within the matrix. What you’re talking about is particular to your problem - it is not a general concept in matrix math. Specifically, for a matrix M:

```
[[ m11, m12, m13, m14 ]
[ m21, m22, m23, m24 ]
[ m31, m32, m33, m34 ]
[ m41, m42, m43, m44 ]]
```

Storing the matrix row-major means the layout in a 1D array would be

```
[ m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44 ]
```

whereas storing the matrix column-major means the layout would be

```
[ m11, m21, m31, m41, m12, m22, m32, m42, m13, m23, m33, m43, m14, m24, m34, m44 ]
```

You’ll notice that these definitions are irrespective of what the values of mij actually are. Your issue is you are storing your matrix of “fresnel vectors” (I don’t know what these are and a google search turned up no useful answers), and you don’t know if you want the matrix or its transpose. That I can’t answer for you.

You can look at the operations you want to do more closely however. E.g. matrix-vector multiplication, where the matrix is multiplied on the right by a column-vector:

```
M * u = v
[[ m11, m12, m13, m14 ] [ u1 ] [ v1 ]
[ m21, m22, m23, m24 ] * [ u2 ] = [ v2 ]
[ m31, m32, m33, m34 ] [ u3 ] [ v3 ]
[ m41, m42, m43, m44 ]] [ u4 ] [ v4 ]
```

You can look at this operation in two different ways. Either you can see it as a series of dot products:

```
v1 = dot( m1j, u )
v2 = dot( m2j, u )
v3 = dot( m3j, u )
v4 = dot( m4j, u )
```

or you could see it as a series of scaled vector additions:

```
v = mi1 * u1
v += mi2 * u2
v += mi3 * u3
v += mi4 * u4
```

Obviously, the first technique addresses the matrix row-by-row, so would need a row-major matrix for efficient access (to avoid a million swizzles), and the series of scaled vector adds needs a column-major matrix (for the same reason). Given the correct storage, there isn’t a single dot-product SSE instruction, so for each dot product, you have to do a multiply, then a horizontal add (a few SSE ops depending on the level of SSE available), whereas scaled vector adds are quick and easy. Therefore, for right-multiplication of matrices by column vectors, column-major is the more efficient storage option.

The process is the same to show that for left-multiplication by row-major vectors, row-major storage is more efficient, but I’ll leave that as an exercise to the reader. =) And again, like I said before, matrix-matrix multiplication is just multiple matrix-vector multiplies, so that’s what determines how efficient it will be. And accessing individual elements is the same in both storage formats.