OpenLLM-France/wikimedia huggingface dataset:
# A Level Computer Science Programming Guide/Arrays
## Declaring Arrays

In Pseudocode, Arrays all have declarable Upper and Lower bounds.
In VB.NET, Arrays all have declarable Upper Bounds, but Lower Bounds are always 0.

### One Dimensional Arrays

| Language | General Usage | Example Usage |
| Pseudocode | DECLARE <Identifier> : ARRAY[<Lower Bound>:<Upper Bound>] OF <Data Type> | DECLARE NameList : ARRAY[1:5] OF STRING DECLARE YearlyRainfall : ARRAY[1900:2100] OF REAL DECLARE AgeList : ARRAY[0:40] OF INTEGER |
| VB.NET | Dim <Identifier>(<Upper Bound>) As <Data Type> | Dim NameList(4) As String Dim YearlyRainfall(200) As Double Dim AgeList(40) As Integer |
| Python | <Identifier> = | NameList = YearlyRainfall = AgeList = |

### Two Dimensional Arrays

| Language | General Usage | Example Usage |
| Pseudocode | DECLARE <Identifier> : ARRAY[<Lower Bound>:<Upper Bound>, <Lower Bound>:<Upper Bound>] OF <Data Type> | DECLARE GameArea : ARRAY[1:32, 0:16] OF STRING DECLARE SudokuGrid : ARRAY[1:9, 1:9] OF INTEGER DECLARE PopulationDensity : ARRAY[1:50, 20:50] OF REAL |
| VB.NET | Dim <Identifier>(<Upper Bound>, <Upper Bound>) As <Data Type> | Dim GameArea(31, 16) As String Dim SudokuGrid(8) As Integer Dim PopulationDensity(49,30) As Double |
| Python | <Identifier1> = <Identifier2> = <Identifier1>.append(<Identifier2>) | Game = GameArea = GameArea.append(Game) SudokuX = SudokuGrid = SudokuGrid.append(SudokuX) Longitude = PopulationDensity = PopulationDensity.append(Longitude) |

## Using Arrays
### One Dimensional Arrays

| Language | General Usage | Example Usage |
| Pseudocode | <Identifier>[<Index>] ← <Value> | NameList[1] ← "Stephen" YearlyRainfall[1985] ← 13.73 AgeList[39] ← 17 |
| VB.NET | <Identifier>(<Index>) = <Value> | NameList(0) = "Stephen" YearlyRainfall(85) = 13.73 AgeList(38) = 17 |
| Python | <Identifier>.append(<Value>) | NameList.append("Stephen") YearlyRainfall.append(13.73) AgeList.append(17) |

### Two Dimensional Arrays

| Language | General Usage | Example Usage |
| Pseudocode | <Identifier>[<Index>,<Index>] ← <Value> | GameArea[16, 5] ← "Fire" SudokuGrid[9, 3] ← 7 PopulationDensity[14, 32] ← 242.023 |
| VB.NET | <Identifier>(<Index>,<Index>) = <Value> | GameArea(15, 5) = "Fire" SudokuGrid(8, 2) = 7 PopulationDensity(13, 12) = 242.023 |
| Python | <Identifier1> = <Identifier2> = <Identifier1>.append(<Identifier2>) | Game.append("Fire") GameArea.append(Game) SudokoX.append(7) SudokuGrid.append(SudokuX) Longitude.append(242.023) PopulationDensity.append(Longitude) |
# Algebra/Chapter 3/Percent

3.7: Percentages

## Percentages

Percentages are another way of representing rational numbers. Rational numbers can be represented as decimals, fractions or percentages.
Percent, when you actually break the word apart, consists of two words: per and cent. Per is a small but extremely powerful word. It means "to divide". Cent is a Latin word for 100. Percent, then, means "divide by 100".
To convert from a fraction to a percentage, we simply multiply the fraction by 100. For example, ${\frac {1}{4}}=({\frac {1}{4}}\times 100)\%=25\%\,$.
To convert from a decimal to a percentage, we first convert the decimal into a fraction, and then proceed with the approach outlined above. For example, $0.15={\frac {15}{100}}=({\frac {15}{100}}\times 100)\%=15\%\,$.
# Adventist Youth Honors Answer Book/Nature/Odonates

