Matrix 1.3-3 - en to lt translation catalogue (242 entries)

en: %s kind not yet implemented
lt: %s rūšis dar neįgyvendinta

en: '%s()' is not yet implemented for  representation '%s'
lt: '%s()' dar neįgyvendinta '%s' atvaizdavimui

en: '%s()' is not yet implemented for element type '%s'
lt: '%s()' dar neįgyvendinta elementų tipui '%s'

en: 'A' must be a square matrix
lt: 'A' turi būti kvadratinė matrica

en: 'NA' indices are not (yet?) supported for sparse Matrices
lt: 'NA' indeksai nėra (dar?) remiami sparse Matrices

en: 'V' is not a *square* matrix
lt: 'V' nėra *kvadratinė* matrica

en: 'V' is not a square matrix
lt: 'V' nėra kvadratinė matrica

en: 'boolArith = %d' not yet implemented
lt: 'boolArith = %d' dar neįgyvendintas

en: 'by' argument is much too small
lt: 'by' argumentas per mažas

en: 'diagonals' matrix must have %d columns (= length(k) )
lt: 'diagonals' matricoje turi būti %d stulpeliai (= length(k) )

en: 'diagonals' must have the same length (%d) as 'k'
lt: 'diagonals' turi būti tokio pat ilgio (%d) kaip ir 'k'

en: 'file' must be a character string or connection
lt: 'file' turi būti simbolių eilutė ar ryšys

en: 'force' must be (coercable to) TRUE or FALSE
lt: 'force' turi būti (verčiama į) TRUE arba FALSE

en: 'giveCsparse' has been deprecated; setting 'repr = "%s"' for you
lt: 'giveCsparse' nebenaudojamas; nustatymas 'repr = "%s"' jums

en: 'giveCsparse' has been deprecated; setting 'repr = "T"' for you
lt: 'giveCsparse' nebenaudojamas; nustatymas 'repr = "T"' jums

en: 'giveCsparse' has been deprecated; will use 'repr' instead
lt: 'giveCsparse' nebenaudojamas; vietoj to naudos 'repr'

en: 'lag' and 'differences' must be integers >= 1
lt: 'lag' ir 'differences' turi būti sveikieji skaičiai >= 1

en: 'lwd' must be NULL or non-negative numeric
lt: 'lwd' turi būti NULL arba ne neigiamas skaitinis

en: 'ncol' is not a factor of length(x)
lt: 'ncol' nėra length(x) faktorius

en: 'ncol' must be >= 0
lt: 'ncol' turi būti >= 0

en: 'nearPD()' did not converge in %d iterations
lt: 'nearPD()' nekonvergavo %d iteracijose

en: 'nrow' and 'ncol' must be the same when 'symmetric' is true
lt: 'nrow' ir 'ncol' turi būti vienodi, kai 'symmetric' yra teisinga

en: 'nrow' is not a factor of length(x)
lt: "nrow" nėra length(x) faktorius

en: 'nrow' must be >= 0
lt: 'nrow' turi būti >= 0

en: 'nrow', 'ncol', etc, are disregarded for matrix 'data'
lt: matricos 'data' atveju neatsižvelgiama į 'nrow', 'ncol' ir t. t.

en: 'nrow', 'ncol', etc, are disregarded when 'data' is "Matrix" already
lt: Į 'nrow', 'ncol' ir t. t. neatsižvelgiama, kai 'data' jau yra "Matrix"

en: 'p' must be a non-decreasing vector (0, ...)
lt: 'p' turi būti nemažėjantis vektorius (0, ...)

en: 'times >= 0' is required
lt: 'times >= 0' yra būtinas

en: 'update' must be logical or '+' or '-'; 'C' a matrix, and 'L' a "CHMfactor"
lt: 'update' turi būti loginis arba '+' arba '-'; 'C' matrica, o 'L' – "CHMfactor"

en: 'x' has invalid data type
lt: 'x' turi neleistiną duomenų tipą

en: 'x' is not positive definite -- chol() undefined.
lt: 'x' nėra teigiamai apibrėžtas -- chol() neapibrėžtas.

