Matrix 1.1-2-2 - en to pl_PL translation catalogue (211 entries)

en: %s %s <Matrix> is undefined
pl_PL: %s %s <Matrix> nie jest określone

en: %s kind not yet implemented
pl_PL: rodzaj %s nie jest jeszcze zaimplementowany

en: '%s()' is not yet implemented for  representation '%s'
pl_PL: '%s()' nie jest jeszcze zaimplementowane dla reprezentacji '%s'

en: '%s()' is not yet implemented for element type '%s'
pl_PL: '%s()' nie jest jeszcze zaimplementowany dla typu '%s' elementu

en: 'A' must be a square matrix
pl_PL: 'A' musi być macierzą kwadratową

en: 'NA' indices are not (yet?) supported for sparse Matrices
pl_PL: indeksy 'NA' nie są (jeszcze?) wspierane dla rzadkich macierzy

en: 'V' is not a *square* matrix
pl_PL: 'V' nie jest macierzą *kwadratową*

en: 'V' is not a square matrix
pl_PL: 'V' nie jest macierzą kwadratową

en: 'by' argument is much too small
pl_PL: argument 'by' jest znacznie za mały

en: 'diagonals' matrix must have %d columns (= length(k) )
pl_PL: macierz 'diagonals' musi mieć %d kolumnę (= length(k) )

en: 'diagonals' must have the same length (%d) as 'k'
pl_PL: 'diagonals' musi mieć tę samą długość (%d) co 'k'

en: 'file' must be a character string or connection
pl_PL: 'file' musi być łańcuchem tekstowym lub połączeniem

en: 'force' must be (coercable to) TRUE or FALSE
pl_PL: 'force' musi być (przekształcalne do) TRUE lub FALSE

en: 'lag' and 'differences' must be integers >= 1
pl_PL: 'lag' oraz 'differences' muszą być liczbami całkowitymi >= 1

en: 'lwd' must be NULL or non-negative numeric
pl_PL: 'lwd' musi mieć wartość NULL lub być nieujemną liczbą

en: 'ncol' is not a factor of length(x)
pl_PL: 'ncol' nie jest czynnikiem długości 'length(x)'

en: 'ncol' must be >= 0
pl_PL: 'ncol' musi być >= 0

en: 'nearPD()' did not converge in %d iterations
pl_PL: funkcja 'nearPD()' nie uzbieżniła się w %d iteracjach

en: 'nrow' and 'ncol' must be the same when 'symmetric' is true
pl_PL: 'nrow' oraz 'ncol' muszą mieć tę samą wartość gdy 'symmetric' ma wartość TRUE

en: 'nrow' is not a factor of length(x)
pl_PL: 'nrow' nie jest czynnikiem długości 'length(x)'

en: 'nrow' must be >= 0
pl_PL: 'nrow' musi być >= 0

en: 'nrow', 'ncol', etc, are disregarded for matrix 'data'
pl_PL: 'nrow', 'ncol', itd., są nieuwzględniane dla 'data' typu macierzowego

en: 'nrow', 'ncol', etc, are disregarded when 'data' is "Matrix" already
pl_PL: 'nrow', 'ncol', itd., nie są uwzględniane gdy 'data' ma już typ 'Matrix'

en: 'p' must be a non-decreasing vector (0, ...)
pl_PL: 'p' musi być niemalejącym wektorem (0, ...)

en: 'times >= 0' is required
pl_PL: wymagane jest 'times >= 0'

en: 'update' must be logical or '+' or '-'; 'C' a matrix, and 'L' a "CHMfactor"
pl_PL: 'update' musi być wartością logiczną lub '+' lub '-'; 'C' musi być macierzą, oraz 'L' musi być obiektem klasy 'CHMfactor'

en: 'x' has invalid data type
pl_PL: 'x' posiada niepoprawny typ danych

en: 'x' is not positive definite -- chol() undefined.
pl_PL: 'x' nie jest dodatnio określone -- nieokreślony 'chol()'.

