OpenLLM-France/wikimedia huggingface dataset:
# Climatology/Cyclones

cyclone is a system of winds rotating counterclockwise in the Northern Hemisphere and clockwise in the Southern Hemisphere. around a low pressure center. There are two types of cyclones:
* Tropical Cyclone
* Temperate cyclone or Midlatitude or Extratropical Cyclones

## Tropical Cyclone

A rotating system of clouds and thunderstorms that originated over tropical or sub-tropical areas.The major tropical-cyclone basins include the North Atlantic (including the Caribbean),Eastern Pacific, Western Pacific, North Indian Ocean, Southwest Indian Ocean, Southern Pacific and Australian region.It develop within 5 and 30 degrees of latitude.In the North Atlantic and Caribbean as well as the northeastern Pacific, they called hurricane. In the Northwest Pacific – the most active tropical-cyclone basin in the world is typhoons.but in the Indian Ocean and South Pacific they are called“tropical cyclones” or “cyclones.”

## Temperate cyclone

The cyclonic storms that develop along frontal boundaries in the middle latitudes called “extratropical cyclones”or “midlatitude cyclones”. The polar front when the temperature difference between two air masses is large. These air masses blow past each other in opposite directions.Coriolis Effect deflects winds to the right in the Northern Hemisphere, causing the winds to strike the polar front at an angle.The temperate cyclones occur mostly in winter, late autumn and spring. They are generally associated with rainstorms and cloudy weather.

### Characteristics of Temperate Cyclones
#### Size and Shape

* The temperate cyclones are asymmetrical and shaped like an inverted ‘V’.
* They stretch over 500 to 600 km.
* They may spread over 2500 km over North America (Polar Vortex).
* They have a height of 8 to 11 km.

#### Wind Velocity And Strength

* The wind strength is more in eastern and southern portions, more over North America compared to Europe.
* The wind velocity increases with the approach but decreases after the cyclone has passed.

#### Structure

* The north-western sector is the cold sector and the north-eastern sector is the warm sector.

#### Orientation And Movement

* Jet stream plays a major role in temperate cyclonogeneis.It also influence the path of temperate cyclones.
# C++ Programming/Programming Languages/C++/Code/Keywords/reinterpret cast

The reinterpret_cast keyword is used to simply cast one type bitwise to another. Any pointer or integral type can be cast to any other with reinterpret cast, easily allowing for misuse. For instance, with reinterpret cast one might, unsafely, cast an integer pointer to a string pointer. It should be used to cast between incompatible pointer types.

## Syntax

The reinterpret_cast<> is used for all non portable casting operations. This makes it simpler to find these non portable casts when porting an application from one OS to another.
The reinterpret_cast<T> will change the type of an expression without altering its underlying bit pattern. This is useful to cast pointers of a particular type into a void* and subsequently back to the original type.
# C++ Programming/Programming Languages/C++/Code/Keywords/static/Internal Linkage
## Internal linkage

When used on a free function, a global variable, or a global constant, it specifies internal linkage (as opposed to extern, which specifies external linkage). Internal linkage limits access to the data or function to the current file.
Examples of use outside of any function or class:

## static int apples = 15;

    defines a "static global" variable named apples, with initial value 15, only visible from this translation unit.

## static int bananas;

    defines a "static global" variable named bananas, with initial value 0, only visible from this translation unit.

## int g_fruit;

    defines a global variable named g_fruit, with initial value 0, visible from every translation unit. Such variables are often frowned on as poor style.

## static const int muffins_per_pan=12;

    defines is a variable named muffins_per_pan, visible only in this translation unit. The static keyword is redundant here.

## const int hours_per_day=24;

    defines a variable named hours_per_day, only visible in this translation unit. (This acts the same as static const int hours_per_day=24; ).

## static void f;

    declares that there is a function f taking no arguments and with no return value defined in this translation unit. Such a forward declaration is often used when defining mutually recursive functions.

## static void f{;}

    defines the function f declared above. This function can only be called from other functions and members in this translation unit; it is invisible to other translation units.
# C++ Programming/Programming Languages/C++/Code/Keywords/inline