en: 'x' is not symmetric -- chol() undefined.
lt: 'x' nėra simetriškas -- chol() neapibrėžtas.

en: 'x' is not symmetric nor triangular
lt: 'x' nėra nei simetriškas, nei trikampis

en: 'x' must be "sparseMatrix"
lt: 'x' turi būti "sparseMatrix"

en: 'x' must have length nrow^2 when 'symmetric' is true
lt: 'x' turi būti ilgio nrow^2, kai 'symmetric' yra teisingas

en: 'x' must inherit from "sparseVector"
lt: 'x' turi paveldėti iš "sparseVector"

en: (un)packing only applies to dense matrices, class(x)='%s'
lt: (iš)pakavimas taikomas tik tankio matricoms, class(x)='%s'

en: .M.repl.i.2col(): 'i' has no integer column number;
     should never happen; please report
lt: .M.repl.i.2col(): 'i' neturi sveiko skaičiaus stulpelio numerio;
     niekada neturėtų įvykti; prašome pranešti

en: .M.repl.i.2col(): drop 'matrix' case ...
lt: .M.repl.i.2col(): išmetė 'matrix' atveją ...

en: .M.sub.i.2col(): 'i' has no integer column number;
     should never happen; please report
lt: .M.sub.i.2col(): 'i' neturi sveiko skaičiaus stulpelio numerio;
     niekada neturėtų įvykti; prašome pranešti

en: <abIndex>  -->  <seqMat>  is not yet implemented
lt: <abIndex>  --><seqMat>  dar neįgyvendinta

en: <abIndex>[i]  is not yet implemented
lt: <abIndex>[i] dar neįgyvendinta

en: <seqMat>  -->  <abIndex>  is not yet implemented
lt: <seqMat>  --> <abIndex> dar neįgyvendintas

en: <sparse>[ <logic> ] : .M.sub.i.logical() maybe inefficient
lt: <sparse>[ <logic> ] : . M.sub.i.logical() gal neefektyvus

en: Both 'symmetric' and 'triangular', i.e. asking for diagonal matrix.  Use 'Diagonal()' instead
lt: Ir 'symmetric', ir 'triangular', t. y. prašant įstrižinės matricos.  Vietoj to naudokite 'Diagonal()'

en: Cholesky(<nsparse...>) -> *symbolic* factorization -- not yet implemented
lt: Cholesky(<nsparse...>) -> *symbolic* faktoringas -- dar neįgyvendintas

en: Cholesky(A) called for 'A' of class "%s";
    	 it is currently defined for sparseMatrix only; consider using chol() instead
lt: Cholesky(A) iškvietė dėl 'A' klasės "%s";
    	 šiuo metu jis nustatytas tik rsparseMatrix; apsvarstyti galimybę vietoj to naudoti chol ()

en: Class %s is not yet implemented
lt: Klasės %s dar neįgyvendinta

en: Cmp.Mat.atomic() should not be called for diagonalMatrix
lt: Cmp.Mat.atomic() negalima būti iškviestas diagonalMatrix

en: FIXME: NOT YET FINISHED IMPLEMENTATION
lt: FIXME: DAR NEBAIGTAS ĮGYVENDINIMAS

en: Internal bug: nargs()=%d; please report
lt: Vidinė klaida: nargs()=%d; prašome pranešti

en: Invalid assembled indicator: %s
lt: Neleistinas surinktas indikatorius: %s

en: Invalid storage format: %s
lt: Neleistinas saugyklos formatas: %s

en: Invalid storage type: %s
lt: Netinkamas saugyklos tipas: %s

en: LU computationally singular: ratio of extreme entries in |diag(U)| = %9.4g
lt: LU skaičiavimo singuliarumas: ekstremalių įrašų santykis |diag(U)| = %9.4g

en: Logic.Mat.atomic() should not be called for diagonalMatrix
lt: Logic.Mat.atomic() neturėtų būti iškviečiamas dėl diagonalMatrix

en: Matrices must have same dimensions in %s
lt: Matricos turi turėti tuos pačius matmenis %s

en: Matrices must have same number of columns in %s
lt: Matricos turi turėti tą patį stulpelių skaičių %s

