R 3.3.0 / matrix 1.2-4 - en to de translation catalogue (219 entries)

en: %s %s <Matrix> is undefined
de: %s %s <Matrix> ist undefiniert

en: %s kind not yet implemented
de: %s-Art noch nicht implementiert

en: '%s()' is not yet implemented for  representation '%s'
de: '%s()' ist noch nicht implementiert für Darstellung '%s'

en: '%s()' is not yet implemented for element type '%s'
de: '%s()' ist noch nicht für Elementtyp '%s' implementiert

en: 'A' must be a square matrix
de: 'A' muss eine quadratische Matrix sein

en: 'NA' indices are not (yet?) supported for sparse Matrices
de: 'NA'-Indizes werden (noch?) nicht für dünn besetzte Matrizen unterstützt

en: 'V' is not a *square* matrix
de: 'V' ist keine *quadratische* Matrix

en: 'V' is not a square matrix
de: 'V' ist keine quadratische Matrix

en: 'boolArith = %d' not yet implemented
de: 'boolArith = %d' noch nicht implementiert

en: 'by' argument is much too small
de: Argument 'by' ist zu klein

en: 'diagonals' matrix must have %d columns (= length(k) )
de: 'diagonals'-Matrix muss %d Spalten haben (= length(k) )

en: 'diagonals' must have the same length (%d) as 'k'
de: 'diagonals' muss die gleiche Länge (%d) wie 'k' haben

en: 'file' must be a character string or connection
de: 'file' muss eine Zeichenkette oder Verbindung sein

en: 'force' must be (coercable to) TRUE or FALSE
de: 'force' muss (umwandelbar nach) TRUE oder FALSE sein

en: 'lag' and 'differences' must be integers >= 1
de: 'lag' und 'differences' müssen ganze Zahlen >=1 sein

en: 'lwd' must be NULL or non-negative numeric
de: 'lwd' muss NULL oder nicht negativ numerisch sein

en: 'ncol' is not a factor of length(x)
de: 'ncol' ist kein Faktor von length(x)

en: 'ncol' must be >= 0
de: 'ncol' muss >= 0 sein

en: 'nearPD()' did not converge in %d iterations
de: nearPD() ist nicht in %d Iterationen konvergiert

en: 'nrow' and 'ncol' must be the same when 'symmetric' is true
de: 'nrow' und 'ncol' müssen gleich sein, wenn 'symmetric' auf true gesetzt ist

en: 'nrow' is not a factor of length(x)
de: 'nrow' ist kein Faktor von length(x)

en: 'nrow' must be >= 0
de: 'nrow' muss >= 0 sein

en: 'nrow', 'ncol', etc, are disregarded for matrix 'data'
de: 'nrow', 'ncol', etc werden nicht für Matrix 'data' berücksichtigt

en: 'nrow', 'ncol', etc, are disregarded when 'data' is "Matrix" already
de: 'nrow', 'ncol', etc. werden nicht berücksichtigt, wenn 'data' bereits 'Matrix' ist

en: 'p' must be a non-decreasing vector (0, ...)
de: 'p' muss ein nicht abnehmender Vektor (0, ...) sein

en: 'times >= 0' is required
de: 'times >= 0' wird benötigt

en: 'update' must be logical or '+' or '-'; 'C' a matrix, and 'L' a "CHMfactor"
de: 'update' muss entweder boolesch, '+' oder '-' sein; 'C' eine Matrix
    und 'L' ein "CHMfactor"

en: 'x' has invalid data type
de: 'x' hat ungültigen Datentyp

en: 'x' is not positive definite -- chol() undefined.
de: 'x' ist nicht positiv definit -- chol() undefiniert.

en: 'x' is not symmetric nor triangular
de: 'x' ist weder symmetrisch noch in Dreiecksform

en: 'x' must be "sparseMatrix"
de: 'x' muss "sparseMatrix" sein

en: 'x' must have length nrow^2 when 'symmetric' is true
de: 'x' muss die Länge nrow^2, wenn 'symmetric' auf true gesetzt ist

en: 'x' must inherit from "sparseVector"
de: 'x' muss von "sparseVector" geerbt sein

en: (un)packing only applies to dense matrices, class(x)='%s'
de: (ent)packen ist nur für dicht besetzte Matrizen anwendbar, class(x)='%s'

