natgillin/translations-raw huggingface dataset:
Denotes a logical range. Must always be escaped within a character class.
Märgib loogilist vahemikku. Märgiklassis vajab alati paomärki.
\\ (backslash)
\\ (längkriips)
The escape character. Must always be escaped.
Paomärk. Vajab alati paomärki.
Alternatives: matching one of
Alternatiivid: sobib üks valikust
If you want to match one of a set of alternative patterns, you can separate those with _BAR_ (vertical bar character).
Kui soovid, et leitaks üks mitme alternatiivse mustri seast, võib alternatiivid eraldada vertikaalse kriipsuga _BAR_.
For example to find either John or Harry you would use an expression John_BAR_Harry.
Näiteks selleks, et leida kas John või Harry, tuleks kirjutada John_BAR_Harry.
Sub Patterns
Alammustrid
Sub patterns are patterns enclosed in parentheses, and they have several uses in the world of regular expressions.
Alammustrid on sulgudesse võetud mustrid, mida saab regulaaravaldistes mitmeti kasutada.
Specifying alternatives
Alternatiivide määramine
You may use a sub pattern to group a set of alternatives within a larger pattern. The alternatives are separated by the character _BAR_ (vertical bar).
Alammustriga saab grupeerida alternatiivide valiku mustris. Alternatiivid tuleb eraldada püstkriipsuga _BAR_.
For example to match either of the words int, float or double, you could use the pattern int_BAR_float_BAR_double. If you only want to find one if it is followed by some whitespace and then some letters, put the alternatives inside a subpattern: (int_BAR_float_BAR_double)\\s+\\w+.
Et sobiks näiteks kas või üks sõnadest int, float or double, saab kasutada mustrit int_BAR_float_BAR_double. Kui soovid leida aga neist ühe vaid juhul, kui sellele järgneb üks või enam tühimärki ja siis veel mingid tähed, anna alternatiivid alammustrina: (int_BAR_float_BAR_double)\\ s+\\ w+.
Capturing matching text (back references)
Sobiva teksti haaramine (tagasiviited)
If you want to use a back reference, use a sub pattern to have the desired part of the pattern remembered.
Kui soovid kasutada tagasiviidet, tarvita alammustrit, mis jätab meelde mustri soovitud osa.
For example, it you want to find two occurrences of the same word separated by a comma and possibly some whitespace, you could write (\\w+), \\s*\\1. The sub pattern \\w+ would find a chunk of word characters, and the entire expression would match if those were followed by a comma, 0 or more whitespace and then an equal chunk of word characters. (The string \\1 references the first sub pattern enclosed in parentheses)
Kui näiteks soovid leida ühe ja sama sõna kaks esinemist, mida eraldab koma ja võib- olla mõned tühimärgid, võid kirjutada (\\ w+),\\ s *\\ 1. Alammuster\\ w+ leiab täheliste märkide kogumi ning kogu avaldis sobib siis, kui sellele järgneb koma, 0 või enam tühimärki ja siis uuesti samasugune täheliste märkide kogum. (String\\ 1 viitab esimesele sulgudes alammustrile.)
Lookahead Assertions
Ettevaatavad eeldused
A lookahead assertion is a sub pattern, starting with either? = or?!.
Ettevaatav eeldus on alammuster, mida alustab kas? = või?!.
For example to match the literal string Bill but only if not followed by Gates, you could use this expression: Bill(?! Gates). (This would find Bill Clinton as well as Billy the kid, but silently ignore the other matches.)
Kui näiteks sobima peab literaalne string Bill, aga ainult juhul, kui sellele ei järgne Gates, võib kasutada sellist avaldist: Bill (?! Gates). See leiab nii väljendid Bill Clinton kui ka Billy the Kid, aga ingoneerib muid sobivusi.
Sub patterns used for assertions are not captured.
Eelduseks kasutatud alammustreid ei haarata.
See also Assertions
Vaata ka osa Eeldused
Characters with a special meaning inside patterns
Eritähendusega märgid mustrites
The following characters have meaning inside a pattern, and must be escaped if you want to literally match them:
Järgmistel märkidel on eritähendus, kui nad esinevad mustris, ning need tuleb varustada paomärgiga, kui neid peab võtma literaalselt:
The escape character.
Paomärk.
Asserts the beginning of the string.
Eeldab stringi algust.
Asserts the end of string.
Eeldab stringi lõppu.
() (left and right parentheses)
() (vasak - ja parempoolne sulg)
Denotes sub patterns.
Märgib alammustreid.
{} (left and right curly braces)
{} (vasak - ja parempoolne looksulg)
Denotes numeric quantifiers.
Märgib numbrilisi kvantoreid.
[] (left and right square brackets)
[] (vasak - ja parempoolne nurksulg)
Denotes character classes.
Märgib märgiklasse.
_BAR_ (vertical bar)
_BAR_ (püstkriips)
logical OR. Separates alternatives.
Loogiline VÕI. Eraldab alternatiive.
+ (plus sign)
+ (plussmärk)
Quantifier, 1 or more.
Kvantor 1 või enam.
* (asterisk)
* (tärn)
Quantifier, 0 or more.
Kvantor 0 või enam.
? (question mark)
? (küsimärk)
An optional character. Can be interpreted as a quantifier, 0 or 1.
Lisamärk, mida võib tõlgendada kvantorina 0 või 1.
Quantifiers allows a regular expression to match a specified number or range of numbers of either a character, character class or sub pattern.
Kvantorid lasevad regulaaravaldisel leida määratud arvu või arvuvahemiku märke, märgiklasse või alammustreid.
Quantifiers are enclosed in curly brackets ({and}) and have the general form {[minimum-occurrences][, [maximum-occurrences]]}
Kvantorid antakse looksulgudes ({ja}) ning nad esinevad üldistatult kujul {[minimaalselt- esinemisi] [, [maksimaalselt- esinemisi]]}
The usage is best explained by example:
Kasutamist selgitab kõige paremini näide:
Exactly 1 occurrence
Täpselt 1 esinemine.
{0,1}
{0, 1}
Zero or 1 occurrences
Null või 1 esinemine.
{,1}
{, 1}
The same, with less work;)
Sama, aga üks märk vähem kirjutada: -)
{5,10}
{5, 10}
At least 5 but maximum 10 occurrences.
Vähemalt 5, aga maksimaalselt 10 esinemist.
At least 5 occurrences, no maximum.
Vähemalt viis esinemist, maksimum puudub.
Additionally, there are some abbreviations:
Lisaks saab kasutada mõningaid lühendeid:
similar to {0,}, find any number of occurrences.
sama, mis {0,}, leiab suvalise arvu esnemisi.
similar to {1,}, at least 1 occurrence.
sama, mis {1,}, vähemalt 1 esinemine.
similar to {0,1}, zero or 1 occurrence.
sama, mis {0, 1}, null või 1 esinemine.
Greed
Ahnus
When using quantifiers with no maximum, regular expressions defaults to match as much of the searched string as possible, commonly known as greedy behaviour.
Kui kasutada kvantoreid ilma maksimumi määramata, otsib regulaaravaldis vaikimisi otsitavat stringi nii palju, kui vähegi võimalik, mida nimetatakse sageli ahneks käitumiseks.
Modern regular expression software provides the means of turning off greediness, though in a graphical environment it is up to the interface to provide you with access to this feature. For example a search dialogue providing a regular expression search could have a check box labelled Minimal matching as well as it ought to indicate if greediness is the default behaviour.
Tänapäevased regulaaravaldiste rakendused pakuvad vahendeid ahnuse väljalülitamiseks, kuigi graafilises keskkonnas on jäänud liidese ülesandeks pakkuda sellist võimalust või mitte. Nii võib näiteks regulaaravaldise võimalusega otsingudialoogis olla märkekast Minimaalne sobivus, samuti võib see märku anda, kas ahnus on vaikimisi sisse lülitatud või mitte.
In context examples
Näited
Here are a few examples of using quantifiers
Mõned näited kvantorite kasutamise kohta.
^\\d{4,5}\\s
^\\ d{ 4, 5}\\ s
Matches the digits in 1234 go and 12345 now, but neither in 567 eleven nor in 223459 somewhere
Sobivad arvud väljendites 1234 läheb ja 12345 nüüd, aga mitte väljendites 567 üksteist või 223459 kuskil.
\\s+
\\ s+
Matches one or more whitespace characters
Sobib üks või enam tühimärki.
(bla){1,}
(bla) {1,}
Matches all of blablabla and the bla in blackbird or tabla
Sobivad kõik väljendid blablabla ja bla väljendites blaster või kõbla.
/ ?gt;
/? gt;
Matches / gt; in lt; closeditem/ gt; as well as gt; in lt; openitemgt;.
Sobib / gt; väljendis lt; closeditem/ gt;, samuti gt; väljendis lt; openitemgt;.
Assertions allows a regular expression to match only under certain controlled conditions.
Eeldused võimaldavad leida regulaaravaldise sobivuse ainult teatud määratud tingimustel.
An assertion does not need a character to match, it rather investigates the surroundings of a possible match before acknowledging it. For example the word boundary assertion does not try to find a non word character opposite a word one at its position, instead it makes sure that there is not a word character. This means that the assertion can match where there is no character, & ie; at the ends of a searched string.
Eeldus ei otsi õigupoolest sobivat märki, vaid uurib lähikonnast võimalikke sobivusi, enne kui midagi omaks võtta. Näiteks sõnapiirde eeldus ei püüa leida mitte antud positsioonis mittetähelist märki, vaid kontrollib, et seal ei oleks tähelist märki. See tähendab, et eeldus sobbi, kui tegemist ei ole märgiga, & ie; tegemist on otsitava stringi alguse ja lõpuga.
Some assertions actually does have a pattern to match, but the part of the string matching that will not be a part of the result of the match of the full expression.
Mõned eeldused ei otsi õigupoolest sobivat mustrit, vaid osa stringi sobivust, mis ei ole terve avaldise sobivuse tulemus.
Regular Expressions as documented here supports the following assertions:
Siin dokumenteeritud regulaaravaldised toetavad järgmisi eeldusi:
^ (caret: beginning of string)
^ (katus: stringi algus)
Matches the beginning of the searched string.
Sobib otsitava stringi algus.
The expression ^Peter will match at Peter in the string Peter, hey! but not in Hey, Peter!
Avaldisega ^Peeter sobib Peeter stringis Peeter, he!, aga mitte stringis Hei, Peeter!.
$(end of string)
$(stringi lõpp)
Matches the end of the searched string.
Sobib otsitava stringi lõpp.
The expression you\\? $will match at the last you in the string You did n't do that, did you? but nowhere in You did n't do that, right?
Avaldisega ju\\? $sobib stringi Sa ei teinud seda, eks ju?, aga mitte stringi Sa ei teinud seda, eks? lõpp.
\\b (word boundary)
\\ b (sõnapiire)
Matches if there is a word character at one side and not a word character at the other.
Sobib, kui ühel pool on täheline märk ja teisel pool mittetäheline märk.
This is useful to find word ends, for example both ends to find a whole word. The expression \\bin\\b will match at the separate in in the string He came in through the window, but not at the in in window.
Sellest on abi konkreetsete sõnade leidmisel, eriti kui näiteks määrata kogu sõna sobivus. Avaldisega\\ bjuures\\ b sobib eraldiseisva sõnaga juures näiteks lauses Ta seisis akna juures vaikides, aga mitte näiteks sõnas juurestik.
\\B (non word boundary)
\\ B (mitte- sõnapiire)
Matches wherever \\b does not.
Sobib kõikjal, kus\\ b ei sobi.
That means that it will match for example within words: The expression \\Bin\\B will match at in window but not in integer or I 'm in love.
See tähendab, et sobivus asub sõna sees: avaldisega\\ Bjuures\\ B sobib alusjuurestik, aga mitte juurestik või sealjuures.
(? =PATTERN) (Positive lookahead)
(? =MUSTER) (positiivne ettevaade)
A lookahead assertion looks at the part of the string following a possible match. The positive lookahead will prevent the string from matching if the text following the possible match does not match the PATTERN of the assertion, but the text matched by that will not be included in the result.
Ettevaatav eeldus uurib sobivuse leidmiseks selle järgnevat stringi. Positiivne ettevaade ei näita sobivust, kui võimalikule sobivusele järgnev tekst ei vasta eelduse MUSTRILE, vaid tekstile, mis sellega sobib, mida ei kaasata tulemusse.
The expression handy(? =\\w) will match at handy in handyman but not in That came in handy!
Avaldisega käsi (? =\\ w) sobib käsi stringis käsitööline, aga mitte stringis See on meie neljas käsi!.
(? !PATTERN) (Negative lookahead)
(?! MUSTER) (negatiivne ettevaade)
The negative lookahead prevents a possible match to be acknowledged if the following part of the searched string does match its PATTERN.
Negatiivne ettevaade ei näita sobivust, kui otsitavale stringile järgnev osa ei vasta MUSTRILE.
The expression const \\w+\\b(? !\\s*amp;) will match at const char in the string const char* foo while it can not match const QString in const QStringamp; bar because the amp; matches the negative lookahead assertion pattern.
Avaldisega const\\ w+\\ b (?!\\ s* amp;) sobib const char in the string const char * foo, aga mitte const QString stringis const QStringamp; bar, sest amp; sobib negatiivse ettevaatava eelduse mustriga.
The & kbugbuster; Handbook
& kbugbuster; i käsiraamat
& kbugbuster; is part of the kdesdk package.
& kbugbuster; on paketi kdesdk osa.
The documentation for & kappname; was not finished when & kde; was installed on this computer.
& kbugbuster; i dokumentatsioon ei olnud lõpetatud ajaks, mil & kde; käesolevasse arvutisse paigaldati.
If you need help, please check The & kde; Website for updates, or by submitting your question to The & kde; User Mailing list.
Kui vajad abi, otsi kde; veebileheküljelt uuendusi või saada oma küsimus kde; kasutajate meililisti.
The & kcachegrind; Handbook
& kcachegrind; i käsiraamat
Josef. Weidendorfer@gmx. de
Josef. Weidendorfer@ gmx. de
Josef Weidendorfer
& Josef. Weidendorfer;
& kcachegrind; is a profile data visualisation tool, written using the & kde; environment.
& kcachegrind; on & kde; töökeskkonna tarbeks loodud profileerimisandmete kuvamise tööriist.
Profiling
Profileerimine
& kappname; is a browser for data produced by profiling tools. This chapter explains what profiling is for, how it is done, and gives some examples of profiling tools available.
& kappname; on profileerimistööriistade tekitatud andmete brauser. Käesolevas peatükis selgitame, mida tähendab üldse profileerimine, kuidas seda tehakse ning räägime veidi olemasolevatest profileerimistööriistadest.
When developing a program, one of the last steps often involves performance optimisations. As it makes no sense to optimise functions rarely used, because that would be a waste of time, one needs to know in which part of a program most of the time is spent.
Programmi luues soovid kindlasti lõpuks muuta selle ka võimalikult kiireks (aga samas ikka töökindlaks!). Aeg on mõistagi kallis väärtus ja optimeerimisfunktsioone kasutatakse harva. Nii on sul vaja teada saada, milline osa programmist kulutab kõige rohkem aega.
For sequential code, collecting statistical data of the programs runtime characteristic like time numbers spent in functions and code lines usually is enough. This is called Profiling. The program is run under control of a profiling tool, which gives the summary of an execution run at the end. In contrast, for parallel code, performance problems typically are caused when one processor is waiting for data from another. As this waiting time usually can not easily attributed, here it is better to generate timestamped event traces. KCachegrind can not visualise this kind of data.
Jadakoodi puhul piisab tavaliselt programmide käituskarakteristika, näiteks funktsioonides ja koodiridades veedetud ajahulga statistiliste andmete kogumisest. Seda nimetatakse profileerimiseks. Vastav programm töötab profileerimistööriista kontrolli all, mis programmi täitmise lõppedes väljastab kokkuvõtte. Paralleelkoodi puhul on aga asjad teisiti - peamiselt tekitab jõudlusprobleeme see, kui üks protsessor ootab teiselt andmeid. Et sellist ooteaega ei ole tavaliselt võimalik väga lihtsalt muuta, on siin mõttekas genereerida ajatempliga sündmuste jäljed. Selliseid andmeid & kcachegrind; ei kuva.
After analysing the produced profile data, it should be easy to see the hot spots and bottlenecks of the code: for example, assumptions about call counts can be checked, and identified code regions can be optimised. Afterwards, the success of the optimisation should be verified with another profile run.
Profileerimisandmete analüüsimisel peaks olema üsna lihtne näha koodi nii- öelda pudelikaelu ning seejärel parandada näiteks väljakutsete esitamise viisi ja optimeerida koodi erinevaid piirkondi. Pärast seda saab uue profileerimisega kontrollida, kui edukas optimeerimine oli.
Profiling Methods
Profileerimismeetodid
To exactly measure the time passed or record the events happening during the execution of a code region (e. g. a function), additional measurement code needs to be inserted before and after the given region. This code reads the time, or a global event count, and calculates differences. Thus, the original code has to be changed before execution. This is called instrumentation. Instrumentation can be done by the programmer itself, the compiler, or by the runtime system. As interesting regions usually are nested, the overhead of measurement always influences the measurement itself. Thus, instrumentation should be done selectively and results have to be interpreted with care. Of course, this makes performance analysis by exact measurement a very complex process.
Koodi piirkonna (eg; funktsiooni) täitmisele kuluva aja täpseks mõõtmiseks või selle käigus toimuvate sündmuste jäädvustamiseks tuleb antud piirkonna ette ja järele lisada mõõtmiskood. See arvestab aega või sündmusi ning arvutab erinevusi. See tähendab, et enne täitmist on vaja muuta originaalkoodi. Seda nimetatakse instrumentatsiooniks. Instrumentatsiooniga võib tegelda nii programmeerija ise, kompilaator või käitussüsteem. Et huvipakkuvad piirkonnad on enamasti pesastatud, mõjutab mõõtmise teostamine otseselt ka mõõtmistulemusi. Seepärast tuleb instrumentatsiooniga olla väga hoolas ning mõõtmise tulemusi enne järelduste tegemist põhjalikult uurida. Pole midagi parata - jõudlusanalüüs on täppismõõtmise korral keeruline ja aeganõudev ettevõtmine.
Exact measurement is possible because of hardware counters (including counters incrementing on a time tick) provided in modern processors, which are incremented whenever an event is happening. As we want to attribute events to code regions, without the counters, we would have to handle every event by incrementing a counter for the current code region ourself. Doing this in software is, of course, not possible; but, on the assumption that the event distribution over source code is similar when looking only at every n-th event instead of every event, a measurement method whose overhead is tunable has been developed: it is called Sampling. Time Based Sampling (TBS) uses a timer to regularly look at the program counter to create a histogram over the program code. Event Based Sampling (EBS) exploits the hardware counters of modern processors, and uses a mode where an interrupt handler is called on counter underflow to generate a histogram of the corresponding event distribution: in the handler, the event counter is always reinitialised to the 'n 'of the sampling method. The advantage of sampling is that the code does not have to be changed, but it is still a compromise: the above assumption will be more correct if n is small, but the smaller the n, the higher the overhead of the interrupt handler.
Täppismõõtmise muudavad võimalikuks tänapäevaste protsessorite pakutavad riistvaralised loendurid (sealhulgas ajalist kasvu arvestavad loendurid), mis arvestavad iga sündmuse aega. Ilma loendurita tuleks meil sündmuste omistamisel koodi piirkondadele tegelda eraldi iga sündmusega, suurendades ise loenduri näitu antud koodi piirkonnas. Tarkvaraliselt ei ole see mõistagi võimalik, kuid eeldades, et sündmuste jaotus koodis on ühetaoline, kui me uurime iga sündmuse asemel ainult iga n- ndat sündmust, siis selle tarbeks on loodud häälestatav mõõtmismeetod, mida nimetatakse diskreetimiseks. Ajapõhine diskreetimine (TBS, Time Based Sampling) kasutab taimerit ja uurib regulaarselt programmi loendurit programmikoodi histogrammi loomiseks. Sündmusepõhine diskreetimine (EBS, Event Based Sampling) kasutab ära tänapäevaste protsessorite riistvaralisi loendureid ning töötab režiimis, milles loenduri alatäite korral kutsutakse välja katkestusetöötleja vastava sündmusjaotuse histogrammi tekitamiseks; töötlejas taaslähtestatakse sündmuseloendur alati diskreetimismeetodi n - väärtusele. Diskreetimise eeliseks on see, et koodi ei tule muuta, kuid see on siiski omamoodi kompromiss: mainitud eeldus võib olla korrektne, kui n on väike, aga mida väiksem on n, seda suurem on katkestusetöötleja üldkulu.
Another measurement method is to simulate things happening in the computer system when executing a given code, i. e. execution driven simulation. The simulation is always derived from a more or less accurate machine model; however, with very detailed machine models, giving very close approximations to reality, the simulation time can be unacceptably high in practise. The advantage of simulation is that arbitrarily complex measurement/ simulation code can be inserted in a given code without perturbing results. Doing this directly before execution (called runtime instrumentation), using the original binary, is very comfortable for the user: no re-compilation is necessary. Simulation becomes usable when simulating only parts of a machine with a simple model; another advantage is that the results produced by simple models are often easier to understand: often, the problem with real hardware is that results include overlapping effects from different parts of the machine.
Teine mõõtmisviis on selle matkimine, mis juhtub arvutis antud koodi täitmisel, & ie; täitmise simulatsioon. Simulatsioon arvestab alati enam- vähem täpse masinamudeliga, kuid väga konkreetsete nõuete korral, kus on vaja äärmiselt realistlikku täpsust, võib simulatsiooniaeg olla tegelikkuses talumatult suur. Simulatsiooni eeliseks on see, et koodi võib ilma häirivaid tulemusi kartmata lisada suvalist, ka keerukat mõõte/ simulatsioonikoodi. Lisamine otse enne täitmist (niinimetatud käitusinstrumentatsioon) originaal- binaarfaili kasutades on kasutajale äärmiselt mugav, sest puudub vajadus taaskompileerimise järele. Simulatsioon on mõttekas siis, kui simuleeritakse ainult teatud masina osi lihtsa mudeliga. Teine positiivne joon on see, et lihtsa mudeli tekitatud tulemusi on enamasti suhteliselt lihtsam mõista - sageli ongi tegeliku riistvara probleemiks see, et tulemustesse satuvad masina erinevate osade omavahel kattuvad efektid.
Profiling Tools
Profileerimistööriistad
Most known is the GCC profiling tool gprof: One needs to compile the program with option -pg; running the program generates a file gmon. out, which can be transformed into human-readable form with gprof. One disadvantage is the needed re-compilation step to prepare the executable, which has to be statically linked. The method used here is compiler-generated instrumention - which measures call arcs happening among functions and corresponding call counts - in conjunction with TBS - which gives a histogram of time distribution over the code. Using both pieces of information, it is possible to heuristically calculate inclusive time of functions, i. e. time spent in a function together with all functions called from it.
Tuntuim sellistest tööriistadest on GCC profileerimistööriist gprof. Selle kasutamiseks tuleb programm kompileerida võtmega - pg, misjärel programmi käivitamine tekitab faili gmon. out, mille käsuga gprof saab muuta inimsilmale arusaadavale kujule. Puuduseks on aga vajadus kasutada kompileerimist, et ette valmistada käivitatav fail, mis peab olema staatiliselt lingitud. Meie kasutame kompilaatori genereeritud instrumentatsiooni, mis mõõdab funktsioonides esinevaid väljakutseteid ja arvestab vastavalt väljakutseid, koos TBS- iga, mis tagab koodi ajajaotuse histogrammi. Nende kahe infokogumi põhjal saab heuristiliselt arvutada funktsioonide kumulatiivset aega, & ie; aega, mis veedetakse funktsioonis koos kõigi sellest välja kutsutud funktsioonidega.