en: Matrices must have same number of rows for arithmetic
lt: Matricos turi turėti tą patį eilučių skaičių aritmetikai

en: Matrices must have same number of rows in %s
lt: Matricos turi turėti tą patį eilučių skaičių %s

en: Matrix seems negative semi-definite
lt: Matrica atrodo pusiau neigiamai apibrėžta

en: Matrix-internal error in <CsparseM>[i,,d]; please report
lt: Matricos vidinė klaida, esanti <CsparseM>[i,,d]; prašome pranešti

en: Matrix-internal error in <TsparseM>[i,,d]; please report
lt: Matricos vidinė klaida, esanti <TsparseM>[i,,d]; prašome pranešti

en: Matrix-internal error in <sparseM>[i,,d]; please report
lt: Matricos vidinė klaida, esanti <sparseM>[i,,d]; prašome pranešti

en: Must specify 'nrow' when 'symmetric' is true
lt: Turi nurodyti 'nrow', kai 'symmetric' yra teisinga

en: NA's in (i,j) are not allowed
lt: NA esantys (i,j) yra neleidžiami

en: NAs are not allowed in subscripted assignments
lt: NA neleidžiamos apatinio indekso priskyrimuose

en: Not a valid format
lt: Neleistinas formatas

en: Only numeric sparse matrices allowed
lt: Leidžiamos tik skaitinės sparse matricos

en: Quadratic matrix '%s' (=: A) is not formally
    	symmetric.  Will be treated as	A A'
lt: Kvadratinė matrica '%s' (=: A) formaliai nėra
    	simetrinis.  Bus traktuojama kaip as	A A'

en: RHS 'b' has wrong length
lt: RHS 'b' ilgis neteisingas

en: RHS 'b' has wrong number of rows:
lt: RHS 'b' turi neteisingą eilučių skaičių:

en: RHS 'value' (class %s) matches 'ANY', but must match matrix class %s
lt: RHS 'value' (%s klasė) atitinka 'ANY', tačiau turi atitikti matricos klasę %s

en: [ <character> ] indexing not allowed: forgot a "," ?
lt: [ <character> ] indeksavimas neleidžiamas: pamiršote "," ?

en: [[ suppressing %d column names %s ... ]]
lt: [[ nerodyti %d stulpelių pavadinimų %s ... ]]

en: [[ suppressing %d column names %s ]]
lt: [[ nerodyti %d stulpelių pavadinimų %s ]]

en: a sparseMatrix should rarely be centered: will not be sparse anymore
lt: sparseMatrix retai turėtų būti centre: daugiau nebus sparse

en: all(<abIndex>) is not yet implemented
lt: all(<abIndex>) dar neįgyvendinti

en: as(.,"dsCMatrix") is deprecated (since 2008); do use as(., "symmetricMatrix")
lt: as(.,"dsCMatrix") nebenaudojamas (nuo 2008 m.); naudoti as(., "symmetricMatrix")

en: as.array(<Matrix>) is deprecated. Use  as(x, "matrix")  or .asmatrix(x) instead.
lt: as.array(<Matrix>) nebenaudojamas. Vietoj to naudokite as(x, "matrix") arba .asmatrix(x).

en: as.matrix(<Matrix>) is deprecated (to become a no-op in the future).
    Use  as(x, "matrix")  or .asmatrix(x) instead.
lt: as.matrix(<Matrix>) yra nebenaudojamas (ateityje taps no-op).
    Vietoj to naudokite as(x, "matrix") arba .asmatrix(x).

en: c(<abIndex>,..) of different kinds, coercing all to 'rleDiff'
lt: c(<abIndex>,..) įvairių rūšių, paverčiant visus į 'rleDiff'

en: cannot coerce 'NA's to "nsparseMatrix"
lt: negalima paversti 'NA' į "nsparseMatrix"

en: cannot coerce 'NA's to "nsparseVector"
lt: negalima paversti 'NA' į "nsparseVector"

en: cannot coerce NA values to pattern "ngCMatrix"
lt: negalima paversti NA reikšmes į modelį "ngCMatrix"

en: cannot coerce NA values to pattern "ntCMatrix"
lt: negalima paversti NA reikšmes į modelį "ntCMatrix"

