ocaml vector space - vector

Question

I have a R3 space and I'm trying to figure some math "problems" with OCAML functions.
Define function "move", which moves plane based on the plane_name (ex. plane1) and vector (x, y, z):
example:
plane1 = [(1,2,-3); (10,5,2); (-2,3,7)]
move plane1 (1,2,-3);;
- : (int * int * int) list = [(2, 4, -6); (11, 7, -1); (-1, 5, 4)]
Thank you

Answer 1

I'll restrict my answer to problem 3.
I don't know where you're at with OCaml and what limitations have been imposed on your answer. (Forgive me, but I'm assuming this is a homework problem.) Let's assume the point of the exercise is to begin to think recursively. So then you want to write a function like this:
let move plane (x, y, z) = (( code goes here ))
For thinking recursively, the basic insight is that a plane is a list of points and you want to do the same thing to all the points. So a lower-level view of the function would be like this:
let rec move point_list (x, y, z) = (( code goes here ))
Now, a list is either empty, or it isn't. You just need to figure out what to do in each case. Furthermore, when the list is not empty you can use your own function recursively as long as you call it with a smaller list.
If, in fact, the point of this exercise is not to learn recursive thinking, then the answer would be completely different. In particular, there's a function in the List module that would make it pretty easy to solve the problem.
Update
Apparently you want to solve the problem non-recursively. To show how this would work, here is a function that takes two points and adds 1 to the x, y, and z coordinates of both points:
let add1 [(x1, y1, z1); (x2, y2, z2)] =
[(x1 + 1, y1 + 1, z1 + 1); (x2 + 1, y2 + 1, z2 + 1)]
This will cause a compiler warning because it fails for many possible inputs. In particular, it fails whenever the list has some number of points other than 2. To eliminate the warning, we need to decide what we want to return for those cases. Let's say we always return the list unchanged in those cases. Then we get the following:
let add1 = function
| [(x1, y1, z1); (x2, y2, z2)] ->
[(x1 + 1, y1 + 1, z1 + 1); (x2 + 1, y2 + 1, z2 + 1)]
| pts -> pts
I guess you know what you want, but this is not particularly idiomatic OCaml.
Another way to solve the problems non-recursively (without rec) would be to use functions from the List module. That would be much more idiomatic, and in fact is probably what I would do in a real-world situation.