OpenLLM-France/wikimedia huggingface dataset:
# C Sharp Programming/Keywords/where

The where keyword has two different meanings:
* It is used to specify one or more constraints on generic type parameters.
* With LINQ, it is used to query a data source and select or filter elements to return.
C# Keywords :
| abstract | as | base | bool | break |
| byte | case | catch | char | checked |
| class | const | continue | decimal | default |
| delegate | do | double | else | enum |
| event | explicit | extern | false | finally |
| fixed | float | for | foreach | goto |
| if | implicit | in | int | interface |
| internal | is | lock | long | namespace |
| new | null | object | operator | out |
| override | params | private | protected | public |
| readonly | ref | return | sbyte | sealed |
| short | sizeof | stackalloc | static | string |
| struct | switch | this | throw | true |
| try | typeof | uint | ulong | unchecked |
| unsafe | ushort | using | var | virtual |
| void | volatile | while |
Special C# Identifiers (Contextual Keywords) :
| add | alias | async | await | dynamic |
| get | global | nameof | partial | remove |
| set | value | when | where | yield |
Contextual Keywords (Used in Queries) :
| ascending | by | descending | equals | from |
| group | in | into | join | let |
| on | orderby | select | where |
# Assemblies and Manifests

A Microsoft dotNET Assembly is an exe or dll. Assemblies are the basic unit of deployment. An assembly consists of 4 components:
* Assembly Metadata (also known as Assembly Manifest)
** This is sort of like a packaging list of everything that is required for this assembly to work. A manifest contains:
*** Version requirements
*** Security Identity
*** Scope of assembly
* Type Metadata
* IL (Intermediate Language)
* Resources
The C Sharp Programming/NET assembly module or this section of C Sharp Programming is a stub. You can help Wikibooks by expanding it.
# C Sharp Programming/Namespaces

Namespaces are used to provide a "named space" in which your application resides. They're used especially to provide the C# compiler a context for all the named information in your program, such as variable names. Without namespaces, for example, you wouldn't be able to make a class named Console, as .NET already uses one in its System namespace. The purpose of namespaces is to solve this problem, and release thousands of names defined in the .NET Framework for your applications to use, along with making it so your application doesn't occupy names for other applications, if your application is intended to be used in conjunction with another. So namespaces exist to resolve ambiguities a compiler wouldn't otherwise be able to do.
Namespaces are easily defined in this way:
There is an entire hierarchy of namespaces provided to you by the .NET Framework, with the System namespace usually being by far the most commonly seen one. Data in a namespace is referred to by using the . operator, such as:
This will call the WriteLine method that is a member of the Console class within the System namespace.
By using the using keyword, you explicitly tell the compiler that you'll be using a certain namespace in your program. Since the compiler would then know that, it no longer requires you to type the namespace name(s) for such declared namespaces, as you told it which namespaces it should look in, if it couldn't find the data in your application.
So one can then type like this:
Namespaces are global, so a namespace in one C# source file, and another with the same name in another source file, will cause the compiler to treat the different named information in these two source files as residing in the same namespace.

## Nested namespaces

Normally, your entire application resides under its own special namespace, often named after your application or project name. Sometimes, companies with an entire product series decide to use nested namespaces though, where the "root" namespace can share the name of the company, and the nested namespaces the respective project names. This can be especially convenient, if you're a developer who has made a library with some usual functionality that can be shared across programs. If both the library and your program shared a parent namespace, that one would then not have to be explicitly declared with the using keyword, and still not have to be completely typed out. If your code was open for others to use, third party developers that may use your code would additionally then see that the same company had developed the library and the program. The developer of the library and program would finally also separate all the named information in their product source codes, for fewer headaches especially, if common names are used.
To make your application reside in a nested namespace, you can show this in two ways. Either like this:
... or like this:
Both methods are accepted, and are identical in what they do.
# Digital Signal Processing/Discrete Cosine Transform
## Discrete Cosine Transform in dsp

