OpenLLM-France/wikimedia huggingface dataset:
# Do-It-Yourself/Ionic wind thruster

An ionic wind thruster is a booster based on ionizing air to create thrust. These thrusters work by adding an electron to a particle of air so that the air is forced away from a the negatively charged grid. This produces a level of thrust T=m*(dv/dt), with T being thrust, m being the mass of the air, and v being the velocity of the air.
A common science fair project may be using a charged grid to 'levitate' an object several decimeters above a surface; more interesting applications may include levitating the hull of a car and building something more akin to Luke Skywalker's speeder or a hoverboard as seen in Back to the Future 2.
The basic design involves using a 555 timer to repeatedly and rapidly pulse a high voltage, low current electrical charge through a grid of wire. Typical values would be 30,000V at 0.001A, or 30kV at 1mA. This is typically enough power to levitate a small grid on its own; however, the grid can be combined with a light-weight plastic skirt or cone to better control the thrust angle and create backpressure. The function of such a cone would be to prevent air from going out sideways, which decreases the amount of thrust in the direction we want; however, too much backpressure will also overpower the total thrust of the system and negate the effect.
# Do-It-Yourself/Pottery
## Coiling technique

One popular technique when constructing pottery is the coiling technique. Here is a simply overview of how to construct a pot using this technique.
* Squeezing the clay into a coil or rolling between your hands are two ways to make coils. This technique can be difficult to make a smooth, round coil because of the uneven pressure from your hands and fingers.
* When hand rolling coils, use a smooth surface, spreading your hands to apply even pressure. Gently roll the clay back and forth.
* Roll the coils so that they are a little thicker than a pencil, then stack the coils one on top of another.
* For strength, force the clay together on the inside of the piece. Use you finger and scrape the top coil onto the coil underneath it.
* When smoothing out the inside of the piece, hold your other hand on the outside so you do not damage what you have completed already.
* If you want the top level, gently turn your piece over and lightly tap it on a smooth surface.
* When you are finished with your piece, let it dry slowly: the grooves in the piece are weak spots and if they dry too quickly they will crack.
# Common Lisp/External libraries/ASDF/Configuring ASDF
## Configuring ASDF

Most frequently, you will add settings for asdf to the configuration file for your lisp system. For example, sbcl uses ~/.sbclrc while cmucl uses ~/.cmucl-init. The most important setting is the central registry described below. Most of the other configuration settings are optional.

### asdf:*central-registry*

The central-registry is a list of file directories that will be searched for system definition (.asd) files and is the least you need to know about configuring ASDF. The safest way to modify asdf:*central-registry* is to use pushnew to push a new directory onto the list.

### Automatically updating stale fasl files

From http://www.cliki.net/asdf

### Alternative to symlinks, search directories recursively

The standard way of adding libraries to ASDF involves either:
* Making a symbolic link for the .asd file in a directory listed in asdf:*central-registry* or
* Adding directories to asdf:*central-registry*.
The following code snippit shows how to recursively search through subdirectories for asdf packages.
From http://www.cliki.net/asdf

## References

* The Common Lisp Wiki: ASDF
# Common Lisp/External libraries/ASDF
## ASDF

ASDF, short for "another system definition facility" simplifies the management of lisp systems. A system is analogous to a package or module from other programming language, and includes one or more files that are compiled and loaded to provide library objects and functions. Using ASDF, the lisp programmer can:
* compile all files included in a system.
* specify other asdf packages as dependencies.
* load all of the files needed for a system.
ASDF has features in common with Ant for java, distutils for python, and cpan for perl. An additional package ASDF-INSTALL can be used to download and install asdf asdf systems. Many lisp libraries are now distributed as ADSF systems, and ASDF is bundled with Allegro Common Lisp, SBCL, ECL, and OpenMCL.

### Sections

* Installing ASDF: for lisp implementations that do not include it.
* Configuring ASDF: specifying the asdf respository.
* Using ASDF: loading, compiling, and recompiling asdf systems.
* Definition Files: creating your own systems.
* ASDF-INSTALL: downloading and installing packages.
* Budden's infrequently asked questions
# Common Lisp/External libraries/ASDF/Installing ASDF
## Installing ASDF
### Is it installed for you?

Many lisp systems encoding SBCL, Allegro, OpenMCL and ECL are bundled with asdf. To test this, try entering the following into a lisp interpreter:
If this succeeds, ASDF is installed and ready to go.