The inline keyword declares an inline function, the declaration is a (non-binding) request to the compiler that a particular function be subjected to in-line expansion; that is, it suggests that the compiler insert the complete body of the function in every context where that function is used and so it is used to avoid the overhead implied by making a CPU jump from one place in code to another and back again to execute a subroutine, as is done in naive implementations of subroutines.
When a function definition is included in a class/struct definition, it will be an implicit inline, the compiler will try to automatically inline that function. No inline keyword is necessary in this case; it is legal, but redundant, to add the inline keyword in that context, and good style is to omit it.
Example:
Inlining can be an optimization, or a pessimization. It can increase code size (by duplicating the code for a function at multiple call sites) or can decrease it (if the code for the function, after optimization, is less than the size of the code needed to call a non-inlined function). It can increase speed (by allowing for more optimization and by avoiding jumps) or can decrease speed (by increasing code size and hence cache misses).
One important side-effect of inlining is that more code is then accessible to the optimizer.
Marking a function as inline also has an effect on linking: multiple definitions of an inline function are permitted (so long as each is in a different translation unit) so long as they are identical. This allows inline function definitions to appear in header files; defining non-inlined functions in header files is almost always an error (though function templates can also be defined in header files, and often are).
Mainstream C++ compilers like Microsoft Visual C++ and GCC support an option that lets the compilers automatically inline any suitable function, even those that are not marked as inline functions. A compiler is often in a better position than a human to decide whether a particular function should be inlined; in particular, the compiler may not be willing or able to inline many functions that the human asks it to.
Excessive use of inlined functions can greatly increase coupling/dependencies and compilation time, as well as making header files less useful as documentation of interfaces.
# C++ Programming/Programming Languages/C++/Code/Keywords/static/Data Member
#### static data member

The use of the static specifier in a data member, will cause that member to be shared by all instances of the owner class and derived classes. To use static data members you must declare the data member as static and initialize it outside of the class declaration, at file scope.
When used in a class data member, all instantiations of that class share one copy of the variable.
In the example above, the static class variable numFoos is shared between all three instances of the Foo class (f1, f2 and f3) and keeps a count of the number of times that the Foo class has been instantiated.
# C++ Programming/Programming Languages/C++/Code/Keywords/return

The return statement causes execution to jump from the current function to whatever function called the current function. An optional a result (return variable) can be returned. A function may have more than one return statement (but returning the same type).

## Syntax

Within the body of the function, the return statement should NOT return a pointer or a reference that has the address in memory of a local variable that was declared within the function, because as soon as the function exits, all local variables are destroyed and your pointer or reference will be pointing to some place in memory which you no longer own, so you cannot guarantee its contents. If the object to which a pointer refers is destroyed, the pointer is said to be a dangling pointer until it is given a new value; any use of the value of such a pointer is invalid. Having a dangling pointer like that is dangerous; pointers or references to local variables must not be allowed to escape the function in which those local (aka automatic) variables live.
However, within the body of your function, if your pointer or reference has the address in memory of a data type, struct, or class that you dynamically allocated the memory for, using the new operator, then returning said pointer or reference would be reasonable:
In most cases, a better approach in that case would be to return an object such as a smart pointer which could manage the memory; explicit memory management using widely distributed calls to new and delete (or malloc and free) is tedious, verbose and error prone. At the very least, functions which return dynamically allocated resources should be carefully documented. See this book's section on memory management for more details.
In this case the SOMETYPE object pointed to by the returned pointer may not be modified, and if SOMETYPE is a class then only const member functions may be called on the SOMETYPE object.
If such a const return value is a pointer or a reference to a class then we cannot call non-const methods on that pointer or reference since that would break our agreement not to change it.
# C++ Programming/Programming Languages/C++/Code/Keywords/sizeof

