在OCaml中从值列表中取值

Question

I am creating a list of lists in OCaml and I am having trouble understanding how I would accomplish my goal.

My goal is to preform the following:

Given V = (0 1 1 -1) as a list:

Preform this equation:

(2*V1 - 1)*(2*V2-1) = ?
(2*V1 - 1)*(2*V3-1) = ?
(2*V1 - 1)*(2*V4-1) = ?
(2*V2 - 1)*(2*V3-1) = ?
(2*V1 - 1)*(2*V4-1) = ?
(2*V3 - 1)*(2*V4-1) = ?

Then translate this into a list of list such as

0  V12 V13 V14
V21 0  V23 V24
V31 V32 0  V34
V41 V42 V43 0

Where the matrix is a reflection of itself.

I am going to use 2 functions do accomplish this.

First one gives the output for one state and the other gives the whole matrix.

Here is what I have going so far:

singleState state =
if state = 0.0 then 0.0
else
    ((2*state) -. 1);;

matrixState V =
if V = [] then []
else
    singleState(hd(V)) * singleState(next item after head) + matrixState(tl(V));;

As you can see I cant figure out how to take the item after the head of V. Such as V2.

Any suggestions for me?

This is what I have so far:

let singleState state = 
    if state = 0.0 then 0.0
    else
        ((2.0 *. state) -. 1.0);;


let rec matrixState V = 
    match V with
    | [] -> []
    | hd :: [] -> V
    | hd :: (nx :: _ as tl) ->
        singleState hd *. singleState nx :: matrixState tl;;

Answer 1

Your best bet is to learn to think in terms of pattern matching. Instead of using = to test whether V is empty, you can write something more like this:

let rec matrixState v =
    match v with
    | [] -> []
    | hd :: [] -> (* Not sure what you want here *)
    | hd :: (nx :: _ as tl) ->
        singleState hd *. singleState nx :: matrixState tl

First of all, keep in mind that this is just a sketch of a function that does what you seem to want your matrixState function to do. I'm not sure how useful it will be in the final answer to your problem.

What this function does is match v (a list) against a series of patterns, and give a different answer depending on which pattern matches.

The first pattern ( [] ) matches an empty list. As in your code, the result is an empty list.

The second pattern ( hd :: [] ) matches a list with just one element in it. I'm not sure what you want to do for this case, so I didn't write the code.

The third pattern ( hd :: (nx :: _ as tl) ) matches a list with two or more elements. It gives the name hd to the first element and the name nx to the second element. Furthermore it gives the name tl to the tail of the list (everything except the first element). This is where you can see the power of OCaml patterns.

Update

(Note: you're supposed to use a SO page to ask one question that has a specific technical answer. You shouldn't use the same page to ask a series of questions. It makes it harder for people later to find answers. If you have a new question you should start it on a new page.)

In OCaml you use names starting with upper case for constructors, and names starting with lower case for ordinary variables. Your code as you give it here won't compile because you're using upper case V as a variable. Note in my code above I used lower case v.

If I change your upper case V to lower case, your code compiles fine for me. I don't get any errors.

(Again, I'd recommend that you do some basic reading about OCaml. It's not to avoid helping you, but rather that I think it would help you more, and more quickly.)