OpenLLM-France/wikimedia huggingface dataset:
# Quenya/Allative
## Usage

The allative corresponds to the preposition "towards" (and this is frequently abbreviated to "to").
So it is used for destinations:
* j$j´&yE5 `B aG7ÎE5"# lelyuvan i ciryanna "I shall go to(wards) the boat"
or for a direction in which the action is performed:
* zF4$8 `Vj$2%j$5"# quentes Elendilenna "he spoke to(wards) Elendil"
* j$2$5 `N81Y5"# lenden ostonna "I went to town"
The preposition "into" is translated by t%6 mir followed by a nominative:
* j$2$5 t%6 `N81Y lenden mir osto "I went into town"
The allative is also used with following verbs:
    alD1E\ caita- "lie", to express whereupon the subject "lies":
   * `B aG7ÎE alD1E `B eDjt#5"#6 i cirya caita i falmannar "the ship lies upon the waves"
    1Uj´#\ tulya- "lead", to express whereinto the subject "is lead":
   * 1Uj´#5 `B 5~V6 `B 1.D7R5"# tulyan i nér i taurenna "I lead the man into the forest"

## Formation
### Singular

The basic ending is \5"# -nna after vowels and \`V5"# -enna after consonants.
Most words simply add this ending:
* `C7E5 aran "king" → `C7E5$5"# aranenna
* 1~C7T tári "queen" → 1~C7T5"# tárinna
* yR2$ vendë "girl" → yR2$5"# vendenna
* 9~C5^ háno "brother" → 9~C5^5"# hánonna
Words that have a stem-form use this stem-form:
* 5~B8 nís "woman" → 5%,R5"# nissenna
* aU7Y curo "device" → aU7U5"# curunna
* j~N5$ lómë "night" → j~Nt%5"# lóminna
Exceptions:
Words ending in \5 -n contract with the ending:
* t%2^5 mindon "tower" → t%2^5"# mindonna
Words ending in \j -l change j l + 5"# nna into \m# -lda:
* t$5$j menel "heaven" → t$5$m# menelda
When using these rules you have to look at the final letter of the stem-form (and not at the final letter of the nominative):
* 1Ej#5 talan "floor" → 1Ej#t$5"# talamenna (stem-form 1Ej#t\ talam-)
* 5~V5 nén "water" → 5$5"# nenna (stem-form 5$5\ nen-)
The allative of contracted stems (see Stem-forms) doesn't use the stem-form but the nominative singular:
* 9C7E5 haran "leader" → 9C7E5"# haranna (stem-form 9C65\ harn-)
Doubled N-stems also use the nominative singular:
* `NjnR5 olwen "branch" → `NjnR5"# olwenna (stem-form `NjnR5"\ olwenn-)

### Plural

The ending is \5"#6 -nnar after vowels and \`B5"#6 -innar after consonants.
* t#aGj macil "sword" → t#aGj%5"#6 macilinnar
* `Vm# elda "elf" → `Nm#5"#6 eldannar
Doubled N-stems use the nominative singular:
* `NjnR5 olwen "branch" → `NjnR5"#6 olwennar (stem-form `NjnR5"\ olwenn-)
Exception: Words ending in \5 -n contract with the ending:
* t%2^5 mindon "tower" → t%2^5"#6 mindonnar

### Dual

U-duals get \5"# -nna:
* `Cm& aldu "a pair of trees" → `Cm&5"# aldunna (nom.sing.: `Cm# alda)
In t-duals the final \1 -t is replaced by \4# -nta:
* aG7ÎE1 ciryat "a pair of ships" → aG7ÎE4# ciryanta (nom.sing.: aG7ÎE cirya)
* `C7E5$1 aranet "a pair of kings" → `C7E5$4# aranenta (nom.sing.: `C7E5 aran)

### Partitive Plural

We add \5"#6 -nnar or \5"# -nna to the nominative partitive plural:
* aG7ÎEj% ciryali "some ships"
    aG7ÎEj%5"#6 - aG7ÎEj%5"# ciryalinnar/ciryalinna (nom.sing.: aG7ÎE cirya)
* eDjt#j% falmali "some (crested or foaming) waves"
    eDjt#j%5"#6 falmalinnar (nom.sing.: eDjt# falma)