The sizeof keyword refers to an operator that works at compile time to report on the size of the storage occupied by a type of the argument passed to it (equivalently, by a variable of that type). That size is returned as a multiple of the size of a char, which on many personal computers is 1 byte (or 8 bits). The number of bits in a char is stored in the CHAR_BIT constant defined in the <climits> header file. This is one of the operators for which operator overloading is not allowed.
For example, the following code uses sizeof to display the sizes of a number of variables:
On most machines (considering the size of char), the above code displays this output:
It is also important to note that the sizes of various types of variables can change depending on what system you're on. Check the data types page for more information.
Syntactically, sizeof appears like a function call when taking the size of a type, but may be used without parentheses when taking the size of a variable type (e.g. sizeof(int)). Parentheses can be left out if the argument is a variable or array (e.g. sizeof x, sizeof myArray). Style guidelines vary on whether using the latitude to omit parentheses in the latter case is desirable.
Consider the next example:
Since sizeof does not evaluate anything at run time, the func function is never called. All information needed is the return type of the function, the first sizeof will return the size of a short (the return type of the function) as the value 2 (in size_t, an integral type defined in the include file STDDEF.H) and the second sizeof will return 4 (the size of size_t returned by the first sizeof).
sizeof measures the size of an object in the simple sense of a contiguous area of storage; for types which include pointers to other storage, the indirect storage is not included in the value returned by sizeof. A common mistake made by programming newcomers working with C++ is to try to use sizeof to determine the length of a string; the std::strlen or std::string::length functions are more appropriate for that task.
sizeof has also found new life in recent years in template meta programming, where the fact that it can turn types into numbers, albeit in a primitive manner, is often useful, given that the template metaprogramming environment typically does most of its calculations with types.
# C++ Programming/Programming Languages/C++/Code/Keywords/namespace

The namespace keyword allows you to create a new scope. The name is optional, and can be omitted to create an unnamed namespace. Once you create a namespace, you'll have to refer to it explicitly or use the using keyword. A namespace is defined with a namespace block.

## Syntax

In many programming languages, a namespace is a context for identifiers. C++ can handle multiple namespaces within the language. By using namespace (or the using namespace keyword), one is offered a clean way to aggregate code under a shared label, so as to prevent naming collisions or just to ease recall and use of very specific scopes. There are other "name spaces" besides "namespaces"; this can be confusing.
Name spaces (note the space there), as we will see, go beyond the concept of scope by providing an easy way to differentiate what is being called/used. As we will see, classes are also name spaces, but they are not namespaces.

## Example

Within this block, identifiers can be used exactly as they are declared. Outside of this block, the namespace specifier must be prefixed (that is, it must be qualified). For example, outside of namespace foo, bar must be written foo::bar.
C++ includes another construct which makes this verbosity unnecessary. By adding the line using namespace foo; to a piece of code, the prefix foo:: is no longer needed.

##### unnamed namespace

A namespace without a name is called an unnamed namespace. For such a namespace, a unique name will be generated for each translation unit. It is not possible to apply the using keyword to unnamed namespaces, so an unnamed namespace works as if the using keyword has been applied to it.

###### Syntax
##### namespace alias

You can create new names (aliases) for namespaces, including nested namespaces.
# C++ Programming/Programming Languages/C++/Code/Keywords/register

The register keyword is a request to the compiler that the specified variable is to be stored in a register of the processor instead of memory as a way to gain speed, mostly because it will be heavily used. The compiler may ignore the request.
The keyword fell out of common use when compilers became better at most code optimizations than humans. Any valid program that uses the keyword will be semantically identical to one without it, unless they appear in a stringized macro (or similar context), where it can be useful to ensure that improper usage of the macro will cause a compile-time error. This keywords relates closely to auto.
# C++ Programming/Programming Languages/C++/Code/Keywords/static/Member Function
##### static member function

Member functions or variables declared static are shared between all instances of an object type. Meaning that only one copy of the member function or variable does exists for any object type.

###### member functions callable without an object

When used in a class function member, the function does not take an instantiation as an implicit this parameter, instead behaving like a free function. This means that static class functions can be called without creating instances of the class:

##### Named constructors

Named constructors are a good example of using static member functions. Named constructors is the name given to functions used to create an object of a class without (directly) using its constructors. This might be used for the following:
* To circumvent the restriction that constructors can be overloaded only if their signatures differ.
* Making the class non-inheritable by making the constructors private.
* Preventing stack allocation by making constructors private
Declare a static member function that uses a private constructor to create the object and return it. (It could also return a pointer or a reference but this complication seems useless, and turns this into the factory pattern rather than a conventional named constructor.)
Here's an example for a class that stores a temperature that can be specified in any of the different temperature scales.
# Core War/Imp

