OpenLLM-France/wikimedia huggingface dataset:
# Chemical Sciences: A Manual for CSIR-UGC National Eligibility Test for Lectureship and JRF/Retention factor

In chromatography, the retardation factor (also known as retention factor) describes the ratio of time spent in the stationary phase relative to time spent in the mobile phase.

## Planar chromatography

The retardation factor in planar chromatography, R$_f$ can be mathematically described by the following ratio:
    $\ R_{f}={\frac {\mbox{migration distance of substance}}{\mbox{migration distance of solvent front}}}$
For example, if particular substance in an unknown mixture travels 2.5 cm and the solvent front travels 5.0 cm, the retention factor would be 0.5. An R$_f$ value will always be in the range 0 to 1: if the substance moves at all, it moves along the direction the solvent ("mobile phase") does less, but cannot move further than the solvent does. R$_f$ values are only useful if they are between these two extremes. One can choose a mobile phase with different characteristics (especially polarity) in order to control how far the substance being investigated migrates. An R$_f$ value is characteristic for any given compound (provided that the same stationary and mobile phases are used).
It can provide corroborative evidence as to the identity of a compound. If the identity of a compound is suspected but not yet proven, an authentic sample of the compound, or standard, is spotted and run on a TLC plate side by side (or on top of each other) with the compound in question. Note that this identity check must be performed on a single plate, because it is difficult to duplicate all the factors which influence R$_f$ exactly from experiment to experiment.

## Column chromatography

In column chromatography the retardation factor, R, is the fraction of the sample in the mobile phase at equilibrium. It is expressed as
    $\ R_{f}={\frac {1}{k+1}}$
where k is the retention factor.

## References

* ↑ Ettre, L. S. (1993), "Nomenclature for chromatography (IUPAC Recommendations 1993)", Pure and Applied Chemistry, 65: 819, doi:10.1351/pac199365040819
* ↑ IUPAC Gold Book - retardation factor in planar chromatography
* ↑ IUPAC Gold Book - retardation factor in column chromatography
# Chemical Sciences: A Manual for CSIR-UGC National Eligibility Test for Lectureship and JRF/Relaxometry

Relaxometry refers to the study and/or measurement of relaxation variables in Nuclear Magnetic Resonance and Magnetic Resonance Imaging.
# English-Hanzi/Lusaka

Lusaka is the capital of Zambia. It is in the east of Zambia. Its population is 2.5 million.
Lusaka是Zambia的首都。它是在Zambia的东部。它的人口是250万。
# English-Hanzi/Luxembourg

Luxembourg is a landlocked country in the west of Europe.
卢森堡是欧洲西部的内陆国家。
# English-Hanzi/London

London is the capital and largest city of England and the United Kingdom. Located on the Thames in southeast England, 80 kilometers from the North Sea estuary, London has been a major settlement for more than 2000 years.
伦敦是英格兰和英国的首都和最大城市。伦敦位于英格兰东南部的泰晤士河上，距北海河口80千米，是2000多年以来的主要定居点。
# English-Hanzi/Longevity

Longevity is a long living time.
长寿是一个长的活着的时间。
# English-Hanzi/Lung

The lung is an organ in many vertebrates (animals having a spine, or backbone). It gives blood oxygen from the air, and takes away carbon dioxide. Most vertebrates that have lungs have two of them.
肺 是 许多 脊椎动物（具有 脊椎 或 脊骨 的 动物）的 器官。它 把 空气 的 氧气 给 血液，并 带走 二氧化碳。大多数 有 肺 的 脊椎动物 有 两个 肺。
# English-Hanzi/Living

A living is a particular way of life.
生活是生命的特定方式。
# English-Hanzi/Living thing

Living thing is a thing that has life, such as an animal or a plant.
生物 是 有 生命 的 东西，如 动物 或 植物。
# English-Hanzi/Location

Location is the position of something.
方位是某事物的位置。
# English-Hanzi/Literature

Literature, most generically, is any body of written works.
一般来说，文学是任何书面作品。
# English-Hanzi/Liver

Liver is an organ in the body. It cleans the blood and produces bile. The bile helps to digest fats.
肝脏 是 体内的 器官。它清理血液并产生胆汁。胆汁帮助消化脂肪。
# D (The Programming Language)/d2/Types and Declaration

| | 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 |

# Lesson 2: Types and Declarations

In this lesson, you will learn how to declare and use variables.

## Concepts

In this lesson we see the declaration and assignment of variables.

### Declaration Syntax

The syntax of declaring variables is type identifier; You can also assign a value at the same time. type identifier = value;

### Declaring Multiple Variables in the Same Line

D allows you to declare multiple variables of the same type in the same line. If you write:
i, j, and k are all declared as ints but only k is assigned 30. It is the same as:

### Implicit Type Inference

If the declaration starts with auto, then the compiler will automatically infer the type of the declared variable. In fact, it doesn't have to be auto. Any storage class would work. Storage classes are built-in D constructs such as auto or immutable. This code declares an unchangeable variable a with a value of 3. The compiler figures out that the type is int.
You will learn much more about storage classes later.

### More about writeln

writeln is a very useful function for writing to stdout. One thing is special about writeln: it can take variables of any type. It can also take an unlimited amount of arguments. For example:
Don't worry, there is nothing magical about writeln. All the functions in the write family are implemented (in 100% valid D code) in stdio.d, which is in the Phobos standard library.

## Tips

* Syntax like this: int i, j, k = 1, 2, 3; is not allowed.
* Syntax like this: int, string i, k; is also not allowed.
* auto is not a type. You cannot do this: auto i; because there's no way the compiler can infer the type of i. auto is merely a storage class, which tells the compiler to infer the type from the value that you assign it to in that same line.
# D Programming/Arrays

To be completed.
* Arrays
** Pointers to data
** Static arrays
** Dynamic arrays
** Associative arrays
* Array Declarations
** Prefix Array Declaration
** Postfix Array Declaration
* Array Slicing
* Array Copying
* Array Setting
* Array Concatenation
* Array Operations
* Rectangular Arrays
* Array Length
** Static Array Length
** Dynamic Array Length
* Array Properties
** Static array properties
** Dynamic array properties
** Associative array properties
* Array Initialization
** Default Initialization
** Void Initialization
** Static Initialization
* Implicit Conversions
# D Programming/DUI

To be completed.
Duit (formerly DUI; now GtkD) is a D language graphical user interface wrapping (or binding) GTK+ graphical toolkit
GtkD is released under the LGPL license.

## GtkD Code Example

Its main website is:
* http://gtkd.org/
Older out-of-date websites are
* http://www.dsource.org/projects/gtkd
* http://dui.sourceforge.net/
# D (The Programming Language)/d2/Types, Continued

| | 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: | Notes for Beginners |

# Lesson 4: Types, Continued

In this lesson, you will see all the other types. Many of these types will be familiar, but be aware that there are many differences between C and D in their built-in types.

## Concepts
### Assertion

Using assert allows you to check if a certain expression is true or not. == means is equal to (do not confuse this with =, which is for assigning variables). The checking is done at runtime, and if whatever is inside the parentheses evaluates to false, then an Assertion Error will happen and the program will terminate.

### Properties and Default Initializers

Types have default initializers. That means, if they are declared but not assigned any value, they will be equal to something by default.
Properties can be queried from any type or object. When a property of a type or object is queried, a dot goes between the property name and the identifier.
The init property of any type contains the value that objects of such a type are initialized to by default. For numeral types, you can find the min and max values with their respective properties: type.min and type.max. You can also find the size of a type in memory: type.sizeof. If you want to declare but don't want to initialize something, you can do this:
Then, i is uninitialized; its value is undefined garbage.

### A Bit of D's Lexical Grammar

D allows you to write numbers in a few useful bases and forms. So, if you wanted to add the hexadecimal number of A4 to one million three hundred thirteen thousand six hundred thirty-seven and the binary number of 1011010101, you can write this:
Note that underscores in the middle of numbers are completely ignored. They are 100% optional and are useful for formatting long numbers.

## Tips

* You may look through this reference for more information about D's lexical grammar. Soon a lesson will be written that contains up-to-date information on the subject.
# D Programming/Attributes

To be completed.
* Linkage Attribute
* Align Attribute
* Deprecated Attribute
* Protection Attribute
* Const Attribute
* Override Attribute
* Static Attribute
* Auto Attribute
* Scope Attribute
* Abstract Attribute
# D (The Programming Language)/d2/Type Conversion

| | 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 |

# Lesson 5: Type Conversion

In this lesson, you will learn how the types of variables can be implicitly and explicitly converted.

## Concepts
### Implicit Integral Conversions

An object of an integral type can be converted to another object of an integral type as long as the destination type is wider than the original type. These conversions are implicit:
bool ⇒ int byte ⇒ int ubyte ⇒ int short ⇒ int ushort ⇒ int char ⇒ int wchar ⇒ int dchar ⇒ uint

### Explicit Conversions

Casting is a way to tell the compiler to try to force an object to change type. In D, you do this by writing cast(type).

## Tips

* You cannot convert an integral value to a string (or the other way around) with a cast. There is a library function which you will learn later for that.
# C Sharp Programming/Control/Form