en: cannot coerce non-symmetric "dgTMatrix" to "dsCMatrix" class
lt: negalima paversti nesimetrinio "dgTMatrix" į "dsCMatrix" klasę

en: chol() is undefined for diagonal matrix with negative entries
lt: chol() neapibrėžtas įstrižainei matricai su neigiamais įrašais

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*.
lt: pavertimas iš list(i1,...,ik, d) į "indMatrix" nepavyko.
     Visi įrašai turi būti vertinami kaip sveikieji ir stulpelių skaičius d ne mažesnis
     nei maksimalus indeksas i*.

en: coercion to "indMatrix" only works from integer numeric
lt: pavertimas į "indMatrix" veikia tik iš sveikųjų skaitinių

en: coercion to "pMatrix" only works from integer numeric
lt: pavertimas į "pMatrix" veikia tik iš sveikųjų skaitinių

en: column indices must be <= ncol(.) which is %d
lt: stulpelių indeksai turi būti <= ncol(.), kuris yra %d

en: complex matrices not yet implemented in Matrix package
lt: kompleksinės matricos dar neįgyvendintos Matrix pakete

en: diag(.) had 0 or NA entries; non-finite result is doubtful
lt: diag(.) turėjo 0 arba NA įrašus; abejotinas ne baigtinis rezultatas

en: diagonalMatrix in .dense2C() -- should never happen, please report!
lt: diagonalMatrix, esanti .dense2C() -- niekada neturėtų atsitikti, prašome pranešti!

en: dim [product %d] do not match the length of object [%d]
lt: dim [product %d] neatitinka objekto ilgio [%d]

en: dim(.) value must be numeric of length 2
lt: dim(.) reikšmė turi būti skaitinio ilgio 2

en: dimensions don't match the number of cells
lt: matmenys neatitinka langelių skaičiaus

en: dimnames [%d] mismatch in %s
lt: dimnames [%d] neatitikimas %s

en: dimnames(.) <- NULL:  translated to 
    dimnames(.) <- list(NULL,NULL)  <==>  unname(.)
lt: dimnames(.) <- NULL: išverstas į 
    dimnames(.) <- list(NULL,NULL) <==> unname(.)

en: element type '%s' not recognized
lt: elemento tipas '%s' neatpažįstamas

en: element type 'complex' not yet implemented
lt: elemento tipas 'complex' dar neįgyvendintas

en: exactly one of 'i', 'j', or 'p' must be missing from call
lt: iškvietimo metu turi trūkti tiksliai vieno iš 'i', 'j' arba 'p'

en: extra argument %s will be disregarded in
     %s | extra arguments %s will be disregarded in
     %s
lt[0]: papildomas argumentas %s, į kurį bus neatsižvelgiama
     %s
lt[1]: papildomi argumentai %s, į kuriuos bus neatsižvelgiama
     %s
lt[2]: papildomų argumentų %s, į kuriuos bus neatsižvelgiama
     %s

en: file is not a MatrixMarket file
lt: failas nėra MatrixMarket failas

en: for symmetric band matrix, only specify upper or lower triangle
     hence, all k must have the same sign
lt: simetrinės juostos matricai nurodykite tik viršutinį arba apatinį trikampį
     taigi, visi k turi turėti tą patį ženklą

en: general Matrix class not yet implemented for %s
lt: bendroji Matrix klasė dar neįgyvendinta %s

en: hit a cycle (1) -- stop iterations
lt: pasiekti ciklą (1) -- sustabdyti iteracijas

en: hit a cycle (2) -- stop iterations
lt: pasiekti ciklą (2) -- sustabdyti iteracijas

en: i1[1] == 0 ==> C-level verbosity will not happen!
lt: i1[1] == 0 ==> C lygio daugiakalbiškumas neįvyks!

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

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

en: in show(); maybe adjust 'options(max.print= *, width = *)'
lt: show(); galbūt pritaikyti 'options(max.print= *, width = *)'

en: incompatible matrix dimensions
lt: nesuderinamos matricos dimensijos

en: index larger than maximal %d
lt: indeksas didesnis nei maksimalus %d

