OpenLLM-France/wikimedia huggingface dataset:
# Wi-Fi/Introduction

A wireless network (Also wireless LAN or WLAN) is a computer network operating by certain frequencies of radio waves. When installed correctly, no difference from a normal wired network should be obvious (Other than the obvious lack of cables).
These are generally used in a home environment for two main reasons: To share printers between them and to share an Internet connection. Normally, networks are created by hooking computers together with network cables and a router (or hub/switch). Wireless networks use various frequency radio waves to do this.

## Common reasons for using a wireless network (in preference to a wired one)

* The most obvious and commonly advertised difference in a wireless network is the lack of network cabling.
** This is especially useful if the network is a new one being planned and/or where the lengths of cabling would be ridiculously long.
* If the devices on the network are movable or move frequently, the lack of a network cable may be useful.

## Downsides

* Current standards of wireless networks have lower bandwidths (Speeds) than wired networks. This may be improved in future standards. Note, however, that common home network usage (Viewing webpages, Emailing, printing, etc) will rarely use the maximum bandwidth of any network. Unless you do a lot of intensive file sharing (such as video sharing), this won't be a problem.
* If improperly or poorly set up, anyone within receiving range can do anything on your network without you knowing.
* Since radio waves are an electromagnetic emission, they decrease in strength over distance. If you have a widely scattered network, those on at the very edge of the signal's range may experience very poor speed and reliability. This can be remedied.
# Wi-Fi/Wardriving