en: 'x' is not symmetric nor triangular
pl_PL: 'x' nie jest macierzą symetryczną ani trójkątną

en: 'x' must be "sparseMatrix"
pl_PL: 'x' musi być obiektem klasy "sparseMatrix"

en: 'x' must have length nrow^2 when 'symmetric' is true
pl_PL: 'x' musi mieć długość równą 'nrow'^2 gdy 'symmetric' ma wartość TRUE

en: 'x' must inherit from "sparseVector"
pl_PL: argument 'x' musi być obiektem klasy "sparseVector"

en: (un)packing only applies to dense matrices, class(x)='%s'
pl_PL: (roz)pakowanie stosuje się jedynie do gęstych macierzy, class(x)='%s'

en: .M.repl.i.2col(): 'i' has no integer column number;
     should never happen; please report
pl_PL: .M.repl.i.2col(): 'i' posiada niecałkowitą liczbę kolumn;
    to nie powinno się nigdy wydarzyć; proszę zgłosić raport

en: .M.repl.i.2col(): drop 'matrix' case ...
pl_PL: .M.repl.i.2col(): zrzuć przypadek 'matrix' ...

en: .M.sub.i.2col(): 'i' has no integer column number;
     should never happen; please report
pl_PL: .M.sub.i.2col(): 'i' posiada niecałkowitą liczbę kolumn;
    to nie powinno się nigdy wydarzyć; proszę zgłosić raport

en: <Matrix> %s %s is undefined
pl_PL: <Matrix> %s %s nie jest określone

en: <abIndex>  -->  <seqMat>  is not yet implemented
pl_PL: <abIndex>  -->  <seqMat> nie jest jeszcze zaimplementowane

en: <abIndex>[i]  is not yet implemented
pl_PL: '<abIndex>[i]'  nie jest jeszcze zaimplementowane

en: <seqMat>  -->  <abIndex>  is not yet implemented
pl_PL: <seqMat>  -->  <abIndex> nie jest jeszcze zaimplementowane

en: <sparse>[ <logic> ] : .M.sub.i.logical() maybe inefficient
pl_PL: <sparse>[ <logic> ] : '.M.sub.i.logical()' może być niewydajne

en: Cholesky(<nsparse...>) -> *symbolic* factorization -- not yet implemented
pl_PL: Cholesky(<nsparse...>) -> *symboliczna* faktoryzacja -- jeszcze niezaimplementowana

en: Cholesky(A) called for 'A' of class "%s";
    	 it is currently defined for sparseMatrix only; consider using chol() instead
pl_PL: metoda 'Cholesky(A)' poprosiła o  'A' klasy '%s';
    	 aktualnie jest ona zdefiniowana jedynie dla klasy 'sparseMatrix'; rozważ w zamian użycie 'metodychol()'

en: Class %s is not yet implemented
pl_PL: Klasa %s nie jest jeszcze zaimplementowana

en: Cmp.Mat.atomic() should not be called for diagonalMatrix
pl_PL: 'Cmp.Mat.atomic()' nie powinien być wywołany dla 'diagonalMatrix'

en: FIXME: NOT YET FINISHED IMPLEMENTATION
pl_PL: FIXME: JESZCZE NIEZAKOŃCZONA IMPLEMENTACJA

en: Internal bug: nargs()=%d; please report
pl_PL: Błąd wewnętrzny: nargs()=%d; proszę zgłosić raport

en: Invalid assembled indicator: %s
pl_PL: Niepoprawnie złożony wskaźnik: %s

en: Invalid storage format: %s
pl_PL: Niepoprawny format przechowywania: %s

en: Invalid storage type: %s
pl_PL: Niepoprawny typ przechowywania: %s

en: LU computationally singular: ratio of extreme entries in |diag(U)| = %9.4g
pl_PL: LU obliczeniowo osobliwa: stosunek ekstremalnych wpisów w |diag(U)| = %9.4g

en: Logic.Mat.atomic() should not be called for diagonalMatrix
pl_PL: 'Logic.Mat.atomic()' nie powinien być wywołany dla 'diagonalMatrix'