### Downloading ASDF

If you have cvs installed, you can download asdf with the following commands. Press enter when prompted for a password.
Alternatively, you can just download asdf.lisp from http://cclan.cvs.sourceforge.net/cclan/asdf/
Under Debian Linux and related systems, you can install asdf with:

### Loading ASDF

Save asdf.lisp and associated other files into a location of your choice. For example my lisp files are in my home directory at /Users/Kirk/lisp. If you install ASDF system wide it may be under /user/local/lib.
Open the startup file for the lisp you are running. For clisp this will be ~/.clisprc.lisp. For cmucl try ~/.cmucl-init. Add the following line:
Replace /Path/to with the full path to the asdf.lisp file.
For example, if you've used cl-asdf package on Debian (or Ubuntu) GNU/Linux, the command will look like this:
# Common Lisp/Beyond ANSI Common Lisp

The implementation-dependent features which exist on most implementations but not a part of ANSI Common Lisp standard.
Since there are no agreed upon interfaces to these facilities, each implementation does these things differently. To make things simpler for the user, oftentimes compatibility packages are maintained to provide a standard interface.
* Debugging - debugging Lisp systems
* OS - communicating with the underlying OS (shell access, etc.)
* Streams - user-defined streams (a.k.a. Gray Streams)
* Sockets - using sockets (using IOLib)
* MOP - Meta Object Protocol (using closer-mop)
* FFI - Foreign Function interface (using CFFI compatibility layer)
* Threads - writing multi-threaded programs (using bordeaux-threads)
* User Control of GC - opening the black box of the Garbage Collector (using trivial-garbage)
* CLX — X Window Programming in Common Lisp
# Common Lisp/Beyond ANSI Common Lisp/User Control of GC

The Common Lisp specification says very little about garbage collection, GC. GC is traditionally treated as a black box that the user never has to worry about: if an object is accessible, then it is still allocated, so no memory errors can occur. There are times, however, that it is useful to gain a little control over garbage collection and memory management. Almost every common lisp implementation has a function called GC that starts the garbage collection process. GC is fairly standard, but other features such as weak pointers, weak hashes, and object finalization have much less standard interfaces, if they are present at all. We will be using the compatibility layer trivial-garbage to provide a standard interface.

## Object Finalization

When the GC reclaims an object, the space is usually just freed. In some circumstances, however, it can be useful to have a procedure that runs when the garbage collector reclaims the data. Object finalization (not to be confused with class finalization) allows you to set such a procedure.
An example of when you might want to use this is when you are allocating foreign memory (memory that is not under control of the garbage collector). Finalization allows you to put that memory under the control of the garbage collector.
We have wrapped our foreign pointer in a Lisp object and set up a finalization procedure for that object. The finalization procedure frees the memory, removing memory leaks.
# Common Lisp/External libraries/ASDF/ASDF-INSTALL

asdf-install is deprecated. Use quicklisp instead.
# Common Lisp/External libraries/ASDF/Using ASDF
## Initialization

In order to be able to use ASDF you might call require first:

## Installing systems using ASDF-Install

In order to install cliki system using ASDF-Install execute following steps:

## Loading systems

In order to load an already installed system call:

## Compiling and testing

In order to compile system sources call:

## See also

* Getting started with ASDF
* ASDF How-To
* First Steps With ASDF And Asdf Install
# English in Use/Hard C and soft C guide

The letter "C" can make two different sounds based on the rules of English pronunciation. It can make the "hard" sound, as in "cake" and "cut", and it can make the "soft" sound as in "cell" and "cinder". This is going to be your guide, an in-depth guide, for how to tell when to use the hard sound, and when to use the soft sound. Despite being a multi-sound letter, the letter "C" is typically quite well-behaved. Much of this information should be quite familiar to you. We as educated, sane, rational adults don't, in the right mind, see a word like "Congress" and expect it to have a soft C, because that's not how CO words are pronounced. "Congress", like billions of other words with a "C" followed by "O", has a hard C, just like the "C" in "cat". In many dictionaries, "C" is the second most common letter for a word to begin with, behind only the letter "S".

## Rules