Odonates :
| Nature North American Division | Skill Level Unknown |
| Nature North American Division | Year of Introduction: 2011 |
* The requirements for this honor have not yet been published. The NAD has accepted the honor, but has not yet released the official requirements. The requirements listed below should be considered an advance, working copy, and they are therefore subject to change — perhaps significantly.
# Adventist Youth Honors Answer Book/Nature/Poisonous plants/Amanitas

Amanitas :
* Description: The genus Amanita contains about 600 species of agarics and contains some of the most toxic known mushrooms, found worldwide. This genus is responsible for 95% of the fatalities resulting from mushroom poisoning, with the death cap accounting for 50% on its own. The most potent toxin present in these mushrooms is alpha-amanitin.
# An Awk Primer/Control Structures

Awk supports control structures similar to those used in C, including:
* if ... else
* while
* for
* break
* continue
There are also control structures different from those used in C:
* for (x in a) - loop in array
* next - go to the next input record
* exit - stop processing the input files, execute END operations, if specified, and finish.

## if ... else

The syntax of "if ... else" is:
The "else" clause is optional. The "condition" can be any expression discussed in the section on pattern matching, including matches with regular expressions. For example, consider the following Awk program:
(Here, semicolons are optional and can be omitted.)
By the way, for test purposes this program can be invoked as:
—where "pgm.txt" is a text file containing the program.
The "action" clauses can consist of multiple statements, contained by curly brackets ("").

## while

The syntax for "while" is:
The "action" is performed as long the "condition" tests true, and the
"condition" is tested before each iteration. The conditions are the same as for the "if ... else" construct. For example, since by default an Awk variable has a value of 0, the following Awk program could print the numbers from 1 to 20:

## for

* The "for" loop is more flexible. It has the syntax:
For example, the following "for" loop prints the numbers 10 through 20 in increments of 2:
This is equivalent to:
The C programming language has a similar "for" construct, with an interesting feature in that multiple actions can be taken in both the initialization and end-of-loop actions, simply by separating the actions with a comma. Most implementations of Awk, unfortunately, do not support this feature.
The "for" loop has an alternate syntax, used when scanning through an array:
Given the example used earlier:
—then the names could be printed with the following statement:
This yields:
Notice that the names are not printed in the proper order. One of the characteristics of this type of "for" loop is that the array is not scanned in a predictable order.

## Unconditional control statements

Awk defines four unconditional control statements: break, continue, next, and exit.
The statements break and continue are strictly associated with the while and for loops:
* break: Causes a jump out of the loop.
* continue: Forces the next iteration of the loop.
The statements next and exit control Awk's input scanning:
* next: Causes Awk to immediately get another line of input and begin scanning it from the first match statement.
* exit: Causes Awk to stop reading its input, execute END operations, if specified, and finish.
# An Awk Primer/Nawk

The original version of Awk was developed in 1977. It was optimized for throwing together "one-liners" or short, quick-and-dirty programs. However, some users liked Awk so much that they used it for much more complicated tasks. To quote the language's authors: "Our first reaction to a program that didn't fit on one page was shock and amazement." Some users regarded Awk as their primary programming tool, and many had in fact learned programming using Awk.
After the authors got over their initial consternation, they decided to accept the fact, and enhance Awk to make it a better general-purpose programming tool. The new version of Awk was released in 1985. The new version is often, if not always, known as Nawk ("New Awk") to distinguish it from the old one.
Function declarations can be placed in a program wherever a match-action clause can. All parameters are local to the function. Local variables can be defined inside the function.
* Command-line parameters can be interpreted using two new predefined variables, ARGC and ARGV, a mechanism instantly familiar to C programmers. ARGC ("argument count") gives the number of command-line elements, and ARGV ("argument vector") is an array whose entries store the elements individually.
* There is a new conditional-assignment expression, known as "?:", which is used as follows:
This translates to:
This construct should also be familiar to C programmers.
This yields:
Nawk also includes a new "delete" function, which deletes array elements:
* A new built-in variable, FNR, keeps track of the record number of the current file, as opposed to NR, which keeps track of the record number of the current line of input, regardless of how many files have contributed to that input. Its behavior is otherwise exactly identical to that of NR.
* While Nawk does have useful refinements, they are generally intended to support the development of complicated programs. My feeling is that Nawk represents overkill for all but the most dedicated Awk users, and in any case would require a substantial document of its own to do its capabilities justice. Those who would like to know more about Nawk are encouraged to read THE AWK PROGRAMMING LANGUAGE by Aho / Weinberger / Kernighan. This short, terse, detailed book outlines the capabilities of Nawk and provides sophisticated examples of its use.
# An Awk Primer/Awk Overview

