OpenLLM-France/wikimedia huggingface dataset:
# Basic Algebra/Introduction to Basic Algebra Ideas/Simple Operations
## Lesson

An operation is a thing you do to numbers. You use signs like: +, –, ×, or ÷ for operations.
The equals sign is not an operation. You use the " = " sign for the equals sign. It is a special sign that you put between two things that are the same.

### Adding

Adding is a way to put two numbers together. You use the " + " sign for the adding operation. If you have 5 apples and a friend has 6 apples, you and your friend have 11 apples. This is 5 + 6 = 11 using the signs of Mathematics, and is read "five plus six equals eleven".
Order is not important when adding. 2 + 3 is the same as 3 + 2.

### Subtracting

Subtracting is a way of taking a number from another number. It is the opposite of adding. You use the " – " sign for the subtracting operation. If you have 5 apples and give 3 to a friend, you then have 2 apples left. This is 5 – 3 = 2 using the signs of Mathematics, and is read "five minus three equals two".
Order is important when subtracting. 3 – 2 is not the same as 2 – 3.

### Multiplying

Multiplying is a way of adding a number many times. You use the " × ", " • " or " * " sign for the multiplying operation. If you have 4 apple trees and every tree has 25 apples, you have 100 apples. This is 4 × 25 = 100 or 25 + 25 + 25 + 25 = 100 in the signs of Mathematics. The first way is shorter and easier to use.
Multiplying 25 by 4 is the same as adding 25, 4 times or adding 4, 25 times.
4 x 25 = 100 should be read "four times twenty-five equals one hundred".
Order is not important when multiplying. 2 × 3 is the same as 3 × 2.

### Dividing

Dividing is a way of subtracting a number many times. It is the opposite of multiplying. You use the " ÷ " or " / " sign for the dividing operation. If 3 friends take an equal part of a bag of 12 apples, every friend gets 4 apples. Or, you may take away (subtract) 3 apples from the bag of 12 apples, exactly 4 times until the bag is empty. This is 12 ÷ 3 = 4 or 12 – 3 – 3 – 3 – 3 = 0 in the signs of Mathematics.
12 ÷ 3 = 4 should be read "twelve divided by three equals 4".
Order is important when dividing. 3 ÷ 2 is not the same as 2 ÷ 3.

## Example Problems

* 3 + 4 = 7
* 5 – 3 = 2
* 6 × 2 = 12
* 13 + 14 = 27
* 21 – 9 = 12
* 8 × 3 = 24

## Practice Games

* Arcademics Grand Prix (Multiplication)
* Arcademics Jet Ski (Addition)
* Arcademics Sailboat (Subtraction)
* Arcademics Drag Race (Division)
# Basic Algebra/Introduction to Basic Algebra Ideas/The Ideas of Algebra

Algebra is a way of working with numbers and signs to answer a mathematics problem (a question using numbers). You use Algebra in life.
It answers, for example, questions like these:
If I have 10 coins and need 25 coins to get a book, how many more coins do I need to get the book?
If you have 6 bottles of milk and you drink 2 bottles in a day, how many days will your milk last?
If you start running a race at a speed of 10 kilometers an hour, and your friend starts running 10 minutes later at a speed of 15 kilometers an hour, when will your friend catch up to you?
Algebra helps answer questions when building houses, making food, and doing science work.
This book will help you learn how to do mathematics using Algebra. It has chapters (parts of the book) with lessons (parts of the chapter about one idea).
A lesson has five parts:
* Vocabulary - lists special words you need for the lesson.
* Lesson - explains a new idea and how to use this idea.
* Example Problems - demonstrates the steps to complete problems using the new idea.
* Practice Games - provides entertaining challenges in which you complete math problems.
* Practice Problems - You practice your skills while completing problems.
# Chemical Sciences: A Manual for CSIR-UGC National Eligibility Test for Lectureship and JRF/Pyrolysis gas chromatography mass spectrometry

Pyrolysis gas chromatography mass spectrometry is a method of chemical analysis in which the sample is heated to decomposition to produce smaller molecules that are separated by gas chromatography and detected using mass spectrometry.

## How it works

