Function 向量化（递归）函数F#

对于F#来说是个新手，由于我的主要工具是R，我发现这些“低级”语言有点挑战性。我试图编写一个递归函数（Cox de Boor），给定一个输入向量x（数组或类似的）返回一个相同长度的向量。其他参数为int、int和float[]。到目前为止，我只设法做到了一个单一的x。我敢肯定我的代码是愚蠢的，所以任何提示都将被感激

let rec basis (x:float) degree i (knots:float[]) =
let B=
    match degree=0 with
    |true -> if (x>=knots.[i-1] && x < knots.[i]) then 1.0 else  0.0
    |false -> let Alpha1 =
                match ((knots.[degree+i-1] - knots.[i-1])=0.0) with
                |true -> 0.0
                |false -> (x-knots.[i-1])/(knots.[degree+i-1]-knots.[i-1])
              let Alpha2 =
                match ((knots.[i+degree]-knots.[i])=0.0) with
                |true-> 0.0
                |false -> (knots.[i+degree]-x)/(knots.[i+degree]-knots.[i])

              Alpha1*(basis x (degree-1) i knots) + Alpha2 * (basis x (degree-1) (i+1) knots)
B

let rec basis（x:float）i度（结：float[]）=
让B=
匹配度=0与
|true->如果（x>=节[i-1]&&x<节[i]），则为1.0，否则为0.0
|false->let Alpha1=
将（（节。[度+i-1]-节。[i-1]）=0.0）与
|正确->0.0
|假->（x节。[i-1]）/（节。[度+i-1]-节。[i-1]）
让字母2=
将（（节。[i+度]-节。[i]）=0.0）与
|正确->0.0
|假->（节。[i+度]-x）/（节。[i+度]-n节。[i]）
Alpha1*（基准x（1度）i节）+Alpha2*（基准x（1度）（i+1）节）
B

干杯， 斯蒂格

我试图复制的代码：

basis <- function(x, degree, i, knots) {
 if(degree == 0){
  B <- ifelse((x >= knots[i]) & (x < knots[i+1]), 1, 0)
  } 
  else {
   if((knots[degree+i] - knots[i]) == 0) {
      alpha1 <- 0
   } 
   else {
      alpha1 <- (x - knots[i])/(knots[degree+i] - knots[i])
   }
   if((knots[i+degree+1] - knots[i+1]) == 0) {
      alpha2 <- 0
   } else {
      alpha2 <- (knots[i+degree+1] - x)/(knots[i+degree+1] - knots[i+1])
   }
 B <- alpha1*basis(x, (degree-1), i, knots) + alpha2*basis(x, (degree-1), (i+1), knots)
 }
return(B)
}

bs <- function(x, degree=3, interior.knots=NULL, intercept=FALSE, Boundary.knots =              c(0,1)) {
if(missing(x)) stop("You must provide x")
if(degree < 1) stop("The spline degree must be at least 1")
   Boundary.knots <- sort(Boundary.knots)
   interior.knots.sorted <- NULL
if(!is.null(interior.knots)) interior.knots.sorted <- sort(interior.knots)
  knots <- c(rep(Boundary.knots[1], (degree+1)), interior.knots.sorted,rep(Boundary.knots[2], (degree+1)))
   K <- length(interior.knots) + degree + 1
   B.mat <- matrix(0,length(x),K)
for(j in 1:K) B.mat[,j] <- basis(x, degree, j, knots)
   if(any(x == Boundary.knots[2])) B.mat[x == Boundary.knots[2], K] <- 1
   if(intercept == FALSE) {
     return(B.mat[,-1])
   } else {
return(B.mat)
}
}

---

basis如果你想用多个x调用basis，我会这样做：

首先将basis的签名更改为

let rec基础阶数i（结：浮点数[]）（x：浮点数）

为所有需要的X调用它，如下所示：

xs |>List.map（基本度数i节）

如果所有其他事情都按预期工作，那么这将为您提供一个数组。这意味着我将所有的x和管道（|>）带到函数
List.map
List.map
获取一个函数和一个元素列表，并将该函数应用于列表中的所有元素，然后返回一个新的列表，其中应用了该函数