The Imp is the simplest program that exists in Core War, consisting of one instruction:
MOV 0,1
The imp places focus on one task: survival. By continuously copying the current instruction to the next cell to be executed, it keeps it self alive simply by never encountering a DAT cell. If left untouched, it will eventually fill the entire core with the same instruction, causing other programs to become imps as well. However, under the rules of Core War, the Imp will never win a match - only draw it.
Since the Imp is a simple program, it can be countered. The basic method is to place either an "Imp gate" or "Alarm" that detects incoming movement. When it tripped, a nearby region is continuously bombed with a data instruction to prevent it from continuing.
# Conworld/Fiction
## Introduction

This book is intended to be a guide for prospective fantasy/sci-fi novelists. I have given a broad outline of the intended structure of this book. Please feel free to edit and contribute wholeheartedly.
There are lots of wannabe writers out there — J.K. Rowlings or J.R.R. Tolkiens in the making. I feel there is a story (or maybe more than one) hidden in each one of us. If only we can bring it / them out, and package it well, it would be a bestseller. This book will help you with that process.
# Core War

Core War is a programming game, based around a variation of assembly language known as Redcode. In a standard game of Core War, two or more programs are placed in a circular region of memory with the objective of causing the other program to fail.
The Redcode language was first described in a 1984 publication, Core War Guidelines, and was since updated with new instructions in a draft released in 1994.

## Table of Contents

* Redcode
* Imp
* Scanner
* Bomber
* Replicator
* Dwarf
# Core War/Dwarf

Dwarf is a simple yet classic warrior. This program "bombs" the core at regularly space locations with DATs, at the same time making sure it doesn't hit itself.
# Cornish/Cornish alphabet
## Cornish alphabet

A a
B b
Ch ch
D d
E e
F f
G g
H h
I i
J j
K k
L l
M m
N n
O o
P p
R r
S s
T t
U u
V v
W w
Y y
# C++ Programming/Programming Languages/Comparisons/Managed C++
#### Managed C++ (C++/CLI)

Managed C++ is a shorthand notation for Managed Extensions for C++, which are part of the .NET framework from Microsoft. This extension of the C++ language was developed to add functionality like automatic garbage collection and heap management, automatic initialization of arrays, and support for multidimensional arrays, simplifying all those details of programming in C++ that would otherwise have to be done by the programmer.
Managed C++ is not compiled to machine code. Rather, it is compiled to Common Intermediate Language, which is an object-oriented machine language and was formerly known as MSIL.
# C Programming/wctype.h/iswlower

It is a standard library function of C language. This function is used to check if entered wide character is lower case or not. a main difference between iswlower and islower is that islower returns nonzero value only if entered character is in the set (a to z), but an additional concept in iswlower is, it returns non zero value only when entered character is in between(a to z) and it is a wide character It comes under standard library function wctype.h.
Syntax
The iswlower function is designed to return non-zero(which is considered as true value) value if wc is a wide character and belongs to (a to z) And again it returns zero representing false value if it does not satisfy above condition
Parameters required a wide character like wc in above example Example
The above code shows us how this function can be used.Thus if entered value is wide character and of lower case and do not contain any symbols, it returns a non zero value.Else it returns a zero. References
* ↑ Definition
* ↑ Iswlower manual page
* ↑ Return value of function
# C Sharp Programming/Basics
## Basics
### Naming conventions

    Quickly describes the generally accepted naming conventions for C#.

### Basic syntax

    Describes the basics in how the applications you write will be interpreted.

### Variables

    The entities used to store data of various shapes.

### Operators

    Summarizes the operators, such as the '+' in addition, available in C#.

### Data structures

    Enumerations, structs, and more.

### Control statements

    Loops, conditions, and more. How the program flow is controlled.

### Exceptions

    Responding to errors that can occur.
# C Sharp Programming/Casting
## Casting

Casting is a way to convert values from one type to another. Mainly, two types of casting exist, Implicit casting and Explicit casting. Boxing occurs when a value type is cast to an object, or reference type.

### Implicit casting

Implicit casting is the way values are cast automatically by the compiler. This happens if and only if no loss of information occurs. Examples can be seen when converting data from smaller integral types to larger types, or derived types to the base type.
Also, this example could work.

### Explicit casting

This type of casting has to be specified by the developer, as a loss of data is possible.

### Best practices

For reference types, direct casting is discouraged unless the object is known to never throw an exception. A common best practice is to use the as keyword.
!Important: Using "as" keyword is the best practice only in case you are doing null check after the cast and then handle exception situation. In other cases better use explicit cast then debug a NullReferenceException