en: index must be numeric, logical or sparseVector for indexing sparseVectors
lt: indeksas turi būti skaitinis, loginis arba sparseVector, sparseVectors indeksavimui

en: inefficient coercion (lost triangularity); please report
lt: neefektyvi pavertimas (prarastas trianguliarumas); prašome pranešti

en: inefficient method used for "- e1"
lt: neefektyvus metodas, naudojamas "- e1"

en: intermediate 'r' is of type %s
lt: tarpinis 'r' yra %s tipo

en: internal bug in "Compare" method (Cmp.Mat.atomic); please report
lt: vidinė klaida "Compare" metode (Cmp.Mat.atomic); prašome pranešti

en: internal bug in "Logic" method (Logic.Mat.atomic); please report
lt: vidinė klaida "Logic" metode (Logic.Mat.atomic); prašome pranešti

en: internal bug: matrix 'i' in replTmat(): please report
lt: vidinė klaida: matrica 'i', esanti replTmat(): prašome pranešti

en: internal bug: missing 'i' in replTmat(): please report
lt: vidinė klaida: trūksta 'i' replTmat(): prašome pranešti

en: invalid 'col.names' string: %s
lt: neleistina 'col.names' eilutė: %s

en: invalid 'contrasts.arg' argument
lt: neleistinas argumentas 'contrasts.arg'

en: invalid 'data'
lt: neleistinas 'data'

en: invalid 'mod': %s
lt: negaliojantis 'mod': %s

en: invalid 'repr'; must be "C", "T", or "R"
lt: negaliojantis 'repr'; turi būti "C", "T" arba "R"

en: invalid 'type'
lt: neleistinas 'type'

en: invalid (to - from)/by in seq(.)
lt: negaliojantis (iki - nuo)/pagal seq(.)

en: invalid character indexing
lt: neleistinas simbolių indeksavimas

en: invalid class: %s
lt: netinkama klasė: %s

en: invalid dimnames given for %s object
lt: neleistinas dimnames %s objektui

en: invalid nargs()= %d
lt: neleistini nargs()= %d

en: invalid or not-yet-implemented 'Matrix' subsetting
lt: neleistinas arba dar neįgyvendintas 'Matrix' pogrupis

en: kronecker method must use default 'FUN'
lt: kronecker metodas turi naudoti numatytąjį 'FUN'

en: length must be non-negative number
lt: ilgis turi būti ne neigiamas skaičius

en: length of 'center' must equal the number of columns of 'x'
lt: 'center' ilgis turi būti lygus stulpelių skaičiui 'x'

en: length of 'scale' must equal the number of columns of 'x'
lt: 'scale' ilgis turi būti lygus stulpelių skaičiui 'x'

en: length of 1st arg does not match dimension of 2nd
lt: 1-mo arg ilgis nesutampa su 2-ojo dimensija

en: length of 2nd arg does not match dimension of first
lt: 2-ojo arg ilgis neatitinka pirmojo dimensijos

en: length(i) is not a multiple of length(x)
lt: length(i) nėra length(x) kartotinis

en: length(x) must be either 1 or #{cols}
lt: length(x) turi būti 1 arba #{cols}

en: logic programming error in printSpMatrix2(), please report
lt: loginio programavimo klaida printSpMatrix2(), prašome pranešti

en: logical subscript too long (%d, should be %d)
lt: loginis apatinis indeksas per ilgas (%d, turėtų būti %d)

en: longer object length
    	is not a multiple of shorter object length
lt: ilgesnis objekto ilgis
    	nėra trumpesnio objekto ilgio kartotinis

en: longer object length is not a multiple of shorter object length
lt: ilgesnis objekto ilgis nėra trumpesnio objekto ilgio kartotinis

en: m[ <ij-matrix> ] <- v: inefficiently treating single elements
lt: m[ <ij-matrix> ] <- v: neefektyviai apdorojant pavienius elementus

en: m[<ij-matrix>]: inefficiently indexing single elements - should not happen, please report!
lt: m[<ij-matrix>]: neefektyviai indeksuojant pavienius elementus - neturėtų įvykti, prašome pranešti!

en: matrix can only be symmetric if square, but n != m
lt: matrica gali būti simetriška tik kvadratinė, bet n != m