The Awk text-processing language is useful for such tasks as:
* Tallying information from text files and creating reports from the results.
* Adding additional functions to text editors like "vi".
* Translating files from one format to another.
* Creating small databases.
* Performing mathematical operations on files of numeric data.
Awk has two faces: it is a utility for performing simple text-processing tasks, and it is a programming language for performing complex text-processing tasks.
The two faces are really the same, however. Awk uses the same mechanisms for handling any text-processing task, but these mechanisms are flexible enough to allow useful Awk programs to be entered on the command line, or to implement complicated programs containing dozens of lines of Awk statements.
Awk statements comprise a programming language. In fact, Awk is useful for simple, quick-and-dirty computational programming. Anybody who can write a BASIC program can use Awk, although Awk's syntax is different from that of BASIC. Anybody who can write a C program can use Awk with little difficulty, and those who would like to learn C may find Awk a useful stepping stone, with the caution that Awk and C have significant differences beyond their many similarities.
There are, however, things that Awk is not. It is not really well suited for extremely large, complicated tasks. It is also an "interpreted" language—that is, an Awk program cannot run on its own, it must be executed by the Awk utility itself. That means that it is relatively slow, though it is efficient as interpretive languages go, and that the program can only be used on systems that have Awk. There are translators available that can convert Awk programs into C code for compilation as stand-alone programs, but such translators have to be purchased separately.
One last item before proceeding: What does the name "Awk" mean? Awk actually stands for the names of its authors: "Aho, Weinberger, & Kernighan". Kernighan later noted: "Naming a language after its authors ... shows a certain poverty of imagination." The name is reminiscent of that of an oceanic bird known as an "auk", and so the picture of an auk often shows up on the cover of books on Awk.

## References

* ↑ Brian W. Kernighan, Rob Pike (1984). The UNIX Programming Environment. Prentice-Hall. ISBN 013937681X.
# An Awk Primer/Awk Program Example
## A Large Program

All this is fun, but each of these examples only seems to nibble away at "coins.txt". Why not have Awk figure out everything interesting at one time?
The immediate objection to this idea is that it would be impractical to enter a lot of Awk statements on the command line, but that's easy to fix. The commands can be written into a file, and then Awk can execute the commands from that file.
Given the ability to write an Awk program in this way, then what should a "master" "coins.txt" analysis program do? Here's one possible output:

### The "Master" Program

The following Awk program generates this information:
This program has a few interesting features:
* Comments can be inserted in the program by preceding them with a #. Awk ignores everything after #.
* Note the statements num_gold++ and num_silver++. C programmers should understand the ++ operator; those who are not can be assured that it simply increments the specified variable by one. There is also a -- that decrements the variable.
* Multiple statements can be written on the same line by separating them with a semicolon (;). Semicolons are optional if there is only one statement on the line.
* Note the use of the printf statement, which offers more flexible printing capabilities than the print statement.

#### The printf Statement

printf has the general syntax:
Special Characters:
* \n New line
* \t Tab (aligned spacing)
Format Codes:
* %i or %d Integer
* %f Floating-point (decimal) number
* %s String
The above description of printf is oversimplified. There are many more codes and options, which will be discussed later.
There is one format code for each of the parameters in the list. Each format code determines how its corresponding parameter will be printed. For example, the format code %2d tells Awk to print a two-digit integer number, and the format code %7.2f tells Awk to print a seven-character floating-point number, including two digits to the right of the decimal point. The decimal point is included as one of the seven characters.
Note also that, in this example, each string printed by printf ends with a \n, which is a code for a newline (ASCII line-feed code). Unlike the print statement, which automatically advances the output to the next line when it prints a line, printf does not automatically advance the output, and by default the next output statement will append its output to the same line. A newline forces the output to skip to the next line.
The tabs created by \t align the output to the nearest tab stop, usually 8 spaces apart. Tabs are useful for creating tables and neatly aligned outputs.