en: .M.repl.i.2col(): 'i' has no integer column number;
     should never happen; please report
de: .M.repl.i.2col(): 'i' hat keine ganzzahlige Spaltennummer.
    Sollte nie passieren. Bitte melden.

en: .M.repl.i.2col(): drop 'matrix' case ...
de: .M.repl.i.2col(): 'matrix'-Fall weglassen ...

en: .M.sub.i.2col(): 'i' has no integer column number;
     should never happen; please report
de: .M.sub.i.2col(): 'i' hat keine ganzzahlige Spaltennummer.
    Sollte nie passieren. Bitte melden!

en: <Matrix> %s %s is undefined
de: <Matrix> %s %s ist undefiniert

en: <abIndex>  -->  <seqMat>  is not yet implemented
de: <abIndex> --> <seqMat> ist noch nicht implementiert

en: <abIndex>[i]  is not yet implemented
de: <abIndex>[i] ist noch nicht implementiert

en: <seqMat>  -->  <abIndex>  is not yet implemented
de: <seqMat> --> <abIndex> ist noch nicht implementiert

en: <sparse>[ <logic> ] : .M.sub.i.logical() maybe inefficient
de: <sparse>[ <logic> ] : .M.sub.i.logical() könnte ineffizient sein

en: Cholesky(<nsparse...>) -> *symbolic* factorization -- not yet implemented
de: Cholesky(<nsparse...>) -> *symbolische* Faktorisierung – noch nicht implementiert

en: Cholesky(A) called for 'A' of class "%s";
    	 it is currently defined for sparseMatrix only; consider using chol() instead
de: Cholesky(A) für 'A' der Klasse "%s" aufgerufen;
    	 es ist derzeit nur für sparseMatrix definiert; erwägen Sie, chol() zu benutzen

en: Class %s is not yet implemented
de: Klasse %s noch nicht implementiert

en: Cmp.Mat.atomic() should not be called for diagonalMatrix
de: Cmp.Mat.atomic() sollte nicht für diagonalMatrix aufgerufen werden

en: FIXME: NOT YET FINISHED IMPLEMENTATION
de: ZU ERLEDIGEN: NOCH NICHT ABGESCHLOSSENE IMPLEMENTIERUNG

en: Internal bug: nargs()=%d; please report
de: Interner Fehler: nargs()=%d; bitte melden

en: Invalid assembled indicator: %s
de: Ungültig zusammengesetzter Indikator: %s

en: Invalid storage format: %s
de: Ungültiges Speicherformat: %s

en: Invalid storage type: %s
de: Ungültiger Speichertyp: %s

en: LU computationally singular: ratio of extreme entries in |diag(U)| = %9.4g
de: Die LU Zerlegung ist computational singulär; Quotient der extremen Elemente von |diag(U)| = %9.4g

en: Logic.Mat.atomic() should not be called for diagonalMatrix
de: Logic.mat.atomic() sollte für diagonalMatrix nicht aufgerufen werden

en: Matrices must have same dimensions in %s
de: Matrizen müssen in %s die gleichen Dimensionen haben

en: Matrices must have same number of columns in %s
de: Matrizen müssen die gleiche Anzahl Spalten in %s haben

en: Matrices must have same number of rows for arithmetic
de: Matrizen müssen für Arithmetik die gleiche Anzahl Zeilen haben

en: Matrices must have same number of rows in %s
de: Matrizen müssen die gleiche Anzahl Zeilen in %s haben

en: Matrix seems negative semi-definite
de: Matrix scheint negativ semidefinit zu sein

en: Matrix-internal error in <CsparseM>[i,,d]; please report
de: Matrixinterner Fehler in <CsparseM>[i,,d]. Bitte berichten

en: Matrix-internal error in <TsparseM>[i,,d]; please report
de: Matrix-interner Fehler in <TsparseM>[i,,d]; Bitte berichten

en: Matrix-internal error in <sparseM>[i,,d]; please report
de: Matrix-interner Fehler in <sparseM>[i,,d]. Bitte berichten

en: Must specify 'nrow' when 'symmetric' is true
de: 'nrow' muss angegeben werden, wenn 'symmetric' auf true gesetzt ist