en: Matrices must have same dimensions in %s
pl_PL: Macierze muszą mieć te same wymiary w %s

en: Matrices must have same number of columns in %s
pl_PL: Macierze muszą mieć tę samą liczbę kolumn w %s

en: Matrices must have same number of rows for arithmetic
pl_PL: Macierze muszą mieć tę samą liczbę wierszy jeśli mają być przeprowadzane działania arytmetyczne

en: Matrices must have same number of rows in %s
pl_PL: Macierze muszą mieć tę samą liczbę wierszy w %s

en: Matrix seems negative semi-definite
pl_PL: Macierz wydaje się być ujemnie określona

en: Matrix-internal error in <CsparseM>[i,,d]; please report
pl_PL: błąd wewnętrzny w pakiecie 'Matrix' w '<CsparseM>[i,,d]'; proszę zgłosić raport

en: Matrix-internal error in <TsparseM>[i,,d]; please report
pl_PL: błąd wewnętrzny pakiecie 'Matrix' w '<TsparseM>[i,,d]'; proszę zgłosić raport

en: Matrix-internal error in <sparseM>[i,,d]; please report
pl_PL: błąd wewnętrzny pakietu 'Matrix' w '<sparseM>[i,,d]'; proszę zgłosić raport

en: Must specify 'nrow' when 'symmetric' is true
pl_PL: 'nrow' musi być określone, gdy 'symmetric' ma wartość TRUE

en: NA's in (i,j) are not allowed
pl_PL: wartości NA w (i,j) nie są dozwolone

en: NAs are not allowed in subscripted assignments
pl_PL: wartości NA nie są dozwolone w indeksowanych przypisaniach

en: Not a valid format
pl_PL: Niepoprawny format

en: Only numeric sparse matrices allowed
pl_PL: Dozwolone są jedynie liczbowe rzadkie macierze

en: Quadratic matrix '%s' (=: A) is not formally
    	symmetric.  Will be treated as	A A'
pl_PL: Macierz kwadratowa '%s' (=: A) nie jest formalnie symetryczna.  Będzie traktowana jako A A'

en: RHS 'value' (class %s) matches 'ANY', but must match matrix class %s
pl_PL: prawa strona 'value' (klasa %s) pasuje do 'ANY', a musi pasować do klasy macierzy '%s'

en: [ <character> ] indexing not allowed: forgot a "," ?
pl_PL: indeksowanie [ <tekst> ] nie jest dozwolone: zapomniałeś ',' ?

en: [[ suppressing %d column names %s ... ]]
pl_PL: [[ zmniejszanie %d nazw kolumn %s ... ]]

en: [[ suppressing %d column names %s ]]
pl_PL: [[ zmniejszanie %d nazw kolumn %s ]]

en: all(<abIndex>) is not yet implemented
pl_PL: 'all(<abIndex>)' nie jest jeszcze zaimplementowane

en: as(.,"dsCMatrix") is deprecated (since 2008); do use as(., "symmetricMatrix")
pl_PL: 'as(.,"dsCMatrix")' jest przestarzałe (0d 2008); używaj 'as(., "symmetricMatrix")'

en: c(<abIndex>,..) of different kinds, coercing all to 'rleDiff'
pl_PL: 'c(<abIndex>,..)' różnych rodzajów, przekształcanie wszystkich do 'rleDiff'

en: cannot coerce 'NA's to "nsparseMatrix"
pl_PL: nie można przekształcić wartości 'NA' na 'nsparseMatrix'

en: cannot coerce 'NA's to "nsparseVector"
pl_PL: nie można przekształcić wartości NA na obiekt klasy "nsparseVector"

en: cannot coerce non-symmetric "dgTMatrix" to "dsCMatrix" class
pl_PL: nie można przekształcić niesymetrycznej macierzy klasy "dgTMatrix" na klasę "dsCMatrix"

