Я думаю, вы здесь слишком сложные мысли. Что не так с двумя отдельными apply() вызовами? Однако есть гораздо лучший способ делать то, что вы здесь делаете, без вызовов цикла / применения. Я рассмотрю их отдельно, но второе решение предпочтительнее, так как оно действительно векторизовано.

Версия с двумя применимыми вызовами

Первые два отдельных вызова apply с использованием функций All-Base R:

df1 <- data.frame(Bar1=c(1,2,3,-3,-2,-1),Bar2=c(3,1,3,-2,-3,-1))
df1 <- transform(df1, MFE = apply(df1, 1, FindMFE), MAE = apply(df1, 1, FindMAE))
df1

Который дает:

> df1
  Bar1 Bar2 MFE MAE
1    1    3   3   0
2    2    1   2   0
3    3    3   3   0
4   -3   -2   0  -3
5   -2   -3   0  -3
6   -1   -1   0  -1

Хорошо, повторение строк df1 дважды, возможно, немного неэффективно, но даже для больших проблем вы уже потратили больше времени, думая о том, чтобы сделать это с умом за один проход, чем вы сэкономите, сделав это способ.

Использование векторизованных функций pmax() и pmin()

Так что лучший способ сделать это - обратить внимание на функции pmax() и pmin() и понять, что они могут делать то же, что и каждый вызов apply(df1, 1, FindFOO(). Например:

> (tmp <- with(df1, pmax(0, Bar1, Bar2, na.rm = TRUE)))
[1] 3 2 3 0 0 0

будет MFE из вашего вопроса. С этим очень просто работать, если у вас есть два столбца, и это всегда Bar1 и Bar2 или первые 2 столбца df1. Но это не очень общий характер; что, если у вас есть несколько столбцов, которые вы хотите вычислить и т. д.? pmax(df1[, 1:2], na.rm = TRUE) не будет делать то, что мы хотим:

> pmax(df1[, 1:2], na.rm = TRUE)
  Bar1 Bar2
1    1    3
2    2    1
3    3    3
4   -3   -2
5   -2   -3
6   -1   -1

Уловка для получения общего решения с использованием pmax() и pmin() состоит в том, чтобы использовать do.call() для организации вызовов этих двух функций за нас. Обновляя ваши функции, чтобы использовать эту идею, мы имеем:

FindMFE2 <- function(x) {
   MFE <- do.call(pmax, c(as.list(x), 0, na.rm = TRUE))
   MFE[is.infinite(MFE)] <- 0
   MFE
}

FindMAE2 <- function(x) {
   MAE <- do.call(pmin, c(as.list(x), 0, na.rm = TRUE))
   MAE[is.infinite(MAE)] <- 0
   MAE
}

которые дают:

> transform(df1, MFE = FindMFE2(df1), MAE = FindMAE2(df1))
  Bar1 Bar2 MFE MAE
1    1    3   3   0
2    2    1   2   0
3    3    3   3   0
4   -3   -2   0  -3
5   -2   -3   0  -3
6   -1   -1   0  -1

а не apply() в поле зрения. Если вы хотите сделать это за один шаг, теперь это намного проще обернуть:

FindMAEandMFE2 <- function(x){
    cbind(MFE = FindMFE2(x), MAE = FindMAE2(x))
}

который можно использовать как:

> cbind(df1, FindMAEandMFE2(df1))
  Bar1 Bar2 MFE MAE
1    1    3   3   0
2    2    1   2   0
3    3    3   3   0
4   -3   -2   0  -3
5   -2   -3   0  -3
6   -1   -1   0  -1

Я показываю три альтернативных однострочника:

• Использование each функции plyr
• Использование функции plyr each с базой R
• Использование векторных функций pmin и pmax

Решение 1.Плир и каждый

Пакет plyr определяет функцию each, которая делает то, что вы хотите. From ?each: Объедините несколько функций в одну функцию. Это означает, что вы можете решить свою проблему, используя однострочник:

library(plyr)
adply(df1, 1, each(MAE=function(x)max(x, 0), MFE=function(x)min(x, 0)))

  Bar1 Bar2 MAE MFE
1    1    3   3   0
2    2    1   2   0
3    3    3   3   0
4   -3   -2   0  -3
5   -2   -3   0  -3
6   -1   -1   0  -1

Решение 2: каждый и основание R

Конечно, вы можете использовать each с базовыми функциями. Вот как вы можете использовать его с apply - просто обратите внимание, что вам нужно транспонировать результаты перед добавлением в исходный data.frame.

library(plyr)
data.frame(df1, 
  t(apply(df1, 1, each(MAE=function(x)max(x, 0), MFE=function(x)min(x, 0)))))

  Bar1 Bar2 MAE MFE
1    1    3   3   0
2    2    1   2   0
3    3    3   3   0
4   -3   -2   0  -3
5   -2   -3   0  -3
6   -1   -1   0  -1

Решение 3.Использование векторизованных функций

Используя векторизованные функции pmin и pmax, вы можете использовать этот однострочник:

transform(df1, MFE=pmax(0, Bar1, Bar2), MAE=pmin(0, Bar1, Bar2))

  Bar1 Bar2 MFE MAE
1    1    3   3   0
2    2    1   2   0
3    3    3   3   0
4   -3   -2   0  -3
5   -2   -3   0  -3
6   -1   -1   0  -1

Здесь есть много хороших ответов. Я начал это, когда Гэвин Симпсон редактировал, поэтому мы затронули схожие темы. То, что делают параллельные min и max (pmin и pmax), в значительной степени соответствует тому, для чего вы пишете свои функции. То, что делает 0 в pmax (0, Bar1, Bar2), может быть немного непрозрачным, но по существу 0 перерабатывается, так что это похоже на выполнение

pmax(c(0,0,0,0,0,0), Bar1, Bar2)

Это займет каждый элемент из трех пройденных элементов и найдет максимальное из них. Таким образом, максимальное значение будет равно 0, если оно было отрицательным, и выполняет большую часть того, что сделал ваш оператор ifelse. Вы можете переписать, чтобы получить векторы и объединить вещи с функциями, аналогичными тем, что вы делали, и это могло бы сделать его немного более прозрачным. В этом случае мы просто передадим фрейм данных новой параллельной и быстрой функции findMFE, которая будет работать с любым числовым фреймом данных и извлекать вектор.

findMFE <- function(dataf){
    MFE <- do.call( pmax, c(dataf, 0, na.rm = TRUE))
}

MFE <- findMFE(df1)

Эта функция добавляет дополнительный столбец нулей в переданный фрейм данных, а затем вызывает pmax, передавая каждый отдельный столбец df1, как если бы это был список (фреймы данных - это списки, поэтому это легко).

Теперь я отмечаю, что вы действительно хотите исправить значения Inf в ваших данных, которых нет в вашем примере ... мы могли бы добавить дополнительную строку в вашу функцию ...

findMFE <- function(dataf){
    MFE <- do.call( pmax, c(dataf, 0, na.rm = TRUE))
    ifelse(is.infinite(MFE), 0, MFE)
}

Теперь это правильное использование функции ifelse () для вектора. Я сделал это в качестве примера для вас, но использование Гэвином Симпсоном MFE [is.infinite (MFE)] ‹- 0 более эффективно. Обратите внимание, что эта функция findMFE не используется в цикле, она просто передает весь фрейм данных.

Сопоставимая находкаMAE ...

findMAE <- function(dataf){
    MAE <- do.call( pmin, c(dataf, 0, na.rm = TRUE))
    ifelse(is.infinite(MAE), 0, MAE)
}

а комбинированная функция просто ...

findMFEandMAE <- function(dataf){
    MFE <- findMFE(dataf)
    MAE <- findMAE(dataf)
    return(data.frame(MFE, MAE))
}

MFEandMAE ‹- findMFEandMAE (df1) df1‹ - cbind (df1, MFEandMAE)

Несколько советов

Если у вас есть скалярный оператор if, не используйте ifelse (), используйте if () else. Это намного быстрее в скалярных ситуациях. И ваши функции скалярны, и вы пытаетесь их векторизовать. ifelse () уже векторизован и работает очень быстро при таком использовании, но намного медленнее, чем if () else при использовании скаляра.

Кроме того, если вы собираетесь помещать что-то в цикл или применять оператор, помещайте туда как можно меньше. Например, в вашем случае ifelse () действительно нужно было вывести из цикла и затем применить ко всему результату MFE.

Если вы действительно этого хотите, вы можете:

FindMAEandMFE <- function(x){
    t(apply(x, 1, function(currow){c(MAE=FindMAE(currow), MFE=FindMFE(currow))}))
}

(не тестировалось - он должен возвращать массив с двумя (я думаю, именованными) столбцами и столько же строк, сколько имел data.frame). Теперь вы можете:

df1<-cbind(df1, FindMAEandMFE(df1))

Очень противно. Пожалуйста, прислушайтесь к совету Гэвина.