en: NA's in (i,j) are not allowed
de: NAs sind in (i,j) nicht erlaubt

en: NAs are not allowed in subscripted assignments
de: NAs sind in indexierten Anweisungen nicht erlaubt

en: Not a valid format
de: Kein gültiges Format

en: Only numeric sparse matrices allowed
de: Nur dünn besetzte Matrizen erlaubt

en: Quadratic matrix '%s' (=: A) is not formally
    	symmetric.  Will be treated as	A A'
de: Die quadratische Matrix '%s' (=: A) ist formal
        nicht symmetrisch.  Wird behandelt wie      A A'

en: RHS 'b' has wrong length
de: RHS 'b' hat falsche Länge

en: RHS 'b' has wrong number of rows:
de: RHS 'b' hat falsche Zahl Zeilen:

en: RHS 'value' (class %s) matches 'ANY', but must match matrix class %s
de: RHS 'value' (Klasse %s) passt zu 'ANY', muss aber zur Matrixklasse %s passen

en: [ <character> ] indexing not allowed: forgot a "," ?
de: [ <Zeichen> ] Indexierung nicht erlaubt: Ein ',' vergessen?

en: [[ suppressing %d column names %s ... ]]
de: [[ unterdrücke %d Spaltennamen %s  ...]]

en: [[ suppressing %d column names %s ]]
de: [[ unterdrücke %d Spaltennamen %s ]]

en: all(<abIndex>) is not yet implemented
de: all(<abIndex>) ist noch nicht implementiert

en: as(.,"dsCMatrix") is deprecated (since 2008); do use as(., "symmetricMatrix")
de: as(.,"dsCMatrix") ist veraltet (seit 2008). Benutzen Sie as(., "symmetricMatrix")

en: c(<abIndex>,..) of different kinds, coercing all to 'rleDiff'
de: c(<abIndex>,..) von unterschiedlichen Arten, alle  werden in 'rleDiff' umgewandelt

en: cannot coerce 'NA's to "nsparseMatrix"
de: 'NA's können nicht in "nsparseMatrix" umgewandelt werden

en: cannot coerce 'NA's to "nsparseVector"
de: Kann NAs nicht in 'nsparseVector' umwandeln

en: cannot coerce non-symmetric "dgTMatrix" to "dsCMatrix" class
de: nicht symmetrische "dgTMatrix" kann nicht in "dsCMatrix" Klasse umgewandelt werden

en: chol() is undefined for diagonal matrix with negative entries
de: chol() ist undefiniert für diagonale Matrix mit negativen Einträgen

en: coercion from list(i1,...,ik, d) to "indMatrix" failed.
     All entries must be integer valued and the number of columns, d, not smaller
     than the maximal index i*.
de: Umwandlung von list(i1,...,ik, d) zu "indMatrix" gescheitert.
     Alle Elemente müssen ganzzahlig sein und die Anzahl Spalten, d, nicht kleiner
     als der maximale Index i*.

en: coercion to "indMatrix" only works from integer numeric
de: Umwandlung zu "indMatrix" funktioniert nur von ganzzahligen numerischen Werten

en: coercion to "pMatrix" only works from integer numeric
de: Umwandlung zu "pMatrix" funktioniert nur von ganzzahligen numerischen Werten

en: column indices must be <= ncol(.) which is %d
de: Spaltenindizes müssen <= ncol(.) sein, das ist %d

en: complex matrices not yet implemented in Matrix package
de: komplexe Matrizen noch nicht im Matrix-Paket implementiert

en: diag(.) had 0 or NA entries; non-finite result is doubtful
de: diag(.) hatte 0 oder NA Einträge. Nicht-endliches Ergebnis ist zweifelhaft

en: diagonalMatrix in .dense2C() -- should never happen, please report!
de: diagonalMatrix in .dense2C() -- sollte niemals vorkommen. Bitte berichten.

en: dim [product %d] do not match the length of object [%d]
de: dim [produkt %d] passt nicht zur Länge des Objekts [%d]

en: dim(.) value must be numeric of length 2
de: dim(.)-Wert muss numerisch sein und die Länge 2 haben

en: dimensions don't match the number of cells
de: Dimensionen passen nicht zur Anzahl der Zellen