Pyrolysis is the thermal dissociation of materials in an inert atmosphere or a vacuum. The sample is put into direct contact with a platinum wire, or placed in a quartz boat inside a platinum coil, and rapidly heated to 600 – 800 C. Large molecules cleave at their weakest points and produce smaller, more volatile fragments. Various methylating reagents, which increase the volatility of polar fragments, can be added to a sample before pyrolysis. These fragments can then be separated on a gas chromatograph (GC).
Not as well-known is the pyrolysis inside a Programmable Temperature Vaporizer (PTV) injector. The reason this technique is relatively unknown is that PTV injectors in general are of yet not often used. With some of the latest versions it is now possible to heat the sample very quickly until an end temperature of 600°C is reached. Some PTV's have a ramp rate of 30°C/sec. The fast ramp rate and the end temperature of 600°C are enough to make good pyrolysis. There are many advantages to using the injector as a pyrolyser. There is a price advantage, and switching from pyrolysing to normal GC injections can be done without changing the configuration of the hardware. Both liquid as well solid samples can be used when a PTV injector with a relative big liner is used. Real quantitative data can be acquired, and good results of derivatization inside the PTV injector are published.

## Applications

Pyrolysis gas chromatography is very useful for the identification of synthetic polymeric media, such as acrylics or alkyds, and synthetic varnishes. It can also be used for environmental samples., including fossils.
ref. to publications of in-injector pyrolysis: - Erwin Kaal, Sjaak de Koning, Stella Brudin, Hans-Gerd Janssen Journal of Chromatography A, 1201 (2008) 169–175. - Hyphenation of aqueous liquid chromatography to pyrolysis-gas chromatography and mass spectrometry for the comprehensive characterization of water-soluble polymers Erwin R. Kaal, Mitsuhiro Kurano, Margit Geißler, Hans-Gerd Janssen Journal of Chromatography A, 1186 (2008) 222–227

## References

* ↑ Halket JM, Zaikin VG (2006). "Derivatization in mass spectrometry --7. On-line derivatisation/degradation". European journal of mass spectrometry (Chichester, England). 12 (1): 1–13. doi:10.1255/ejms.785. PMID 16531644.
* ↑ "National Gallery of Art Conservation: Scientific Research". Retrieved 2007-08-21.
* ↑ Janos P (2003). "Separation methods in the chemistry of humic substances". Journal of chromatography. A. 983 (1–2): 1–18. doi:10.1016/S0021-9673(02)01687-4. PMID 12568366.
* ↑ Poinar HN (2002). "The genetic secrets some fossils hold". Acc. Chem. Res. 35 (8): 676–84. doi:10.1021/ar000207x. PMID 12186573.
# Chemical Sciences: A Manual for CSIR-UGC National Eligibility Test for Lectureship and JRF/Questions and Answers
### Problem Set

* Short note on Chemical Sciences: A Manual for CSIR-UGC National Eligibility Test for Lectureship and JRF/Proton Enhanced Nuclear Induction Spectroscopy
# C Programming/stdio.h/perror

The POSIX error function, perror, is used in C and C++ to print an error message to stderr, based on the error state stored in errno.It prints str and an implementation-defined error message corresponding to the global variable errno.

## History

The definition of perror was first released in Issue 1 of the System V Interface Definition.

## Usage
### Semantics

If the parameter prefix is non-NULL, perror will first print prefix followed by a colon and a space to standard error. Then, it will print the result of strerror to standard error, followed by a newline character. For instance the above example may print

## References

* ↑ ISO/IEC 9899:1999 specification (PDF). p. 305, § 7.19.10.2.

## External links

* C++ reference for std::perror
# C Programming/stdio.h/rewind

rewind is a function in the C programming language that is specified in the stdio.h library header file. The function moves the file position indicator to the beginning of the specified stream, while also clearing the error and EOF flags associated with that stream.
rewind acts as if fseek(stream, 0L, SEEK_SET) was called for the stream passed, except that rewind causes the error indicator to also be cleared.

## References

* ↑ , The Open Group Base Specifications Issue 7, IEEE Std 1003.1-2008.
# C Programming/stdio.h/remove

remove is a function in C programming language that removes a certain file. It is included in the C standard library header file stdio.h.
The prototype of the function is as follows:
If successful, the function returns zero. Nonzero value is returned on failure and errno variable is set to corresponding error code.

## Sample usage

The following program demonstrates common usage of remove:
To implement a simple remove utility:

## External links

* C++ reference for std::remove
# C Programming/stdio.h/setvbuf