(Note: The ending \5"#6 -nnar is preferred.)
>> Neo-Quenya >> Nouns >> Allative
# Quenya/Adverbs

As in all languages Quenya has 2 types of adverbs:
* basic adverbs
* adverbs derived from adjectives
The basic adverbs are separate words that aren't derived from another word, e.g.
There are consequently no rules on how to form them.
To make an adjective into an adverb, we use following rules:
    An adjective on \`C -a gets the ending \yR -vë
   * `C2# anda "long" → `C2$yR andavë "longly"
   * 1UjaD tulca "firm" → 1UjaDyR tulcavë "firmly"
   * 8lDj# saila "wise" → 8lDj#yR sailavë "wisely"
    In an adjective on \`V -ë this letter is replaced by \`ByR -ivë:
   * t^7R morë "black" → t^7TyR morivë "blackly"
   * 5%2$ nindë "thin" → 5%2%yR nindivë "thinly"
   * t&,R mussë "soft" → t&,GyR mussivë "softly"
    The ending \yR -vë descends from the ancient elvish root 'be' "as". Therefore, -n + -be = \w$ -mbë:
   * eG7T5 firin "dead" → eG7Tw$ firimbë "deadly"
   * 1R7R5 teren "slender" → 1R7Rw$ terembë "slenderly"
The following adjective has an irregular adverb:
>> Neo-Quenya >> Adverbs
# Statistics/Links
## External links

* Statistics software listed at Wikipedia
* Excel Reference at WikiBooks
* Statistics concept maps by Gary Cziko
* SOCR Resource at UCLA
* Excel Statistics Lab Manualis written in an Excel for easy use.
* SOCR Statistics EBook, an ebook tightly integrating mathematical concepts, statistical reasoning, computational tools, interactive simulations, web-applets, and resources for data analysis and visualization
# Scheme Programming/Mutability
## Mutation

Mutation is a common side-effect in programming. To mutate a variable once it has been defined means to alter its value. For example,
will evaluate to 3. However, suppose x is mutated to the value 5. Then evaluating x will instead yield 5.
Mutation of a variable in Scheme is accomplished with the set! procedure. The reason for the exclamation point (often referred to as a "bang!") is to warn the programmer that calling the set! procedure causes a side effect; this is common practice for naming Scheme functions. For example, we might mutate x from 3 to 5 in the following way:
This results in the following:
After calling the set! procedure, all future references to x use its new value of 5 instead of its old value of 3. Attempting to call set! on an undefined identifier or one which is out of scope is an error.
Some Scheme programmers discourage the use of set!, and this is reflected in its naming. Mutation is generally much more common than recursion in many languages (especially those that are prone to stack overflows) but this is not necessarily the case with Scheme. In fact, some implementations of Scheme may even be less efficient when using mutation instead of recursion to design algorithms. This is one reason for many Scheme programmers' reliance on recursion. Standard Scheme is also required to properly handle tail call optimization, which also also helps prevent stack overflow. Some also consider purely functional programs (those that involve no use of mutation or side-effects) easier to formally prove correct.
There are several variations on the set! function. The set-car! and set-cdr! functions mutate the car and cdr values, respectively, of a pair.
This yields
As previously mentioned, mutation is not always required in Scheme. It is more natural in Scheme to use recursion to accomplish many simple tasks than it is to use mutation. Consider the following version of list-max:
This version is easy to understand for users who have no prior experience programming and so have no concept of variables. On the other hand, this version of find-list-max looks rather awkward:
It takes 3 more lines of code to accomplish the same task, but nothing has been gained in terms of speed or clarity. (In fact, on some Scheme implementations this may run even slower.)
# Scheme Programming/Libraries

With the release of R7RS-small, which has been more accepted by the Scheme community as a better balance between minimalism and utility than R6RS, the writing of portable libraries in standard Scheme is becoming more possible. While many Scheme implementations have yet to implement the R7RS library syntax, the following lesson will work with at least these implementations:
* Chibi
* Chicken
* Gambit
* Gauche
* Guile
* Husk
* Kawa
* Larceny
* MIT Scheme
* Picrin
* Sagittarius
Libraries in R7RS generally have the following structure:
And libraries can be loaded at the beginning of an R7RS program with this syntax:
In order to learn how to write a library, we write a short example together. Our library will implement a mutable stack data structure using lists and define-record-type. The name of the library is (wikibooks stack) and the names it will export are stack, stack?, stack-empty?, stack-length, stack-top, stack-push!, and stack-pop!. Here is what our starting library will look like.
We almost always want to import (scheme base) because that includes bindings for define, lambda, quote, and other fundamental Scheme forms. It is possible we will need to import other libraries, but this is enough for now.
In order to write the body of the library, the definitions either have to be contained in a (begin ...) or kept in a separate file. For a short library, enclosing in (begin ...) is not a bad idea, so that is what we will do. First, using define-record-type which is built into R7RS, we will introduce the stack data structure. Here is what our library looks like now.
This defined a disjoint data type called <stack> which has a single field called values, which is retrieved with stack->list and set with set-stack-values!. The predicate for this disjoint data type is stack? and its constructor is list->stack. The structure of define-record-type will be fully explained in a future R7RS lesson, and it is identical to that of SRFI 9.
The next step will be to define the procedures we want to export. For brevity, here is the entire code of a possible implementation.
Where this file must be saved depends on the implementation. Some will only load a file ending in .sld, and others will only load a file ending in .scm. However once it is installed properly, the library can then be loaded into a REPL or program as
And we are done writing our first library! Now, if the library gets much longer, it may be annoying to continue indenting two nested blocks. R7RS provides another way of including source code, using the (include path) syntax. Here is an alternative way the library may look:
The contents of the begin block would then be stored in the file stack.body.scm, completely removing the need for indentation.
# Scheme Programming/Memoisation

Memoization is a programming technique that allows programs to remember the results of prior computations. This technique has numerous benefits; here we will address its use in speeding up certain algorithms.
For example, the following program to compute Fibonacci numbers is correct, but slow:
Those with some understanding of analysis of algorithms will note that each call to (fibonacci n) for n > 2 requires two more calls of the fibonacci function, so the algorithm has a worst case running time of O(2$^n$). We can clearly do better. Observe that (fibonacci 1000) takes quite a while to compute, and may even crash your interpreter if it runs out of memory.
# Scheme Programming/Index

This is an alphabetical index of the book.
# Statistics/Testing Data/z-testsprop
## z test statistic: one proportion

A test statistic that represents the difference between the hypothesized proportion and the observed proportion is used when the binomial parameter p is being tested through the use of a hypothesis-testing procedure. This value is then divided by the standard error. When n is significantly large (n > 20, np > 5, and nq > 5), the test assumptions have been satisfied, and the null hypothesis is true, then we assume that the test statistic is normally distributed.
# Statistics/Testing Data/z-testsprop2
## z test statistic: two proportions

The test statistic is the difference between the observed proportions divided by the standard error when the hypothesis being tested is there is no difference between the two proportions.
# Statistics/Testing Statistical Hypothesis

There are many different tests for the many different kinds of data. A way to get started is to understand what kind of data you have. Are the variables quantitative or qualitative? Certain tests are for certain types of data depending on the size, distribution or scale. Also, it is important to understand how samples of data can differ. The 3 primary characteristics of quantitative data are: central tendency, spread, and shape.
When most people "test" quantitative data, they tend to do tests for central tendency. Why? Well, let's say you had 2 sets of data and you wanted to see if they were different from each other. One way to test this would be to test to see if their central tendency (their means for example) differ.
Imagine two symmetric, bell shaped curves with a vertical line drawn directly in the middle of each, as shown here. If one sample was a lot different than another (a lot higher in values, etc.) then the means would be different typically. So when testing to see if two samples are different, usually two means are compared.
Two medians (another measure of central tendency) can be compared also. Or perhaps one wishes to test two samples to see if they have the same spread or variation. Because statistics of central tendency, spread, etc. follow different distributions - different testing procedures must be followed and utilized.
In the end, most folks summarize the result of a hypothesis test into one particular value - the p-value. If the p-value is smaller than the level of significance (usually $\alpha =5\%$, but even lower in other fields of science i.e. Medicine) then you reject the null-hypothesis, but this does not mean you accept the alternative hypothesis. The p-value is essentially the probability of obtaining a test statistic at least as extreme as the one observed. If the p-value is greater than the level of significance you fail to reject the null-hypothesis, but this does not mean that the null-hypothesis is correct.
# Pro Engineer/WebLink

Pre-requisites to using Web/Link
Set IE security Active scripting – Enable Initialize and script ActiveX controls not marked as safe – Enable Add www.ptc.com to intranet zone
Check out troubleshooting section on http://www.proetoolbox.co.uk if have problems.
# Probability

PROBABILITY
This book is an introduction to the mathematical theory of probability.

## Contents

* Local Manual of Style

### Preliminaries

* Introduction
* Set Theory

### General probability

* Combinatorics
* Probability Spaces
* Conditional Probability

### Random variables

* Random Variables
* Important Distributions
* Joint Distributions and Independence
* Properties of Distributions
* Conditional Distributions
* Transformation of Random Variables

## Further reading

* Index
* Links
* For a gentler introduction to probability, see High School Mathematics Extensions/Discrete Probability.
* Many subjects have probability as a prerequisite: Engineering Analysis, Signals and Systems, Statistics.
# Probability/Index

This is an alphabetical index of the book.

## B

* Binominal distribution

## C

* Combination
* Combinatorics
* Continuous variable
* Conditional probability

## D

* Discrete variable

## I

* Independent event

## N

* Normal distribution

## O

* Outcome

## P

* Permutation
* Poisson distribution
* Probability space

## R

* Random variable

## U

* Uniform distribution
# Pro Engineer/View

The view of a model can be manipulated using only the middle mouse button of a scrolling mouse.
Pressing the middle mouse button (MMB) and dragging the cursor will spin the model. The action is analogous to placing your hand on the model and rolling it across the background - the near part of the model moves with the cursor.
Using the scroll wheel zooms in and out. Scrolling down pulls the MODEL towards you - imagine pulling the scroll wheel towards you - and scrolling up does the opposite. (This action is the opposite of many applications like online maps programs, and even other CAD programs).
You can also use the scroll wheel to pan, but this takes some practice. Move the cursor to the side of the screen you want to pan away from & zoom out (scroll up), then move the cursor to the other side of the screen and zoom in (scroll down).
# Programming Basics/Objects

Objects are a useful tool to handle flexible situations in code. Object Oriented Programming style uses objects extensively.
# Programming Basics/Strings

A string is a data type used to store sequences of characters. Strings are often simply an array of characters.
# Programming Basics/Variables

Variables are tools which are used to store data.
Programming languages often use types to distinguish different kinds of data stored in variables.
| Data Type | Description | Example 1 | Example 2 | Example 3 |
| Integer | Any whole number. | 1 | 300 | 48 |
| Character | A letter of the alphabet. | a | z | y |
| String | A collection of text | Wikibooks | Programming Basics | Hello world! |
# Programming Fundamentals/ASCII Character Set

Brief explanation of ASCII character set with web links to more information and tables.
ASCII stands for American Standard Code for Information Interchange (pronounced "ask-key"). Computers can only understand numbers, so an ASCII code is the numerical representation of a character such as 'a' or '@' or an action of some sort. ASCII was developed a long time ago and now the non-printing characters are rarely used for their original purpose. The first 32 values (0 to 31) and the last value (127) are the non-printing characters.
Several software products can be used to create an ASCII text file.
* Notepad within Windows OS and it uses by default the .txt extension.
* Microsoft Word by saving the file as 'text only' and it uses by default the .txt extension.
* Integrated Development Environment (IDE) compliers for most programming languages usually save source code as ASCII text files but they will use an extension that describes the content of the text file. Example: C++ usually uses .cpp as the extension.
The following web links provide more information and tables listing the ASCII Character Set:
* http://asciiset.com/
* http://www.asciitable.com/
* http://en.wikipedia.org/wiki/ASCII
* Engineering Tables/ASCII Table - Printable Characters
# Programming Fundamentals/Address Operator

An introduction to the address operator as used within the C++ programming language.

## Address Operator in C++

"Every variable is assigned a memory location whose address can be retrieved using the address operator &. The address of a memory location is called a pointer. Every variable in an executing program is allocated a section of memory large enough to hold a value of that variable’s type." Thus, whether the variables are global scope and use the data area for storage or local scope and use the stack for storage; you can ask the question at what address in the memory does this variable exist. Given an integer variable named age:
We can use the address operator [which is the ampersand or &] to determine where it exists (or its address) in the memory by:
This expression is a pointer data type. The concept of an address and a pointer are one in the same. A pointer points to the location in memory because the value of a pointer is the address were the data item resides in the memory.
The address operator is commonly used in two ways:
* To do parameter passing by reference
* To establish the value of pointers
Both of these items are covered in the supplemental links to this module.
You can print out the value of the address with the following code:
This will by default print the value in hexadecimal. Some people prefer an integer value and to print it as an integer you will need to cast the address into a long data type:
One additional tidbit, an array’s name is by definition a pointer to the arrays first element. Thus:
establishes "iqs" as a pointer to the array.

## Definitions
### address operator

    The ampersand or &.

### pointer

    A variable that holds an address as its value.

## References

* ↑ Tony Gaddis, Judy Walters and Godfrey Muganda, Starting Out with C++ Early Objects Sixth Edition (United States of America: Pearson – Addison Wesley, 2008) 597.
# Programming Fundamentals/Arithmetic Operators
## Overview

The basic arithmetic operations are addition, subtraction, multiplication, and division. Arithmetic is performed according to an order of operations.

## Discussion

An operator performs an action on one or more operands. The common arithmetic operators are:
| Action | Common Symbol |
| Addition | + |
| Subtraction | - |
| Multiplication | * |
| Division | / |
| Modulus (associated with integers) | % |
These arithmetic operators are binary that is they have two operands. The operands may be either constants or variables.
age + 1
This expression consists of one operator (addition) which has two operands. The first is represented by a variable named age and the second is a literal constant. If age had a value of 14 then the expression would evaluate (or be equal to) 15.
These operators work as you have learned them throughout your life with the exception of division and modulus. We normally think of division as resulting in an answer that might have a fractional part (a floating-point data type). However, division, when both operands are of the integer data type, may act differently. Please refer to the next section on “Integer Division and Modulus”.

### Arithmetic Assignment Operators

Many programming languages support a combination of the assignment (=) and arithmetic operators (+, -, *, /, %). Various textbooks call them “compound assignment operators” or “combined assignment operators." Their usage can be explained in terms of the assignment operator and the arithmetic operators. In the table, we will use the variable age and you can assume that it is of integer data type.
| Arithmetic assignment examples: | Equivalent code: |
| age += 14; | age = age + 14; |
| age -= 14; | age = age - 14; |
| age *= 14; | age = age * 14; |
| age /= 14; | age = age / 14; |
| age %= 14; | age = age % 14; |

### Flowchart
## References

* cnx.org: Programming Fundamentals – A Modular Structured Approach using C++
* Flowgorithm – Flowchart Programming Language
* ↑ Wikipedia: Arithmetic operators
# Programming Basics/Printable version

The current, editable version of this book is available in Wikibooks, the open-content textbooks collection, at
https://en.wikibooks.org/wiki/Programming_Basics

# Introduction
## Concepts

* What is programming?
* What is an algorithm?
* What is coding?
* What is a programming language?
* What is a translator?

# Variables

Variables are tools which are used to store data.
Programming languages often use types to distinguish different kinds of data stored in variables.
| Data Type | Description | Example 1 | Example 2 | Example 3 |
| Integer | Any whole number. | 1 | 300 | 48 |
| Character | A letter of the alphabet. | a | z | y |
| String | A collection of text | Wikibooks | Programming Basics | Hello world! |

# Functions

Functions used to store code that is used multiple times throughout a program, especially bits of code that repeat throughout a program.
Functions often take input to make them more versatile. This input is called an argument.

# Conditions

Conditions are used in programming to only do something in the event of something else. This is incredibly useful in a number of tasks.
For example, one might prevent divide by zero errors by check to make sure the devisor is not zero first, and then only dividing if the devisor is not zero.

# Loops

Loops are used to repeat sections of code, either infinitely, or until a condition is met.
There are two common types of loops, While loops and For loops.

# Arrays

Arrays are used to hold multiple related variables.
Example Array :
| 0 | 1 | 2 | 3 | 4 |
| A | r | r | a | y |

# Strings

A string is a data type used to store sequences of characters. Strings are often simply an array of characters.

# Files

Files are used to save data to a storage device, which is useful for a number of purposes.

# Objects

Objects are a useful tool to handle flexible situations in code. Object Oriented Programming style uses objects extensively.