en: dimnames [%d] mismatch in %s
de: dimnames [%d] passen nicht in %s

en: dimnames(.) <- NULL:  translated to 
    dimnames(.) <- list(NULL,NULL)  <==>  unname(.)
de: dimnames(.) <- NULL: übersetzt in
    dimnames(.) <- list(NULL,NULL)  <==>  unname(.)

en: element type '%s' not recognized
de: Elementtyp '%s' nicht erkannt

en: element type 'complex' not yet implemented
de: Elementtyp 'complex' noch nicht implementiert

en: exactly one of 'i', 'j', or 'p' must be missing from call
de: exakt eins von 'i', 'j' oder 'p' muss im Aufruf fehlen

en: extra argument %s will be disregarded in
     %s | extra arguments %s will be disregarded in
     %s
de[0]: extra Argument %s wird nicht berücksichtigt in %s
de[1]: extra Argumente %s werden nicht berücksichtigt in %s

en: file is not a MatrixMarket file
de: Datei ist keine MatrixMarket-Datei

en: for symmetric band matrix, only specify upper or lower triangle
     hence, all k must have the same sign
de: geben Sie für symmetrische Bandmatrizen nur oberes oder unteres Dreieck an.
     deshalb müssen alle k dasselbe Vorzeichen haben.

en: general Matrix class not yet implemented for %s
de: allgemeine Matrixklasse noch nicht implementiert für %s

en: hit a cycle (1) -- stop iterations
de: auf einen Zyklus getroffen (1) – Iterationen stoppen

en: hit a cycle (2) -- stop iterations
de: auf einen Zyklus getroffen (2) – Iterationen stoppen

en: i1[1] == 0 ==> C-level verbosity will not happen!
de: i1[1] == 0 ==> C-Ebene wird nicht detailliert sein!

en: in Summary(<ANY>, .): %s(<%s>, <%s>,...)
de: in Summary(<ANY>, .): %s(<%s>, <%s>, ...)

en: incompatible matrix dimensions
de: inkompatible Matrixdimensionen

en: index larger than maximal %d
de: Index größer als maximales %d

en: index must be numeric, logical or sparseVector for indexing sparseVectors
de: Index muss numerisch, logisch oder sparseVector sein, um sparseVector zu indizieren

en: inefficient coercion (lost triangularity); please report
de: ineffiziente Umwandlung (Dreiecksgestalt verloren). Bitte berichten

en: inefficient method used for "- e1"
de: ineffiziente Methode für '- e1' benutzt

en: intermediate 'r' is of type %s
de: Zwischenergebnis 'r' ist vom Typ %s

en: internal bug in "Compare" method (Cmp.Mat.atomic); please report
de: interner Fehler in der "Compare"-Methode (Cmp.Mat.atomic). Bitte berichten

en: internal bug in "Logic" method (Logic.Mat.atomic); please report
de: interner Fehler in der "Logic"-Methode (.Logic.Mat.atomic). Bitte berichten

en: internal bug: matrix 'i' in replTmat(): please report
de: interner Fehler: Matrix 'i' in replTmat(): Bitte berichten

en: internal bug: missing 'i' in replTmat(): please report
de: interner Fehler: Fehlendes 'i' in replTmat(): Bitte berichten

en: invalid 'col.names' string: %s
de: ungültige 'col.names'-Zeichenkette: %s

en: invalid 'contrasts.arg' argument
de: unzulässiges 'contrasts.arg' Argument

en: invalid 'data'
de: ungültiges 'data'

en: invalid 'mod': %s
de: ungültiges 'mod': %s

en: invalid 'type'
de: ungültiger 'type'

en: invalid (to - from)/by in seq(.)
de: unzulässiges (to - from)/by in seq(.)

en: invalid character indexing
de: ungültige Zeichenindexierung

en: invalid class: %s
de: ungültige Klasse: %s

en: invalid dimnames given for %s object
de: ungültige dimnames für %s Objekt gegeben

en: invalid nargs()= %d
de: ungültige nargs()= %d

en: invalid or not-yet-implemented 'Matrix' subsetting
de: ungültige oder noch nicht implementierte 'Matrix'-Untermenge

en: kronecker method must use default 'FUN'
de: kronecker-Methode muss Standard 'FUN' benutzen