setvbuf is a function in standard C which lets the programmer control the buffering of a file stream. It is declared in <stdio.h>; its function prototype is:
The stream argument is a pointer to the file stream for which the relevant buffering operations will be performed; buf is a character array of size in length, or a null pointer; and mode is the kind of buffering desired: _IOFBF, for fully buffered, _IOLBF for line buffered and _IONBF for unbuffered. These three macros are defined in <stdio.h>. setvbuf returns zero on success or nonzero on failure.
If buf is a null pointer, the system will dynamically allocate a buffer of the specified size (size characters). If mode is _IONBF, the stream I/O will not be buffered, causing each subsequent I/O operation on the stream to be performed immediately, and the buf and size arguments are ignored.
A related function, setbuf also controls the buffering of a file stream. Unlike setvbuf, setbuf takes only two arguments. The prototype is:
setbuf's behavior is equivalent to:
That is, if buf is not NULL, set the stream to fully buffered using the given buffer; otherwise, set the stream to unbuffered. If a buffer is provided to setbuf, it must be at least BUFSIZ bytes long. The function always succeeds.
The code below is very unstable and might not work properly on specific compilers. It may even buffer overflow.. C99 says that setvbuf may not be called after writing to the stream, so this code invokes undefined behavior. C99 footnote 230 (non-normative) says the stream should be closed before buf is deallocated at the end of main.

## Example

The output of this program should be Hello world followed by a newline. Note this example is broken as it implements what the manpage clearly labels as a bug: The buffer needs to be still there when the stream is closed. Here, the buffer goes away upon leaving main, but the stream is closed only afterwards when the program terminates.

## External links

* C++ reference for std::setvbuf
# C Programming/stdio.h/putc

putc is the function in stdio.h. It is simplest way to write the file once it is open. It writes the character to stream and advances the position indicator. It is output function. The character is written at the current position of the stream as indicated by the internal position indicator, which is then advanced one character.
putc is equivalent to fputc and also expects a stream as parameter, but putc may be implemented as a macro, so the argument passed should not be an expression with potential side effects.
See putchar for a similar function without stream parameter.

## Parameters
### character

    Character to be written. The character is passed as its int promotion.

### stream

    Pointer to a FILE object that identifies the stream where the character is to be written.

## Return value

If there are no errors, the same character that has been written is returned. If an error occurs, EOF is returned and the error indicator is set.

## Example

/* putc example: alphabet writer */ <Source lang="c">
* include <stdio.h>
int main {
} </syntaxhighlight>

## Output

This example program creates a file called alphabet.txt and writes ABCDEFGHIJKLMNOPQRSTUVWXYZ to it.
# C Programming/stdio.h/putchar

putchar is a function in the C programming language that writes a single character to the standard output stream, stdout. Its prototype is as follows:
    int putchar (int character)
The character to be printed is fed into the function as an argument, and if the writing is successful, the argument character is returned. Otherwise, end-of-file is returned.
The putchar function is specified in the C standard library header file stdio.h.

## Sample usage

The following program uses getchar to read characters into an array and print them out using the putchar function after an end-of-file character is found.
The program specifies the reading length's maximum value at 1000 characters. It will stop reading either after reading 1000 characters or after reading in an end-of-file indicator, whichever comes first.

## References

* ↑ ISO/IEC 9899:1999 specification (PDF). p. 299, § 7.19.7.9.

## External links

* C++ reference for std::putchar
# C Programming/stdio.h/puts

puts is a function used to output a string (plus a newline), for example,
output (on stdout):
Differences from printf:
1. puts prints a newline after the supplied text
2. puts prints the string as is (it does not process % codes).
We can also pass a variable to puts, for example,
output:
puts has the following prototype:
It will print each byte at str until a null is reached, then print a newline. puts returns the number of bytes written (including the newline), or EOF (if an error occurred.)
To print a string without processing % codes, or outputting a newline, try:
# C Programming/stdio.h/rename

rename is a function in the C programming language that renames a certain file.
The prototype of the function is:
    int rename(const char *oldname, const char *newname)
