[R/FDAClassifPreprocWrapper.R:12:29:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAClassifPreprocWrapper.R#L12) *style:* **Commas should always have a space after.**
```r
  requirePackages("stringi",default.method = "load")
                            ^
```
[R/FDAClassifPreprocWrapper.R:16:5:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAClassifPreprocWrapper.R#L16) *style:* **Variable or function name should be dotted.case.**
```r
    taskTs = makeFDAClassifTask(data = data, target = target, positive = args$positive)
    ^~~~~~
```
[R/FDAClassifPreprocWrapper.R:17:5:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAClassifPreprocWrapper.R#L17) *style:* **Variable or function name should be dotted.case.**
```r
    taskFa = convertFDATaskToNormalTask(task = taskTs)
    ^~~~~~
```
[R/FDA_feal_twoStepAIC.R:1:1:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDA_feal_twoStepAIC.R#L1) *style:* **Variable or function name should be dotted.case.**
```r
MAGICNumber4TWOSTEPAIC = 163
^~~~~~~~~~~~~~~~~~~~~~
```
[R/FDA_feal_twoStepAIC.R:21:35:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDA_feal_twoStepAIC.R#L21) *style:* **Commas should always have a space after.**
```r
  filename = paste("steplm1", "-",format(Sys.time(), "%b%d%H%M%S"), ".RData" , sep="")
                                  ^
```
[R/FDA_feal_twoStepAIC.R:21:78:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDA_feal_twoStepAIC.R#L21) *style:* **Commas should never have a space before.**
```r
  filename = paste("steplm1", "-",format(Sys.time(), "%b%d%H%M%S"), ".RData" , sep="")
                                                                            ~^
```
[R/FDA_feal_twoStepAIC.R:21:83:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDA_feal_twoStepAIC.R#L21) *style:* **Put spaces around all infix operators (except exponentiation).**
```r
  filename = paste("steplm1", "-",format(Sys.time(), "%b%d%H%M%S"), ".RData" , sep="")
                                                                                ~^~
```
[R/FDA_feal_twoStepAIC.R:35:35:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDA_feal_twoStepAIC.R#L35) *style:* **Commas should always have a space after.**
```r
  filename = paste("steplm2", "-",format(Sys.time(), "%b%d%H%M%S"), ".RData" , sep="")
                                  ^
```
[R/FDA_feal_twoStepAIC.R:35:78:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDA_feal_twoStepAIC.R#L35) *style:* **Commas should never have a space before.**
```r
  filename = paste("steplm2", "-",format(Sys.time(), "%b%d%H%M%S"), ".RData" , sep="")
                                                                            ~^
```
[R/FDA_feal_twoStepAIC.R:35:83:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDA_feal_twoStepAIC.R#L35) *style:* **Put spaces around all infix operators (except exponentiation).**
```r
  filename = paste("steplm2", "-",format(Sys.time(), "%b%d%H%M%S"), ".RData" , sep="")
                                                                                ~^~
```
[R/FDAconvertTask.R:34:5:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAconvertTask.R#L34) *style:* **Variable or function name should be dotted.case.**
```r
    modelSh = do.call(getFDAShapeletFeatures, new.args)
    ^~~~~~~
```
[R/FDAconvertTask.R:88:40:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAconvertTask.R#L88) *style:* **Only use double-quotes.**
```r
  colnames(newdata) = c(target, paste0('V', 1:(ncol(newdata) - 1) ))
                                       ^~~
```
[R/FDAconvertTask.R:88:66:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAconvertTask.R#L88) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  colnames(newdata) = c(target, paste0('V', 1:(ncol(newdata) - 1) ))
                                                                 ^
```
[R/FDAconvertTask.R:107:40:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAconvertTask.R#L107) *style:* **Only use double-quotes.**
```r
  colnames(newdata) = c(target, paste0('V', 1:(ncol(newdata) - 1) ))
                                       ^~~
```
[R/FDAconvertTask.R:107:66:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAconvertTask.R#L107) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  colnames(newdata) = c(target, paste0('V', 1:(ncol(newdata) - 1) ))
                                                                 ^
```
[R/FDAfeatures_FDboost.R:24:111:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAfeatures_FDboost.R#L24) *style:* **Commas should never have a space before.**
```r
getFDAFDboostFeatures = function(data, target, have.target = TRUE, include.target = FALSE, bsignal.knots =10L ,bsignal.df = 3L) {
                                                                                ~^
```
[R/FDAfeatures_FDboost.R:24:112:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAfeatures_FDboost.R#L24) *style:* **Commas should always have a space after.**
```r
getFDAFDboostFeatures = function(data, target, have.target = TRUE, include.target = FALSE, bsignal.knots =10L ,bsignal.df = 3L) {
                                                                                ^
```
[R/FDAfeatures_FDboost.R:47:52:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAfeatures_FDboost.R#L47) *warning:* **Avoid 1:ncol(...) expressions, use seq_len.**
```r
  blrn = FDboost::bsignal(x = as.matrix(data), s = 1:ncol(data), knots = bsignal.knots , degree = bsignal.df)
                                                   ^
```
[R/FDAfeatures_FDboost.R:47:88:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAfeatures_FDboost.R#L47) *style:* **Commas should never have a space before.**
```r
  blrn = FDboost::bsignal(x = as.matrix(data), s = 1:ncol(data), knots = bsignal.knots , degree = bsignal.df)
                                                                                ~^
```
[R/FDAfeatures_FDboost.R:48:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAfeatures_FDboost.R#L48) *style:* **Variable or function name should be dotted.case.**
```r
  features_bsignal = mboost::extract(object = blrn, what = "design")  # get the design matrix from base learner
  ^~~~~~~~~~~~~~~~
```
[R/FDAfeatures_FDboost.R:49:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAfeatures_FDboost.R#L49) *style:* **Variable or function name should be dotted.case.**
```r
  d_fdboost = as.data.frame(features_bsignal)
  ^~~~~~~~~
```
[R/FDAfeatures_fourier.R:44:27:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAfeatures_fourier.R#L44) *style:* **Commas should always have a space after.**
```r
  ffttrafo = t(apply(data,1, fft))
                          ^
```
[R/FDAfeatures_fourier.R:48:23:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAfeatures_fourier.R#L48) *style:* **Variable or function name should be dotted.case.**
```r
         amplitude = {fftPA = getFourierAmplitude(fourier.comp = ffttrafo)},
                      ^~~~~
```
[R/FDAfeatures_fourier.R:49:19:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAfeatures_fourier.R#L49) *style:* **Variable or function name should be dotted.case.**
```r
         phase = {fftPA = getFourierPhase(fourier.comp = ffttrafo)}
                  ^~~~~
```
[R/FDAfeatures_fourier.R:53:5:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAfeatures_fourier.R#L53) *style:* **Variable or function name should be dotted.case.**
```r
    fftPA = as.data.frame(matrix(fftPA, nrow = 1))
    ^~~~~
```
[R/FDAfeatures_fourier.R:55:5:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAfeatures_fourier.R#L55) *style:* **Variable or function name should be dotted.case.**
```r
    fftPA = as.data.frame(fftPA)
    ^~~~~
```
[R/FDAfeatures_fpca.R:40:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAfeatures_fpca.R#L40) *style:* **Variable or function name should be dotted.case.**
```r
  features_fpca = rst$scores
  ^~~~~~~~~~~~~
```
[R/FDAfeatures_fpca.R:41:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAfeatures_fpca.R#L41) *style:* **Variable or function name should be dotted.case.**
```r
  d_fpca = as.data.frame(features_fpca)
  ^~~~~~
```
[R/FDAfeatures_fpca.R:42:30:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAfeatures_fpca.R#L42) *style:* **Commas should always have a space after.**
```r
  names(d_fpca) = paste0("V",1:ncol(d_fpca))
                             ^
```
[R/FDAfeatures_fpca.R:42:30:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAfeatures_fpca.R#L42) *warning:* **Avoid 1:ncol(...) expressions, use seq_len.**
```r
  names(d_fpca) = paste0("V",1:ncol(d_fpca))
                             ^
```
[R/FDAfeatures_multiResNaive.R:46:6:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAfeatures_multiResNaive.R#L46) *style:* **Place a space before left parenthesis, except in a function call.**
```r
  for(fdn in names(fd.features)){
     ^
```
[R/FDAfeatures_multiResNaive.R:71:36:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAfeatures_multiResNaive.R#L71) *style:* **Trailing whitespace is superfluous.**
```r
  feat.list = vector("list", n.obs)
                                   ^~
```
[R/FDAfeatures_wavelets.R:39:5:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAfeatures_wavelets.R#L39) *style:* **Place a space before left parenthesis, except in a function call.**
```r
  if(inherits(data, "matrix"))
    ^
```
[R/FDAfeatures_wavelets.R:51:18:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAfeatures_wavelets.R#L51) *style:* **Commas should always have a space after.**
```r
    a = t(data[i,])
                 ^
```
[R/FDAfeatures_wavelets.R:53:42:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/FDAfeatures_wavelets.R#L53) *style:* **Commas should always have a space after.**
```r
    wtdata = rbind(wtdata, unlist(c(wt@W,wt@V[[wt@level]])))
                                         ^
```
[R/RLearner_FDAclassif_kernel.R:30:83:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/RLearner_FDAclassif_kernel.R#L30) *style:* **Commas should always have a space after.**
```r
  learned.model = fda.usc::classif.kernel(group = glearn, fdataobj = data.fdclass,...)
                                                                                ^
```
[R/RLearner_FDAclassif_np.R:31:79:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/RLearner_FDAclassif_np.R#L31) *style:* **Commas should always have a space after.**
```r
  learned.model = fda.usc::classif.np(group = glearn, fdataobj = data.fdclass,...)
                                                                              ^
```
[R/RLearner_FDAregr_fgam.R:19:18:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/RLearner_FDAregr_fgam.R#L19) *warning:* **Unneded concatenation of a constant. Remove the "c" call.**
```r
    properties = c("numerics"),
                 ^
```
[R/RLearner_FDAregr_fgam.R:49:20:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/RLearner_FDAregr_fgam.R#L49) *style:* **Put spaces around all infix operators (except exponentiation).**
```r
    mat.list[[fdn]]=  as.matrix(d[, tdesc$fd.features[[fdn]], drop = FALSE])
                  ~^
```
[R/RLearner_FDAregr_fgam.R:70:6:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/RLearner_FDAregr_fgam.R#L70) *style:* **Place a space before left parenthesis, except in a function call.**
```r
  for(i in 1:num4channel){
     ^
```
[R/RLearner_FDAregr_fgam.R:71:34:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/RLearner_FDAregr_fgam.R#L71) *style:* **Put spaces around all infix operators (except exponentiation).**
```r
    list4mat[[name4channel[[i]]]]=  as.matrix(subset(df, select = channel.list[[i]]))
                                ~^
```
[R/RLearner_FDAregr_fgam.R:78:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/RLearner_FDAregr_fgam.R#L78) *style:* **Variable or function name should be dotted.case.**
```r
  mextra_para  = list(...)
  ^~~~~~~~~~~
```
[R/RLearner_FDAregr_fgam.R:81:67:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/RLearner_FDAregr_fgam.R#L81) *style:* **Only use double-quotes.**
```r
  pred = predict(.model$learner.model, newdata = list4mat, type = 'response')
                                                                  ^~~~~~~~~~
```
[R/RLearner_classif_rknn.R:25:37:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/RLearner_classif_rknn.R#L25) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  c(list(data = z$data, y = z$target ), list(...))
                                    ^
```
[R/RLearner_regr_GPfit.R:42:116:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/RLearner_regr_GPfit.R#L42) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  res = GPfit::GP_fit(d$data[, not.const], d$target, corr = list(type = type, power = power, nu = matern_nu_k + 0.5 ), ...)
                                                                                ^
```
[R/RLearner_regr_glm.R:59:69:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/RLearner_regr_glm.R#L59) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
    m = stats::glm(f, data = d, control = ctrl, family = family, ... )
                                                                    ^
```
[R/RLearner_regr_glm.R:61:89:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/RLearner_regr_glm.R#L61) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
    m = stats::glm(f, data = d, control = ctrl, weights = .weights, family = family, ... )
                                                                                ^
```
[R/RLearner_regr_randomForest.R:149:44:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/RLearner_regr_randomForest.R#L149) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  bist = ((1 / se.ntree) - (1 / ntree)) / ( se.boot * se.ntree * (se.ntree - 1)) * bias
                                           ^
```
[R/RLearner_regr_rknn.R:25:37:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/RLearner_regr_rknn.R#L25) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  c(list(data = z$data, y = z$target ), list(...))
                                    ^
```
[R/StackedLearner.R:556:50:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/StackedLearner.R#L556) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
      m = makeLearner("regr.nnet", predict.type = )
                                                 ^
```
[R/StackedLearner.R:678:25:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/StackedLearner.R#L678) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
    neighbour = max.col( -dist.mat - diag(Inf, n))
                        ^
```
[R/selectFeaturesRandom.R:15:30:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/R/selectFeaturesRandom.R#L15) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
    return(rbinom(n, 1, prob) )
                             ^
```
[inst/makeData.R:97:119:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/inst/makeData.R#L97) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
fuelSubset$uvvis.lambda = with(fuelSubset, (uvvis.lambda - min(uvvis.lambda)) / (max(uvvis.lambda) - min(uvvis.lambda) ))
                                                                                ^
```
[inst/makeData.R:98:109:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/inst/makeData.R#L98) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
fuelSubset$nir.lambda = with(fuelSubset, (nir.lambda - min(nir.lambda)) / (max(nir.lambda) - min(nir.lambda) ))
                                                                                ^
```
[tests/testthat/test_FDA_FPCA.R:5:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_FPCA.R#L5) *style:* **Variable or function name should be dotted.case.**
```r
  taskTs = makeFDAClassifTask(data = gp, target = "X1", positive = "1")
  ^~~~~~
```
[tests/testthat/test_FDA_FPCA.R:6:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_FPCA.R#L6) *style:* **Variable or function name should be dotted.case.**
```r
  refData = getTaskData(taskTs, target.extra = TRUE)
  ^~~~~~~
```
[tests/testthat/test_FDA_FPCA.R:9:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_FPCA.R#L9) *style:* **Variable or function name should be dotted.case.**
```r
  f_df = getFDAFPCAFeatures(data = refData$data, target = "X1", have.target = TRUE, include.target = FALSE)
  ^~~~
```
[tests/testthat/test_FDA_FPCA.R:10:38:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_FPCA.R#L10) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  expect_true((nrow(f_df) == nrow(gp) ))
                                     ^
```
[tests/testthat/test_FDA_Fourier.R:6:61:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Fourier.R#L6) *style:* **Put spaces around all infix operators (except exponentiation).**
```r
  gp = data.frame(v1 = 1:5, v2 = 2:6, v3 = 3:7, v4 = 4:8, X1= as.factor(c(-1,1,1,-1, 1)))
                                                           ~^
```
[tests/testthat/test_FDA_Fourier.R:6:78:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Fourier.R#L6) *style:* **Commas should always have a space after.**
```r
  gp = data.frame(v1 = 1:5, v2 = 2:6, v3 = 3:7, v4 = 4:8, X1= as.factor(c(-1,1,1,-1, 1)))
                                                                             ^
```
[tests/testthat/test_FDA_Fourier.R:6:80:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Fourier.R#L6) *style:* **Commas should always have a space after.**
```r
  gp = data.frame(v1 = 1:5, v2 = 2:6, v3 = 3:7, v4 = 4:8, X1= as.factor(c(-1,1,1,-1, 1)))
                                                                               ^
```
[tests/testthat/test_FDA_Fourier.R:6:82:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Fourier.R#L6) *style:* **Commas should always have a space after.**
```r
  gp = data.frame(v1 = 1:5, v2 = 2:6, v3 = 3:7, v4 = 4:8, X1= as.factor(c(-1,1,1,-1, 1)))
                                                                                ^
```
[tests/testthat/test_FDA_Fourier.R:8:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Fourier.R#L8) *style:* **Variable or function name should be dotted.case.**
```r
  taskTs = makeFDAClassifTask(data = gp, target = "X1", positive = "1")
  ^~~~~~
```
[tests/testthat/test_FDA_Fourier.R:9:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Fourier.R#L9) *style:* **Variable or function name should be dotted.case.**
```r
  refData = getTaskData(taskTs, target.extra = TRUE)
  ^~~~~~~
```
[tests/testthat/test_FDA_Fourier.R:11:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Fourier.R#L11) *style:* **Variable or function name should be dotted.case.**
```r
  taskFa = convertFDATaskToNormalTask(task = taskTs, method = "fourier", pars = list(fft.coeff = "amplitude"))
  ^~~~~~
```
[tests/testthat/test_FDA_Fourier.R:12:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Fourier.R#L12) *style:* **Variable or function name should be dotted.case.**
```r
  faData = getTaskData(taskFa, target.extra = TRUE)
  ^~~~~~
```
[tests/testthat/test_FDA_Fourier.R:13:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Fourier.R#L13) *style:* **Variable or function name should be dotted.case.**
```r
  taskFp = convertFDATaskToNormalTask(task = taskTs, method = "fourier", pars = list(fft.coeff = "phase"))
  ^~~~~~
```
[tests/testthat/test_FDA_Fourier.R:14:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Fourier.R#L14) *style:* **Variable or function name should be dotted.case.**
```r
  fpData = getTaskData(taskFp, target.extra = TRUE)
  ^~~~~~
```
[tests/testthat/test_FDA_Fourier.R:20:35:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Fourier.R#L20) *style:* **Put spaces around all infix operators (except exponentiation).**
```r
  expect_true(all(fpData$data < pi/2 & fpData$data > -pi/2))
                                 ~^~
```
[tests/testthat/test_FDA_Fourier.R:20:57:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Fourier.R#L20) *style:* **Put spaces around all infix operators (except exponentiation).**
```r
  expect_true(all(fpData$data < pi/2 & fpData$data > -pi/2))
                                                       ~^~
```
[tests/testthat/test_FDA_PreprocWrapper.R:4:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_PreprocWrapper.R#L4) *style:* **Variable or function name should be dotted.case.**
```r
  taskFa = convertFDATaskToNormalTask(task = gunpoint.task, method = "fourier",
  ^~~~~~
```
[tests/testthat/test_FDA_PreprocWrapper.R:6:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_PreprocWrapper.R#L6) *style:* **Variable or function name should be dotted.case.**
```r
  taskFp = convertFDATaskToNormalTask(task = gunpoint.task, method = "fourier",
  ^~~~~~
```
[tests/testthat/test_FDA_PreprocWrapper.R:11:60:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_PreprocWrapper.R#L11) *style:* **Only use double-quotes.**
```r
  lrn = makeFDAClassifPreprocWrapper(learner = makeLearner('classif.ranger'))
                                                           ^~~~~~~~~~~~~~~~
```
[tests/testthat/test_FDA_Wavelets.R:6:19:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Wavelets.R#L6) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  gp = data.frame( X1= as.factor(c(-1,1,1,-1, 1)) ,v1 = 1:5, v2 = 12:16, v3 = 3:7, v4 = 4:8)
                  ^
```
[tests/testthat/test_FDA_Wavelets.R:6:22:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Wavelets.R#L6) *style:* **Put spaces around all infix operators (except exponentiation).**
```r
  gp = data.frame( X1= as.factor(c(-1,1,1,-1, 1)) ,v1 = 1:5, v2 = 12:16, v3 = 3:7, v4 = 4:8)
                    ~^
```
[tests/testthat/test_FDA_Wavelets.R:6:39:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Wavelets.R#L6) *style:* **Commas should always have a space after.**
```r
  gp = data.frame( X1= as.factor(c(-1,1,1,-1, 1)) ,v1 = 1:5, v2 = 12:16, v3 = 3:7, v4 = 4:8)
                                      ^
```
[tests/testthat/test_FDA_Wavelets.R:6:41:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Wavelets.R#L6) *style:* **Commas should always have a space after.**
```r
  gp = data.frame( X1= as.factor(c(-1,1,1,-1, 1)) ,v1 = 1:5, v2 = 12:16, v3 = 3:7, v4 = 4:8)
                                        ^
```
[tests/testthat/test_FDA_Wavelets.R:6:43:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Wavelets.R#L6) *style:* **Commas should always have a space after.**
```r
  gp = data.frame( X1= as.factor(c(-1,1,1,-1, 1)) ,v1 = 1:5, v2 = 12:16, v3 = 3:7, v4 = 4:8)
                                          ^
```
[tests/testthat/test_FDA_Wavelets.R:6:51:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Wavelets.R#L6) *style:* **Commas should never have a space before.**
```r
  gp = data.frame( X1= as.factor(c(-1,1,1,-1, 1)) ,v1 = 1:5, v2 = 12:16, v3 = 3:7, v4 = 4:8)
                                                 ~^
```
[tests/testthat/test_FDA_Wavelets.R:6:52:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Wavelets.R#L6) *style:* **Commas should always have a space after.**
```r
  gp = data.frame( X1= as.factor(c(-1,1,1,-1, 1)) ,v1 = 1:5, v2 = 12:16, v3 = 3:7, v4 = 4:8)
                                                   ^
```
[tests/testthat/test_FDA_Wavelets.R:8:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Wavelets.R#L8) *style:* **Variable or function name should be dotted.case.**
```r
  taskTs = makeFDAClassifTask(data = gp, target = "X1", positive = "1")
  ^~~~~~
```
[tests/testthat/test_FDA_Wavelets.R:9:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Wavelets.R#L9) *style:* **Variable or function name should be dotted.case.**
```r
  taskW = convertFDATaskToNormalTask(task = taskTs, method = "wavelets", pars = list(filter = "haar"))
  ^~~~~
```
[tests/testthat/test_FDA_Wavelets.R:10:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Wavelets.R#L10) *style:* **Variable or function name should be dotted.case.**
```r
  wData = getTaskData(taskW, target.extra = TRUE)
  ^~~~~
```
[tests/testthat/test_FDA_Wavelets.R:12:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Wavelets.R#L12) *style:* **Variable or function name should be dotted.case.**
```r
  taskWb = convertFDATaskToNormalTask(task = taskTs, method = "wavelets", pars = list( filter = "d4", boundary = "reflection"))
  ^~~~~~
```
[tests/testthat/test_FDA_Wavelets.R:12:87:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Wavelets.R#L12) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  taskWb = convertFDATaskToNormalTask(task = taskTs, method = "wavelets", pars = list( filter = "d4", boundary = "reflection"))
                                                                                ^
```
[tests/testthat/test_FDA_Wavelets.R:13:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Wavelets.R#L13) *style:* **Variable or function name should be dotted.case.**
```r
  wbData = getTaskData(taskWb, target.extra = TRUE)
  ^~~~~~
```
[tests/testthat/test_FDA_Wavelets.R:19:17:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Wavelets.R#L19) *style:* **Commas should always have a space after.**
```r
    a = t(raw[i,])
                ^
```
[tests/testthat/test_FDA_Wavelets.R:22:34:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Wavelets.R#L22) *style:* **Commas should always have a space after.**
```r
    bb = rbind(bb, unlist(c(wt@W,wt@V[[wt@level]])))
                                 ^
```
[tests/testthat/test_FDA_Wavelets.R:27:17:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Wavelets.R#L27) *style:* **Commas should always have a space after.**
```r
    a = t(raw[i,])
                ^
```
[tests/testthat/test_FDA_Wavelets.R:29:34:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_Wavelets.R#L29) *style:* **Commas should always have a space after.**
```r
    dd = rbind(dd, unlist(c(wt@W,wt@V[[wt@level]])))
                                 ^
```
[tests/testthat/test_FDA_base_nonFDALrnOnFDATask.R:5:10:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_base_nonFDALrnOnFDATask.R#L5) *style:* **Commas should always have a space after.**
```r
  data[1,1] = NA
         ^
```
[tests/testthat/test_FDA_classif_glm.R:13:18:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_classif_glm.R#L13) *style:* **Put spaces around all infix operators (except exponentiation).**
```r
  dat = list("df"=dataf,"x"=mlearn)
                ~^~
```
[tests/testthat/test_FDA_classif_glm.R:13:25:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_classif_glm.R#L13) *style:* **Commas should always have a space after.**
```r
  dat = list("df"=dataf,"x"=mlearn)
                        ^
```
[tests/testthat/test_FDA_classif_glm.R:13:28:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_classif_glm.R#L13) *style:* **Put spaces around all infix operators (except exponentiation).**
```r
  dat = list("df"=dataf,"x"=mlearn)
                          ~^~
```
[tests/testthat/test_FDA_classif_glm.R:19:20:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_classif_glm.R#L19) *style:* **Put spaces around all infix operators (except exponentiation).**
```r
  newdat = list("x"=mtest)
                  ~^~
```
[tests/testthat/test_FDA_classif_glm.R:23:7:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_classif_glm.R#L23) *style:* **Commas should always have a space after.**
```r
  ph[,"label"] = glearn
      ^
```
[tests/testthat/test_FDA_classif_np.R:21:7:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_classif_np.R#L21) *style:* **Commas should always have a space after.**
```r
  ph[,"label"] = glearn
      ^
```
[tests/testthat/test_FDA_classif_shapelets.R:12:54:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_classif_shapelets.R#L12) *style:* **Commas should always have a space after.**
```r
  m = shapeletLib::learnShapeletModel(data = gp[1:50,-1], label = as.factor(gp[1:50,1]))
                                                     ^
```
[tests/testthat/test_FDA_classif_shapelets.R:12:85:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_classif_shapelets.R#L12) *style:* **Commas should always have a space after.**
```r
  m = shapeletLib::learnShapeletModel(data = gp[1:50,-1], label = as.factor(gp[1:50,1]))
                                                                                ^
```
[tests/testthat/test_FDA_classif_shapelets.R:13:58:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_classif_shapelets.R#L13) *style:* **Commas should always have a space after.**
```r
  p1 = predict(object = m, newdata = as.matrix(gp[51:200,-1]))
                                                         ^
```
[tests/testthat/test_FDA_classif_shapelets.R:14:14:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_classif_shapelets.R#L14) *style:* **Commas should always have a space after.**
```r
  levs = c(2,1)
             ^
```
[tests/testthat/test_FDA_featExtract_FDboost.R:4:79:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featExtract_FDboost.R#L4) *style:* **Commas should always have a space after.**
```r
  gp = data.frame(v1 = 1:5, v2 = 2:6, v3 = 3:7, v4 = 4:8, X1 = as.factor(c(-1,1,1,-1, 1)))
                                                                              ^
```
[tests/testthat/test_FDA_featExtract_FDboost.R:4:81:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featExtract_FDboost.R#L4) *style:* **Commas should always have a space after.**
```r
  gp = data.frame(v1 = 1:5, v2 = 2:6, v3 = 3:7, v4 = 4:8, X1 = as.factor(c(-1,1,1,-1, 1)))
                                                                                ^
```
[tests/testthat/test_FDA_featExtract_FDboost.R:4:83:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featExtract_FDboost.R#L4) *style:* **Commas should always have a space after.**
```r
  gp = data.frame(v1 = 1:5, v2 = 2:6, v3 = 3:7, v4 = 4:8, X1 = as.factor(c(-1,1,1,-1, 1)))
                                                                                ^
```
[tests/testthat/test_FDA_featExtract_FDboost.R:5:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featExtract_FDboost.R#L5) *style:* **Variable or function name should be dotted.case.**
```r
  taskTs = makeFDAClassifTask(data = gp, target = "X1", positive = "1")
  ^~~~~~
```
[tests/testthat/test_FDA_featExtract_FDboost.R:6:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featExtract_FDboost.R#L6) *style:* **Variable or function name should be dotted.case.**
```r
  refData = getTaskData(taskTs, target.extra = TRUE)
  ^~~~~~~
```
[tests/testthat/test_FDA_featExtract_FDboost.R:11:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featExtract_FDboost.R#L11) *style:* **Variable or function name should be dotted.case.**
```r
  f_df = getFDAFDboostFeatures(data = refData$data, target = "X1", have.target = TRUE,
  ^~~~
```
[tests/testthat/test_FDA_featExtract_FDboost.R:13:38:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featExtract_FDboost.R#L13) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  expect_true((nrow(f_df) == nrow(gp) ))
                                     ^
```
[tests/testthat/test_FDA_featextraction_base.R:7:119:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featextraction_base.R#L7) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  d = extractFDAFeatures(data = gp$data, target = getTaskTargetNames(gunpoint.task), method = "wavelets", args = list( filter = "d4", boundary = "reflection"))
                                                                                ^
```
[tests/testthat/test_FDA_featextraction_base.R:21:127:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featextraction_base.R#L21) *style:* **Commas should never have a space before.**
```r
  d = extractMultiFDAFeatures(data = fuel$data, target = getTaskTargetNames(fuelsubset.task), fd.features = tdesc$fd.features , method = "wavelets", args = list( filter = "d4", boundary = "reflection"))
                                                                                ~^
```
[tests/testthat/test_FDA_featextraction_base.R:21:162:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featextraction_base.R#L21) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  d = extractMultiFDAFeatures(data = fuel$data, target = getTaskTargetNames(fuelsubset.task), fd.features = tdesc$fd.features , method = "wavelets", args = list( filter = "d4", boundary = "reflection"))
                                                                                ^
```
[tests/testthat/test_FDA_featextraction_base.R:23:127:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featextraction_base.R#L23) *style:* **Commas should never have a space before.**
```r
  d = extractMultiFDAFeatures(data = fuel$data, target = getTaskTargetNames(fuelsubset.task), fd.features = tdesc$fd.features , method = "fourier", args = list())
                                                                                ~^
```
[tests/testthat/test_FDA_featextraction_base.R:25:127:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featextraction_base.R#L25) *style:* **Commas should never have a space before.**
```r
  d = extractMultiFDAFeatures(data = fuel$data, target = getTaskTargetNames(fuelsubset.task), fd.features = tdesc$fd.features , method = "multiRes", args = list())
                                                                                ~^
```
[tests/testthat/test_FDA_featextraction_base.R:27:127:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featextraction_base.R#L27) *style:* **Commas should never have a space before.**
```r
  d = extractMultiFDAFeatures(data = fuel$data, target = getTaskTargetNames(fuelsubset.task), fd.features = tdesc$fd.features , method = "bsignal", args = list())
                                                                                ~^
```
[tests/testthat/test_FDA_featextraction_base.R:29:127:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featextraction_base.R#L29) *style:* **Commas should never have a space before.**
```r
  d = extractMultiFDAFeatures(data = fuel$data, target = getTaskTargetNames(fuelsubset.task), fd.features = tdesc$fd.features , method = "fpca", args = list())
                                                                                ~^
```
[tests/testthat/test_FDA_featsel_twoStepAIC.R:3:1:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featsel_twoStepAIC.R#L3) *style:* **Variable or function name should be functionCamel.case.**
```r
makeData_art_10 = function(n){
^~~~~~~~~~~~~~~
```
[tests/testthat/test_FDA_featsel_twoStepAIC.R:7:16:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featsel_twoStepAIC.R#L7) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  l4c$x2 = exp( 3 * rnorm(n))
               ^
```
[tests/testthat/test_FDA_featsel_twoStepAIC.R:12:22:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featsel_twoStepAIC.R#L12) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  l4c$x7 = 0.5 * exp( 4 * rnorm(n)) # lognormal
                     ^
```
[tests/testthat/test_FDA_featsel_twoStepAIC.R:16:62:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featsel_twoStepAIC.R#L16) *style:* **Trailing whitespace is superfluous.**
```r
  l4c$y = 3 * l4c$x2 - 4 * l4c$x8 + 5 * l4c$x9 + 3 * rnorm(n)
                                                             ^
```
[tests/testthat/test_FDA_featsel_twoStepAIC.R:23:1:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featsel_twoStepAIC.R#L23) *style:* **Variable or function name should be functionCamel.case.**
```r
makeData_art_10_2 = function(n){
^~~~~~~~~~~~~~~~~
```
[tests/testthat/test_FDA_featsel_twoStepAIC.R:27:16:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featsel_twoStepAIC.R#L27) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  l4c$x2 = exp( 3 * rnorm(n))
               ^
```
[tests/testthat/test_FDA_featsel_twoStepAIC.R:32:22:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featsel_twoStepAIC.R#L32) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  l4c$x7 = 0.5 * exp( 4 * rnorm(n)) # lognormal
                     ^
```
[tests/testthat/test_FDA_featsel_twoStepAIC.R:36:31:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featsel_twoStepAIC.R#L36) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  l4c$y = 3 * (l4c$x2 * l4c$x3 ) * - 4 * (l4c$x8 * l4c$x7) + 5 * (l4c$x9 * l4c$x1) + 3 * rnorm(n)
                              ^
```
[tests/testthat/test_FDA_featsel_twoStepAIC.R:36:98:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featsel_twoStepAIC.R#L36) *style:* **Trailing whitespace is superfluous.**
```r
  l4c$y = 3 * (l4c$x2 * l4c$x3 ) * - 4 * (l4c$x8 * l4c$x7) + 5 * (l4c$x9 * l4c$x1) + 3 * rnorm(n)
                                                                                ^
```
[tests/testthat/test_FDA_featsel_twoStepAIC.R:47:78:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featsel_twoStepAIC.R#L47) *style:* **Trailing whitespace is superfluous.**
```r
  mmodel = selectForward2Step(d = regr.train, target = "medv", muffle = TRUE)
                                                                             ^
```
[tests/testthat/test_FDA_featsel_twoStepAIC.R:52:33:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featsel_twoStepAIC.R#L52) *style:* **Commas should always have a space after.**
```r
test_that("regr_twoStepAIC_art",{
                                ^
```
[tests/testthat/test_FDA_featsel_twoStepAIC.R:54:24:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featsel_twoStepAIC.R#L54) *style:* **Commas should always have a space after.**
```r
  regr.train = df[1:40,] # 4 times the feature number
                       ^
```
[tests/testthat/test_FDA_featsel_twoStepAIC.R:55:27:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featsel_twoStepAIC.R#L55) *style:* **Commas should always have a space after.**
```r
  regr.test = df[501:1000,]
                          ^
```
[tests/testthat/test_FDA_featsel_twoStepAIC.R:56:75:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featsel_twoStepAIC.R#L56) *style:* **Trailing whitespace is superfluous.**
```r
  mmodel = selectForward2Step(d = regr.train, target = "y", muffle = TRUE)
                                                                          ^
```
[tests/testthat/test_FDA_featsel_twoStepAIC.R:60:35:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featsel_twoStepAIC.R#L60) *style:* **Commas should always have a space after.**
```r
test_that("regr_twoStepAIC_art_2",{
                                  ^
```
[tests/testthat/test_FDA_featsel_twoStepAIC.R:62:24:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featsel_twoStepAIC.R#L62) *style:* **Commas should always have a space after.**
```r
  regr.train = df[1:40,]
                       ^
```
[tests/testthat/test_FDA_featsel_twoStepAIC.R:63:27:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featsel_twoStepAIC.R#L63) *style:* **Commas should always have a space after.**
```r
  regr.test = df[501:1000,]
                          ^
```
[tests/testthat/test_FDA_featsel_twoStepAIC.R:64:75:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featsel_twoStepAIC.R#L64) *style:* **Trailing whitespace is superfluous.**
```r
  mmodel = selectForward2Step(d = regr.train, target = "y", muffle = TRUE)
                                                                          ^
```
[tests/testthat/test_FDA_featsel_twoStepAIC.R:66:1:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_featsel_twoStepAIC.R#L66) *style:* **Trailing whitespace is superfluous.**
```r

^~
```
[tests/testthat/test_FDA_multiResNaive.R:6:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_multiResNaive.R#L6) *style:* **Variable or function name should be dotted.case.**
```r
  TL  = 200 # length of each time serie instance
  ^~
```
[tests/testthat/test_FDA_multiResNaive.R:7:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_multiResNaive.R#L7) *style:* **Variable or function name should be dotted.case.**
```r
  Ts = replicate(I, rnorm(TL))
  ^~
```
[tests/testthat/test_FDA_multiResNaive.R:9:36:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_multiResNaive.R#L9) *style:* **Remove spaces before the left parenthesis in a function call.**
```r
  ngp = extractFDAMultiResFeatures (data = gp, curve.lens = c(100, 100), res.level = 3, shift = 0.5)
                                   ^
```
[tests/testthat/test_FDA_multiResNaive.R:17:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_multiResNaive.R#L17) *style:* **Variable or function name should be dotted.case.**
```r
  TL  = 200 # length of each time serie instance
  ^~
```
[tests/testthat/test_FDA_multiResNaive.R:18:3:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_multiResNaive.R#L18) *style:* **Variable or function name should be dotted.case.**
```r
  Ts = replicate(I, rnorm(TL))
  ^~
```
[tests/testthat/test_FDA_multiResNaive.R:28:41:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_multiResNaive.R#L28) *style:* **Put spaces around all infix operators (except exponentiation).**
```r
  dfn = getMultiFDAMultiResFeatures(data= df, fd.features = fdf)
                                       ~^
```
[tests/testthat/test_FDA_multiResNaive.R:37:40:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_multiResNaive.R#L37) *style:* **Put spaces around all infix operators (except exponentiation).**
```r
  dfn = extractFDAMultiResFeatures(data= df, curve.lens = rep(180,2))
                                      ~^
```
[tests/testthat/test_FDA_multiResNaive.R:37:67:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_FDA_multiResNaive.R#L37) *style:* **Commas should always have a space after.**
```r
  dfn = extractFDAMultiResFeatures(data= df, curve.lens = rep(180,2))
                                                                  ^
```
[tests/testthat/test_Fda_convert_task.R:5:90:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_Fda_convert_task.R#L5) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  task = trafoFDATaskToRegrTask(task = fuelsubset.task, method = "wavelets", pars = list( filter = "d4", boundary = "reflection"))
                                                                                ^
```
[tests/testthat/test_Fda_convert_task.R:6:38:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_Fda_convert_task.R#L6) *style:* **Put spaces around all infix operators (except exponentiation).**
```r
  expect_true(nrow(getTaskData(task))== dim(fuel$data)[1])
                                    ~^
```
[tests/testthat/test_base_learnerArgsToControl.R:15:22:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_base_learnerArgsToControl.R#L15) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  arg1 = quote(expr = )
                     ^
```
[tests/testthat/test_base_learnerArgsToControl.R:16:22:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_base_learnerArgsToControl.R#L16) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  arg2 = quote(expr = )
                     ^
```
[tests/testthat/test_base_learnerArgsToControl.R:41:24:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_base_learnerArgsToControl.R#L41) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  devmax = quote(expr = )
                       ^
```
[tests/testthat/test_base_measures.R:448:58:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_base_measures.R#L448) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  qsr.test = 1 - mean(rowSums((pred.probs - model.matrix( ~ . + 0, data = as.data.frame(tar.classif)))^2))
                                                         ^
```
[tests/testthat/test_base_tuning.R:25:46:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_base_tuning.R#L25) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
    j = which(pp$cp == cp & pp$minsplit == ms )
                                             ^
```
[tests/testthat/test_classif_logreg.R:22:98:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_classif_logreg.R#L22) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  testCV("classif.logreg", binaryclass.df, binaryclass.target, tune.train = tt, tune.predict = tp )
                                                                                ^
```
[tests/testthat/test_classif_multinom.R:21:98:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_classif_multinom.R#L21) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  testCV("classif.multinom", multiclass.df, multiclass.target, tune.train = tt, tune.predict = tp )
                                                                                ^
```
[tests/testthat/test_classif_naiveBayes.R:16:100:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_classif_naiveBayes.R#L16) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  testCV("classif.naiveBayes", multiclass.df, multiclass.target, tune.train = tt, tune.predict = tp )
                                                                                ^
```
[tests/testthat/test_classif_probit.R:19:98:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_classif_probit.R#L19) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  testCV("classif.probit", binaryclass.df, binaryclass.target, tune.train = tt, tune.predict = tp )
                                                                                ^
```
[tests/testthat/test_classif_qda.R:18:93:](https://github.com/mlr-org/mlr/blob/aa2e76ac04ee8e3d6a35a136903d8f2850b9b756/tests/testthat/test_classif_qda.R#L18) *style:* **Do not place spaces around code in parentheses or square brackets.**
```r
  testCV("classif.qda", multiclass.df, multiclass.target, tune.train = tt, tune.predict = tp )
                                                                                ^
```


![](https://github.trello.services/images/mini-trello-icon.png) [Add bootstrap to client side](https://trello.com/c/ly9sQya1/7-add-bootstrap-to-client-side)


Won't compile on Windows.


@kakshay21 Jenkins CI reporting about code analysis
See the full report here: http://jenkins.plone.org/job/package-plone.app.discussion/25/violations
```
plone/app/discussion/conversation.py:334:5: D001 found adapts( replace it with zope.component.adapter
plone/app/discussion/conversation.py:415:5: D001 found adapts( replace it with zope.component.adapter
plone/app/discussion/testing.py:43:9: D001 found xmlconfig.file( replace it with self.loadZCML(
plone/app/discussion/upgrades.py:63:25: S001 found module formatter
plone/app/discussion/browser/captcha.py:25:5: D001 found adapts( replace it with zope.component.adapter
plone/app/discussion/browser/captcha.py:26:15: Q000 Remove bad quotes.
plone/app/discussion/browser/captcha.py:28:1: E305 expected 2 blank lines after class or function definition, found 1
plone/app/discussion/browser/captcha.py:37:5: D001 found adapts( replace it with zope.component.adapter
plone/app/discussion/browser/captcha.py:69:1: W391 blank line at end of file
plone/app/discussion/browser/comment.py:115:1: E305 expected 2 blank lines after class or function definition, found 1
plone/app/discussion/browser/traversal.py:24:5: D001 found adapts( replace it with zope.component.adapter
plone/app/discussion/browser/comments.py:6:1: I001 isort found an import in the wrong position
plone/app/discussion/browser/validator.py:37:5: D001 found adapts( replace it with zope.component.adapter
plone/app/discussion/tests/test_indexers.py:5:1: I001 isort found an import in the wrong position
plone/app/discussion/tests/test_events.py:8:1: I001 isort found an import in the wrong position
```
Follow [these instructions](https://github.com/plone/jenkins.plone.org/blob/master/docs/source/run-qa-on-package.rst) to reproduce it locally.


If message size is a concern we should look into other serialization formats instead of trying to manually shrink the sizes. Protobuf could be an alternative. JSON is not the most efficient serialization out there.


Note:
Commented out SMTP function because its unsafe to test in school (SMTP ports are blocked)


I only had time to do a quick test, so maybe I overlooked something. (not many people help me with PR reviews :)

I will try an look at this today


This doesn't seem "exact" to me. Exact would be "strcmp"...


Created multidev environment [9mobilevn#ci-10](https://dashboard.pantheon.io/sites/024265b2-7c0b-4e16-a735-75af3d0e6aa8#ci-10).

[![Visit Site](https://raw.githubusercontent.com/pantheon-systems/ci-drops-8/0.1.0/data/img/visit-site-36.png)](https://ci-10-9mobilevn.pantheonsite.io/)


主要是解决二重查询时候出现聚合查询时候的bug，标题备注写错了


what is the path location of this file in windows OS


Ho unito la branch, effettivamente hai ragione sul fatto che alcune cose
forse sono ripetute.
Alcuni articoli di MDN sono anche già tradotti.
Anche a me era venuto il dubbio se trattare o meno Poedit nella seconda
sezione, probabilmente ci starebbe meglio, più che altro l'ho lasciato
nella sezione 3 perché altrimenti la sezione sui file .po sarebbe stata
proprio due righe e un rimando a Poedit (non credo abbia senso
descrivere nel dettaglio il formato dei file .po perché potrebbe
aggiungere più confusione che altro per un nuovo traduttore).
OmegaT io l'ho usato poco e se Valter lo conosce meglio mi farebbe molto
piacere potesse riguardare quella parte.


Congrats!


On Wed, May 3, 2017 at 10:14 PM, Khem Raj <notifications@github.com> wrote:

> Can Igalia fork be merged here ? Least I would like to see is two diverged
> layers creating more confusion and fragmented scene
>
Sure but they need to propose a pull request with the changes they wish
merged/which are ready.

--
Otavio Salvador                             O.S. Systems
http://www.ossystems.com.br        http://code.ossystems.com.br
Mobile: +55 (53) 9981-7854            Mobile: +1 (347) 903-9750


Thanks Ben appreciate your time! Always happy to help out if I can.

Cheers


The undefined check isn't needed. `project.version == null` checks for undefined as well.


docker image: 496870459963.dkr.ecr.eu-west-1.amazonaws.com/photobox/jenkins-tests:testing_2, endpoint: http://jenkins-tests-jenkins-testing.k8s-test.photobox.com


My commit message got lost:
- when connected to shotgun 7.2 and above, adds support for the software entity
- adds parameters needed for the upcoming websockets integration
- adds support for better grouping and group defaults
- refactor of business logic and code organization
- support for automatic software scanning interfaces
- bumps core dependency to 18.54
- adds a dependency on shogun utils 5.1.0+


The last comma is no necessary... but... if you put it there it means next time you extend the list it won't be forgotten.


No i don't understeand what you tell, speak your original language


Please review revert in PR #103


@lixiaobin0303 检查一下前后写的数据源是否正确


@wdhonor 看一下里面的Item的高度


comment


Incorrect comments are worse than no comments. Please ensure the documentation is correct when adding new functions.


@Trickhan


Pulled common code into new method showButtons()


@dbuxton yes, fairly sure this is the cause


cpm function from edgeR package


I think here we would want to return some sort of state to the `load` function. So that they can disable forms etc if they want to


We have the defect open. It's just a reminder this could break some border line cases. The solution is more involved.


Oh, thanks.


IMHO it's a really bad idea to write an attribute without the user knowing about it. This might have unwanted side effects.


I believe they use clang.

http://clang-developers.42468.n3.nabble.com/clang-and-Wframe-larger-than-td4045414.html


Yes, and that's also the error you get when you don't have rights to write the attribute. In that case the message is just wrong.
Besides, this tool shouldn't overcome the bugs in the kernel. If there's no kernel backing code, then why is there an attribute in the first place?


Issue #63 (mistakenly noted as #64 in the commit message).


@ged-odoo did you review this one entirely?


Why are you using `element.setAttribute` and not `element.contentEditable`?


yes but the problem is that text is different in those:

zone: AWS zone. If not specified, a random zone from those where Kubernetes cluster has a node is chosen.

zone: GCE zone. If not specified, a random zone in the same region as controller-manager will be chosen.

the problem in these texts is that it says "random zone". It is not really random zone. So that is incorrect imo


mmh isn't git supposed to fix that?


https://github.com/kubernetes/kubernetes/blob/master/pkg/volume/util.go#L295 "Volumes are generally round-robin-ed across all active zones" That is not random :) should I change texts to aws + gce as well


@Udara-U3 do you have the SVG or similar editable format so that we can edit and reuse these for later releases?


docker image: 496870459963.dkr.ecr.eu-west-1.amazonaws.com/photobox/jenkins-tests:testing_2, endpoint: http://jenkins-tests-jenkins-testing.k8s-test.photobox.com


@aab-odoo sorry... yes, it is quite good


TeamCity Xbim :: Xbim Geometry :: XbimGeometry [Build 354](http://xbimbuilds.cloudapp.net/viewLog.html?buildId=1565&buildTypeId=Xbim_XbimGeometry_XbimGeometry) is now running


<img width="383" alt="2017-05-04 19 30 41" src="https://cloud.githubusercontent.com/assets/20424289/25700035/c005dc16-3100-11e7-9a96-5c417fdb39e9.png">


Write-only attributes will return -EPERM when you try to read them, not -EINVAL.
Like the 'multichip_sync' attr of 'ad9361-phy'.


Created multidev environment [9mobilevn#ci-11](https://dashboard.pantheon.io/sites/024265b2-7c0b-4e16-a735-75af3d0e6aa8#ci-11).

[![Visit Site](https://raw.githubusercontent.com/pantheon-systems/ci-drops-8/0.1.0/data/img/visit-site-36.png)](https://ci-11-9mobilevn.pantheonsite.io/)


tror bare du kan skrive: include '/views/meta-boxes/slider-info.php';?


@lukastosic thanks for letting me know, I hope we can get this upstreamed somehow in one form or another, so that I won't have to rebase it upon every new release.

Sadly, I'm no frontend developer and very short of time, so feel free to comment in swagger-api#2891 if you can help turning this into a configurable plugin suitable for inclusion upstream or something like that... I hereby place my changes in public domain if that helps ;-)


This could be dropped as well - we don't really care about triggers in this tool.


Ciao a tutti,

Appena possibile controllo :)

Valter
Open Source is better!
Sent from my Android device

Il 4 mag 2017 12:12, "gialloporpora" <notifications@github.com> ha scritto:

Ho unito la branch, effettivamente hai ragione sul fatto che alcune cose
forse sono ripetute.
Alcuni articoli di MDN sono anche già tradotti.
Anche a me era venuto il dubbio se trattare o meno Poedit nella seconda
sezione, probabilmente ci starebbe meglio, più che altro l'ho lasciato
nella sezione 3 perché altrimenti la sezione sui file .po sarebbe stata
proprio due righe e un rimando a Poedit (non credo abbia senso
descrivere nel dettaglio il formato dei file .po perché potrebbe
aggiungere più confusione che altro per un nuovo traduttore).
OmegaT io l'ho usato poco e se Valter lo conosce meglio mi farebbe molto
piacere potesse riguardare quella parte.

—
You are receiving this because you were mentioned.
Reply to this email directly, view it on GitHub
<https://github.com/kitsunenosaraT/Mozilla-Italia-l10n-guide/commit/dbb27e88fe62339cbc33968be1ee931ffe1e4ce0#commitcomment-22014112>,
or mute the thread
<https://github.com/notifications/unsubscribe-auth/AKc5r9XsI999lRVzCzr0xGwUGhlDgwEpks5r2aSIgaJpZM4NQbDL>
.


Mangler sanititation dude


It misses one description for --debug_attr


Der er vidst et mellemrum for meget her


For long names, I would prefer a dash instead of underscore (--device-attr instead of --device_attr).


Skulle måske splittes ud i en klasse for sig selv


Created multidev environment [9mobilevn#ci-12](https://dashboard.pantheon.io/sites/024265b2-7c0b-4e16-a735-75af3d0e6aa8#ci-12).

[![Visit Site](https://raw.githubusercontent.com/pantheon-systems/ci-drops-8/0.1.0/data/img/visit-site-36.png)](https://ci-12-9mobilevn.pantheonsite.io/)


cnc2 kam dazu


Del commits op ples


No, it should work fine with the default gproxy.
However, this file:
https://community.griefco.de/files/file/2-gproxydll/

Does have this extension build in.


Vidst ikke så godt med html og javascript i php filen -- Include i stedet


IIRC htmlspecialchars_decode was used to handle things like accents in french, but I could be wrong.


Don't forget to add env var 'server-link'


Hvorfor har du return i en view fil?
- Smid javascript i sin ejen fil


@fossfreedom SVG is a vector format, This is a Raster Graphic. So if you want I can also commit .Tif editable file or in .PSD format.


Should this not be :
`#if ! (NET40 || NET45)`
If so, I'll include it with another patch that I'll submit toon.


Looks good to me 👍


-9331*0,951 @


This crashes if pkg.reactSnapshot is undefined (which is quite common since there's nothing about options like paths in the readme).
You should use a default fallback like:
`const paths = pkg.reactSnapshot && pkg.reactSnapshot.paths || []`


Change inside 'p' tag


Du kan smække urlen in som første parameter i stedet.. Tænker det ser lidt mere "clean" ud


Hahah noob


Virkede ikke :/


Created multidev environment [9mobilevn#ci-13](https://dashboard.pantheon.io/sites/024265b2-7c0b-4e16-a735-75af3d0e6aa8#ci-13).

[![Visit Site](https://raw.githubusercontent.com/pantheon-systems/ci-drops-8/0.1.0/data/img/visit-site-36.png)](https://ci-13-9mobilevn.pantheonsite.io/)


Spacing issues.


yes, prøvede jeg .. virkede nogen gange .. rip wp


<img width="384" alt="2017-05-04 19 44 59" src="https://cloud.githubusercontent.com/assets/20424289/25700323/3d98b10c-3102-11e7-9473-7f5f7c2567f0.png">


yep - any format to allow easy editing.  Is there a way to edit .psd files in linux ?


c b1 git tavu


Hvorfor udskriver du det ikke bare i stedet for at gemme det til en variabel?


jeg ville gerne lave en samlet løsning


added a change


Keep HTML out of PHP files ;-))))))))))))))))))))))))))))))))


Brug __FILE__ som andet parameter. Så skulle den være i vinkel 📐


har du set hvad jeg gør senere ??????


Linjeskift - MB


Hermit, can you add support for your anti map hack tool?


Vedi se é chiaro.

-------------------------------------------------------------------
Dear Zahra,
the second step extracts from the OSM dataset only the features which have
a correspondence in the REF dataset and therefore are suitable for the
comparison. This procedure is performed through a complex geometric
processing which compares each REF feature with all the OSM features
falling inside a buffer around the REF feature. The buffer is one of the
parameter that you have to set and can be derived from the results of the
first step.
To perform the comparison the procedure computes the angular coefficient of
the REF feature and each correspondent OSM feature: if the difference
between the two angular coefficients exceeds a user-specified threshold
(e.g 30°), then the OSM feature is deleted.

Being the comparison performed feature by feature, if the REF dataset has
huge dimensions the second step requires high computational times. To this
reason the module provides a REF dataset generalization option which
applies the Douglas-Peucker algorithm. If you select this option you have
to specify the threshold value for the line feature generalization; usually
we suggest to use values equal or less than the accuracy of the REF data.

You can find more information at the following links:

http://geomatica.como.polimi.it/workbooks/n12/FOSS4G-eu15_submission_70.pdf
https://www.researchgate.net/publication/298296464_Towards_an_Automated_Comparison_of_OpenStreetMap_with_Authoritative_Road_Datasets

https://www.slideshare.net/mingo23/a-grassbased-automated-procedure-to-compare-openstreetmap-and-authoritative-road-network-datasets

Regards,

2017-05-03 11:03 GMT+02:00 zahrapashaei <notifications@github.com>:

> Hi Monia
> Thanks for your kind reply,
> I have got the result of first module, but again I have problem in running
> second module, could you help me in performing second module.
> what are inputs?(is it like previous step)
> what is the threshold value for angular coefficient?
>
> thanks so much
> Best Regards
> Zahra
>
> —
> You are receiving this because you commented.
> Reply to this email directly, view it on GitHub
> <https://github.com/MoniaMolinari/OSM-roads-comparison/commit/1a4a2bb80cd4b8a2ab7b3518ac12cfadbe7e109e#commitcomment-21995481>,
> or mute the thread
> <https://github.com/notifications/unsubscribe-auth/AOElbfV4bS7p5iLXJUgqklDdu18GgsMjks5r2ELHgaJpZM4NLXs4>
> .
>


virkede ikke, men tror det var fordi jeg brugte include_once da jeg havde return på  den.


I am Locking this conversation. Please create a issue here https://github.com/sunel/Magento-Import-Expo. Will discuss over there


update


Ja sorry, så det efter.. - Godt arbejde 👍


####commit update


This broke my tests :(.

Can we restore existing behaviour when for when passing something like:

```
array(
   'foo' => 'bar'
)
```
for `$raw_arguments`.

Also, given that it is 'raw', should we not be escaping it?


@fossfreedom Nope not .PSD, but .TIF is editable using Gimp :smile:


**Conceitos**.

#Memórias RAM, ROM, Paginação de Memória e SWAP.

`MEMÓRIA RAM
`
A memória RAM é um componente essencial não apenas nos computadores. Por mais que exista espaço de armazenamento disponível, na forma de um HD ou memória flash, é sempre necessária uma certa quantidade de memória RAM e, naturalmente, quanto mais melhor. A memória RAM (Random Access Memory - Memória de Acesso Aleatório) é um hardware de armazenamento randômico e volátil de memória. Isto significa que esta peça armazena dados de programas em execução enquanto o computador está ligado. Assim, é diferente de outras memórias, tal como o ROM, que tem a capacidade de armazenar informação independentemente das condições de energia disponíveis. Então, a memória RAM é um dispositivo utilizado para o gerenciamento de dados e informações circunstancialmente com programas e software. Esta memória permite o funcionamento destas aplicações e uma vez desligada ou interrompida o funcionamento do sistema a informação se perde, pois, muitas vezes não se trata de arquivos ou dados guardados por importância, mas simplesmente de dados necessários para o desempenho do software em questão. As memórias desta índole podem ser dividas em estáticas e dinâmicas. As primeiras mantêm seu conteúdo inalterado desde que exista uma fonte de energia. As segundas, ao contrário, envolvem uma "leitura destrutiva", ou seja, a informação é perdida ao ser lida e para evitar isso deve-se restaurar os dados com uma operação de "refresco". Uma RAM pode ter diversos tamanhos expressos em megabytes ou gigabytes e, desta forma, permite usos de menor ou maior nível. Por exemplo, a utilização simultânea de vários programas, ou então, o acréscimo da velocidade de conexão ou de funcionamento do computador.

SRAM

O segundo tipo é o SRAM ou, memória estática de acesso aleatório. Essa possui um circuito em uma forma conhecida como Flip-flop, que contém quatro ou seis transistores e fios. A vantagem desse tipo é que não há necessidade de ser refrescada. Sendo assim, é mais rápida que o primeiro tipo. No entanto, ocupa também bem mais espaço em um chip que uma célula de memória dinâmica. O que resulta na menor quantidade de memória que se pode ter por chip, fazendo da SRAM um componente bem mais caro.

Dual Channel

As memórias têm evoluído muito e agregado cada vez mais funcionalidades para aplicarem suas capacidades e o Dual Channel é uma delas. A característica dá a possibilidade do chipset ou o processador de comunicarem-se com duas vias de memória ao mesmo tempo. O resultado é o fornecimento do dobro de largura de dados do barramento.

DRAM

Existem dois tipos básicos de memórias RAM. O mais barato e comum deles é a DRAM ou memória dinâmica de acesso aleatório. Nesse tipo, um transistor e um capacitor unem-se para formar uma célula de memória, que é responsável por um bit de dados. Enquanto o capacitor conserva o bit de informação, o transistor age como um controle, que permite ao chip ler o capacitor ou mudar seu estado. A DRAM costuma ser uma memória mais lenta, pois passa por um processo de refrescamento dos dados, o que leva tempo e deixa a memória lenta.

Módulos de Memória

Mais um aspecto importante nas memórias RAM, ao qual deve-se ficar atento, principalmente se for adquirir novas, é o seu módulo. Isto é, o formato dos conectores da placa de memória. Isso acontece porque as placas-mães devem ter compatibilidade com o conector na memória. Os modelos para desktops que ficaram mais conhecidos são: o SIMM, single in-line memory module; o DIMM, dual in-line memory module e o RIMM, Rambus in-line memory module. Já o modelo SODIMM serve para notebooks. Essas são memórias que se diferenciam essencialmente nos modos como organizam os pinos nos conectores e transmitem os dados.

DDR

A DDR ou, Double Data Rate (taxa dupla de transferência) é mais um para a lista dos aperfeiçoamentos na engenharia das memórias RAM. Essa funcionalidade possibilita a transferência de dois dados simultaneamente.

MEMÓRIA ROM

A memória ROM é um tipo de memória que permite apenas a leitura, ou seja, as suas informações são gravadas pelo fabricante uma única vez e após isso não podem ser alteradas ou apagadas, somente acessadas. São memórias cujo conteúdo é gravado permanentemente. Uma memória somente de leitura propriamente dita vem com seu conteúdo gravado durante a fabricação. Atualmente, o termo Memória ROM é usado informalmente para indicar uma gama de tipos de memória que são usadas apenas para a leitura na operação principal de dispositivos eletrônicos digitais, mas possivelmente podem ser escritas por meio de mecanismos especiais. Entre esses tipos encontramos as PROM, as EPROM, as EEPROM e as memórias flash. Ainda de forma mais ampla, e de certa forma imprópria, dispositivos de memória terciária, como CD-ROMs, DVD-ROMs, etc., também são algumas vezes citados como memória ROM. Apesar do nome memória ROM ser usado algumas vezes em contraposição com o nome memória RAM, deve ficar claro que ambos os tipos de memória são de acesso aleatório.

Aplicações da Memória ROM

As memórias ROM (Read-Only Memory - Memória Somente de Leitura) recebem esse nome porque os dados são gravados nelas apenas uma vez. Depois disso, essas informações não podem ser apagadas ou alteradas, apenas lidas pelo computador, exceto por meio de procedimentos especiais. Outra característica das memórias ROM é que elas são do tipo não voláteis, isto é, os dados gravados não são perdidos na ausência de energia elétrica ao dispositivo. A memória ROM está presente em qualquer dispositivo digital, como por exemplo um relógio. Sempre que um computador é iniciado, ele necessita de informações existentes em algum lugar para carregar suas funções básicas e/ou principais de uma forma que elas sempre sejam acessíveis e não se apaguem ao interromper a alimentação. Satélites, controles remotos, impressoras, celulares, todos os aparelhos digitais comportam uma ROM para realizarem suas tarefas básicas. O uso da memória ROM vêm aumentando conforme surgem novas tecnologias, além de serem portadores de firmwares, hoje utilizam-se memórias flash (que também são memórias ROM) para o armazenamento de diversos tipos de dados. Uma grande perspectiva para as Flash Rom é a possibilidade de um dia esta memória poder substituir de vez os tão usados discos rígidos, mas isto ainda não é possível, pois as memórias flash embora possam comportar diversos dados, ainda possuem capacidade muito menor do que os HDs enquanto o preço é bem superior. A memória rom de seu micro é responsável pela a BIOS sistema que é responsável por "acordar" todos seus componentes e também pelo auto-teste responsável por fazer testes na memória e outros componentes do hadware e também pelo Setup responsável pela configuração de sua máquina. Ou seja, é na memória rom que tudo começa.

Principais tipos de memória ROM são:

PROM

Programmable Read-Only Memory: esse é um dos primeiros tipos de memória ROM. A gravação de dados neste tipo é realizada por meio de aparelhos que trabalham através de uma reação física com elementos elétricos. Uma vez que isso ocorre, os dados gravados na memória PROM não podem ser apagados ou alterados.

EEPROM

(Electrically-Erasable Programmable Read-Only Memory): este tipo de memória ROM também permite a regravação de dados, no entanto, ao contrário do que acontece com as memórias EPROM, os processos para apagar e gravar dados são feitos eletricamente, fazendo com que não seja necessário mover o dispositivo de seu lugar para um aparelho especial para que a regravação ocorra.

EAROM

(Electrically-Alterable Programmable Read-Only Memory): as memórias EAROM podem ser vistas como um tipo de EEPROM. Sua principal característica é o fato de que os dados gravados podem ser alterados aos poucos, razão pela qual esse tipo é geralmente utilizado em aplicações que exigem apenas reescrita parcial de informações.

EPROM

(Erasable Programmable Read-Only Memory): as memórias EPROM têm como principal característica a capacidade de permitir que dados sejam regravados no dispositivo. Isso é feito com o auxílio de um componente que emite luz ultravioleta. Nesse processo, os dados gravados precisam ser apagados por completo. Somente depois disso é que uma nova gravação pode ser feita.

Flash

As memórias Flash também podem ser vistas como um tipo de EEPROM, no entanto, o processo de gravação (e regravação) é muito mais rápido. Além disso, memórias Flash são mais duráveis e podem guardar um volume elevado de dados. É possível saber mais sobre esse tipo de memória no artigo Cartões de memória Flash, publicado aqui no InfoWester.

CD-ROM, DVD-ROM e afins

Essa é uma categoria de discos ópticos onde os dados são gravados apenas uma vez, seja de fábrica, como os CDs de músicas, ou com dados próprios do usuário, quando o próprio efetua a gravação. Há também uma categoria que pode ser comparada ao tipo EEPROM, pois permite a regravação de dados: CD-RW e DVD- RW e afins.

PAGINAÇÃO DE MEMÓRIA

A paginação da memória do computador é um processo de virtualização da memória que consiste na subdivisão da memória física em pequenas partições (frames), para permitir-lhe uma utilização mais eficiente. As frames da memória física correspondem a páginas de memória virtual. A alocação de memória é requisitada por páginas, a menor unidade deste método. Cada página é mapeada numa frame de memória através de um processo que chama paginação. A paginação é implementada normalmente por unidades dedicadas de hardware integradas nos processadores. No caso dos processadores da família Intel x86, esta funcionalidade está atribuída à MMU. A paginação é obtida através de consulta a tabelas que relacionam os endereços lineares das páginas de memória com os endereços físicos das frames de memória respectivas. Neste sistema, cada processo no computador tem a sua própria tabela de páginas, em que a cada endereço virtual corresponde o endereço físico em que a informação está efectivamente armazenada. Visto que a informação está dividida em pequenas unidades, o seu armazenamento não tem de ser necessariamente sequencial, o que elimina a fragmentação externa da memória. A paginação permite que o programa possa ser espalhado por áreas não contíguas de memória. Com isso, o espaço de endereçamento lógico de um processo é dividido em páginas lógicas de tamanho fixo e a memória física é dividida em páginas com tamanho fixo, com tamanho igual ao da página lógica. Nisso, o programa é carregado página a página, cada página lógica ocupa uma página física e as páginas físicas não são necessariamente contíguas. O endereço lógico é inicialmente dividido em duas partes: um número de página lógica (usado como índice no acesso a tabela de páginas, de forma a obter o número da página física correspondente) e um deslocamento dentro da página. Não existe fragmentação externa, porém existe fragmentação interna (Ex: um programa que ocupe 201kb, o tamanho de página é de 4 kb, serão alocadas 51 páginas resultando uma fragmentação interna de 3kb). Além da localização a tabela de páginas armazena também o bit de validade, (1 ou TRUE) se a página está na memória (0 ou FALSE) se a página não está na memória. E a transferência das páginas de processo podem ser transferidas para a memória por demanda, levando apenas o que é necessário para a execução do programa ou por paginação antecipada, onde o sistema tenta prever as páginas que serão necessárias à execução do programa.

MEMÓRIA SWAP

A memória SWAP surgiu, basicamente, para estender a capacidade de computadores com memórias RAM muitas vezes limitadas em micros antigos, sendo usada hoje em dia mais como válvula de escape, caso a memória principal acabe. Sendo um recurso finito de hardware muito limitado e caro há décadas atrás para ser utilizado em demasia, então, teve-se a ideia de armazenar os dados da memória no HD, aumentando assim, a capacidade do computador em responder a processos, mesmo que ela acabe ou socorrendo o sistema nessas situações, evitando assim, uma negação de serviço pela escassez de recursos. O swap pode ficar tanto em uma partição, quanto em um arquivo no disco. No caso de ficar numa partição em um disco comum (não-SSD), recomenda-se colocar a partição no início do disco, assim a leitura durante a rotação do disco magnético é mais rápida. No caso de partições em disco SSD, tanto faz pois não há rotações como um disco comum. Algumas distribuições, como Debian e Ubuntu, tem no instalador uma opção para colocar a partição no início do disco. No GNU/Linux a memória SWAP é quase obrigatória, tendo em vista que este S.O. sustenta servidores com grandes fluxos diários de dados. Uma falha de memória ou ausência da mesma, poderia acarretar em custos para empresas ou consequências mais graves, se for uma máquina firewall ou proxy. Sendo assim, essa importante peça tem sua partição separada das demais, assim como a /home e /root, temos a /swap.

Tamanho para uso

Desde os primórdios dos tempos, e você ainda vai encontrar muito essa informação, recomendava-se colocar sempre o dobro da RAM como swap. Por exemplo: se uma máquina tem 1GB de RAM, coloca-se 2GB de swap. Mas esse tipo de conselho era mais comum quando as máquinas tinham pouco de RAM. Se um servidor tem 16GB, geralmente não é necessário você colocar 32GB de swap. Essa regra do dobro foi alterada mais recentemente. Se a máquina tem até 2GB de RAM, coloque o dobro. A partir daí, cada GB adicional de RAM é apenas RAM+2GB na Swap. Ou seja: •Um sistema de 2GB de RAM teria 4GB de swap (2×2). •Um sistema de 3GB de RAM teria 5GB de swap (3+2). •Um sistema de 8GB de RAM teria 10GB de swap (8+2). •Um sistema de 16GB de RAM teria 18GB de swap (16+2).


Spacing between $this and the dash?


indent for meget


Prøvede du at gå op i start?


good thing.

Offtopic, the AMH tool is outdated ENT don't using it, its bugged.. they saying in forums. Must be removed.


Spacing between the method name and ().


Indentation :)


文字化けです


Sorry 😢


yes , correct must be `#if ! (NET40 || NET45)`


<?php echo $slider->ID; ?> tak
http://stackoverflow.com/questions/15847072/php-vs-php-echo-whats-the-difference-which-one-is-better-to-use


@Celthi 根据我目前下载的情况，所有课时的字幕都变为网页（后缀名为.srt，但实际内容为html）


Again with the HTML. ;)


Building createMap.so came up with a few warnings, that helped improve the quality of my code slightly, e.g. using uint8_t rather than int for some variables that were being compared to other unsigned integers.

In an interactive Python session, after importing createMap, you can now use:
`>>> createMap.test()`
to see the new variables that can be tested (getting those to display is kind of a hack). There must be at least one (width/height), and they can either be done by typing out in full, e.g:
`>>> createMap.test(width = 5, height = 5, pathLength = 3)`
or, if no optional arguments are being skipped (i.e. you CAN do arguments 1, 2, 3, but CANNOT do 1, 3, 4) then just by using values:
`>>> createMap.test(7, 7, 3, 8)`

WARNING! Using different width and height, and using even numbers for width and height, have not been tested yet. They will probably cause nasty crashes!

![createmapscreenshot](https://cloud.githubusercontent.com/assets/462459/25700557/22452602-30c0-11e7-827a-be8442e34c55.png)


Sut et pik


Thanks, I was struggling with this...


I don't know why that happened. Probably something related to file encoding.


Indentation.


Switching between _ and camelcase


# Conceitos: Multiprogramação e Programação Concorrente.

Multiprogramação

Se trata de um conceito fundamental em sistemas operacionais é o conceito de processo, onde basicamente se trata de um programa em execução, ele consiste em um programa executável, os seus dados, o seu stack pointer e registradores, enfim todas as informações necessárias para executar o programa. Periodicamente o sistema operacional decide se a execução de um processo deve ser interrompida e a execução de um outro processo deve ser iniciada pela razão do primeiro já ter tido mais do que a sua `fatia' de tempo de CPU, em um sistema de multiprogramação a CPU fica se alternando entre a execução de vários processos, cada um por dezenas ou centenas de milissegundos. Um processo pode estar em um dos seguintes estados:

Running: usando a CPU naquele instante; Ready: pronto para ser executado, temporariamente parado para que outro processo possa ser executado; e Blocked: impossibilitado de ser executado até que algum evento externo ocorra. Em um sistema de multiprogramação temos frequentemente a situação onde vários processos estão prontos para serem executados, quando mais de um processo está ready, o sistema operacional deve decider qual processo deve ser executado primeiro, a parte do sistema operacional que toma esta decisão é chamada de scheduler. O algoritmo que é usado é chamado de scheduler algorithm, a cada interrupção do relógio, o sistema operacional toma o controle e decide se o processo que está sendo executado deve continuar a ser executado ou deve ser suspenso para que outro processo passe a ser executado, a estratégia que permite que um processo que está sendo executado seja suspenso temporariamente é chamada de preemptive schedule. Existem scheduling algoritms que assumem que todos os processos que são iguais, entretanto, existem muitas pessoas que possuem e administram centros de computação que discordam disto. Por exemplo, em um centro de computação de uma universidade pode ser dada a mais alta prioridade aos processos de diretores, depois aos de professores, depois aos de secretarias, depois aos de porteiros, ...e finalmente aos de alunos. Isto é chamado de um priority schedule (alguns podem chamar isto de injustiça). Para evitar que processos que têm alta prioridade fiquem sendo executados indefinidamente o scheduler pode baixar a prioridade do processo que está sendo executado a cada interrupção do relógio. Alguns priority schedulers fazem uso de classes de prioridade, os processos na classe de prioridade mais baixa podem ser executados sem serem suspensos por no máximo uma QUANTA (uma quantidade de tempo de CPU). Processos na próxima classe de prioridade pode ser executado por no máximo duas QUANTAS, e assim por diante. Sempre que um processo usa toda as QUANTAS alocadas para ele este processo é rebaixado de classe. Quando um processo deseja imprimir um arquivo, ele coloca o nome do arquivo em um diretório especial chamado de spooler directory. Um outro processo, o printer daemon, periodicamente verifica se existe algum arquivo a ser impresso, se existir ele imprime o arquivo e remove o nome do arquivo do diretório spooler.

# Programação Concorrente

Suas Definições

A grande maioria dos programas escritos são programas seqüenciais. Nesse caso, existe somente um fluxo de controle (fluxo de execução, linha de execução, thread) no programa. Isso permite, por exemplo, que o programador realize uma "execução imaginária" de seu programa apontando com o dedo, a cada instante, o comando que está sendo executada no momento. Um programa concorrente pode ser visto como se tivesse vários fluxos de execução. Para o programador realizar agora uma "execução imaginária", ele vai necessitar de vários dedos, um para cada fluxo de controle.

O termo "programação concorrente" vem do inglês concurrent programming, onde concurrent significa "acontecendo ao mesmo tempo". Uma tradução mais adequada seria programação concomitante. Entretanto, o termo programação concorrente já está solidamente estabelecido no Brasil. Algumas vezes é usado o termo programação paralela com o mesmo sentido. É comum em sistemas multiusuário que um mesmo programa seja executado simultaneamente por vários usuários. Por exemplo, um editor de texto. Entretanto, ter 10 execuções simultâneas do editor de texto não faz dele um programa concorrente. O que se tem são 10 processos independentes executando o mesmo programa seqüencial (compartilhando o mesmo código). Cada processo tem a sua área de dados e ignora a existência das outras execuções do programa. Programação Concorrente não se difere tanto do contexto de Multiprogramação, a ideia agora e voltada para o meio da programação aonde se desenvolve algo ou Processo/Aplicação em que no meio há necessidade de execução de funções paralelas, contudo dentro de um mesmo Processo/Aplicação, então surge a Threads, que são implementadas durante a fabricação de uma aplicação que é capaz de processar “dois processos” de uma mesma aplicação em paralelo seguindo a lógica de multiprogramação. Por exemplo enquanto é baixado um arquivo PDF, além do processo de estar baixando o arquivo, existe um outro processo rodando para exibir a barra de progresso do download, esse é um bom e simples exemplo de programação concorrente.

Fontes:

https://www.ime.usp.br/~gold/cursos/2002/mac2301/ep2/ep2/node3.html

http://wiki.icmc.usp.br/images/f/f9/Aula-01-Introducao-Programacao-Concorrente.pdf


Here you use space between the parameters but at other places in the file you don't.


Will be done very soon.


fjern mellemrum, det er grimt


Thanks! This fixes my setuptools problem. `firedrake-update` is working for me now.


no.. you need a .editorconfig file. youll have to install a VS addon for it to work. everyone else's IDEs are supporting it nowadays too. Its easy and examples are not hard to find. Here's yours:

```
root = true
[*]
indent_style = space
indent_size = 4
```


than*


has*


Du grim


You could have used WP_query but the sql seems fine. Nice that you've used sanitize though 👍


AMH Tool will not be provided, already asked for that.


Thanks!


this is the description of palette..


TeamCity Market :: INFRA :: Graphouse :: Graphouse on change [Build 93](https://teamcity.yandex-team.ru/viewLog.html?buildId=8670168&buildTypeId=MarketInfra_Graphouse_GraphouseOnChangeOpensource) outcome was **SUCCESS**
Summary: Tests passed: 14 Build time: 00:00:42


Kenneth doesn't like html in php 🌮


done


Remove aaa maybe


Maybe also remove bb


Doc?


delete


it may be time to make this a template... the shell script reading config.xml isn't bad but it should be future-proof also?


This reminded me to create #117.


can this be condensed into "compression" ? it's already in the webgui section


this is the same as in query.ts


Functions for registering custom post types are usually named accordingly, like "register_cpt_slideshow" or whatever


Make pep8 changes


`if (distance<File>(s, pos.square<KING>(Them)>=3)`


Same as above - code is fine however 👍


Good work, man. I like how small are your commits. Very easy to review 👍


Appropriately named, but use of spaces is a little mixed


Fix the CircleCI . Can't make .phar file.


Dear Zahra,
the second step extracts from the OSM dataset only the features which have a correspondence in the REF dataset and therefore are suitable for the comparison. This procedure is performed through a complex geometric processing which compares each REF feature with all the OSM features falling inside a buffer around the REF feature. The buffer is one of the parameter that you have to set and can be derived from the results of the first step.
To perform the comparison the procedure computes the angular coefficient of the REF feature and each correspondent OSM feature: if the difference between the two angular coefficients exceeds a user-specified threshold (e.g 30°), then the OSM feature is deleted.
Being the comparison performed feature by feature, if the REF dataset has huge dimensions the second step requires high computational times. To this reason the module provides a REF dataset generalization option which applies the Douglas-Peucker algorithm. If you select this option you have to specify the threshold value for the line feature generalization; we suggest to set this value equal to the intrinsic accuracy of the REF dataset.

You can find more information at the following links:
https://www.researchgate.net/publication/298296464_Towards_an_Automated_Comparison_of_OpenStreetMap_with_Authoritative_Road_Datasets
https://www.slideshare.net/mingo23/a-grassbased-automated-procedure-to-compare-openstreetmap-and-authoritative-road-network-datasets

Regards,

Monia


Bracket is placed on a new line where it's placed differently in the other functions


We don't need no stinking docs!

It's doc'ed (and fixed up) in later commit.


TeamCity Xbim :: Xbim Geometry :: XbimGeometry [Build 354](http://xbimbuilds.cloudapp.net/viewLog.html?buildId=1565&buildTypeId=Xbim_XbimGeometry_XbimGeometry) outcome was **SUCCESS**
Summary: Running Build time: 00:34:57


moved


workspaceName.namespace should be in here too and make sure it is used in the template.


Consistent ifs 👍


Hier wordt gebruik gemaakt van een Object Initializer  : https://msdn.microsoft.com/en-us/library/bb397680.aspx


I remember setting an option in the git repo to automagically translate tabs to space and viceversa.


Just for the info: This two options are still needed to build kernel without user intervention.
Will fix myself.


##This is a markdown file


Kenneth probably won't like js in php, but otherwise it's fine


Congrats!
Where did the old comments go? They might have been of some interest for the maintainers and for others, too.

However, you must also provide the bench number in the latest commit message. Otherwise it won't pass the AppVeyor check.


Hier wordt gebruik gemaakt van een constructor.


Hier moeten we de default constructor of een constructor zonder parameters voor hebben!


Looks nice 👍


@fichtner your probably right here, I was under the assumption that we wouldn't want to create a dependency with configd here, although I wasn't entirely sure why.


Should probably just be a .js-file instead


@fichtner sorry about that, I named it webuicompression to ease the grep. If we're turning it into a template, I can rename it.


@pbiecek I thought that all TCGA citations might be included with `broad` . Will we use all `BroadGDAC` `TGCAP` and `GDC` in citations? We might make 1 citation from a specific field - this might save us some space


since all the extensions foo and PHP version specific code is gone it's time indeed. helps to know that configd works very well too :D


commit message is not really clear. here is a suggestion

[FIX] web: fix toolbar test (should not depend on document)

Unit tests are executed after module installation, which is sometimes challenging when some part of the UI is modified by another module.  In this case, a test in module web/ was implicitely relying on a behaviour introduced by the module document.  So, the test failed when document was not installed.

Since the installation of ´document´ module changes the toolbar display, we check in the test if the module is installed to do the correct assertion.


ok


A lot of different functionality - and languages - in the same function. It's mostly consistent however 👍


khj


Please bump version number when adding new features.


Update invoke-phant0m.py


Add option to parse T and P byte units.
https://bugzilla.redhat.com/show_bug.cgi?id=1384106


ok, I will refactor this asap and commit a modified version. I would like to include this functionality in one of the upcoming minor releases.


Hi Joerg,

Thank you, I really don't know, the way I modify stockfish code and compile is all online through GitHub, I never downloaded any program, so everytime Stockfish official has a new merged patch I need to delete my whole repository, then go to stockfish-official and "Fork" again, to start over, and sometimes the comments gets deleted too.
If you know a way of updating my master to match the master of stockfish-official without doing that step let me know.


That doesn't sound normal. That may have only been in your local repository--but in any event, if it was, I guess you should be dismayed if it didnt work for that commit. It's not an option you can set in git such that it can be pushed. (it would need to be in something like .gitattributes)


any reason to remove SYSTEM here? our build now breaks of warnings from within ospray


No update to Python 3.6?  ;-)


The tricky thing is that we are downloading data from TGCAP but right now the official repository is CGC, so IMHO we should mention both. broad and BroadGDAC shall be combined, but afaik only one of them is used in the text thus one one is in references.


LGTM


Thanks for using me


Whitespace could be removed


This should be in your global `.gitignore` file on you working machine


@mbrav Try adding the `--verbose` flag to your Jekyll build commands. It'll let you know what `.markdown` files jekyll-seo-tag is breaking the build on.

In your case it looks like it's not dealing well with the posts that don't have a title e.g. `2017-01-07-.markdown`.


Why not leave PhantomJS as the test-browser?
Now everybody needs Chrome to test it...


multiple encode


Why did the max-eta for jets changed to 5.2 instead of 4.7?

process.skimEventProducer.maxEtaForJets = cms.double(5.191)


Ah, I think I might have confused you a bit yesterday.  To clarify, there are two interesting type parameters for recursors:
 1. The type of the terms that we recurse over.  (Here it is `int`.)
 2. The type that we eliminate into (that is, the return type of the recursor).  (Here it is `rtype`.)

Now you've already implemented parameter 1.  When I said that the type of a recursor depends on the type, I was referring to 2.--for example, lists would have a different recursor than natural numbers.  To compare, these would be the recursor types I would expect for natural numbers and lists:
```
nat_rec: ?a > (nat > ?a > ?a) > nat > ?a
list_rec: ?a > (?b > list ?b > ?a > ?a) > list ?b > ?a
```

 * Please don't call natural numbers `int`.
 * There is no need to append the elimination type to the constant name (`R-$rtype`).  You can and should reuse the same name for all elimination types (`R`, or better yet something that tells you the type like e.g. `nat_rec`).  When adding the recursor constant to the context, you can use type variables: `ctx += hoc"nat_rec: (nat > ?r > ?r) > ?r > nat > ?r"`.


Ed... oops!  That's on the `efischer/dev` branch which is "private,"
right?  I work remotely, and there is no good remote Git client.  On my
desktop, I use SmartGit.  When I want to see the current set of changes in
a graphical way, I push a 'tmp' commit on the remote computer, then pull it
onto my desktop, then view/edit/redo the commit, then "push-with-replace"
whatever results.  As long as the branch is "private," there is no problem
with using push-with-replace.

Don't worry, this commit will be replaced with something more meaningful
when I'm done with the current mini-project.

-- Elizabeth

On Thu, May 4, 2017 at 1:51 AM, Ed Bueler <notifications@github.com> wrote:

> Being cheeky: https://xkcd.com/1296/
>
> —
> You are receiving this because you authored the thread.
> Reply to this email directly, view it on GitHub
> <https://github.com/pism/pism/commit/46d566f1b0bb9b3f84b20e5f6ec32507e10ddb13#commitcomment-22011416>,
> or mute the thread
> <https://github.com/notifications/unsubscribe-auth/AB1cd5QNaignPYaeyi5KSSp1Sv732Niuks5r2WdfgaJpZM4NQQC3>
> .
>


BTW, virion support has been [officially released on Poggit](https://twitter.com/poggitci/status/860086702446002176). Consider using libasynql :D