en: length must be non-negative number
de: Länge muss eine nicht negative Zahl sein

en: length of 1st arg does not match dimension of 2nd
de: Länge des ersten arg passt nicht zur Dimension des zweiten

en: length of 2nd arg does not match dimension of first
de: Länge des zweiten Arguments passt nicht zur Dimension des ersten

en: length(i) is not a multiple of length(x)
de: length(i) ist kein Vielfaches von length(x)

en: length(x) must be either 1 or #{cols}
de: length(x) muss 1 oder #{cols} sein

en: logic programming error in printSpMatrix2(), please report
de: logischer Programmierfehler in printSpMatrix2(), bitte berichten

en: logical subscript too long (%d, should be %d)
de: logisches Subskript zu lang (%d, sollte %d sein)

en: longer object length
    	is not a multiple of shorter object length
de: längere Objektlänge
    	ist kein Vielfaches der kürzeren Objektlänge

en: longer object length is not a multiple of shorter object length
de: längere Objektlänge ist kein Vielfaches der kürzeren Objektlänge

en: m[ <ij-matrix> ] <- v: inefficiently treating single elements
de: m[ <ij-matrix> ] <- v: Einzelne Elemente ineffizient behandelt

en: m[ <ij-matrix> ]: inefficiently indexing single elements
de: m[ <ij-matrix> ]: ineffiziente Indexierung einzelner Elemente

en: matrix is not diagonal
de: Matrix ist nicht diagonal

en: matrix with non-zero off-diagonals cannot be coerced to "diagonalMatrix"
de: Matrix mit Nichtdiagonalelementen ungleich Null kann nicht in "diagonalMatrix" umgewandelt werden

en: model frame and formula mismatch in model.matrix()
de: Model-Frame und Formel passen nicht zusammen in model.matrix()

en: must either specify 'A' or the functions 'A.x' and 'At.x'
de: muss entweder 'A' angeben oder die Funktionen 'A.x' und 'At.x'

en: must have exactly one non-zero entry per row
de: muss genau einen Nicht-Null-Eintrag pro Zeile haben

en: names(dimnames(<matrix>)) must be NULL or of length two
de: names(dimnames(<matrix>)) muss entweder NULL oder von Länge 2 sein

en: nargs() = %d should never happen; please report.
de: nargs() = %d sollte niemals vorkommen. Bitte berichten.

en: nargs() = %d.  Extraneous illegal arguments inside '[ .. ]' (i.2col)?
de: nargs() = %d. Irrelevante ungültige Argumente innerhalb '[ .. ]' (i.2col)?

en: nargs() = %d.  Extraneous illegal arguments inside '[ .. ]' (i.logical)?
de: nargs() = %d. Irrelevante ungültige Argumente innerhalb '[ .. ]' (i.logical)?

en: nargs() = %d.  Extraneous illegal arguments inside '[ .. ]' ?
de: nargs() = %d. Irrelevante ungültige Argumente innerhalb '[ .. ]'?

en: negative values are not allowed in a matrix subscript
de: negative Werte sind in einer Matrix-Subskript nicht erlaubt

en: no 'dimnames[[.]]': cannot use character indexing
de: keine 'dimnames[[.]]': Zeichenindexierung kann nicht benutzt werden

en: non-conformable arguments
de: nicht passende Argumente

en: non-conformable matrix dimensions in %s
de: nicht konforme Matrixdimensionen in %s

en: non-matching dimensions
de: nicht passende Dimensionen

en: non-square matrix
de: nicht quadratische Matrix

en: not a positive definite matrix
de: keine positiv definite Matrix

en: not a square matrix
de: keine quadratische Matrix

en: not a symmetric matrix; consider forceSymmetric() or symmpart()
de: keine symmetrische Matrix. Erwägen Sie forceSymmetric() oder symmpart()

en: not a triangular matrix
de: keine Dreiecksmatrix

en: not converged in %d iterations
de: nicht konvergiert in %d Iterationsschritten

en: not enough new vecs -- stop iterations
de: nicht genügend neue Vektoren – Iterationen stoppen

en: not yet implemented
de: noch nicht implementiert

en: not yet implemented .. please report
de: noch nicht implementiert ... bitte melden