en: matrix is not diagonal
lt: matrica nėra įstrižainė

en: matrix with non-zero off-diagonals cannot be coerced to "diagonalMatrix"
lt: matricos su ne nulinėmis įstrižainėmis negalima paversti į "diagonalMatrix"

en: model frame and formula mismatch in model.matrix()
lt: modelio sistemos ir formulės neatitikimas model.matrix()

en: must either specify 'A' or the functions 'A.x' and 'At.x'
lt: turi nurodyti 'A' arba funkcijas 'A.x' ir 'At.x'

en: must have exactly one non-zero entry per row
lt: eilutėje turi būti lygiai vienas ne nulinis įrašas

en: names(dimnames(<matrix>)) must be NULL or of length two
lt: names(dimnames(<matrix>)) turi būti NULL arba dviejų ilgių

en: nargs() = %d should never happen; please report.
lt: nargs() = %d niekada neturėtų įvykti; prašome pranešti.

en: nargs() = %d.  Extraneous illegal arguments inside '[ .. ]' (i.2col)?
lt: nargs() = %d.  Pašaliniai neteisėti argumentai viduje '[ .. ]' (i.2col)?

en: nargs() = %d.  Extraneous illegal arguments inside '[ .. ]' (i.logical)?
lt: nargs() = %d.  Pašaliniai neteisėti argumentai viduje '[ .. ]' (i.logical)?

en: nargs() = %d.  Extraneous illegal arguments inside '[ .. ]' ?
lt: nargs() = %d.  Pašaliniai neteisėti argumentai viduje '[ .. ]' ?

en: negative values are not allowed in a matrix subscript
lt: matricos apatiniame indekse neigiamos reikšmės neleidžiamos

en: no 'dimnames[[.]]': cannot use character indexing
lt: nėra 'dimnames[[.]]': negalima naudoti simbolių indeksavimo

en: non-conformable arguments
lt: neatitinkantys argumentai

en: non-conformable matrix dimensions in %s
lt: neatitinkantys matricos matmenys, esantys %s

en: non-matching dimensions
lt: nesutampančios dimensijos

en: non-square matrix
lt: nekvadratinė matrica

en: not a positive definite matrix
lt: ne teigiamai abiprėžta matrica

en: not a square matrix
lt: ne kvadratinė matrica

en: not a symmetric matrix; consider forceSymmetric() or symmpart()
lt: ne simetriška matrica; apsvarstykite forceSymmetric() arba symmpart()

en: not a triangular matrix
lt: ne trikampė matrica

en: not converged in %d iterations
lt: nekonverguoja %d iteracijose

en: not enough new vecs -- stop iterations
lt: nepakanka naujų vecs -- sustabdyti iteracijas

en: not yet implemented
lt: dar neįvykdyta

en: not yet implemented .. please report
lt: dar neįgyvendinta .. prašome pranešti

en: not yet implemented for %s
lt: dar neįgyvendinta %s

en: not yet implemented for class %s
lt: dar neįgyvendinta klasei %s

en: not yet implemented for matrix with typeof %s
lt: dar neįgyvendinta matricai su typeof %s

en: not-yet-implemented 'Matrix[<-' method
lt: dar neįgyvendintas 'Matrix[<-' method

en: not-yet-implemented coercion to "TsparseMatrix"
lt: dar neįgyvendinta paverstas į "TsparseMatrix"

en: not-yet-implemented method for %s(<%s>).
     ->>  Ask the package authors to implement the missing feature.
lt: dar neįgyvendintas metodas dėl %s (<%s>).
     ->> Paprašykite paketo autorių įgyvendinti trūkstamą funkciją.

en: not-yet-implemented method for %s(<%s>, <%s>).
     ->>  Ask the package authors to implement the missing feature.
lt: dar neįgyvendintas metodas dėl %s (<%s>, <%s>).
     ->> Paprašykite paketo autorių įgyvendinti trūkstamą funkciją.

en: not-yet-implemented method for <%s> %%*%% <%s>
lt: dar neįgyvendintas metodas <%s> %%*%% <%s>

en: nothing to replace with
lt: nėra nieko pakeisti su