en: chol() is undefined for diagonal matrix with negative entries
pl_PL: 'chol()' jest nieokreślona dla macierzy diagonalnych z ujemnymi wpisami

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*.
pl_PL: przekształcenie z 'list(i1,...,ik, d)' na obiekt klasy "indMatrix" nie powiodło się.
     Wszystkie wpisy muszą być wartościami całkowitymi a liczba kolumn d nie może być mniejsza niż maksymalny indeks i*.

en: coercion to "indMatrix" only works from integer numeric
pl_PL: przekształcenie na "indMatrix" działa jedynie dla liczb całkowitych

en: coercion to "pMatrix" only works from integer numeric
pl_PL: przekształcenie na obiekt klasy "pMatrix" działa jedynie dla liczb całkowitych

en: column indices must be <= ncol(.) which is %d
pl_PL: indeksy kolumn muszą być <= 'ncol(.)' który wynosi %d

en: complex matrices not yet implemented in Matrix package
pl_PL: macierze zespolone nie są jeszcze zaimplementowane w pakiecie 'Matrix'

en: diag(.) had 0 or NA entries; non-finite result is doubtful
pl_PL: 'diag(.)' posiadało wpisy 0 lub NA; nieskończony wynik jest wątpliwy

en: diagonalMatrix in .dense2C() -- should never happen, please report!
pl_PL: 'diagonalMatrix' w '.dense2C()' -- nie powinno nigdy się wydarzyć, proszę zgłosić raport!

en: dim [product %d] do not match the length of object [%d]
pl_PL: wymiar [produkt %d] nie zgadza się z długością obiektu [%d]

en: dim(.) value must be numeric of length 2
pl_PL: wartości 'dim(.)' muszą być liczbami o długości 2

en: dimensions don't match the number of cells
pl_PL: wymiary nie zgadzają się z liczbą komórek

en: dimnames [%d] mismatch in %s
pl_PL: niezgodność nazw wymiarów [%d] w %s

en: dimnames(.) <- NULL:  translated to 
    dimnames(.) <- list(NULL,NULL)  <==>  unname(.)
pl_PL: dimnames(.) <- NULL: przetłumaczono na
    dimnames(.) <- list(NULL,NULL)  <==>  unname(.)

en: element type '%s' not recognized
pl_PL: element typu '%s' nie został rozpoznany

en: element type 'complex' not yet implemented
pl_PL: typ elementu 'complex' nie jest jeszcze zaimplementowany

en: exactly one of 'i', 'j', or 'p' must be missing from call
pl_PL: dokłanie jeden z 'i', 'j', lub 'p' musi być nieobecny w wywołaniu

en: file is not a MatrixMarket file
pl_PL: plik nie jest plikiem typu 'MatrixMarket'

en: for symmetric band matrix, only specify upper or lower triangle
     hence, all k must have the same sign
pl_PL: dla symetrycznej macierzy wstęgowej, określ jedynie górny oraz dolny trójkąt
    tak więc, wszystkie k muszą mieć ten sam znak

en: general Matrix class not yet implemented for %s
pl_PL: ogólna klasa 'Matrix' jeszcze nie jest zaimplementowana dla %s

en: hit a cycle (1) -- stop iterations
pl_PL: natrafiona na cykl (1) -- zatrzymywanie iteracji

en: hit a cycle (2) -- stop iterations
pl_PL: natrafiona na cykl (2) -- zatrzymywanie iteracji

en: i1[1] == 0 ==> C-level verbosity will not happen!
pl_PL: i1[1] == 0 ==> tryb 'verbose' poziomu C nie zostanie wykonany!

en: in Summary(<ANY>, .): %s(<%s>, <%s>,...)
pl_PL: w funkcji 'Summary(<ANY>, .): %s(<%s>, <%s>,...)'

en: incompatible matrix dimensions
pl_PL: niezgodne wymiary macierzy

en: index larger than maximal %d
pl_PL: indeks dłuższy niż maksymalny możliwy %d

en: index must be numeric, logical or sparseVector for indexing sparseVectors
pl_PL: indeks musi być typem liczbowym, logicznym lub obiektem klasy 'sparseVector' na potrzeby indeksowania obiektów klasy 'sparseVector'

