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

en: Not a valid format
lt: Neleistinas formatas

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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: vector too long in Matrix - vector operation
lt: vektorius, esantis Matrix, per ilgas - vektoriaus operacija

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

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

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

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

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

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

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

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

en: too many arguments
lt: per daug argumentų

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

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

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

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

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

en: not yet implemented
lt: dar neįvykdyta

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: <abIndex>  -->  <seqMat>  is not yet implemented
lt: <abIndex>  --><seqMat>  dar neįgyvendinta

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

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

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: when 'A' is specified, 'A.x' and 'At.x' are disregarded
lt: kai nurodyta 'A', į 'A.x' and 'At.x' neatsižvelgiama

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

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: not enough new vecs -- stop iterations
lt: nepakanka naujų vecs -- sustabdyti iteracijas

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

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

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

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: '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: matrix can only be symmetric if square, but n != m
lt: matrica gali būti simetriška tik kvadratinė, bet n != m

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: 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: invalid 'repr'; must be "C", "T", or "R"
lt: negaliojantis 'repr'; turi būti "C", "T" arba "R"

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

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

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

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

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: 'x' must have length nrow^2 when 'symmetric' is true
lt: 'x' turi būti ilgio nrow^2, kai 'symmetric' yra teisingas

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

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

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

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

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

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

en: non-conformable arguments
lt: neatitinkantys argumentai

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: invalid 'col.names' string: %s
lt: neleistina 'col.names' eilutė: %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: suppressing %d columns and %d rows
lt: nerodyti %d stulpelių ir %d eilučių

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

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

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

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

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

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: .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: such indexing must be by logical or 2-column numeric matrix
lt: toks indeksavimas turi būti loginis arba 2 stulpelių skaitinė matrica

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

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

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

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: m[ <ij-matrix> ] <- v: inefficiently treating single elements
lt: m[ <ij-matrix> ] <- v: neefektyviai apdorojant pavienius elementus

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

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: not-yet-implemented 'Matrix[<-' method
lt: dar neįgyvendintas 'Matrix[<-' method

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

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

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

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

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

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: you cannot mix negative and positive indices
lt: negalite maišyti neigiamų ir teigiamų indeksų

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

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

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

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

en: invalid character indexing
lt: neleistinas simbolių indeksavimas

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

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

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

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 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 being coerced from Tsparse* to CsparseMatrix
lt: x[.,.] <- val: x yra paverčiamas iš Tsparse* į CsparseMatrix

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

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

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

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

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