The following code example creates a new instance of a Form and calls the ShowDialog method to display the form as a dialog box. The example sets the FormBorderStyle, AcceptButton, CancelButton, MinimizeBox, MaximizeBox, and StartPosition properties to change the appearance and functionality of the form to a dialog box. The example also uses the Add method of the form's Controls collection to add two Button controls. The example uses the HelpButton property to display a help button in the caption bar of the dialog box.
# C Sharp Programming/Design Patterns

Design Patterns are common building blocks designed to solve everyday software issues. Some basic terms and example of such patterns include what we see in everyday life. The design patterns are broadly classified into 3 types:
1. Creational: These patterns are designed for class instantiation. They can be either class-creation patterns or object-creational patterns.
2. Structural: These patterns are designed with regard to a class's structure and composition. The main goal of most of these patterns is to increase the functionality of the class(es) involved, without changing much of its composition.
3. Behavioral: These patterns are designed depending on how one class communicates with others.

## Factory Pattern

The factory pattern is a method call that uses abstract classes and its implementations, to give the developer the most appropriate class for the job.
Lets create a couple of classes first to demonstrate how this can be used. Here we take the example of a bank system.
This Transaction class is incomplete, as there are many types of transactions:
* Opening
* Credits
* Withdrawals
* Transfers
* Penalty
* Correction
* Closure
For this example, we will take credit and withdrawal portions, and create classes for them.
The problem is that these classes do much of the same thing, so it would be helpful, if we could just give it the values, and it will work out what class type we require. Therefore, we could come up with some ways to distinguish between the different types of transactions:
* Positive values indicate a credit.
* Negative values indicate a withdrawal.
* Having two account numbers and a positive value would indicate a transfer.
* Having two account numbers and a negative value would indicate a closure.
* etc.
So, let us write a new class with a static method that will do this logic for us, ending the name Factory:
Now, you can use this class to do all of the logic and processing, and be assured that the type you are returned is correct.

## Singleton

The singleton pattern instantiates only 1 object, and reuses this object for the entire lifetime of the process. This is useful, if you wish the object to maintain state, or if it takes lots of resources to set the object up. Below is a basic implementation:
The Singleton property will expose the same instance to all callers. Upon the first call, the object is initialised and on subsequent calls this is used.
Examples of this pattern include:
* ConfigurationSettings (Generic settings reader)
* HttpApplication (Application object in ASP .NET)
* HttpCacheUtility (Cache object in ASP .NET)
* HttpServerUtility (Server object in ASP .NET)
# C Sharp Programming/Encapsulation

Encapsulation is depriving the user of a class of information the user does not need, and preventing the user from manipulating objects in ways not intended by the designer.
A class element having public protection level is accessible to all code anywhere in the program. These methods and properties represent the operations allowed on the class to outside users.
Methods, data members (and other elements) with private protection level represent the internal state of the class (for variables), and operations that are not allowed to outside users. The private protection level is default for all class and struct members. This means that if you do not specify the protection modifier of a method or variable, it is considered as private by the compiler.
For example:
In this example, the public method the Frog class exposes are JumpLow and JumpHigh. Internally, they are implemented using the private Jump function that can jump to any height. This operation is not visible to an outside user, so they cannot make the frog jump 100 meters, only 10 or 1. The Jump private method is implemented by changing the value of a private data member _height, which is also not visible to an outside user. Some private data members are made visible by Properties.

## Protection Levels
### Private

Private members are only accessible within the class itself. A method in another class, even a class derived from the class with private members cannot access the members. If no protection level is specified, class members will default to private.

### Protected

Protected members can be accessed by the class itself and by any class derived from that class.

### Public

Public members can be accessed by any method in any class.
It is good programming practice not to expose member variables to the outside, unless it is necessary. This is true especially for fields that should only be accessible over accessor and mutator methods (getters and setters). Exceptions are member variables that are constant.

### Internal

Internal members are accessible only in the same assembly and invisible outside it. If no protection level is specified for top level classes, they are treated as internal, and can only be accessed within the assembly.

### Protected Internal

Protected internal members are accessible from any class derived from that class, or any class within the same assembly. So, it means protected or internal.
Here, an example:

## References

* ↑ Joe Mayo (2007-04-27). "Type Member Access Modifiers". http://www.csharp-station.com/: C# STATION. Retrieved 2011-08-12. Either code from derived type or code in the same assembly. Combination of protected OR internal. {{cite web}}: External link in |location= (help)
# C Sharp Programming/Encapsulation2
## Properties

Properties encapsulate the control of an object's state.
For example, the following Customer class encapsulates a customer's name:
The above Name property has three important parts: the declaration, the set accessor, and the get accessor.

### Property declaration

The access modifier determines who can manipulate this data. Properties can be scoped as public, private, protected, or internal.
The type determines what kind of type it can accept or return.
The property name declares the name used to access the property.

### Accessors