en: not yet implemented for %s
de: noch nicht implementiert für %s

en: not yet implemented for class %s
de: noch nicht implementiert für Klasse %s

en: not yet implemented for matrix with typeof %s
de: noch nicht implementiert für Matrix mit typeof %s

en: not-yet-implemented 'Matrix[<-' method
de: noch nicht implementierte 'Matrix[<-'-Methode

en: not-yet-implemented coercion to "TsparseMatrix"
de: noch nicht implementierte Typumwandlung zu 'TsparseMatrix'

en: not-yet-implemented method for %s(<%s>).
     ->>  Ask the package authors to implement the missing feature.
de: noch nicht implementierte Methode für %s(<%s>).
     ->> Bitten Sie die Autoren des Pakets, diese fehlende Funktion zu implementieren.

en: not-yet-implemented method for %s(<%s>, <%s>).
     ->>  Ask the package authors to implement the missing feature.
de: noch nicht implementierte Methode für %s(<%s>, <%s>).
     ->> Bitten Sie die Autoren des Pakets, diese fehlende Funktion zu implementieren.

en: not-yet-implemented method for <%s> %%*%% <%s>
de: noch nicht implementierte Methode für <%s> %%*%% <%s>

en: nothing to replace with
de: nichts zu ersetzen mit

en: number of items to replace is not a multiple of replacement length
de: Anzahl der zu ersetzenden Elemente ist kein Vielfaches der Austauschlänge

en: number of non zeros is smaller than 'nnz' because of duplicated (i,j)s
de: Anzahl von Nicht-Nullen ist kleiner als 'nnz' wegen doppelter (i,j)s

en: number of rows are not compatible for %s
de: Anzahl der Zeilen ist nicht kompatibel für %s

en: only 2-dimensional tables can be directly coerced to sparse matrices
de: nur 2-dimensionale Tabellen könne direkt in eine dünn besetzte Matrix umgewandelt werden

en: only square matrices can be used as incidence matrices for graphs
de: nur quadratische Matrizen können als Inzidenzmatrizen für Graphen benutzt werden

en: prod(<abIndex>) is not yet implemented
de: prod(<abIndex>) ist noch nicht implementiert

en: programming error: min() should have dispatched w/ 1st arg much earlier
de: Programmierfehler: min() ohne erstes Argument hätte eher abgefangen sein müssen

en: qr.R(<sparse>) may differ from qr.R(<dense>) because of permutations.  Possibly use our qrR() instead
de: qr.R(<sparse>) könnte von qr.R(<dense>) aufgrund von Permutationen abweichen. Evtl. besser qrR() nutzen.

en: rankMatrix(<large sparse Matrix>, method = '%s') coerces to dense matrix.
     Probably should rather use method = 'qr' !?
de: rankMatrix(<large sparse Matrix>, method = '%s') wird in dicht
    besetzte Matrix umgewandelt. Evtl. eher method = 'qr' nutzen?

en: rankMatrix(x, method='qr'): computing t(x) as nrow(x) < ncol(x)
de: rankMatrix(x, method='qr'): t(x) berechnet, da nrow(x) < ncol(x)

en: rcond(.) via sparse -> dense coercion
de: rcond(.) über Umwandlung dünn besetzt -> dicht besetzt

en: readMM(): column values 'j' are not in 1:nc
de: readMM(): Spalte	 Werte 'j' sind nicht in 1:nc

en: readMM(): row	 values 'i' are not in 1:nr
de: readMM(): Zeile	 Werte 'i' sind nicht in 1:nr

en: replacing "indMatrix" entries is not allowed, as rarely sensible
de: Ersetzen von "indMatrix"-Einträgen ist nicht erlaubt, da selten sinnvoll

en: representation '%s' not recognized
de: Repräsentation '%s' nicht erkannt

en: resulting x-slot has different type than x's or y's
de: resultierender x-slot hat einen anderen Typ als x oder y

en: row indices must be <= nrow(.) which is %d
de: Zeilenindizes müssen <= nrow(.) sein, das ist %d

en: some arguments are not matrices
de: einige Argumente sind keine Matrizen

en: such indexing must be by logical or 2-column numeric matrix
de: solche Indexierung muss von logischer oder 2-spaltig numerischer Matrix sein