### Running the Program

I stored this program in a file named "summary.awk", and invoked it as follows:
The output was:

## Practice

So far you have enough information to make good use of Awk. The next chapter provides a much more complete description of the language.
* Modify the above program to tally and display the countries from "coins.txt".
* Write a program that counts and displays the number of blank and non-blank lines (use NF).
* Modify the program from #2 to count the average number of words per line.
# An Awk Primer/Awk Quick Reference Guide

This final section provides a convenient lookup reference for Awk programming.
—where:
The search can be constrained to particular fields:
Strings can be ORed in a search:
The search can be for an entire range of lines, bounded by two strings:
The search can be for any condition, such as line number, and can use the following comparison operators:
Different conditions can be ORed with "||" or ANDed with "&&".
If a metacharacter is part of the search string, it can be "escaped" by preceding it with a "\".
Shorthand assignments:
* The only unique string operation is concatenation, which is performed simply by listing two strings connected by a blank space.
* Arithmetic functions:
* String functions:
* length
Scanning through an associative array with "for":
Unconditional control statements:
General format:
Newlines must be explicitly specified with a "\n".
General form of format code:
The optional "number" can consist of:
* A leading "-" for left-justified output.
* An integer part that specifies the minimum output width. (A leading "0"
The format codes are:
# An Awk Primer/Operations
## Relational Operators

Awk's relational operations have already been discussed. As a quick reminder, here they are:
* < Less than
* <= Less than or equal to
* > Greater than
* >= Greater than or equal to
* == Equal to
* != Not equal to
* ~ Matches (compares a string to a regular expression)
* !~ Does not match
Note that, unlike some languages, relational expressions in Awk do not return a value. They only evaluate to a true condition or a false condition. That means that a Awk program like this:
It doesn't print anything at all, and trying to use relational expressions as part of an arithmetic expression causes an error.

### Logic Operators

To group together the relational operator into more complex expressions, Awk provides three logic (or Boolean) operators:
* && And (reports "true" if both sides are true)
* || Or (reports "true" if either side, or both, are true)
* ! Not (Reverses true/false of the following expression)

## Arithmetic Operators

Awk uses the standard four arithmetic operators:
* + Addition
* - Subtraction
* * Multiplication
* / Division
* ^ Exponentiation (** may also work)
* % Remainder
All computations are performed in floating-point. They are performed with the expected order of operations.

### Increments

There are increment and decrement operators:
* ++ Increment
* -- Decrement
The position of these operators with respect to the variable they operate on is important. If ++ precedes a variable, that variable is incremented before it is used in some other operation. For example:
This will print 4. If ++ follows a variable, that variable is incremented after it is used in some other operation. For example:
This will print 3, but x will equal four from that point on. Similar remarks apply to --. Of course, if the variable being incremented or decremented is not part of some other operation at that time, it makes no difference where the operator is placed.

### Compound Assignments

Awk also allows the following shorthand operations for modifying the value of a variable:
You get the idea. This shortcut is available for all of the arithmetic operations (+= -= *= /= ^= %=).

## Concatenation

There is only one unique string operation: concatenation. Two strings can be easily concatenated by placing them consecutively on the same line. Only a space needs to separate them. For example:
This prints:
The strings can be concatenated even if they are variables. This produces the same result as above:
The parentheses might not be necessary, but they are often used to make sure that the concatenation is interpreted correctly.

## The Conditional

There is an interesting operator called the conditional operator. It has two parts. Look at this example:
This will print either "too expensive" or "cheap" depending on the value of price. The condition before the question mark is evaluated. If true, the first statement is executed, and if false the second is executed. The statements are separated by a colon.
# An Awk Primer/Licensing
## Licensing

The original version of this book was written by Greg Goebel, and is available at http://www.vectorsite.net/tsawk.html. This original version has been released by its author into the public domain.
Newer revisions here on Wikibooks have been licensed under the following license:
# An Awk Primer/Numbers and Strings
## Numbers

Numbers can be expressed in Awk as either decimal integers or floating-point quantities. For example:
* 789
* 3.141592654
* +67
* +4.6E3
* -34
* -2.1e-2
There is no provision for specifying values in other bases, such as hex or octal; however, as will be shown later, it is possible to output them from Awk in hex or octal format.

## Strings

Strings are expressed in double quotes. For example:
* "All work and no play makes Jack a homicidal maniac!"
* "1987A1"
* "do re mi fa so la ti do"
Awk also supports null strings, which are represented by empty quotes: "".
There are various "special" characters that can be embedded into strings:
* \n Newline (line feed)
* \t Horizontal tab (aligns to next column of 8 spaces)
* \b Backspace
* \r Carriage return
* \f Form feed (possibly causes a new page, if printing)
A double-quote (") can be embedded in a string by preceding it with a backslash, and a backslash can be embedded in a string by typing it in twice: \\. If a backslash is used with other characters (say, \m), it is simply treated as a normal character.
# Bicycles/Maintenance and Repair/Suspension

Chapters: 01. Introduction 02. What Style of Riding is for Me 03. Equipment and Accessories
04. Riding tips and safety tips 05. Guide to safety 06. Maintenance and repair 07. Modifications External Links
Suspension on a bike is extremely helpful when on dirt tracks or up in the mountains. I would recommend a mountain bike with only front suspension as full suspension will slow you down too much with the weight.
# Bicycles/Maintenance and Repair/Shifters

Chapters: 01. Introduction 02. What Style of Riding is for Me 03. Equipment and Accessories
04. Riding tips and safety tips 05. Guide to safety 06. Maintenance and repair 07. Modifications External Links

## See Also

   * Rapidfire shifter lubrication - (i.e. Shimano A20)
   * SRAM Gripshift 3.0 'comp' Cable Replacement
# Bicycles/Maintenance and Repair/Tools and Supplies

Chapters: 01. Introduction 02. What Style of Riding is for Me 03. Equipment and Accessories
04. Riding tips and safety tips 05. Guide to safety 06. Maintenance and repair 07. Modifications External Links

### Basic Tools

Tools every cyclist should consider having:
* Allen wrenches (2-8mm)
* Chain tool
* Screwdrivers (Phillips and flathead)
* Open and/or box wrenches (8, 9, 10, and 15mm are the most common for bike use)
* Tire levers
* Pump
* Puncture repair kit
Cyclists traveling long distances may wish to carry these tools with them. Alternately, they may wish to carry a multi-tool.

### Intermediate Tools

Tools for cyclists with more of an interest in bicycle repair:
* Pedal wrench
* Cone wrenches
* An appropriately sized spoke wrench
* Chain whip
* Crank puller
* Cable cutter
* Hammer
* Headset wrench
* T25 torx wrench
* Cassette tool
* Truing jig
* Wheel dishing gauge
* Chain wear indicator
* Repair stand

### Professional Tools

Tools for cyclists who are prepared to fix anything that may go wrong on a bicycle:
* Bottom bracket tapping and facing tool
* Bottom bracket tool
* Crown race setting tool
* Headset cup remover
* Headset press
* Starnut driver
* Head tube facer/reamer

## Supplies

* Degreaser
* Grease
* Oil
* Penetrating oil
* Thread locking compound
* Tire patch compound
* Tire patches
* Ti Prep
* Cable ends to prevent cables from fraying.
# Bicycles/Maintenance and Repair/Tools and Supplies/Bottom Bracket Tool

A bottom bracket tool is specifically designed to remove and insert the bottom bracket of a bicycle.
Bottom brackets are, unfortunately, one of the less standardised parts of a bicycle. Over the years manufacturers have come up with many different approaches to providing gripping surfaces for the bottom bracket to be inserted or removed. A typical repair shop will, correspondingly, have a variety of tools available for different styles of bottom bracket.
One of the older and more common systems uses the combination of a lock ring remover and a pin wrench. the left bearing cone is removed in order for the bearings and axle to be removed.The bearing cone has two shallow holes drilled into it. When a pin wrench is inserted into these holes, the bearing cone can be threaded in or out.
The lock ring is a circular nut used to prevent the left bearing cone from loosening by accident. The lock ring remover is inserted into one of several notches in the lock ring in order for it to be removed.