Setting the Name property for the Customer class is done through the set accessor, defined using the set keyword.
Similarly, the get keyword creates a get accessor to encapsulate the logic to perform when clients retrieve the value of the property.
Above, the simple set accessor and get accessor make property behave very much like a simple field. That may not be the desired behavior. If not, we can add logic to check the value passed into the set accessor:
Above, if the client requests to set the value to null, the set accessor does not change the field. Also, if the _name field hasn't yet been set, the get accessor returns a default value.

### Using properties

Clients can use property much like they use simple class fields:
The above code prints the following:

## Accessibility levels

The various accessibility levels C# provides are, from most public to least:
| Accessibility | Usage restriction |
| public | None. |
| internal | The containing assembly. |
| protected internal | The containing assembly or types derived from the containing class. |
| protected | The containing class or types derived from it. |
| private | The containing type. |
If no accessibility level is specified, a default level is used. They are:
| Type | Default accessibility |
| namespace | public (and the only allowed) |
| enum | public |
| class | private |
| interface | public |
| struct | private |
| (others) | internal |
Note: namespace-level elements (e.g. a class declared directly under a namespace) cannot be declared as stricter than internal.
# C Sharp Programming/Extension methods

Extension methods are a feature new to C# 3.0 and allow you to extend existing types with your own methods. While they are static, they are used as if they are normal methods of the class being extended. Thus, new functionality can be added to an existing class without a need to change or recompile the class itself. However, since they are not directly part of the class, extensions cannot access private or protected methods, properties, or fields.
Extension methods should be created inside a static class. They themselves should be static and should contain at least one parameter, the first preceded by the this keyword:
The type of the first parameter (in this case List<T>) specifies the type with which the extension method will be available. You can now call the extension method like this:
Here is the rest of the program:
Note that extension methods can take parameters simply by defining more than one parameter without the this keyword.
# C Sharp Programming/Data structures

There are various ways of grouping sets of data together in C#.

## Enumerations

An enumeration is a data type that enumerates a set of items by assigning to each of them an identifier (a name), while exposing an underlying base type for ordering the elements of the enumeration. The underlying type is int by default, but can be any one of the integral types except for char.
Enumerations are declared as follows:
The elements in the above enumeration are then available as constants:
If no explicit values are assigned to the enumerated items as the example above, the first element has the value 0, and the successive values are assigned to each subsequent element. However, specific values from the underlying integral type can be assigned to any of the enumerated elements (note that the variable must be type cast in order to access the base type):
The underlying values of enumerated elements may go unused when the purpose of an enumeration is simply to group a set of items together, e.g., to represent a nation, state, or geographical territory in a more meaningful way than an integer could. Rather than define a group of logically related constants, it is often more readable to use an enumeration.
It may be desirable to create an enumeration with a base type other than int. To do so, specify any integral type besides char as with base class extension syntax after the name of the enumeration, as follows:
The enumeration type is also helpful, if you need to output the value. By calling the .ToString method on the enumeration, will output the enumerations name (e.g. CardSuit.Hearts.ToString will output "Hearts").

## Structs

Structures (keyword struct) are light-weight objects. They are mostly used when only a data container is required for a collection of value type variables. Structs are similar to classes in that they can have constructors, methods, and even implement interfaces, but there are important differences.
* Structs are value types while classes are reference types, which means they behave differently when passed into methods as parameters.
* Structs cannot support inheritance. While structs may appear to be limited with their use, they require less memory and can be less expensive, if used in the proper way.
* Structs always have a default constructor, even if you don't want one. Classes allow you to hide the constructor away by using the "private" modifier, whereas structures must have one.
A struct can, for example, be declared like this:
The Person struct can then be used like this:
It is also possible to provide constructors to structs to make it easier to initialize them:
There is also an alternative syntax for initializing structs:
Structs are really only used for performance reasons or, if you intend to reference it by value. Structs work best when holding a total equal to or less than 16 bytes of data. If in doubt, use classes.

## Arrays

Arrays represent a set of items all belonging to the same type. The declaration itself may use a variable or a constant to define the length of the array. However, an array has a set length and it cannot be changed after declaration.
# Data Mining Algorithms In R/Packages/optimsimplex
## Description

Provides a building block for optimization algorithms based on a simplex. The optimsimplex package may be used in the following optimization methods: the simplex method of Spendley et al., the method of Nelder and Mead, Box’s algorithm for constrained optimization, the multi-dimensional search by Torczon, etc...

## Requirements

optimbase

## General API

* optimsimplex-package
* Function evaluations
* Get functions
* optimsimplex.destroy
* optimsimplex.log
* optimsimplex.new
* optimsimplex.print
* optimsimplex.reflect
* optimsimplex.shrink
* optimsimplex.utils
* Set functions
* Simplex gradient