en: sum(<abIndex>) is not yet implemented
de: sum(<abIndex>) ist noch nicht implementiert

en: symmetric matrix must be square
de: symmetrische Matrix muss quadratisch sein

en: symmetry form '%s' is not yet implemented
de: Symmetrieform '%s' noch nicht implementiert

en: symmetry form '%s' not recognized
de: Symmetrieform '%s' nicht erkannt

en: symmetry form 'hermitian' not yet implemented for reading
de: Symmetrieform 'hermitian' noch nicht zum Lesen implementiert

en: symmetry form 'skew-symmetric' not yet implemented for reading
de: Symmetrieform 'skew-symmetric' noch nicht zum Lesen implementiert

en: temporarily disabled
de: zeitweise ausgeschaltet

en: the %d-th (sub)-diagonal (k = %d) is too short; filling with NA's
de: die  %d-te (Unter)-Diagonale (k = %d) ist zu kurz und wird mit NA aufgefüllt

en: the matrix is not triangular
de: die Matrix ist nicht dreieckig

en: the number of non-zero entries differs from nrow(.)
de: die Anzahl der Nicht-Null-Einträge weicht von nrow(.) ab

en: too many arguments
de: zu viele Argumente

en: too many replacement values
de: zu viele Austauschwerte

en: trimmed mean of 'sparseVector' -- suboptimally using as.numeric(.)
de: getrimmter Mittelwert von 'sparseVector' – suboptimalerweise wird as.numeric(.) benutzt

en: type '%s' not recognized
de: Typ '%s' nicht erkannt

en: undefined method for class %s
de: undefinierte Methode für Klasse %s

en: update must be TRUE/FALSE or '+' or '-'
de: update muss entweder TRUE/FALSE, '+' oder '-' sein

en: using	 "old code" part in  Csparse subassignment
de: benutzt wird	 'alter Kode'-Teil in Csparse-Unterzuweisung

en: using slow kronecker() method
de: langsame kronecker()-Methode wird benutzt

en: using"old code" part in Csparse subassignment
     >>> please report to Matrix-authors@r-project.org
de: benutzt wird 'alter Kode'-Teil in Csparse-Unterzuweisung
     >>> bitte an Matrix-authors@r-project.org berichten

en: variable '%s' converted to a factor
de: Variable '%s' konvertiert in einen Faktor

en: variable '%s' is absent, its contrast will be ignored
de: Variable '%s' fehlt, ihr Kontrast wird irgnoriert

en: vector too long in Matrix - vector operation
de: Vektor zu lang in der Matrix - Vektor Operation

en: when 'A' is specified, 'A.x' and 'At.x' are disregarded
de: wenn 'A' angegeben wurde, werden 'A.x' und 'At.x' nicht berücksichtigt

en: wrong sign in 'by' argument
de: falsches Vorzeichen im Argument 'by'

en: x / 0 for an <abIndex> x with sign-change
     no longer representable as 'rleDiff'
de: x / 0 für einen <abIndex> x mit Vorzeichenwechsel
     nicht länger als 'rleDiff' darstellbar

en: x[.,.] <- val : x being coerced from Tsparse* to CsparseMatrix
de: x[.,.] <- val : x wird von Tsparse* in CsparseMatrix umgewandelt

en: x[.,.] <- val: x is %s, val not in {TRUE, FALSE} is coerced NA |--> TRUE.
de: x[.,.] <- val: x ist %s, val nicht in {TRUE, FALSE} wird umgewandelt NA |--> TRUE.

en: x[.,.] <- val: x is %s, val not in {TRUE, FALSE} is coerced.
de: x[.,.] <- val: x ist %s, val nicht in {TRUE, FALSE} wird umgewandelt

en: x[.] <- val: x is %s, val not in {TRUE, FALSE} is coerced.
de: x[.] <- val: x ist %s, val nicht in {TRUE, FALSE}, wird umgewandelt.

en: x[.] <- val: x is %s, val not in {TRUE, FALSE} is coerced; NA |--> TRUE.
de: x[.] <- val: x ist %s, val nicht in {TRUE, FALSE}, wird umgewandelt;
    NA |--> TRUE.

en: you cannot mix negative and positive indices
de: Sie können positive und negative Indizes nicht mischen