en: inefficient coercion (lost triangularity); please report
pl_PL: nieefektywne przekształcenie (utracono trójkątność); proszę zgłosić raport

en: inefficient method used for "- e1"
pl_PL: nieefektywna metoda użyta dla '- e1'

en: intermediate 'r' is of type %s
pl_PL: pośrednie 'r' jest typu %s

en: internal bug in "Compare" method (Cmp.Mat.atomic); please report
pl_PL: błąd wewnętrzny w metodzie 'Compare' (Cmp.Mat.atomic); proszę zgłosić raport

en: internal bug in "Logic" method (Logic.Mat.atomic); please report
pl_PL: błąd wewnętrzny w metodzie 'Logic' (.Logic.Mat.atomic); proszę zgłosić raport

en: internal bug: matrix 'i' in replTmat(): please report
pl_PL: wewnętrzny błąd: macierz 'i' w 'replTmat()': proszę zgłosić raport

en: internal bug: missing 'i' in replTmat(): please report
pl_PL: błąd wewnętrzny: brakuje 'i' w 'replTmat()': proszę zgłosić raport

en: invalid 'col.names' string: %s
pl_PL: niepoprawny łańcuch 'col.names': %s

en: invalid 'contrasts.arg' argument
pl_PL: niepoprawny argument 'contrasts.arg'

en: invalid 'data'
pl_PL: niepoprawne 'data'

en: invalid 'mod': %s
pl_PL: niepoprawne 'mod': %s

en: invalid 'type'
pl_PL: niepoprawny 'type'

en: invalid (to - from)/by in seq(.)
pl_PL: niepoprawne '(to - from)/by' w 'seq(.)'

en: invalid character indexing
pl_PL: niepoprawne tekstowe indeksowanie

en: invalid class: %s
pl_PL: niepoprawna klasa: %s

en: invalid dimnames given for %s object
pl_PL: podano niepoprawne nazwy wymiarów dla obiektu %s

en: invalid nargs()= %d
pl_PL: niepoprawne nargs()=%d

en: invalid or not-yet-implemented 'Matrix' subsetting
pl_PL: niepoprawne lub jeszcze niezaimplementowane podstawienie 'Matrix'

en: kronecker method must use default 'FUN'
pl_PL: metoda kroneckera musi użyć domyślnej 'FUN'

en: length must be non-negative number
pl_PL: długość musi być nieujemną liczbą

en: length of 1st arg does not match dimension of 2nd
pl_PL: długość pierwszego argumentu nie zgadza się z wymiarem drugiego

en: length of 2nd arg does not match dimension of first
pl_PL: długość drugiego argumentu nie zgadza się z wymiarem pierwszego

en: length(i) is not a multiple of length(x)
pl_PL: 'length(i)' nie jest wielokrotnością 'length(x)'

en: length(x) must be either 1 or #{cols}
pl_PL: 'length(x)' musi wynosić 1 lub #{kolumn}

en: logic programming error in printSpMatrix2(), please report
pl_PL: błąd logiczny programu w 'printSpMatrix2()', proszę zgłosić raport

en: logical subscript too long (%d, should be %d)
pl_PL: indeks logiczny jest zbyt długi (%d, powinien być %d)

en: longer object length
    	is not a multiple of shorter object length
pl_PL: długość dłuższego obiektu
    	nie jest wielokrotnością długości krótszego obiektu

en: longer object length is not a multiple of shorter object length
pl_PL: długość dłuższego obiektu nie jest wielokrotnością długości krótszego obiektu

en: m[ <ij-matrix> ] <- v: inefficiently treating single elements
pl_PL: m[ <ij-matrix> ] <- v: nieefektywne traktowanie pojedynczych elementów

en: m[ <ij-matrix> ]: inefficiently indexing single elements
pl_PL: m[ <ij-matrix> ]: nieefektywne indeksowanie pojedynczych elementów