* The sound of the letter "C" depends on the letter that follows it.
* If the letter "C" is followed by "E", "I", or "Y", it makes the soft sound. The soft C sounds like the letter "S" as in "salad". Examples include "cell", "cider", and "Cynthia".
* If the letter "C" is followed by H, then this consonant cluster makes its own sound, as in "chair" and "chill".
* In some words, "CH" makes the hard C sound. Examples include "chorus", "chord", "chasm", and all words starting with "Christ", including the name of a very popular day of the year, Christmas.
* If the letter "C" is followed by "A", "L", "O", "R", or "U", it makes the hard sound. The hard C sounds like the letter "K" as in "king". Examples include "card", "clam", "coat", "crate", and "cut".
* If a word has a "double C", it helps to view this word as a composite. The first "C" is hard, and the second "C" is hard or soft based on the above rules. Words like "accuse" have two hard C's back-to-back, so they have the hard C sound. In the word "accident", the second C is soft because it is followed by "I", and the hard and soft C's together form the "X" sound.
# English in Use/Phrasal Verbs

Phrasal verbs are usually verbs + prepositions or verbs + particles. Phrasal verbs are used frequently in English, mostly in informal language but increasingly also in formal situations. Most phrasal verbs have an equivalent formal word which could replace them (i.e. put out a fire - extinguish a fire). Phrasal verbs are a problem for many learners of English because most languages don't have anything similar and the meaning of many phrasal verbs is often not obvious.

## Examples

Here are some examples of phrasal verbs (on the left hand side) and a rough meaning for them (on the right). The phrasal verb in each sentence is written in bold text.
* Charlie will look after the children - Charlie will take care of the children.
* The plane took off at 17:30 - The plane left the ground at 17:30.
* Police are looking into the crime - Police are investigating the crime.
* The man picked up the rubbish from the ground - The man took and collected the rubbish.
As you can see from the above list the meaning is not always obvious - look after could be interpreted as looking at something after it's happened but the meaning is non literal. Only pick up has an obvious meaning in the above list.

## Separable & Non Separable Phrasal Verbs

Phrasal verbs are either separable or non-separable. A separable phrasal verb can be have the object of the phrasal verb either in the middle of the phrasal verb or after it (e.g. pick rubbish up - or - pick up rubbish). With non separable phrasal verbs, the object must come after the phrasal verb only (e.g. Police are looking into the crime NOT Police are looking the crime into)
# English in Use/Phrases
## Prepositional phrase

Prepositions of time:
1.On
* on my birthday
* on June 19th
* on a warm day
* on holiday
2.at
* at night
* at the moment
* at the beginning
3. In
* in the past
* in 15 minutes
* in January

## Infinitive phrase

Introduction · About :
| Words: | Articles · Nouns · Pronouns · Verbs · Adjectives · Adverbs · Prepositions, Conjunctions, and Interjections · Verbals |
| Sentences: | Sentences Overview · Basic Components · Phrases · Clauses · Fragments and Run-on Sentences |
| Usage: | Adjective and Adverb Usage · Pronoun Usage · Subject-verb Agreement · Verb Usage |
| Punctuation: | End Marks · Commas · Apostrophes · Quotations · Other Common Punctuation Marks · Less Common Typographical Marks |
| Other key topics: | Time and Date · Capitalization · Spelling · Figures of Syntax · Syntax · Recent Grammar Restructure Attempts |
| Appendices: | Glossary · Q&A · External Resources · Common errors · History · Dictionary · Thesaurus |
# Differentiable Manifolds/Orientation

Definition (orientation):
Let $M$ be a differentiable manifold. An orientation of $M$ is a family of atlases $(\varphi _{\alpha })_{\alpha \in A}$ on $M$ such that for all $\alpha ,\beta \in A$
    $\det \left(D(\varphi _{\alpha }\circ \varphi _{\beta }^{-1})\right)>0$.
Proposition (an orientation of a manifold induces an orientation on its boundary):
Let $M$ be a differentiable manifold. If $(\varphi _{\alpha })_{\alpha \in A}$ is an orientation of $M$, then an orientation of $\partial M$ is given by
    $(\pi _{2,\ldots ,n}\circ \varphi _{\alpha }\upharpoonright \partial M)_{\alpha \in A}$,
where $\pi _{2,\ldots ,n}$ is defined as follows:
    $\pi _{2,\ldots ,n}:\mathbb {R} ^{n}\to \mathbb {R} ^{n-1},~\pi _{2,\ldots ,n}(x_{1},\ldots ,x_{n}):=(x_{2},\ldots ,x_{n})$