en: number of items to replace is not a multiple of replacement length
lt: keičiamų elementų skaičius nėra keičiamo ilgio kartotinis

en: number of non zeros is smaller than 'nnz' because of duplicated (i,j)s
lt: ne nulių skaičius yra mažesnis už 'nnz' dėl dubliuotų (i,j)s

en: number of rows are not compatible for %s
lt: eilučių skaičius nesuderinamas su %s

en: only 2-dimensional tables can be directly coerced to sparse matrices
lt: tik 2 matmenų lentelės gali būti tiesiogiai paverstos į sparse matricas

en: only square matrices can be used as incidence matrices for graphs
lt: tik kvadratinės matricos gali būti naudojamos kaip paplitimo matricos grafikams

en: prod(<abIndex>) is not yet implemented
lt: prod(<abIndex>) dar neįgyvendintas

en: programming error: min() should have dispatched w/ 1st arg much earlier
lt: programavimo klaida: min() turėjo išsiųsti w/ 1st arg daug anksčiau

en: qr.R(<sparse>) may differ from qr.R(<dense>) because of permutations.  Possibly use our qrR() instead
lt: qr.R(<sparse>) gali skirtis nuo qr.R(<dense>) dėl perstatų.  Galbūt vietoj to naudokite mūsų qrR()

en: qr2rankMatrix(.): QR has negative diag(R) entries
lt: qr2rankMatrix(.): QR turi neigiamų diag(R) įrašų

en: qr2rankMatrix(.): QR with only %d out of %d finite diag(R) entries
lt: qr2rankMatrix(.): QR tik su %d iš %d baigtinių diag(R) įrašų

en: rankMatrix(<large sparse Matrix>, method = '%s') coerces to dense matrix.
     Probably should rather use method = 'qr' !?
lt: rankMatrix(<large sparse Matrix>, method = '%s') paverčiamas į tankio matricą.
     Tikriausiai reikėtų naudoti metodą = 'qr' !?

en: rankMatrix(x, method='qr'): computing t(x) as nrow(x) < ncol(x)
lt: rankMatrix(x, method='qr'): skaičiavimas t(x) kaip nrow(x) < ncol(x)

en: rcond(.) via sparse -> dense coercion
lt: rcond(.) per sparse -> dense pavertimą

en: readMM(): column values 'j' are not in 1:nc
lt: readMM(): stulpelių reikšmės 'j' nėra 1:nc

en: readMM(): row	 values 'i' are not in 1:nr
lt: readMM(): eilučių	 reikšmės 'i' nėra 1:nr

en: replacing "indMatrix" entries is not allowed, as rarely sensible
lt: pakeisti "indMatrix" įrašų neleidžiama, kaip retai praktiškų

en: representation '%s' not recognized
lt: neatpažįstamas atvaizdavimas '%s'

en: resulting matrix dimension would be too large
lt: gautas matricos matmuo būtų per didelis

en: resulting x-slot has different type than x's or y's
lt: gautas x-slot turi skirtingą tipą nei x arba y

en: row indices must be <= nrow(.) which is %d
lt: eilučių indeksai turi būti < = nrow(.), kuris yra %d

en: some arguments are not matrices
lt: kai kurie argumentai nėra matricos

en: such indexing must be by logical or 2-column numeric matrix
lt: toks indeksavimas turi būti loginis arba 2 stulpelių skaitinė matrica

en: sum(<abIndex>) is not yet implemented
lt: sum(<abIndex>) dar neįgyvendinta

en: suppressing %d columns
lt: nerodyti %d stulpelių

en: suppressing %d columns and %d rows
lt: nerodyti %d stulpelių ir %d eilučių

en: suppressing %d rows
lt: nerodyti %d eilučių

en: symmetric matrix must be square
lt: simetrinė matrica turi būti kvadratinė

en: symmetry form '%s' is not yet implemented
lt: simetrinė forma '%s' dar neįgyvendinta

en: symmetry form '%s' not recognized
lt: simetrinė forma '%s' neatpažįstama

en: symmetry form 'hermitian' not yet implemented for reading
lt: simetrinė forma 'hermitian' dar neįgyvendinta skaitymui