en: matrix is not diagonal
pl_PL: macierz nie jest diagonalna

en: matrix with non-zero off-diagonals cannot be coerced to "diagonalMatrix"
pl_PL: macierz z niezerowaymi wartościami pozadiagonalnymi nie może zostać przekształcona w na obiekt klasy "diagonalMatrix"

en: model frame and formula mismatch in model.matrix()
pl_PL: niezgodność ramki modelu oraz formuły w 'model.matrix()'

en: must either specify 'A' or the functions 'A.x' and 'At.x'
pl_PL: potrzeba określić 'A' lub funkcje 'A.x' oraz 'At.x'

en: must have exactly one non-zero entry per row
pl_PL: potrzeba mieć dokładnie jeden niezerowy wpis na wiersz

en: nargs() = %d should never happen; please report.
pl_PL: 'nargs() = %d' nie powinno się wydarzyć; proszę zgłosić raport.

en: nargs() = %d.  Extraneous illegal arguments inside '[ .. ]' (i.2col)?
pl_PL: nargs() = %d.  Obce nielegalne argumenty wewnątrz '[ .. ]' (i.2col)?

en: nargs() = %d.  Extraneous illegal arguments inside '[ .. ]' (i.logical)?
pl_PL: nargs() = %d.  Obce nielegalne argumenty wewnątrz '[ .. ]' (i.logical)?

en: nargs() = %d.  Extraneous illegal arguments inside '[ .. ]' ?
pl_PL: nargs() = %d.  Obce nielegalne argumenty wewnątrz '[ .. ]' ?

en: negative values are not allowed in a matrix subscript
pl_PL: ujemne wartości nie są dozwolone w indeksach macierzy

en: no 'dimnames[[.]]': cannot use character indexing
pl_PL: brak 'dimnames[[.]]': nie można używać indeksowania tekstowego

en: non-conformable matrix dimensions in %s
pl_PL: niezgodne wymiary macierzy w %s

en: non-matching dimensions
pl_PL: niezgodne wymiary

en: non-square matrix
pl_PL: niekwadratowa macierz

en: not a positive definite matrix
pl_PL: to nie jest dodatnio określona macierz

en: not a square matrix
pl_PL: to nie jest macierz kwadratowa

en: not a symmetric matrix; consider forceSymmetric() or symmpart()
pl_PL: to nie jest macierz symetryczna; rozważ 'forceSymmetric()' lub 'symmpart()'

en: not a triangular matrix
pl_PL: to nie jest macierz trójkątną

en: not converged in %d iterations
pl_PL: nie uzbieżnił się w %d iteracjach

en: not enough new vecs -- stop iterations
pl_PL: zbyt mało nowych wektorów -- zatrzymywanie iteracji

en: not yet implemented
pl_PL: jeszcze niezaimplementowane

en: not yet implemented .. please report
pl_PL: jeszcze niezaimplementowane .. proszę zgłosić raport

en: not yet implemented for %s
pl_PL: jeszcze nie jest zaimplementowana dla %s

en: not yet implemented for class %s
pl_PL: jeszcze niezaimplementowane dla klasy %s

en: not yet implemented for matrix with typeof %s
pl_PL: jeszcze niezaimplementowana dla macierzy z typem %s

en: not-yet-implemented 'Matrix[<-' method
pl_PL: jeszcze niezaimplementowana metoda 'Matrix[<-'

en: not-yet-implemented coercion to "TsparseMatrix"
pl_PL: jeszcze niezaimplementowane przekształcenie na 'TsparseMatrix'

en: not-yet-implemented method for %s(<%s>).
     ->>  Ask the package authors to implement the missing feature.
pl_PL: metoda jeszcze niezaimplementowana dla %s(<%s>).
     ->>  Poproś autorów pakietu o zaimplementowanie brakującej funkcjonalności.

en: not-yet-implemented method for %s(<%s>, <%s>).
     ->>  Ask the package authors to implement the missing feature.