Proof: The given family of functions defines an atlas on $\partial M$, so that the proposition will be proven once it is demonstrated that the requirement regarding the positivity of the determinant is satisfied.
Indeed, let $\alpha ,\beta \in A$. Then
    $\pi _{2,\ldots ,n}\circ \varphi _{\alpha }\upharpoonright \partial M\circ (\pi _{2,\ldots ,n}\circ \varphi _{\beta }\upharpoonright \partial M)^{-1}=\pi _{2,\ldots ,n}\circ (\varphi _{\alpha }\circ \varphi _{\beta }^{-1})\circ (\pi _{2,\ldots ,n}\upharpoonright \{(x_{1},\ldots ,x_{n})\in \mathbb {R} ^{n}|x_{1}=0\})^{-1}$.
Since $\varphi _{\alpha }\circ \varphi _{\beta }^{-1}$ maps the set $\{(x_{1},\ldots ,x_{n})\in \mathbb {R} ^{n}|x_{1}=0\}$ to itself, the first row of $D(\varphi _{\alpha }\circ \varphi _{\beta }^{-1})$ is zero so long as $x\in \{(x_{1},\ldots ,x_{n})\in \mathbb {R} ^{n}|x_{1}=0\}$, except the very first entry. Yet the very last entry must be non-negative so long as $x\in \{(x_{1},\ldots ,x_{n})\in \mathbb {R} ^{n}|x_{1}=0\}$, since otherwise the fundamental theorem of calculus and the continuity of the derivative would imply that for a $y:=(y_{1},\ldots ,y_{n})\in \mathbb {R} ^{n}$ such that $y_{n}>0$ was sufficiently small, $\varphi _{\alpha }\circ \varphi _{\beta }^{-1}(y)$ would be contained within
    $\{(x_{1},\ldots ,x_{n})\in \mathbb {R} ^{n}|x_{n}<0\}$,
contrary to the definition of charts that contain a piece of the boundary. Hence, upon carrying out a Leibniz expansion of $D(\varphi _{\alpha }\circ \varphi _{\beta }^{-1})$ along the first row, we obtain that the matrix obtained from $D(\varphi _{\alpha }\circ \varphi _{\beta }^{-1})$ by removing the first row and the first column has positive determinant. Yet the definitions of the respective partial derivatives as limits show that this matrix is exactly the matrix
    $D(\pi _{2,\ldots ,n}\circ (\varphi _{\alpha }\circ \varphi _{\beta }^{-1})\circ (\pi _{2,\ldots ,n}\upharpoonright \{(x_{1},\ldots ,x_{n})\in \mathbb {R} ^{n}|x_{1}=0\})^{-1})$. $\Box$
# Differentiable Manifolds/De Rham cohomology

Proposition (the differentiable forms of a differentiable manifold and the Cartan derivative constitute a cochain complex):
Let $M$ be a differentiable manifold of class ${\mathcal {C}}^{k}$. Then the diagram
    $0\longrightarrow \Omega ^{0}(M){\overset {d}{\longrightarrow }}\Omega ^{1}(M){\overset {d}{\longrightarrow }}\Omega ^{2}(M){\overset {d}{\longrightarrow }}\cdots$
constitutes a chain complex of modules over ${\mathcal {C}}^{k}(M)$, where $d$ shall denote the Cartan derivative.
Proof: This follows immediately from the fact that applying the Cartan derivative twice always yields zero. $\Box$
Definition (de Rham cohomology):
Let $M$ be a differentiable manifold of class ${\mathcal {C}}^{k}$. The cohomology arising from the chain complex
    $0\longrightarrow \Omega ^{0}(M){\overset {d}{\longrightarrow }}\Omega ^{1}(M){\overset {d}{\longrightarrow }}\Omega ^{2}(M){\overset {d}{\longrightarrow }}\cdots$
is called de Rham cohomology. The $k$-th ${\mathcal {C}}^{k}(M)$-module of this cohomology is commonly denoted $H_{\text{dR}}^{k}(M)$.
# Differentiable Manifolds/Lie groups

Definition (Lie group):
A Lie group is a differentiable manifold $G$ whose group law (denoted here by juxtaposition) has the following properties:
* The function $G\times G\to G$, $(g,h)\mapsto gh$ is differentiable
* The function $G\to G$, $h\mapsto h^{-1}$ is differentiable
# Differentiable Manifolds/Differential forms