War Driving (wôr dri'vin) v. Driving around looking for wireless networks. -term coined by Pete Shipley
The term wardriving generally covers the practice of discovering and mapping (with the help of GPS) the wireless networks available in a particular area. Useful statistics are gathered from this activity, including statistics on the encryption used in discovered networks. Wardriving does not include the unethical activity of unauthorised connection to wifi networks (encrypted or unencrypted).
WARNING: THE TECHNIQUES DESCRIBED ON THIS PAGE MAY BE ILLEGAL IN YOUR JURISDICTION. THIS PAGE IS PROVIDED FOR INFORMATIONAL PURPOSES ONLY. PLEASE CHECK WITH YOUR LAWYER FOR MORE INFORMATION

## Equipment

To 'wardrive', you need the following equipment:
* A computer (preferably a laptop or PocketPC, as they are far more portable)
* A wifi card.
* Transportation.
* Software (Such as Netstumbler for Windows, Kismet for Linux, and KisMAC for Mac OS X)
* A GPS receiver (optional but necessary to create a map)
* External omnidirectional antenna, such as a Cantenna (optional)
* External unidirectional antenna (optional)

## How to Wardrive

After you have installed and started your sniffing software and have activated your wireless card, you should configure your GPS adapter. After that, drive to the area that you wish to investigate and pick up signals of the active wifi networks.

## Links

* Wardriving.com the latest changes in 2012
# The Pyrogenesis Engine/Overview

Pyrogenesis has two faces: one, the core engine itself, is written in C++. Ideally, only the most low-level functionality, which requires access to system interfaces or crucially needs to be very fast, is implemented here.
The other face of Pyrogenesis is a Javascript interface, which is accessed by specialized scripts through a number of runtimes.
Each runtime can be thought of as an instance of the SpiderMonkey Javascript interpreter used by the Pyrogenesis engine - it is a scripting environment or sandbox in which Javascript scripts are executed. Every runtime runs in isolation and can not immediately interact with the state of the other runtimes.
About scripting: engine creates multiple JS runtimes, one for simulation, one for AI, one for GUI and one for RMS. (Others?)
# The Pyrogenesis Engine/Simulation

The most important aspect of any game is its gameplay. In Pyrogenesis, the simulation can be thought of as the place where gameplay is executed. The simulation is the part of the engine that takes commands from the players (including the AI) and turns them into actions in the game world.
The simulation subsystem is defined in simulation2/Simulation2.cpp. Its central class, CSimulation2Impl is instantiated by ???, constructed from a unit manager (CUnitManager) and a terrain (CTerrain). From this alone, we can deduce that the simulation deals with how units interact with each other and with the terrain of a map.
When CSimulation2Impl is instantiated, it also initializes a component manager (CComponentManager?). Components are one of the most crucial concepts to grasp in order to understand how the simulation works. Programatically, components are merely subsystems accessed via the component manager. For instance, there is a pathfinder component for deriving the shortest path across a terrain, a sound manager component for outputting music and sound effects, and a projectile manager component for driving ballistic calculations of things like arrows and spears.
However, though each of these subsystems (components) are instantiated only once by the component manager (I think), they can be associated with any entity in the game world (I think) and will only ever be used in relation to one such entity at a time (I think). Thus, as a user of the simulation, it may be easier to think of the simulation as consisting of a set of entities, each "having" (being associated with) one or more components. For instance, a soldier unit may have a Pathfinder component, so it can find its way over the map, and an Attack component, so it can fight any enemies it comes across, and an Armour component, so it can handle damage dealt by other units.
Regarding how to load a single instance of a component for one whole session: For a single component you need to attach it to the system entity which unfortunately requires a C++ change. The location is: source/simulation2/Simulation2.cpp:128
# The Q Document

The Q Document is a hypothetical document which some scholars suspect was used as a source for the Gospel of Matthew and the Gospel of Luke. This book will discuss the reason some scholars believe Q existed and what they believe Q might have looked like. It will also include the reasons that some scholars doubt the existence of the Q Document. Finally, the book will include those portions of the Gospel of Luke which are suspected to have been copied from the Q Document.

## Table of Contents

* The Synoptic Gospels and the The Synoptic Problem
* Markan priority and the Triple Tradition
* The Two-source Hypothesis and the Double Tradition
* The Q Document
* The Q Community
* Q Strata
* The case against Q
* History of the Q hypothesis
* Expanded contents of Q
* Bibliography / Further Reading
# The Q Document/The Synoptic Gospels
## The Synoptic Gospels

Of the four canonical gospels included in the New Testament, three are very similar: Mark, Matthew, and Luke. These gospels often recount the same stories about Jesus, generally follow the same sequence and, often use the same or similar wording. Because they share the same view, these three gospels are known as the Synoptic Gospels (from Greek synoptic, meaning "seeing with the same eyes").
A substantial amount of material is repeated in all three synoptic gospels. This material is known as the triple tradition. About half of the material in the synoptic gospels (taken together) would be considered "triple tradition" material.
Another substantial block of material is repeated in both Matthew and Luke, but is absent from Mark. This material is known as the double tradition. About one-fifth of the material in the synoptic gospels (taken together) would be considered "double tradition" material.
A small amount material (about 9%) is found in both Mark and Matthew, but not in Luke. A very small amount of material (about 2%) is found in Mark and Luke, but not in Matthew.
Additionally, each gospel has some material that is unique to it alone. Luke has a relatively large amount of such material-- Luke-only material makes up about 15% of the synoptics. Matthew-only material, meanwhile, makes up about 9% of the synoptics. Mark has the least amount of unique material-- Mark-only material makes up less than 1% of the synoptics.

## The Synoptic Problem

The relationships between the three synoptic gospels goes beyond mere similarity in viewpoint. The gospels often recount the stories, usually in the same exact order, sometimes even using the exact same words. Some sections are repeated nearly verbatim.
Scholars note that the similarities between the Mark, Matthew, and Luke are too great to be accounted for by mere coincidences. Since multiple eyewitnesses reporting the exact same events will basically never relate a story using exactly the same word-for-word telling, Scholars and theologians have long assumed there was some literary relationship between the three synoptic gospels.
The precise nature of the relationships between the gospels of Mark, Matthew, and Luke is know as the Synoptic Problem. The recognition of the question, and attempts to resolve it, date to antiquity. For example, Augustine of Hippo, a 5th century bishop, tried to explain the relationships between the synoptic gospels by proposing that perhaps Matthew was written first, then Mark was written using Matthew as a source, and finally Luke was written using Matthew and Mark as sources. Although this specific solution has fallen out favor with modern scholars, it represents one of the earliest and most influential proposed solutions to the synoptic problem.

## References

* ↑ Matt 3:7-10 & Luke 3:7-9. Text from 1894 Scrivener New Testament
# The Python Class/Exceptions
## What makes up an exception?

All exceptions have to be derived from BaseException. In an analogy, this could be the world. There are 4-5 derivatives of BaseException, which are Exception, KeyboardInterrupt, SystemExit and a few others that are exit exceptions.
When you use the except part of a try/except, it will intercept any exceptions of the exceptions type and in the sub exceptions. This is useful because if you wanted to stop all error exceptions, you would use except:. However, this also blocks SystemExit (run by exit) and KeyboardInterrupt (activated by doing Ctrl/Cmd/...+C), which we would not want to block because then the program could not exit automatically (you would have to click on the x).
We could do except Exception:, and this is perfect because you can still exit, but it will not let any errors such as ValueErrors stop your program.
If we only want to block all ValueErrors, we would just do except ValueError:. This matters because when you make your own exceptions, you dont want your exception to be stopped by other exceptions (most of the time).

## Creating a custom exception

When we create a class, in order to make it an exception, we need to make it a subclass of an existing class. This is where the parentheses come in. You can either define classes as
or
However, a parent class can go into the parentheses to make it a subclass. In an exception, it would be
Now, if we were to try raising the x without the Exception, we would get TypeError: exceptions must derive from BaseException. If we were to raise the one with the exception, we would get

### Giving it a message

Sure, if properly named, your exception might help. However, you might want to include an error message or pass variable values in to help the user figure out the problem. To do this, we have to access the exception's __init__. We pass in our message in our own __init__ function.
Now if we were to raise x it would say:
It now has a message.

### Sub-classing another exception

To subclass another exception, just replace x with the Exception's class. For example, if we wanted to make y, we would write

#### Why would we subclass?

Subclassing is a good idea because then you can skip only the exceptions that come with certain operations, such as file reading. Let's make an exception that will raise if a file is too big.
If we wanted to make a program that will skip all OS errors, including this one if there are any problems, we would write except OSError:.
# Zelda franchise strategy guide/Enemies/Floormaster

Floormasters are enemies in some Legend of Zelda games

## Ocarina of Time

Floormasters are enemies in the game The Legend of Zelda: Ocarina of Time. They take the form of dead hands with clawlike fingernails.
Floormasters are rather difficult to defeat at first. When a Floormaster is attacked it will separate into three mini-Floormasters. They need to be destroyed before they unite. If a smaller monster manages to grab the player after two are destroyed, it turns into a new Floormaster. The spin attack or Din's Fire is especially useful as mini-Floormasters tend to blindly run into Link after retreating. If a Floormaster turns green, it is invincible. Link will need to stay away from it until it goes back to its normal color, or defend himself with his shield. Some Floormasters are invisible, so Link needs the Lens of Truth to see them, disabling the use of the spin attack or Din's Fire.
They are related to the Wallmaster, a giant hand that dwells on the ceiling.

## Majora's Mask

Floormasters appear in this game too, in Ikana's castle. In this game the sunlight is their major weakness and will be harmed upon contact. They can be also beaten by reflecting light via the Mirror Shield onto them.

## The Wind Waker

In The Legend of Zelda: The Wind Waker, they are black hands with a violet glow around them. They reside in small holes on the floors of the Earth and Wind Temples, but are also found in smaller, mini-dungeons throughout the Great Sea (such as on Needle Rock Isle). There is one in the Forsaken Fortress as well. However, these holes are different - they move, wiggle, and perpetually suck inward as would a black hole. Their personality according to their figurine is surprisingly lonely.
A Floormaster's attack in this game is very similar to the Wallmaster's attack in The Ocarina of Time. They will try to grab Link and take him to a previous room, this will also happen to a partner. However, you will be able to see the Floormaster's hole before you are attacked. They can also pick up nearby objects and throw them at Link, including bombs you drop.

## The Minish Cap

In The Legend of Zelda: The Minish Cap, they are Large blue glowing hands. waiting long enough in a room that they are in may result in them coming after you. they don't have very many attacks, and there are also wallmasters.
# XQuery/Introduction to XML Search
## Motivation

You want to have a high-level overview of XML Search terms and technologies.

## Search Terms

* Structured Search - retaining and using the structure of a document to aid in search result ranking
* Search Document - a document or document fragment that is returned as the result of a search. Note that in the search examples the word "document" may imply an entire XML document or a fragment or item in such a document.
* Search Query - a word or phrase to find
* Boolean Search - a search for an XML document that is either true or false with no ordering of search results
* Search Hit - a match of a query to a document or document fragment
* Hit Scoring - a method of assigning a weight to a search result for sorting. For example if a term occurs more frequently in a document it might receive a higher score
* Search Ranking - an order list of search results
* Global Search - searching one or more item types in a database
* Item Viewer - a program used to view a specific item type in a collection

## References

Christopher D. Manning, Prabhakar Raghavan and Hinrich Schütze, Introduction to Information Retrieval, Cambridge University Press. 2008: online edition
# XQuery/Latent Semantic Indexing
## Motivation

You have a collection of documents and for any document you want to find out what documents are the most similar to any given document.

## Method

We will use a text-mining technique called "Latent Semantic Indexing". We will first create a matrix of all concept words (terms) by all the documents. Each cell will have the frequency count of terms in each document. We then send this term-document matrix to a service that performs a standard Singular Value Decomposition or SVD. SVD is a very compute-intensive algorithm that can take many hours or days of calculation if you have a large number of words and documents. The SVD service then return a set of "Concept Vectors" that can be used to group related documents.

## Sample Data

To keep the example simple, we will just use the document titles, not the full documents.
Here are some document titles:
Our first step will be to build a Word-Document Matrix. This matrix has all the words in the document in a column and one column for each document.
We will do this in several steps.
* Get all the words from all the documents an put them into a single sequence
* Create a list of the distinct words that are not "stop words"
* For each word:
** For each document count the frequency that this word appears in the document

## Sample Word-Document Matrix

| Word | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
| Applications | | | | 0.03125 | | | |
| Architectural | | | | | | 0.03125 | |
| Auto-generation | 0.03125 | | | | | | |
| Building | | | | 0.03125 | | | |
| Cookbook | | 0.03125 | 0.03125 | | 0.03125 | | |
| Investiment | | | | | | | 0.03125 |
| Overview | | | | | | 0.03125 | |
| RESTful | | | | 0.03125 | | | |
| Return | | | | | | | 0.03125 |
| Tutorial | | 0.03125 | 0.03125 | | 0.03125 | | |
| Web | | | | 0.03125 | | | |
| XForms | 0.03125 | | 0.03125 | | | | |
| XQuery | 0.03125 | 0.03125 | | | | | |
| XRX | | | | 0.03125 | 0.03125 | 0.03125 | 0.03125 |

## Creating Sigma Values

The Sigma matrix is a matrix that is multiplied by both the word vectors and the documents vectors:
# XQuery/Installing the XSL-FO module

You may have to work with your eXist system administrator to first enable the XSL-FO XQuery module in order for these examples to run. This can be done by using the following steps.

## Step 1: Enable the XSLFO XQuery Module

Edit the conf.xml file in the $EXIST_HOME directory. You must un-comment the xslfo module.

## Step 2: Edit the extensions build.properties file

If your eXist was not built from source the fo module and supporting fop.jar file must also be included in your exist-modules.jar file in all production systems. This can be done by downloading the eXist source and changing the build.properties file setting to be true. For details please see the eXist build instructions
$EXIST_HOME lib/extensions/build.properties or $EXIST_HOME extensions/build.properties
If you are running release 1.4 of eXist, the Apache FOP version referenced might no longer be available. If you have a line like the following in your build-properties like this:

## Step 3: Update the path to the new XSL-FO zip file in the configuration file

You will find that the Apache project removed the old binaries (not always best practice).
This is the new line this should be replaced with.
And additionally change references to the deprecated version in $EXIST_HOME extensions/modules/build.xml to point to the newer version. E.g:

## Step 4 Download the new XSLFO Zip file

When you run a build the next time this will download the Apache FOP jar file from the Apache web site.
Sample from build log:

## Step 5 Verify that the new XSLFO Library is available

Note that in addition to the fop binary the following jar file is required by the FOP processor.
On UNIX:
This can be downloaded from the Apache XML Graphics Commons Distribution Mirror

## Step 6 Copy the Java files

Copy the jar files from $EXIST-HOME/lib/user/fop.jar and the new $EXIST-HOME/lib/extensions/exist-modules.jar on to your production systems. Note you should make sure the source and destination systems are the same version.
If you want to have fop hyphenate your text, put the fop-hyphen.jar into $EXIST-HOME/lib/user/ and restart eXist. fo:blocks with the attribute hyphenate set to true in you fo or xsl file will be hyphenated then if you add a language attribute to the fo:page-sequence. The patterns for many languages are available here: http://sourceforge.net/projects/offo/
Note that your exist-modules.jar file can then be placed on the systems that do not have the source code. There is currently no method to use FOP without downloading the source. Also note that you can verify that your exist-modules.jar file contains the XSLFO classes by running:
You can now check that the jar files are correctly installed in the user libraries directory:
Which returns

## Build The Extensions

Type the following into the shell:
If the build fails with
, it helps to create the classes folder, afterwards build is successful:

## Verify that the jar files are in the right position

Or on a windows system you can change the jar file file name to end with .zip, uncompress and check that the xslfo classes are in the exist-modules file.
# XQuery/Link gathering
## Motivation

You want to gather the links on a blog page.

## Method

We use the doc function to perform an HTTP GET on a remote web page. If the page is a well formed XML file you can then extract all the unorder list items by adding a ul predicate to the doc function.
This script fetches the blog page and selects the urls in the link section, which reference other blog articles. Each referenced article is fetched and the urls marked as external are selected. The result is returned as XML.
Execute

## Version 2

Dropping the intermediate variables allows the structure to be seen more clearly:
Execute

## Repository Schemas

Daniel is proposing a standard for supporting the extraction of data such as this from a site. Such a schema would define a view of a set of documents sufficient to allow the extraction above to be based on the schema.
We can go some way towards this with a view schema represented as an ER model, with added implementation-dependent paths.
This schema can then be used by a generic script link gathering script:
This script now performs the task of link gathering on any site whose page structure can be defined in terms of the schema with appropriate paths.
Execute

## Relative and absolute URIs

The previous version works only if the URIs are absolute. A little more work is needed if not:
So with a different schema - same model, different paths:
which is a view schema of this test site
Execute

## Virtual Paths

The navigation path is still hard-coded in the script. We would like to write path expressions where the steps are defined in the schema. This path would then be interpreted in the context of the schema.

### View Schema

In this example, the test site has been expanded to include a separate index page and some additional components in the view:
Index

### Path language

This prototype uses a simple path language.The step -> dereferences a relative or absolute URL. Where a step is recognised as an attribute of the current entity, the associated path expression is used, otherwise the step is executed as XPath. The first step identifies the (entity) type of the initial document.
For example:

#### index/link/->/title

List the titles of the pages in the index.
Run

#### index/link/->/author/string(.)

List the authors of the pages referenced in the index.
Run

#### page/inner/->/external

List the url of all distinct external links of all pages referenced by the index page.
Run

#### page/inner/->/inner/->/title

List the titles of pages linked to the initial page.
Run

### Script

The core function processes a virtual path in the context of a schema.

## Acknowledgments

This example is based on an article by Daniel Bennett .