pl_PL: metoda jeszcze niezaimplementowana dla %s(<%s>, <%s>).
     ->>  Poproś autorów pakietu o zaimplementowanie brakującej funkcjonalności.

en: not-yet-implemented method for <%s> %%*%% <%s>
pl_PL: jeszcze niezaimplementowana metoda dla <%s> %%*%% <%s>

en: nothing to replace with
pl_PL: nic do zastąpienia

en: number of items to replace is not a multiple of replacement length
pl_PL: liczba pozycji do zastąpienia nie jest wielokrotnością długości elementu zastępującego

en: number of rows are not compatible for %s
pl_PL: liczba wierszy nie jest zgodna dla %s

en: only 2-dimensional tables can be directly coerced to sparse matrices
pl_PL: jedynie 2-wymiarowe tablice mogą zostać bezpośrednio przekształcone w rzadkie macierze

en: only square matrices can be used as incidence matrices for graphs
pl_PL: jedynie kwadratowe macierze mogą zostać użyte jako macierz incydencji dla grafów

en: prod(<abIndex>) is not yet implemented
pl_PL: 'prod(<abIndex>)' nie jest jeszcze zaimplementowane

en: programming error: min() should have dispatched w/ 1st arg much earlier
pl_PL: błąd programistyczny: 'min()' powinno zostać wysłane z pierwszym argumentem znacznie wcześniej

en: qr.R(<sparse>) may differ from qr.R(<dense>) because of permutations.  Possibly use our qrR() instead
pl_PL: 'qr.R(<rzadkie>)' może różnić się od 'qr.R(<gęste>)' z powodu permutacji. Być może użyj metody qrR() w zamian

en: rankMatrix(<large sparse Matrix>, method = '%s') coerces to dense matrix.
     Probably should rather use method = 'qr' !?
pl_PL: rankMatrix(<duża rzadka macierz>, method = '%s') przekształca macierz do gęstej macierzy.
     Prawdopodobnie należy użyć 'method = "qr"' !?

en: rankMatrix(x, method='qr'): computing t(x) as nrow(x) < ncol(x)
pl_PL: rankMatrix(x, method='qr'): obliczanie t(x) jako nrow(x) < ncol(x)

en: rcond(.) via sparse -> dense coercion
pl_PL: 'rcond(.)' poprzez przekształcenie rzadkie -> gęste

en: readMM(): column values 'j' are not in 1:nc
pl_PL: readMM(): wartości kolumny 'j' nie są w przedziale 1:nc

en: readMM(): row	 values 'i' are not in 1:nr
pl_PL: readMM(): wartości wiersza 'i' nie są w przedziale 1:nr

en: replacing "indMatrix" entries is not allowed, as rarely sensible
pl_PL: zastępowanie wpisów "indMatrix" jest niedozwolone, ponieważ jest to rzadko sensowne

en: representation '%s' not recognized
pl_PL: reprezentacja '%s' nie została rozpoznana

en: row indices must be <= nrow(.) which is %d
pl_PL: indeksy wiersza muszą być <= 'nrow(.)' który wynosi %d

en: some arguments are not matrices
pl_PL: niektóre argumenty nie są macierzami

en: such indexing must be by logical or 2-column numeric matrix
pl_PL: takie indeksowanie musi być wykonane poprzez macierz logiczną lub 2-kolumnową macierz liczbową

en: sum(<abIndex>) is not yet implemented
pl_PL: 'sum(<abIndex>)' nie jest jeszcze zaimplementowane

en: symmetric matrix must be square
pl_PL: macierz symetryczna musi być kwadratowa

en: symmetry form '%s' is not yet implemented
pl_PL: forma symetryczna '%s' nie jest jeszcze zaimplementowana

en: symmetry form '%s' not recognized
pl_PL: forma symetryczna '%s' nie została rozpoznana

en: symmetry form 'hermitian' not yet implemented for reading
pl_PL: forma symetryczna 'hermitian' nie jest jeszcze zaimplementowana na potrzeby odczytu