en: symmetry form 'skew-symmetric' not yet implemented for reading
lt: simetriška forma 'skew-symmetric', dar neįgyvendinta skaitymui

en: temporarily disabled
lt: laikinai išjungtas

en: the %d-th (sub)-diagonal (k = %d) is too short; filling with NA's
lt: %d įstrižainė (k = %d) yra per trumpa; užpildymas su NA

en: the matrix is not triangular
lt: matrica nėra trikampė

en: the number of non-zero entries differs from nrow(.)
lt: ne nulinių įrašų skaičius skiriasi nuo nrow(.)

en: too many arguments
lt: per daug argumentų

en: too many replacement values
lt: per daug pakeitimo reikšmių

en: triangular matrix must be square
lt: trikampė matrica turi būti kvadratinė

en: triangular matrix must have all i >= j or i <= j
lt: trikampė matrica turi turėti visus i >= j arba i <= j

en: trimmed mean of 'sparseVector' -- suboptimally using as.numeric(.)
lt: apdorotas 'sparseVector' vidurkis -- suboptimally naudojant as.numeric(.)

en: type '%s' not recognized
lt: tipas '%s' neatpažįstamas

en: undefined method for class %s
lt: neapibrėžtas metodas klasei %s

en: uniDiag=TRUE, but not all diagonal entries are 1
lt: uniDiag=TRUE, bet ne visi įstrižainės įrašai yra 1

en: uniDiag=TRUE, not all entries in diagonal coded as 1
lt: uniDiag=TRUE, ne visi įstrižainės įrašai, koduoti kaip 1

en: update must be TRUE/FALSE or '+' or '-'
lt: atnaujinimas turi būti TRUE/FALSE arba '+' arba '-'

en: using	 "old code" part in  Csparse subassignment
lt: naudojant	 "senojo kodo" dalį Csparse antriniame priskyrime

en: using slow kronecker() method
lt: naudojant lėtą kronecker() metodą

en: using"old code" part in Csparse subassignment
     >>> please report to Matrix-authors@r-project.org
lt: naudojant "senojo kodo" dalį Csparse antriniame priskyrime
     >>> prašome pranešti Matrix-authors@r-project.org

en: variable '%s' is absent, its contrast will be ignored
lt: kintamojo '%s' nėra, jo kontrastas bus ignoruojamas

en: vector too long in Matrix - vector operation
lt: vektorius, esantis Matrix, per ilgas - vektoriaus operacija

en: when 'A' is specified, 'A.x' and 'At.x' are disregarded
lt: kai nurodyta 'A', į 'A.x' and 'At.x' neatsižvelgiama

en: wrong sign in 'by' argument
lt: neteisingas ženklas 'by' argumente

en: x / 0 for an <abIndex> x with sign-change
     no longer representable as 'rleDiff'
lt: x / 0 dėl <abIndex> x su ženklo pakeitimu
     nebeatitinkamas kaip 'rleDiff'

en: x[.,.] <- val : x being coerced from Tsparse* to CsparseMatrix
lt: x[.,.] <- val: x yra paverčiamas iš Tsparse* į CsparseMatrix

en: x[.,.] <- val: x is %s, val not in {TRUE, FALSE} is coerced NA |--> TRUE.
lt: x[...] <- val: x yra %s, val, kurio nėra {TRUE, FALSE} yra paverčiamas NA |--> TRUE.

en: x[.,.] <- val: x is %s, val not in {TRUE, FALSE} is coerced.
lt: x[.,.] <- val: x yra %s, val, kurio nėra {TRUE, FALSE} yra paverčiamas.

en: x[.] <- val: x is %s, val not in {TRUE, FALSE} is coerced.
lt: x[.] <- val: x yra %s, val, kurio nėra {TRUE, FALSE} yra paverčiamas.

en: x[.] <- val: x is %s, val not in {TRUE, FALSE} is coerced; NA |--> TRUE.
lt: x[.] <- val: x yra %s, val, kurio nėra {TRUE, FALSE} yra paverčiamas; NA |--> TRUE.

en: you cannot mix negative and positive indices
lt: negalite maišyti neigiamų ir teigiamų indeksų