Zero is returned upon success. Other integers are returned upon failure and errno is set to an error code in this case.
The rename function is specified in the stdio.h library header file in C and the cstdio header in C++. It is specified in ANSI C.
In POSIX, rename will fail (with EXDEV) if the old and new names are on different mounted file systems. If a call to rename succeeds it is guaranteed to have been atomic from the point of view of the current host (i.e., another program would only see the file with the old name or the file with the new name, not both or neither of them).
The Windows C library version of rename fails if the destination file already exists (POSIX would only fail if the user does not have permission to remove the destination file). Although the underlying WIN32 call has (since Win2K) had an option to replicate the POSIX atomic behavior, the library has never been fixed to use this.

## References

* ↑ ISO/IEC 9899:1999 specification (PDF). p. 268, § 7.19.4.2.
* ↑ rename: rename a file – System Interfaces Reference, The Single UNIX® Specification, Issue 7 from The Open Group

## External links

* C++ reference for std::rename
# C Programming/Coroutines

A little known fact is that most C implementations have built-in primitives that can be used for cooperative multitasking / coroutines. They are setcontext and setjmp.

## setjmp

The function setjmp is used in a pair with longjmp to transfer execution to a different point in the code. It relies on an existing jmp_buf declaration.
setjmp stores the current execution point in memory, which remains valid as long as the containing function doesn't return. It initially returns 0. Control is returned to setjmp once longjmp is called with the original jmp_buf and the replacement return value.
Note that jmp_buf is passed to setjmp without using the address-of operator.
The easiest way to understand setjmp and longjmp, is that setjmp stores the state of the cpu which includes program counter, stack pointer, all the registers, including the bits of the flags register, at the location pointed to by jmp_buf , which is defined some LEN+1, which is enough bytes to store the registers of whatever CPU is involved. The longjmp(buf) , never returns, because it restores the CPU from the contents of struct jmp_buf buf previously set by a previous call the setjmp, so execution begins from after setjmp was called, but the return value of setjmp is not 0, but whatever value was used in the second parameter to longjmp. This is similar to the fork system call, which returns 0 to the child process, and the PID of the child process to the parent.
The internet suggests co-routines are useful for implementing software as state machines cooperating, such as lexer processing input text and emitting tokens , so that a parser can decide to store the token and ask for the next one, or to act on its current set of token . This is not multithreaded programs synchronising on data, with possibly race conditions if a bug forgets to acquire a lock, but with setjmp and longjmp, seems to be cooperative processes that guarantee only one process will run at a time, with no worries about context switches waking up sleeping processes ( using separate jmp_buf static locations, each process can call setjmp for its own jmp_buf, before calling longjmp later on if zero was returned, or continue a loop to process shared data for non-zero returns).
# C Programming/History

