Ich habe einen Glättungsspline an Daten in R mit @ angepass

library(splines)
Model <- smooth.spline(x, y, df =6) 

Ich möchte den angepassten Spline für beliebige neue Daten in einem externen Code (nicht in R) auswerten. Mit anderen Worten, machen Sie, was daspredict.smooth.spline Funktion tut. Ich habe mir das @ angeschaModel Objekt

> str(Total_work_model)
List of 15
 $ x       : num [1:14] 0.0127 0.0186 0.0275 0.0343 0.0455 ...
 $ y       : num [1:14] 3174 3049 2887 2862 2975 ...
 $ w       : num [1:14] 1 1 1 1 1 1 1 1 1 1 ...
 $ yin     : num [1:14] 3173 3075 2857 2844 2984 ...
 $ data    :List of 3
  ..$ x: num [1:14] 0.0343 0.0455 0.0576 0.0697 0.0798 ...
  ..$ y: num [1:14] 2844 2984 3048 2805 2490 ...
  ..$ w: num [1:14] 1 1 1 1 1 1 1 1 1 1 ...
 $ lev     : num [1:14] 0.819 0.515 0.542 0.568 0.683 ...
 $ cv.crit : num 6494075
 $ pen.crit: num 3260
 $ crit    : num 3
 $ df      : num 8
 $ spar    : num 0.353
 $ lambda  : num 8.26e-05
 $ iparms  : Named int [1:3] 3 0 10
  ..- attr(*, "names")= chr [1:3] "icrit" "ispar" "iter"
 $ fit     :List of 5
  ..$ knot : num [1:20] 0 0 0 0 0.056 ...
  ..$ nk   : int 16
  ..$ min  : num 0.0127
  ..$ range: num 0.104
  ..$ coef : num [1:16] 3174 3132 3027 2871 2842 ...
  ..- attr(*, "class")= chr "smooth.spline.fit"
 $ call    : language smooth.spline(x = Phi00, y = Total, df = 8)
 - attr(*, "class")= chr "smooth.spline"

Ich denke derModel$fit$knot undModel$fit$coef Vektoren enthalten die vollständige Beschreibung der Anpassung. Beachten Sie, dass die Knoten 20 sind, währendx undy haben jeweils 14 Elemente: Ich dachte immer, ein glättender Spline hätte so viele Knoten wie passende Punkte. Da jedoch die ersten drei und die letzten drei Knoten identisch sind, ist 20-6 = 14 sinnvoll. Das Problem ist, dass ich nicht weiß, wie man @ benutModel$fit$knot undModel$fit$coef, um Vorhersagen außerhalb von R zu treffen. Ich habe versucht, @ anzuschauepredict.smooth.spline, aber überraschenderweise ist es das, was ich bekomme

> library(splines)
> predict.smooth.spline
Error: object 'predict.smooth.spline' not found

EDIT: da anscheinend einige benutzer die frage falsch verstanden haben, weiß ich wie man @ benutpredictin R, um neue Werte für meinen Glättungsspline zu erhalten. Das Problem ist, dass ich diese Vorhersagen in einem externen Code machen möchte. Also wollte ich mir den Code für die Funktion ansehenpredict.smooth.spline, damit ich versuchen kann, den Algorithmus außerhalb von R zu reproduzieren. Normalerweise können Sie in R den Code einer Funktion lesen, indem Sie ihren Namen (ohne Argumente und ohne Klammern) an der R-Eingabeaufforderung eingeben. Aber wenn ich versuche, das mit @ zu tpredict.smooth.spline, Ich erhalte den obigen Fehler.

EDIT2: Dank der großartigen Hilfe von @ r2evans habe ich die Quelle für das @ gefundepredict Methode vonsmooth.spline. Ich (glaube ich) verstehe das meiste davon:

> stats:::predict.smooth.spline.fit
function (object, x, deriv = 0, ...) 
{
    if (missing(x)) 
        x <- seq.int(from = object$min, to = object$min + object$range, 
            length.out = length(object$coef) - 4L)
    xs <- (x - object$min)/object$range
    extrap.left <- xs < 0
    extrap.right <- xs > 1
    interp <- !(extrap <- extrap.left | extrap.right)
    n <- sum(interp)
    y <- xs
    if (any(interp)) 
        y[interp] <- .Fortran(C_bvalus, n = as.integer(n), knot = as.double(object$knot), 
            coef = as.double(object$coef), nk = as.integer(object$nk), 
            x = as.double(xs[interp]), s = double(n), order = as.integer(deriv))$s
    if (any(extrap)) {
        xrange <- c(object$min, object$min + object$range)
        if (deriv == 0) {
            end.object <- Recall(object, xrange)$y
            end.slopes <- Recall(object, xrange, 1)$y * object$range
            if (any(extrap.left)) 
                y[extrap.left] <- end.object[1L] + end.slopes[1L] * 
                  (xs[extrap.left] - 0)
            if (any(extrap.right)) 
                y[extrap.right] <- end.object[2L] + end.slopes[2L] * 
                  (xs[extrap.right] - 1)
        }
        else if (deriv == 1) {
            end.slopes <- Recall(object, xrange, 1)$y * object$range
            y[extrap.left] <- end.slopes[1L]
            y[extrap.right] <- end.slopes[2L]
        }
        else y[extrap] <- 0
    }
    if (deriv > 0) 
        y <- y/(object$range^deriv)
    list(x = x, y = y)
}

Ich habe jedoch zwei Schwierigkeiten:

das.Fortran() Funktion ruft eine Fortran-Subroutine aufbvalus derenQuell ist ganz einfach. Jedoch,bvalus ruft wiederum @ abvalue das ist viel mehrkomplizier und ruft @ ainterv dessen Quelle ich nicht finden kann. Schlechte Nachrichten:bvalue ist viel zu kompliziert für mich (ich bin definitiv kein Fortran-Experte). Gute Nachricht: der externe Code, der @ reproduzieren mupredict.smooth.spline.fit ist auch ein Fortran-Code. Im schlimmsten Fall kann ich meinen Kollegen bitten, die Quelle von @ anzugebebvalus undbvalue in seinem Code. Allerdings würde ich auch in diesem zugegebenermaßen nicht so schönen Szenario den Quellcode für @ vermissinterv (Ich hoffe es nennt sich nicht anders !!!).

Ich verstehe nicht, was hier gemacht wird (beachte, dass mich nur das @ interessiederiv == 0 Fall)

k

  if (any(extrap)) {
        xrange <- c(object$min, object$min + object$range)
        if (deriv == 0) {
            end.object <- Recall(object, xrange)$y
            end.slopes <- Recall(object, xrange, 1)$y * object$range
            if (any(extrap.left)) 
                y[extrap.left] <- end.object[1L] + end.slopes[1L] * 
                  (xs[extrap.left] - 0)
            if (any(extrap.right)) 
                y[extrap.right] <- end.object[2L] + end.slopes[2L] * 
                  (xs[extrap.right] - 1)
        }

Eine Art von rekursivem Code? Irgendeine Hilfe hier?