The Discrete Cosine Transform (DCT) is a transform that is very common when encoding video and audio tracks on computers. Many "codecs" for movies rely on DCT concepts for compressing and encoding video files. The DCT can also be used to analyze the spectral components of images as well. The DCT is very similar to the DFT, except the output values are all real numbers, and the output vector is approximately twice as long as the DFT output. It expresses a sequence of finite data points in terms of sum of cosine functions.

## Uses of DCT

The JPEG process is a widely used form of lossy image compression that centers around the Discrete Cosine Transform. The DCT works by separating images into parts of differing frequencies.
# Digital Signal Processing/Discrete-Time Fourier Transform

The Discrete-Time Fourier Transform (DTFT) is the cornerstone of all DSP, because it tells us that from a discrete set of samples of a continuous function, we can create a periodic summation of that function's Fourier transform. At the very least, we can recreate an approximation of the actual transform and its inverse, the original continuous function. And under certain idealized conditions, we can recreate the original function with no distortion at all. That famous theorem is called the Nyquist-Shannon sampling theorem.

## DTFT

[DTFT]
    $X(e^{j\omega })=\sum _{n=-\infty }^{\infty }x[n]e^{-j\omega n}$
The resulting function, $X(e^{j\omega })$ is a continuous function that is interesting for analysis. It can be used in programs, such as Matlab, to design filters and obtain the corresponding time-domain filter values.

## DTFT Convolution Theorem

Like the CTFT, the DTFT has a convolution theorem associated with it. However, since the DTFT results in discrete-frequency values, the convolution theorem needs to be modified as such:

### DTFT Convolution Theorem

    Multiplication in the continuous time domain becomes discrete convolution in the discrete frequency domain. Convolution in the continuous time domain becomes multiplication in the discrete frequency domain.

## Energy

It is sometimes helpful to calculate the amount of energy that exists in a certain set. These calculations are based off the assumption that the different values in a set are voltage values, however this doesn't necessarily need to be the case to employ these operations.
We can show that the energy of a given set can be given by the following equation:
    ${\mathcal {E}}_{x}=\sum _{n=-\infty }^{\infty }\left|x[n]\right|^{2}$

## Energy in Frequency

Likewise, we can make a formula that represents the power in the continuous-frequency output of the DTFT:
    ${\mathcal {E}}_{x}={\frac {1}{2\pi }}\int _{-\infty }^{\infty }\left|X(e^{j\omega })\right|^{2}d\omega$

## Parseval's Theorem

Parseval's theorem states that the energy amounts found in the time domain must be equal to the energy amounts found in the frequency domain:
    $\sum _{n=-\infty }^{\infty }\left|x[n]\right|^{2}={\frac {1}{2\pi }}\int _{-\pi }^{\pi }\left|X(e^{j\omega })\right|^{2}d\omega$

## Power Density Spectrum

We can define the power density spectrum of the continuous-time frequency output of the DTFT as follows:
    $S_{xx}(e^{j\omega })=\left|X(e^{j\omega })\right|^{2}$
The area under the power density spectrum curve is the total energy of the signal.
# Digital Signal Processing/DSP Programming

Digital Signal Processing units, on first glance, are very similar to other programmable microprocessors, microcontrollers, and FPGAs. However, DSP chips frequently have certain features and limitations involved that other categories of chips don't have. This chapter will attempt to explain, in broad language-neutral terms, some of the issues involved with DSP programming.

## Saturation Arithmetic