Definition (wedge product bundle):
Let $M$ be a differentiable manifold and $\bigoplus ^{n}T^{*}M$ be the $(0,n)$-tensor bundle of $M$. The wedge product bundle of degree $n$, denoted $\bigwedge ^{n}T^{*}M$, is the subbundle of $\bigoplus ^{n}T^{*}M$ made of the elements of $\bigoplus ^{n}T^{*}M$ which are invariant under all vector bundle isomorphisms
Definition (n-form):
Let $M$ be a differentiable manifold. An $n$-form on $M$ is an element of
    $\Gamma \left(\bigwedge ^{n}T^{*}M\right)$,
the sections of the vector bundle $\bigwedge ^{n}T^{*}M$.
# D (The Programming Language)/d2/Hello, World!/More Info about the Write Family

| | Topics: | Language and Phobos - DGui (example placeholder - can be any library) |
| Previous | Lessons: | 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 10 - T |

## More Info about the write Family

The four functions in the write family in std.stdio are: write, writef, writeln, and writefln. They are based on the C functions from cstdio (the D bindings to them are in core.stdc.stdio) for writing to streams. This subpage assumes that you have solid knowledge of the C standard library.

### stdout

The std.stdio module imports core.stdc.stdio, thereby gaining access to a stream named stdout. Most of the time, stdout is the console, and it is most often line-buffered, even though the type of buffering is actually implementation-defined. So, line-buffering for stdout will be assumed for the rest of this article, even though it is not standard.

### The Functions, How They Work
#### Map of What Happens

    I. Start here if you are using write. For each argument that write is called with: goto A. with that argument.
       A. If the argument is of some string type: goto 1. Else: goto B.
          1. If the argument is a char string and fwide(stdout, 0) <= 0: the argument will be passed to fwrite to be written to stdout, flushing will occur if the buffer is full, and maybe if there is a newline in the argument (especially on Linux). Else: goto 2.
          2. Each character from the argument is written to stdout by being passed to either fputc or fputwc, depending on whether the character's type. If the buffer becomes full or if the argument is a newline character, flushing will occur.
       B. The argument is not of some string type. goto 1.
          1. If the argument is some char type: goto I.A.2. Else: goto 2.
          2. The argument will be converted to a char string with std.format, goto I.A.1.
    II. Start here if you are using writeln. goto A.
       A. If there are no arguments: Use fputc to output a newline to stdout. Flushing will occur. Else: goto B.
       B. If there is one argument and that argument is a const(char) (string) value: use fprintf to print out that string with a newline at the end, and flushing will occur. Else: goto C.
       C. If there is more than one argument, or if there is only one argument that is not a string value: Add the char value of '\n' to the end of the arguments list, and then for each argument: goto I.A. with that argument.
    III. Start here if you are using writef. goto A.
       A. If the first and only argument is a char: goto I.A.2. with that argument. Else: All the arguments are formatted (C-style) together with std.format, and goto I.A.1. with that result.
    IV. Start here if you are using writefln. goto A.
       A. If the first and only argument is a char: goto I.A.2. with each of these two: (that argument, a newline char).
       Else: All the arguments are formatted (C-style) together with std.format, and goto I.A.1. with each of these two: (the result from formatting, a newline char).
# D (The Programming Language)/d2/Lessons Style Guide

| | Topics: | Language and Phobos - DGui (example placeholder - can be any library) | |
| Previous | Lessons: | 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 10 - T | Next |
| | Subpages: | Subpage 1 for any extra info that some readers may find useful - Subpage 2 |

# Lesson T: A Style Guide

In this template-like guide, you see the general layout for these phobos/language lesson pages.

## Introductory Code
### Code Example 1 Title

You may write a description of the code sample.

### Code Example 2 Title

Code examples are for introducing the concepts of the lesson to the reader. They do not necessarily have to show every concept. It's even nicer if the code example did something useful and/or interesting.

## Concepts
### Concept 1

The navbar at the top is a template. You can look at the source code of this page to see how it is used. The 0 and the T lessons are there on the navbar temporarily until the lessons get better (when these lessons can actually be used for learning).

### Concept 2

Concepts are generally very important and crucial pieces of information about D. It is okay to assume that the reader has solid knowledge of C or C++ when writing these concepts.

## Conclusion

Lessons can optionally have a conclusion. Often, the conclusion is used to inform the reader about what direction the next lessons go in and how it all ties together.

## Tips

* Tips are information that aren't quite important enough to put inside of the concepts section. Do not use <syntaxhighlight> or <syntaxhighlight> tags here.
* Tip 1
* Tip 2
* Thank you for reading.