The field of computing as we know it today started in 1947 with three scientists at Bell Telephone Laboratories—William Shockley, Walter Brattain, and John Bardeen—and their groundbreaking invention: the transistor. In 1956, the first fully transistor-based computer, the TX-0, was completed at MIT. The first integrated circuit was created in 1958 by Jack Kilby at Texas Instruments, but the first high-level programming language existed even before then.
The Fortran project was developed in 1954 by IBM. A shortening of "The IBM Mathematical Formula Translating System", the project had the purpose of creating and fostering development of a procedural, imperative programming language that was especially suited to numeric computation and scientific computing. It was a breakthrough in terms of productivity and programming ease (compared to assembly language) and speed (Fortran programs ran nearly as fast as, and in some cases, just as fast as, programs written in assembly). Furthermore, Fortran was written at a high-enough level (and thus was machine independent enough) to become the first widely adopted programming language. The Algorithmic Language (Algol 58) was derived from Fortran in 1958 and evolved into Algol 60 in 1960. The Combined Programming Language (CPL) was then created out of Algol 60 in 1963. In 1967, it evolved into Basic CPL (BCPL), which was the basis for B, which was created in 1971, and served as the basis of C.
Created by Ken Thompson at Bell Labs, B was a stripped-down version of BCPL that was also a compiled language (see User's Reference to B) used in early internal versions of the UNIX operating system. As Dennis Ritchie noted in his Development of the C Language :
   The B compiler on the PDP-7 did not generate machine instructions, but instead 'threaded code', an interpretive scheme in which the compiler's output consists of a sequence of addresses of code fragments that perform the elementary operations. The operations typically — in particular for B — act on a simple stack machine.
Thompson and Ritchie improved B, and called the result NB. Further extensions to NB created its logical successor, C. Most of UNIX was rewritten in NB, and then C, which resulted in a more portable operating system. The portability of UNIX was the main reason for the initial popularity of both UNIX and C. Rather than creating a new operating system for each new machine, system programmers could simply write the few system-dependent parts required for the machine, and then write a C compiler for the new system. Since most of the system utilities were thus written in C, it simply made sense to also write new utilities in C.
The American National Standards Institute began work on standardizing the C language in 1983, and completed the standard in 1989. The standard, ANSI X3.159-1989 "Programming Language C", served as the basis for all implementations of C compilers. The standards were later updated in 1990 and 1999, allowing for features that were either in common use, or were appearing in C++.
# C Programming/Code library

The following is an implementation of the Standard C99 version of <assert.h>:
# C Programming/GNU C Library Reference
## Header files

| argp.h | Interface for parsing unix-style argument vectors. |
| argz.h | Allocate/grow argz vectors. |
| envz.h | |
| execinfo.h | Backtrace support. |
| libintl.h | |

## Table of functions
### argp.h

| argp_error argp_failure argp_help argp_parse | argp_state_help argp_usage |

### argz.h

| argz_add argz_add_sep argz_append argz_count | argz_create argz_create_sep argz_delete argz_extract | argz_insert argz_next argz_replace argz_stringify |

### envz.h

| envz_add envz_entry envz_get envz_merge | envz_remove envz_strip |

### execinfo.h

* backtrace
* backtrace_symbols
* backtrace_symbols_fd

### libintl.h

| bind_textdomain_codeset bindtextdomain dcgettext dcngettext | dgettext dngettext gettext ngettext | textdomain |

## Standard Library Extensions

Platform facilities that extend the standard library headers.

### assert.h

* assert_perror

### complex.h

| clog10 clog10f clog10fN clog10fNx | clog10l |

### fenv.h

* fedisableexcept
* feenableexcept
* fegetexcept

### math.h

| j0fN j0fNx j1fN j1fNx jnfN jnfNx lgammafN_r lgammafNx_r | pow10 pow10f pow10l sincos sincosf sincosfN sincosfNx sincosl | y0fN y0fNx y1fN y1fNx ynfN ynfNx |

### signal.h

* sysv_signal

### stdio.h

| asprintf clearerr_unlocked feof_unlocked ferror_unlocked fgets_unlocked fileno_unlocked fmemopen fopencookie | fputs_unlocked fread_unlocked fwrite_unlocked getdelim fputs_unlocked fread_unlocked fwrite_unlocked getdelim | getline obstack_printf obstack_vprintf open_memstream snprintf tmpnam_r vasprintf vsnprintf |

### stdlib.h

| alloca canonicalize_file_name clearenv drand48_r ecvt_r erand48_r getpt initstate_r | jrand48_r lcong48_r lrand48_r mrand48_r nrand48_r ptsname_r qecvt qecvt_r | qfcvt qfcvt_r qgcvt random_r rpmatch secure_getenv seed48_r setstate_r | srand48_r srandom_r |
# Conart/Illumination

Making an illuminated manuscript takes time and effort, though can be a real boost to a conworld's artistic culture.
One could do it the traditional way. First, create a sketch, then add gold leaf (could be golden foil or just gold ink) before adding other colours, like reds and blues, to make the picture. The writing is normally beautiful and often uses calligraphy. Due to the time taken to illuminate, most manuscripts limit illumination mainly to pictures and first letters, though your world could be different.
However, if one wants to save time, one could just get out some coloured pens or pencils and make the colours like that.
One thing to consider when using illumination in your conworld is where it would be used; most of the time, it would only be used for important or religious documents. They can be used to show many things, like wealth, power or holiness; decide what illumination will convey.
Sometimes, single letters, normally capitals, are illuminated and have a story of figure hidden in them. You may want to consider making your world like this, to save time.

## Real Examples

* Book of Kells
# Conart/Music/Difference
### So, what is different in these other scales?

Except that the pianos will have different layouts for their keys, there will be certain differences:
* intervals can sound sweeter or harsher, depending on the characteristics of the scale
* intervals can be perfectly tuned, or only approximately in tune
* there can be more or less available chords
* transposing and modulation can become more or less difficult
* and of course, different scales lend themselves to different purposes
* instruments will be slightly different
However, there also is an opposite effect:
* the available instruments will affect what kind of scales are probable to evolve
* the kind of music will affect what kind of scales are probable to evolve