en: symmetry form 'skew-symmetric' not yet implemented for reading
pl_PL: forma symetryczna 'skew-symmetric' nie jest jeszcze zaimplementowana na potrzeby odczytu

en: temporarily disabled
pl_PL: funkcja jest tymczasowo niedostępna

en: the %d-th (sub)-diagonal (k = %d) is too short; filling with NA's
pl_PL: (pod)-diagonala %d (k = %d) jest zbyt krótkal wypełnianie wartościami NA

en: the matrix is not triangular
pl_PL: macierz nie jest trójkątna

en: the number of non-zero entries differs from nrow(.)
pl_PL: liczba niezerowych wpisów różni się od 'nrow(.)'

en: too many arguments
pl_PL: zbyt wiele argumentów

en: too many replacement values
pl_PL: zbyt dużo wartości zamieniających

en: trimmed mean of 'sparseVector' -- suboptimally using as.numeric(.)
pl_PL: przycięta średnia 'sparseVector' -- optymalnie używając 'as.numeric(.)'

en: type '%s' not recognized
pl_PL: typ '%s' nie został rozpoznany

en: undefined method for class %s
pl_PL: niezdefiniowana metoda dla klasy %s

en: update must be TRUE/FALSE or '+' or '-'
pl_PL: 'update' musi wynosić TRUE/FALSE lub '+' lub '-'

en: using	 "old code" part in  Csparse subassignment
pl_PL: używanie	 części 'old code' w przypisaniu w 'Csparse'

en: using slow kronecker() method
pl_PL: używanie powolnej metody 'kronecker()'

en: using"old code" part in Csparse subassignment
     >>> please report to Matrix-authors@r-project.org
pl_PL: używanie części 'old code' w przypisaniu w 'Csparse'
    >>> proszę zgłosić raport na adres 'Matrix-authors@r-project.org'

en: variable '%s' converted to a factor
pl_PL: zmienna '%s' została zamieniona na czynnik

en: variable '%s' is absent, its contrast will be ignored
pl_PL: zmienna '%s' jest nieobecna, jej kontrast zostanie zignorowany

en: vector too long in Matrix - vector operation
pl_PL: wektor jest zbyt długi w operacji macierz-wektor

en: when 'A' is specified, 'A.x' and 'At.x' are disregarded
pl_PL: gdy 'A' jest określone, 'A.x' oraz 'At.x' są odrzucane

en: wrong sign in 'by' argument
pl_PL: niepoprawny znak w argumencie 'by'

en: x / 0 for an <abIndex> x with sign-change
     no longer representable as 'rleDiff'
pl_PL: x / 0 dla '<abIndex> x' ze zmianą znaku nie jest dłużej reprezentowalne jako 'rleDiff'

en: x[.,.] <- val : x being coerced from Tsparse* to CsparseMatrix
pl_PL: x[.,.] <- wartość : 'x' zostaje przekształcone z 'Tsparse*' na 'CsparseMatrix'

en: x[.,.] <- val: x is %s, val not in {TRUE, FALSE} is coerced NA |--> TRUE.
pl_PL: x[.,.] <- wartość: 'x' to %s, wartość nie w zakresie {TRUE, FALSE} zostaje przekształcona NA |--> TRUE.

en: x[.,.] <- val: x is %s, val not in {TRUE, FALSE} is coerced.
pl_PL: x[.,.] <- wartość: 'x' to %s, wartość nie w zakresie {TRUE, FALSE} zostaje przekształcona.

en: x[.] <- val: x is %s, val not in {TRUE, FALSE} is coerced.
pl_PL: x[.] <- wartość: 'x' to %s, wartość nie w zakresie {TRUE, FALSE} zostaje przekształcona.

en: x[.] <- val: x is %s, val not in {TRUE, FALSE} is coerced; NA |--> TRUE.
pl_PL: x[.] <- wartość: 'x' to %s, wartość nie w zakresie {TRUE, FALSE} zostaje przekształcona; NA |--> TRUE.

en: you cannot mix negative and positive indices
pl_PL: nie można mieszać ujemnych oraz dodatnich indeksów