Intel-compatible microprocessors, something that most programmers are familiar with, have several features that people have come to expect from programmable chips. In particular, Intel-compatible chips have an arithmetic mode known as "Roll-Over Arithmetic", also called modular arithmetic. Let's say that we have the integer number 250 (decimal) stored in a byte-sized register. If we add 10 to that number, the processor will overflow, and will roll-over the answer, giving us the answer 4. However, DSP chips frequently do not roll-over, and instead saturate to the maximum value.
Let's say we are processing a grayscale image. This image has byte-sized integer values of white/black value as such: Pure white is 255, and pure black is 0. Now, let's say we want to "brighten" every pixel by 10 points, to improve visibility. So we create a loop, and we go through each pixel in the image, adding 10 to the value at any particular point. But what happens if we add 10 to a pixel that is already pure white? In a regular Intel-compatible chip, the value 255 + 10 = 9. In effect, if we make the white pixels brighter, we are turning them black! now, to avoid this, DSP chips saturate, and will go up to the highest value (255), and won't roll over. So, on a DSP chip, white can't get any whiter. Here are some examples (using unsigned bytes):
    $255+10=255$
    $0-10=0$

## Multiply and Accumulate (MAC)

In difference equations, we have seen that multiply and addition operations are the most common. Let's look at a general example:
    $Ax_{n}+Bx_{n-1}+Cx_{n-2}+Dx_{n-3}+...$
Now, we notice that each element in this equation is multiplied by a coefficient, and added to the total. DSP engineers have noticed this pattern, and have optimized DSP chips to be able multiply and add very quickly (at the expense of other operations missing or slow). In fact, many DSP chips will have instructions known as multiply and accumulate, which will perform both operations simultaneously, much quicker than a normal processor could do.
# Digital Signal Processing/Continuous-Time Fourier Transform

The Continuous-Time Fourier Transform (CTFT) is the version of the fourier transform that is most common, and is the only fourier transform so far discussed in EE wikibooks such as Signals and Systems, or Communication Systems. This transform is mentioned here as a stepping stone for further discussions of the Discrete-Time Fourier Transform (DTFT), and the Discrete Fourier Transform (DFT). The CTFT itself is not useful in digital signal processing applications, so it will not appear much in the rest of this book

## CTFT Definition

The CTFT is defined as such:
[CTFT]
    ${\mathcal {F}}(\omega )=\int f(t)e^{-j\omega t}dt$

## Convolution Theorem

Multiplication in the time domain becomes convolution in the frequency domain. Convolution in the time domain becomes multiplication in the frequency domain. This is an example of the property of duality. The convolution theorem is a very important theorem, and every transform has a version of it, so it is a good idea to become familiar with it now (if you aren't previously familiar with it).

## Further reading

For more information about the Fourier Transform, see Signals and Systems.
# Digital Signal Processing/Digital Systems
## Systems Introduction

Digital systems can be conceptually very difficult to understand at first. Let's start out with a block diagram:
We have a digital system, h[n], that is going to alter the input (x[n]) in some way, and produce an output (y[n]). At each integer value for discrete time, n, we will feed 1 value of x[n] into the machine, turn the crank, and create 1 output value for y[n].

## Basic Example

Let's say that h[n] is a multiplier circuit with a value of 5. Every input value is multiplied by 5, and that is the output. In other words, we can show our difference calculus equation as such:
    $y\left[n\right]=5x\left[n\right]$
now, for each successive value for n, we can calculate our output value, y[n]. As an example, using the above difference equation, we can feed in an experimental input:
And by multiplying each data item by 5, we get the following result:

## Properties of Digital systems

A loose definition of a causal system is a system in which the output does not change before the input. All real systems are causal, and it is impossible to create a system that is not causal.

## Circuit Symbols

* wires
* pickoff nodes
* adders
* multipliers

## Physically Realizeable Systems

There is a distinction to be made between systems which are possible mathematically, and systems that can be physically implemented in digital hardware. Some systems might look good on paper, but they are difficult, if not impossible, to actually build. One criterion we have already seen is that a physically realizable digital system must not rely on future values, only on past values. We will discuss other criteria in future chapters, as the concepts involved become more familiar.
# Cybersecurity/Certification map
## Basic

| Certification | Description | Vendor | Exam Code | Prerequisites | Renewal |
| CompTIA Security+ | Entry-level certification covering foundational security concepts | CompTIA | SY0-601 | None | Every 3 years |
| Certified Ethical Hacker | Focuses on ethical hacking and penetration testing techniques | EC-Council | 312-50 (CEH) | 2 years of work experience in the Information Security domain | Every 3 years |
| CISSP | Advanced certification for information security professionals | (ISC)² | CISSP | Minimum of 5 years of cumulative, paid, full-time work experience | Every 3 years through CPEs |
# Cyberbotics' Robot Curriculum/Contents
## Table of contents

This is the javaLatex TOC.
* About this book
* What is Artificial Intelligence?
* What are Robots?
* E-puck and Webots
* Getting started
* Beginner programming Exercises
* Novice programming Exercises
* Intermediate programming Exercises
* Advanced programming Exercises
* Cognitive Benchmarks
# Cyberbotics' Robot Curriculum/What are Robots?

Robots are electro-mechanical machines, interacting autonomously with their environment. They include sensors allowing them to perceive the environment. They also include actuators allowing them to modify their environment. Finally, they include a micro-processor allowing them to process the sensory information and control their actuators accordingly.

## Robots in our Everyday Life

There exist few applications of robots in our everyday life. The most well known applications are probably toys and autonomous vacuum cleaners (see figure with toy robots), but there are also grass mower robots, mobile robots in factories, robots for space exploration, surveillance robots, etc. These devices are becoming increasingly complex in term of sensors, actuators and information processing.

## Robots as Artificial Animals

Like animals, robots can move, perceive their environment and act. Like animals, they need energy to be able to operate. This is probably why several examples of animal robots were developed for toy applications. This includes the Sony Aibo dog robot (see figure), the Furby toy and later the Pleo dinosaur robot. From the mechanical and electronic points of view, these robots are very advanced. They are equipped with many sensors (distance sensors, cameras, touch sensors, position sensors, temperature sensors, battery level sensors, accelerometers, microphones, wireless communication, etc.) and actuators (motors, speakers, LEDs, etc.). They also include a significant processing power with powerful onboard micro-controllers or micro-processors. Moreover, the latest Aibo robots and several vacuum cleaner robots are able to search their recharging station, to dock on it, recharge their batteries and move on once the battery is charged. This makes them even more autonomous. However, their learning capabilities and ability to adapt to unknown situations is often still very limited. Hence, this affect to comparison with real animals in term of intelligence. When observing an Aibo robot and a real dog, there is no doubt for most observers that the dog is more intelligent than the robot. The same could probably apply if you compare the Pleo toy robot with a real reptile. However, since reptiles appear to be more primitive than dogs, the difference of intelligence in the Pleo / reptile case may not be as evident as in the Aibo / dog case.
The conclusion we can draw from the above paragraph is that the hardware technology for intelligent robots is currently available. However, we still need to invent a better software technology to drive these robots. In other words, we currently have the bodies of our intelligent robots, but we lack their minds. This is probably the reason why most of the toy and vacuum cleaner robots described here are still provided with a remote control...
Hence this book will not focus on robot hardware, but rather on robot software because robot software is the greatest research challenge to overcome to be able to design more and more intelligent robots.
# Conlang/Advanced/Grammar/Alignment/Ergative

The Ergative alignment, formally known as Absolutive-Ergative alignment, is a rather common grammatical case system. Absolutive-Ergative differentiates between the Agent, it being marked in the Ergative case, from the Subject, with the fusion of both seen in Nominative-Accusative systems. The Absolutive case marks the Object and Subject the same, often leaving them unmarked.

## Distribution and Spread

The Absolutive-Ergative system is almost absent in Indo-European languages which are by far mostly Nominative-Accusative. In Europe, the only Ergative language is Basque. Ergative languages are spread thinly throughout the world, with certain pockets that contain a high concentration of Ergative languages. While Absolutive-Ergative languages cover an area from north Canada to Tibet and Iran, one of the main concentrations are in the Caucasus languages (think Georgian), Australian ones, and Eskimo-Aleut. Other Ergative languages exist, and Tibetan is a good example.
# Conlang/Advanced/Grammar/Alignment/Sources

* Re: Trigger language?, Christophe Grandsire, CONLANG-L, 2003.
* The Lexical Semantics of a Machine Interlingua, Rick Morneau, 2007.
* Notes on Language Creation: Ergativity, David J. Peterson, 2010.
* The 2010 Smiley Award Winner: ámman îar, David J. Peterson, 2010.
* The Blue Bird of Ergativity, Scott Delancey, University of Oregon, 2005. (pp. 1-15 in F. Qeixalos, ed., Ergativity in Amazonia III. Proceedings of the Workshop on "Ergatividade na Amazônia", Centre d'Études des Langues Indigènes d'Amérique (CELIA), Centre National de la Recherche Scientifique, Paris.)
* Conlangery #36: Morphosyntactic Alignment, Conlangery Podcast, 2012.
* Specificity and Objecthood in Tagalog, Joseph Sabbagh, 2012.
* Difference between Ayeri and Austronesian languages: A Question of Alignment XII: Conclusion, Carsten Becker, 2017.
* A 2006 CONLANG list thread about how Austronesian languages differ from trigger conlangs
* A March 2008 thread on the same subject
* David J. Peterson's trigger conlang X
* Wikipedia:Morphosyntactic alignment
# Conlang/Advanced/Grammar/Natural
## Constraints on natural languages

This section discusses various advanced (well, moderately advanced) theoretical frameworks for the study of natural language.
Throughout this book, we try not to commit to specialized theories, and we've warned — at the starts of both the Intermediate and Advanced levels — against overcommitting to specific theoretical frameworks. Nevertheless, some theoretical ideas must be leaned on, if cautiously, in a discussion of language. Morphemes are a theory, which is sometimes more useful than at other times (as we noted at Intermediate grammar). Even words, syllables, and phonemes are particular ways of analyzing language, and occasionally one might want to step outside those ways of thinking about it. Those, though, are relatively simple theoretical ideas. There are more sophisticated theoretical frameworks out there, and it's useful to know about them — both because they can sometimes be used in conlanging, and so that you won't be completely at sea when you encounter references to them. And that is what this section of this book is for.
A linguistic theory can overconstrain or underconstrain. Or both at once; and there are at least three different ranges of interest: the range of things known to happen in natural languages, the range of things that could happen in human natural languages (whether we know of examples or not), and, widest of all, the range of things that a conlanger might want to explore. Thus, overconstraint can prevent things known to happen, things we just don't about, and things we could wish to imagine; while underconstraint can allow things that, beyond merely not observed to occur naturally, beyond not possible naturally, may really not work out well, aesthetically or logistically.
Some theoretical frameworks are primarily analytical, describing how to break down existing languages into parts; as we remarked earlier, this can be especially problematic for use in conlanging because they are especially likely to underconstrain, failing to provide guidance for building a language rather than taking one apart. The more advanced frameworks described in this section, though, are often to some extent generative, aspiring to describe how languages are put together; which of course leaves them prone to overconstraint — or misconstraint.
On the positive side, the choice to use some theoretical linguistic framework in a conlang can provide guidance for decisions one would otherwise have to make freehand, and hopefully produce something with a feeling of plausible coherence about it.

## What's in this section?

The parts of this section are:
* Constituency grammar: Grammar organized around phrase structure, i.e., hierarchical groupings of words.
* Dependency grammar: Grammar organized around dependencies between words, rather than phrase structure.
* Construction grammar: Grammar organized around pairings of forms with functions.
* Optimality theory: Language feature derivation from optimal resolution of conflicting constraints.
* Contrastive hierarchy: Phonology derivation from a hierarchy of phonetic features.