text:
> [Go to French version](/fr/Règlements/Codification%20des%20règlements%20du%20Canada/301-400/C.R.C.,%20ch.%20342.md)

# Regulations Respecting the Implementation of Adjustment Assistance to Railway Companies and Employees Affected by Changes in Railway Passenger Services

**C.R.C., c. 342**

Enabling authorities:
- APPROPRIATION ACT NO. 1, 1977

- [APPROPRIATION ACTS](/en/Acts/Revised%20Statutes%20of%20Canada/Z/Z-01.md)

----------

## Short Title

**1** These Regulations may be cited as the Railway Passenger Services Adjustment Assistance Regulations.

## Interpretation

**2**

- **(1)** In these Regulations,

***benefits*** means the benefits and expenses referred to in subparagraph (c)(ii) of Department of Transport Vote 52d, Appropriation Act No. 1, 1977; (*bénéfices*)

***changes*** means changes in the provision, management or operation of selected Railway Passenger Services as a result of
- **(a)** the implementation of the provisions of the contract between the Minister of Transport and VIA Rail Canada Inc., entered into pursuant to Department of Transport Vote 52d of Appropriation Act No. 1, 1977, or
- **(b)** the discontinuance of a Railway Passenger Service; (*changements*)

***cost*** means the cost incurred by a railway company with respect to the provision of benefits; (*coûts*)

***government arrangement*** means an arrangement between the Minister of Transport and a railway company with respect to the reimbursement of the prescribed portion of the cost; (*entente gouvernementale*)

***prescribed portion*** means the portion prescribed from time to time by the Governor in Council; (*proportion déterminée*)

***Railway Passenger Service*** means a passenger train service that does not accommodate principally persons who commute between points on the railway; (*service de transport ferroviaire de passagers*)

***special agreement*** means an agreement between a railway company or railway companies and a trade union or trade unions with respect to the provision of benefits that result from the special agreement process; (*accord spécial*)

***special agreement process*** means the negotiating process between a railway company and a trade union commenced with the undertaking between the parties that the arbitration provisions set out in these Regulations will apply to and be binding upon the parties in the event of the dispute between them on any matter arising in respect of the benefits and conditions referred to in subsection 5(2); (*processus d’accord spécial*)

***trade union*** means an employee organization certified or recognized as bargaining agent for employees of a railway company. (*syndicat*)

- **(2)** Any word or expression used in these Regulations that is not defined in subsection (1) shall have the same meaning as in the Railway Act.
> SOR/85-701, s. 1; SOR/88-401, s. 1.

## Application

**3** The Minister of Transport may reimburse a railway company for the prescribed portion of the cost incurred by the company for the provision of benefits where
- **(a)** the cost results from changes implemented during the period beginning on March 29, 1977 and ending on December 31, 1990;
- **(b)** a special agreement exists between the railway company and a trade union or trade unions; and
- **(c)** a government arrangement exists between the railway company and the Minister of Transport.
> SOR/81-25, s. 1; SOR/85-701, s. 2; SOR/86-56, s. 1.

## Special Agreements

**4** In negotiating a special agreement, the parties to the special agreement process shall, inasmuch as the following are generally incorporated in their existing job security agreements, give consideration to the following:
- **(a)** in so far as possible, ensuring continuing employment for the employees concerned;
- **(b)** where preferred and to the extent possible, keeping employees in gainful employment at the same location;
- **(c)** where necessary, training employees for alternative employment;
- **(d)** when required, providing appropriate assistance in relocation;
- **(e)** in so far as possible, avoiding loss of employees’ earnings;
- **(f)** developing a separation plan for the assistance of employees close to or eligible for retirement who wish to leave the work force;
- **(g)** minimizing seniority obstacles for the purpose of facilitating
	- **(i)** continuing employment by Canadian National Railway Company, Canadian Pacific Railway Limited, Toronto Terminal Railway Company or Toronto, Hamilton and Buffalo Railway Company, where mutually agreed to by the parties, and
	- **(ii)** the transfer of employees to VIA Rail Canada Inc.;
- **(h)** where employees are laid off, providing reasonable weekly lay-off benefits or severance payments; and
- **(i)** assisting employees unable to maintain their jobs to secure employment outside the railway industry.
> SOR/81-735, s. 1.

**5**

- **(1)** A special agreement shall provide for the benefits and the terms and conditions of those benefits contained in
	- **(a)** Railway Job Security, Technological, Operational, Organizational Changes Agreements between Canadian National Railway Company, Canadian Pacific Railway Limited and non-operating shop-craft or other unions; or
	- **(b)** Railway Material Change Agreements between Canadian National Railway Company, Canadian Pacific Railway Limited and United Transportation Union and Brotherhood of Locomotive Engineers.

- **(2)** A special agreement may provide for benefits and conditions in addition to those referred to in subsection (1), consistent with the principles referred to in section 4.

**6** A special agreement shall be the only instrument applicable with respect to benefits and the words, terms and conditions of such an instrument shall not be amended, revised or otherwise changed without
- **(a)** a joint request from the parties to the special agreement; and
- **(b)** the consent, in writing, of the Minister of Labour.

**7** A special agreement shall not provide for benefits to employees other than those adversely affected by the implementation of changes.

## Arbitration

**8**

- **(1)** Where, in negotiating a special agreement, a settlement has not been reached by the parties to the special agreement process (hereinafter referred to as “the parties”) on any issue arising under subsection 5(2) within 60 days after the date a railway company has served notice on a trade union, either party may inform the Minister of Labour, by notice in writing, of their failure to reach a settlement.

- **(2)** Within a reasonable period after his receipt of a notice referred to in subsection (1), the Minister of Labour or a representative designated by him shall confer with the parties in order to assist them in reaching a settlement.

- **(3)** Where the Minister of Labour or his representative is unsuccessful in assisting the parties in reaching a settlement, either party may, within seven days following the conference with the Minister of Labour or his representative, request, by notice in writing to the other party, that the matter be referred to a single arbitrator.

- **(4)** Where, within seven days of a request referred to in subsection (3), the parties cannot agree on the selection of an arbitrator, either party may submit to the Minister of Labour an application to appoint an arbitrator.

- **(5)** Within a reasonable period after his receipt of an application referred to in subsection (4), the Minister of Labour shall select and appoint an arbitrator.

- **(6)** On the appointment of an arbitrator, the parties shall prepare a joint statement of any issues arising under subsection 5(2) that remain in dispute and shall submit that statement to the arbitrator prior to the hearing.

- **(7)** Within 21 days of his appointment the arbitrator shall convene a hearing of the parties.

- **(8)** Within 60 days of his appointment the arbitrator shall make an award.

- **(9)** An arbitral award shall be final and binding on the parties and for the purposes of these Regulations shall be deemed to be an integral part of the special agreement.

- **(10)** An arbitral award, notwithstanding a decision to the contrary by the arbitrator as to its duration, shall be the only arbitral award applicable in respect of any matter referred to arbitration under this section.

- **(11)** Any time limit established pursuant to this section may be extended by agreement between the parties.

## Non-unionized Employees

**9**

- **(1)** Where non-unionized employees have been adversely affected by the implementation of changes, they shall be provided with benefits consistent with existing railway policies and practices and may be provided with additional benefits.

- **(2)** Every railway company affected by changes in Railway Passenger Services shall provide a detailed statement of the benefits to be provided to non-unionized employees pursuant to subsection (1) to the Minister of Transport and that statement shall, for the purposes of these Regulations, be considered to be a special agreement.

## Government Arrangement

**10**

- **(1)** A government arrangement shall not provide for the reimbursement of a greater portion of the cost than the prescribed portion.

- **(2)** A government arrangement shall not be executed until the appropriate special agreement has been signed by the parties to the special agreement.

## Reimbursement

**11** Reimbursement to a railway company of the prescribed portion of the cost shall be made in accordance with the appropriate government arrangement.

## Records

**12** A railway company shall keep detailed records of all transactions made by the company with respect to cost and shall make the records available for inspection by the Minister of Transport or his authorized representative on an agreed periodic basis.

url: https://raw.githubusercontent.com/TravisMadill/CanadianLaws/776186d75e6e345dc5a0f1cd9243028efa9ac34c/en/Regulations/Consolidated Regulations of Canada/301-400/C.R.C., c. 342.md

repository: TravisMadill/CanadianLaws

repo_name: TravisMadill/CanadianLaws


text:
# Encrypted Test Data

Test files in this directory are encrypted because they contain personal data.

## Encrypting data

1. Run the following to prevent error “gpg Inappropriate ioctl for device” (see [here](https://stackoverflow.com/a/57591830))

   ```shell
   $ GPG_TTY=$(tty); export GPG_TTY
   ```

2. Create a directory for each test case and encrypt it as follows:

   ```shell
   $ gpgtar --symmetric --output 234567.gpg 234567
   ```

## Decrypting data

To decrypt all test data (i.e. all `*.gpg` files), simply run the following script with the proper secret:

```shell
$ ./decrypt.sh secrect
```

license: MIT

repository: qqilihq/partial-emlx-converter

branch_name: refs/heads/master

extension: md

gha_language: TypeScript

gha_license_id: MIT

license_type: permissive

repo_name: qqilihq/partial-emlx-converter


text:
---
title: linux basics: material 7 - formatting
categories:
    - linux
    - linux basics
tags:

---

## Formatting

BE CAREFUL: FORMATTING WILL ERASE ALL EXISTING DATA!

formatting means create a FS.

    mkfs.ext4 /dev/sdb1
    mkfs -t ext4 /dev/sdb1

check a disk with mkfs, looks for bad element meaning the diskend of life:

    mkfs -t ext4 -c /dev/sdb1

-m: % reserved space to prevent user to fullfill disk.

### SWAP formatting

    mkswap /dev/sdbX #format
    swapon /dev/sdbX #tell system to use it as swap

repository: benIT/github-blog

repo_name: benIT/github-blog


text:
# RESTing with Symfony

Well hi there! This repository holds the code for the *whole* Symfony
REST tutorial series on KnpUniversity:

* [Episode 1](http://knpuniversity.com/screencast/symfony-rest)
* [Episode 2](http://knpuniversity.com/screencast/symfony-rest2)
* [Episode 3](http://knpuniversity.com/screencast/symfony-rest3)
* [Episode 4](http://knpuniversity.com/screencast/symfony-rest4)
* [Episode 5](http://knpuniversity.com/screencast/symfony-rest5)

## Setup the Project

Ok, cool - this will be easy!

1. Make sure you have [Composer installed](https://getcomposer.org/).

2. Install the composer dependencies:

```bash
composer install
```

Or you may need to run `php composer.phar install` - depending on *how*
you installed Composer. This will probably ask you some questions
about your database (answer for your system) and other settings
(just hit enter for these).

3. Load up your database

Make sure `app/config/parameters.yml` is correct for your database
credentials. Then:

```bash
php bin/console doctrine:database:create
php bin/console doctrine:schema:update --force
php bin/console doctrine:fixtures:load
```

4. Start up the built-in PHP web server:

```bash
php bin/console server:run
```

Then find the site at http://localhost:8000.

You can login with:

user: weaverryan
pass: foo

Have fun!

license: Unlicense

repository: Anamican/sws

repo_name: Anamican/sws


text:
# KPrototype plus (kpplus)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-informational.svg)](https://GitHub.com/Naereen/StrapDown.js/graphs/commit-activity) [![made-with-python](https://img.shields.io/badge/Made%20with-Python-1f425f.svg)](https://www.python.org/) [![PyPI license](https://img.shields.io/pypi/l/ansicolortags.svg)](https://pypi.org/project/kpplus/)

## Description

K-prototype is a clustering method invented to support both categorical and numerical variables[1]

**KPrototype plus (kpplus)** is a Python 3 package that is designed to increase the performance of [nivoc's KPrototypes function](https://github.com/nicodv/kmodes) by using [Numba](http://numba.pydata.org/).

This code is part of [Stockholms diabetespreventiva program](https://www.folkhalsoguiden.se/amnesomraden1/analys-och-kartlaggning/sdpp/).

### Performance improvement
As an [example](example/example.ipynb), I used one of the [Heart Disease Data Sets](https://archive.ics.uci.edu/ml/datasets/Heart+Disease) from [UCI](https://archive.ics.uci.edu/ml/index.php) to test the performance.
This data set contains 4455 rows, 7 categorical variables, and 5 numerical variables.
We compare the performance between nicodv's kprototype function and k_prototype_plus.

~~~~
< nicodv's kprototype >
CPU times: user 2.14 s, sys: 18.2 ms, total: 2.16 s
Wall time: 1min 41s
~~~~
~~~~
< k_prototype_plus >
CPU times: user 298 ms, sys: 9.24 ms, total: 308 ms
Wall time: 13.4 s
~~~~

**Notice:** Only Cao initiation is supported as the initiation method[2].

## System requirement
[![Generic badge](https://img.shields.io/badge/Python-3.7.1-informational.svg)](https://www.python.org/) [![Generic badge](https://img.shields.io/badge/Pandas-0.25.3-informational.svg)](https://pandas.pydata.org/) [![Generic badge](https://img.shields.io/badge/Numpy-1.17.0-informational.svg)](https://numpy.org/) [![Generic badge](https://img.shields.io/badge/Joblib-0.13.2-informational.svg)](https://joblib.readthedocs.io/en/latest/) [![Generic badge](https://img.shields.io/badge/Numba-0.45.1-informational.svg)](http://numba.pydata.org/)

## Installiation

```
pip install kpplus
```

## Usage
```python
from kpplus import KPrototypes_plus
model = KPrototypes_plus(n_clusters = 3, n_init = 4, gamma = None, n_jobs = -1)  #initialize the model
model.fit_predict(X=df, categorical = [0,1])  #fit the data and categorical into the mdoel

model.labels_                          #return the cluster_labels
model.cluster_centroids_               #return the cluster centroid points(prototypes)
model.n_iter_                          #return the number of iterations
model.cost_                            #return the costs
```
**n_clusters:** the number of clusters

**n_init:** the number of parallel oprations by using different initializations

**gamma (optional):** A value that controls how algorithm favours categorical variables. (By default, it is the mean std of all numeric variables)

**n_jobs (optional, default=-1):** The number of parallel processors. ('-1' means using all the processor)

**X:** 2-D numpy array (dataset)

**types:** A numpy array that indicates if the variable is categorical or numerical.

For example: ```types = [1,1,0,0,0,0]``` means the first two variables are categorical and the last four variables are numerical.

## Acknowledgement
I'm extremely grateful to [Dr. Diego Yacaman Mendez](https://staff.ki.se/people/dieyac?_ga=2.70810192.1199119869.1588953123-1873461028.1579027503) and [Dr. David Ebbevi](https://www.linkedin.com/in/debbevi/?originalSubdomain=se) for their support. They are two brilliant researchers who started this project with excellent knowledge of medical science, epidemiology, statistics and programming.

## Reference
[1] Huang Z. Extensions to the k-Means Algorithm for Clustering Large Data Sets with Categorical Values. Data Mining and Knowledge Discovery. 1998;2(3):283-304.
[2] Cao F, Liang J, Bai LJESwA. A new initialization method for categorical data clustering. 2009;36(7):10223-8.

gha_language: Python


text:
# pyStarDictViewer
Python+Tkinter solution for browsing StarDict dictionaries

Formatting options are still quite limited.

In the search entry it's possible to enter `:d` to jump to
dictionary list or quickly select a dictionary with `:dN`
where N is number of a dictionary


text:
# Command Line Interface

The bot can be controlled from the command line.

## Command line format

```
bin/mmbot [-vdt] [-f <config_file>] [-p <number>] <cmd> <args...>
```

Switches must appear before the <cmd> because all arguments after the <cmd> are passed as arguments of the command.

## Switches

### Switch -v

Redirects log to stderr ("verbose mode"). This switch cannot be used when the bot starts in daemon mode

### Switch -d

Temporarily enforces `debug` mode of logging ("debug")

### Switch -t

Enforces `dry_run=1` for all trading pairs ("test")

### Switch -f

Changes location of configuration file. Default location is at path `../conf/mmbot.conf` relative to bot's binary file

### Switch -p

Opens port to access web interface. Number specifies port to open. The port is bound to localhost - this option cannot be used to open port to the internet.

## Service control commands

### start

Starts the Bot in daemon mode

### stop

Stops the running Bot

### restart

Restarts the running Bot (combination of stop+start)

### status

Shows status of the Bot

### pidof

If the Bot is already running, it shows its PID

### wait

Holds until the Bot is stopped

repository: ondra-novak/mmbot

repo_name: ondra-novak/mmbot


text:
---
layout: post
title: "MRG701"
description: ""
category: genes
tags:
---

* **Information**
    + Symbol: MRG701
    + MSU: [LOC_Os04g01130](http://rice.plantbiology.msu.edu/cgi-bin/ORF_infopage.cgi?orf=LOC_Os04g01130)
    + RAPdb: [Os04g0101300](http://rapdb.dna.affrc.go.jp/viewer/gbrowse_details/irgsp1?name=Os04g0101300)

* **Publication**
    + [MRG702, a reader protein of H3K4me3 and H3K36me3, is involved in brassinosteroid-regulated growth and flowering time control in rice.](http://www.ncbi.nlm.nih.gov/pubmed?term=MRG702, a reader protein of H3K4me3 and H3K36me3, is involved in brassinosteroid-regulated growth and flowering time control in rice.%5BTitle%5D), 2015, Plant Physiol.

* **Genbank accession number**

* **Key message**

* **Connection**

[//]: # * **Key figures**


text:
+++
title = "Overview"
weight = 1
template = "doc.html"
+++

Iris is the HTTP client vane.

Iris gets passed HTTP requests, makes the request to the specified URL, and returns the HTTP response.

## Sections

[Data Types](/docs/arvo/iris/data-types) - Reference documentation of the data types used by Iris.

[API Reference](/docs/arvo/eyre/tasks) - The `task`s Iris takes and the `gift`s it returns.

[Example](/docs/arvo/iris/example) - An example of using Iris to fetch a remote HTTP resource.


text:
# ulauncher-kv

Ulauncher extension for set and get snippets of any text in a local database

![kv](kv.gif)

# Install

Open ulauncher preferences window -> extensions -> add extension and paste the following url:

```
https://github.com/laercioskt/ulauncher-kv
```

# Usage

Enter a query in the form of

```
[set] <key> <value> | [get] <key> [unset] | <key> (simple way to [get])
```

## example of store a new "key" -> "value"

```
kv set someKey some value
```

## example of remove a "key" -> "value"

```
kv get someKey unset
```

## examples of get "value" filtering by "key"

```
kv get someKey
```

```
kv get partofakey
```

```
kv someKey
```

```
kv partofakey
```

repository: gitter-badger/ulauncher-kv

repo_name: gitter-badger/ulauncher-kv


text:
---
layout: post
categories: blog, arxiv
title: ArXiv Notes
use_math: true
---

* Table of Contents
{:toc}

# ArXiv Notes for 05/23/2017

## Testing General Relativity with stellar orbits around the supermassive black hole in our Galactic center

By A. Hees et al., [1705.07902](https://arxiv.org/abs/1705.07902)

Strong regime tests of GR using MW SMBH.

## ISM properties of a Massive Dusty Star-Forming Galaxy discovered at z ~ 7

By W. Strandet et al., [1705.07912](https://arxiv.org/abs/1705.07912)

High-redshift (z about 6.9) SPT source. About 3.3e11 Msun of mass.

gha_language: HTML


text:
# ArcGIS Runtime SDK for .NET - Toolkit

The ArcGIS Runtime SDK for .NET Toolkit contains controls and utilities you can use with [ArcGIS Runtime SDK for .NET](http://links.esri.com/dotnetsdk).

You can use the Toolkit in your projects by:
1. Building the source code available in this repo (see instructions below)
2. Installing the latest stable release or pre-release from NuGet
    - Stable: [![NuGet](https://img.shields.io/nuget/v/Esri.ArcGISRuntime.Toolkit.svg)](https://www.nuget.org/packages/Esri.ArcGISRuntime.Toolkit)
    - Pre-release: [![NuGet](https://img.shields.io/nuget/vpre/Esri.ArcGISRuntime.Toolkit.svg)](https://www.nuget.org/packages/Esri.ArcGISRuntime.Toolkit/absolutelatest)

Two concurrent and supported versions of ArcGIS Runtime SDK are available: 100.x and 10.2.x

- [100.x (current version)](https://developers.arcgis.com/net/latest/)
- [10.2.x (previous version)](https://developers.arcgis.com/net/10-2/)

**The Toolkit for v100.x is currently in Beta: [Get the latest!](https://www.nuget.org/packages/Esri.ArcGISRuntime.Toolkit/absolutelatest)**

## Features

- Compass: Shows a compass direction when the map is rotated. Auto-hides when the map points north up.
- FeatureDataField: Displays and optionally allows editing of a single field attribute of a feature.
- Legend: Displays a legend for a single layer in your map (and optionally for its sub layers).
- MeasureToolbar: Allows measurement of distances and areas on the map view.
- ScaleLine: Displays current scale reference.
- SignInForm: Displays a UI dialog to enter or select credentials to use when accessing secure ArcGIS resources.
- ChallengeHandler: Displays SignInForm when accessing secure ArcGIS resources, as well as helper classes for storing credentials in Windows' credentials cache.
- SymbolDisplay: Renders a symbol in a control.
- TableOfContents: Creates a tree-view of the entire map document. Optionally displays legend information for the layers.

## Feature availibility by platform/API

|Component |UWP  |WPF  |Xamarin.Android  |Xamarin.iOS  |Xamarin.Forms |
|---|---|---|---|---|---|
|Compass   |*   |*   |   |   |   |
|FeatureDataField   |*   |*   |   |   |   |
|Legend   |*   |*   |   |   |   |
|MeasureToolbar   |*   |*   |   |   |   |
|ScaleLine   |*   |*   |*   |*   |*   |
|SignInForm   |   |*   |   |   |   |
|SymbolDisplay   |*   |*   |   |   |   |
|TableOfContents   |   |*   |   |   |   |

## Instructions for Building

1. Confirm that your system meets the requirements for compiling the Toolkit:
    - Visual Studio 2017 Update 3 (or later) with the following workloads:
        - `Universal Windows Platform development` (UWP)
        - `.NET desktop development` (WPF)
        - `Mobile development with .NET` (Xamarin.Android, Xamarin.iOS, and Xamarin.Forms)
2. Confirm your system meets the requirements for developing with ArcGIS Runtime SDK for .NET:
   - [WPF](http://developers.arcgis.com/net/desktop/guide/system-requirements.htm)
   - [UWP](https://developers.arcgis.com/net/latest/uwp/guide/system-requirements.htm)
   - [Xamarin.Android](https://developers.arcgis.com/net/latest/android/guide/system-requirements.htm)
   - [Xamarin.iOS](https://developers.arcgis.com/net/latest/ios/guide/system-requirements.htm)
   - [Xamarin.Forms (Android, iOS, and UWP)](https://developers.arcgis.com/net/latest/forms/guide/system-requirements.htm)
3. Fork and then clone the repo or download the .zip file.
4. Include (i) or reference (ii) the Toolkit in your projects:
* Note the Toolkit references [ArcGIS Runtime SDK for .NET](http://esriurl.com/dotnetsdk) by Nuget package. The package is automatically downloaded when you build the solution for the first time.
    1. Include the appropriate platform Projects in your Solution.
        - WPF (src\Esri.ArcGISRuntime.Toolkit\WPF\Esri.ArcGISRuntime.Toolkit.WPF.csproj)
        - UWP (\src\Esri.ArcGISRuntime.Toolkit\UWP\Esri.ArcGISRuntime.Toolkit.UWP.csproj)
        - Xamarin.Android (\src\Esri.ArcGISRuntime.Toolkit\Android\Esri.ArcGISRuntime.Toolkit.Android.csproj)
        - Xamarin.iOS (\src\Esri.ArcGISRuntime.Toolkit\iOS\Esri.ArcGISRuntime.Toolkit.iOS.csproj)
        - Xamarin.Forms (\src\Esri.ArcGISRuntime.Toolkit\XamarinForms\Esri.ArcGISRuntime.Toolkit.Xamarin.Forms.csproj)
    2. Build the Toolkit and reference the NuGet package you built.
        - Building each Toolkit project automatically creates the NuGet package for each platform in the project Output folder.
        - Create a local nuget source/feed and set it to the \Output\NuGet\Release folder.
        - Add the nuget package using the standard Nuget package manager dialog in Visual Studio.
        - It is also possible to create a nuget source pointing to the latest build (automatically updated after each pull-request gets merged): `https://ci.appveyor.com/nuget/arcgis-toolkit-dotnet`.
        - See [Setting Up Local NuGet Feeds](https://docs.microsoft.com/en-us/nuget/hosting-packages/local-feeds) for more information.

## System Requirements

* Requirements for development and deployment:
  * [Windows Desktop](https://developers.arcgis.com/net/latest/wpf/guide/system-requirements.htm)
  * [Universal Windows Platform (UWP)](https://developers.arcgis.com/net/latest/uwp/guide/system-requirements.htm)
  * [Xamarin.Android](https://developers.arcgis.com/net/latest/android/guide/system-requirements.htm)
  * [Xamarin.iOS](https://developers.arcgis.com/net/latest/ios/guide/system-requirements.htm)
  * [Xamarin.Forms](https://developers.arcgis.com/net/latest/forms/guide/system-requirements.htm)

## Resources

* [ArcGIS Runtime SDK for .NET](http://esriurl/dotnetsdk)

## Issues

Find a bug or want to request a new feature?  Please let us know by [submitting an issue](https://github.com/Esri/arcgis-toolkit-dotnet/issues/new).

## Contributing

Anyone and everyone is welcome to [contribute](CONTRIBUTING.md).

## v10.2.7

Looking for the Toolkit for ArcGIS Runtime SDK for .NET v10.2.7?

Go to the 10.2.7 tag: https://github.com/Esri/arcgis-toolkit-dotnet/tree/v10.2.7

## Licensing

Copyright © 2014-2017 Esri.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

   http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

A copy of the license is available in the repository's [license.txt](/license.txt) file.


text:
# Project Licenses
This file was generated by the [PHP Legal Licenses](https://github.com/Comcast/php-legal-licenses) utility. It contains the name, version and commit sha, description, homepage, and license information for every dependency in this project.

## Dependencies

### nesbot/carbon (Version 2.28.0 | e2bcbcd)
An API extension for DateTime that supports 281 different languages.
Homepage: http://carbon.nesbot.com
Licenses Used: MIT
Copyright (C) Brian Nesbitt

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is furnished
to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

### spatie/enum (Version 2.3.3 | 517a1cd)
PHP Enums
Homepage: https://github.com/spatie/enum
Licenses Used: MIT
The MIT License (MIT)

Copyright (c) Spatie bvba<EMAIL_ADDRESS>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

### symfony/polyfill-mbstring (Version v1.13.1 | 7b4aab9)
Symfony polyfill for the Mbstring extension
Homepage: https://symfony.com
Licenses Used: MIT
Copyright (c) 2015-2019 Fabien Potencier

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is furnished
to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

### symfony/translation (Version v5.0.2 | 3ae6fad)
Symfony Translation Component
Homepage: https://symfony.com
Licenses Used: MIT
Copyright (c) 2004-2019 Fabien Potencier

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is furnished
to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

### symfony/translation-contracts (Version v2.0.1 | 8cc682a)
Generic abstractions related to translation
Homepage: https://symfony.com
Licenses Used: MIT
Copyright (c) 2018-2019 Fabien Potencier

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is furnished
to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

### symfony/var-dumper (Version v5.0.2 | d7bc61d)
Symfony mechanism for exploring and dumping PHP variables
Homepage: https://symfony.com
Licenses Used: MIT
Copyright (c) 2014-2019 Fabien Potencier

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is furnished
to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

### tightenco/collect (Version v6.9.0 | 67525fa)
Collect - Illuminate Collections as a separate package.
Homepage: Not configured.
Licenses Used: MIT
Full license text not found in dependency source.

gha_language: PHP


text:
## What is PowerShell

Replacement for `cmd.exe` and VBScript

Made for the admin and the developer

Made for the console and scripts

Made for extensibility

---

## Why PowerShell

Everything is an object

Naming convention

Integrated help system

Remoting

Cross Platform

---

## History

"New" shell for Windows (born in 2006)

Scripting language for Windows

Created by Jeffrey Snover @ Microsoft

Windows PowerShell is feature complete

PowerShell Core works cross-platform

repository: nicholasdille/Sessions

repo_name: nicholasdille/Sessions


text:
Meldo is a simple module that abstracts away LLVM related boilerplate and
provides direct access to some V8 heap structures.

Currently it is extremely primitive and undocumented. It was written for
[moe.js](https://code.google.com/p/moe-js/).

Here is a small example of "melding" a function that multiplies two floating
point arguments:

    var meldo = new Meldo;
    with (meldo) {
      var x = unboxNumber(arg(0));  // fetch arg #0 and unbox it
      var y = unboxNumber(arg(1));  // fetch arg #1 and unbox it
      var result = fmul(x, y);      // multiply two double values
      ret(boxNumber(result));       // box result and return it
    }
    var func = meldo.meld();

Meldo is very low-level and requires deep understanding of V8 innards.

repository: mraleph/node-llvm

repo_name: mraleph/node-llvm


text:
This document is deprecated, please visit the [wiki entry here](https://github.com/bderiso/Microsoft-Github-acquisition/wiki/GitHub-Alternatives) or [contribute to the Google Sheet](https://docs.google.com/spreadsheets/d/1LZryaOx4VYHQ_oWLtRjvFrr4RhVjR484eFe7du3Usa4/edit?usp=sharing):

#
The heart of the issue is healthy competition (indeed, the anti-trust proceedings against Microsoft in the 90's were focused on that problem).
It is very understandable Github's market-share and Microsoft's industry dominace would make this asquisition scary for those who value
Github's independance.

----
# Thanks

This features list was correlated by [Serphentas](https://github.com/Serphentas) & [bderiso](https://github.com/bderiso).

The following people posted linked which I found helpful for compiling this document:

Github users: [xkr47](https://github.com/upend/IF_MS_BUYS_GITHUB_IMMA_OUT/issues/14#issuecomment-394244758), [austinhuang0131](https://github.com/upend/IF_MS_BUYS_GITHUB_IMMA_OUT/issues/9#issuecomment-394409579), [awilfox](https://github.com/upend/IF_MS_BUYS_GITHUB_IMMA_OUT/issues/1#issuecomment-394126231), [genacrys](https://github.com/upend/IF_MS_BUYS_GITHUB_IMMA_OUT/issues/44#issue-329293886), [rdococ](https://github.com/upend/IF_MS_BUYS_GITHUB_IMMA_OUT/issues/43#issue-329273818)

YCombimantor users: [Yetanfou](https://news.ycombinator.com/item?id=17213780) & [TheAceOfHearts](https://news.ycombinator.com/item?id=17223201)

repository: bderiso/Microsoft-Github-acquisition

path: /Github Alternatives.md

filename: Github Alternatives.md

repo_name: bderiso/Microsoft-Github-acquisition


text:
[![npm package][npm-badge]][npm]
[![dependencies][david-dm]][david]

# Reactuate Events

Reactuate Events is an answer to maintaining complex single-component UX
workflows in React that do not exactly fit into the Flux architecture as they
don't belong to the global state of the application and should be rather kept
inside of the component. Most common examples of that would be generic components such as complex table navigators, forms with complex validation
and verification workflows.

Traditional answer to this is to use callbacks that modify the state to reflect
where the user is at and what should be rendered to him. The problem with this
approach is that different pieces of the workflow become disconnected. Not only
it's hard to comprehend such code, it is also difficult to maintain it because
of the complexity of servicing all potential scenarios.

Reactuate Events uses an **experimental** ES7 feature of [asynchronous functions](https://tc39.github.io/ecmascript-asyncawait/) to reduce the complexity of this problem. Instead of connecting disjoint pieces,
one can write a sequential event handling function.

This library's benefit comes at the expense of a somewhat reduced utility of
hot code replacement (if you use it), since your asynchronous processor
function won't change midway. That said, the functionality provided by such functions often implies changes to state management in the component, or change in logic, which would often require a reload anyway.

*Please note that this is an extremely early prototype, bugs are very likely and the API* **will** *change.*

## Enabling Events

In order to enable component to use Reactuate Events, we need to compose it with `enableEvents`:

```js
import { enableEvents } from 'reactuate-events'

class MyComponent extends React.Component {}

MyComponent = enableEvents(MyComponent)
```

## Registering Events

We can enable events at any time, however, the initialization most commonly
would happen in the component's constructor:

```js
constructor() {
  super()

  this.createEvent("Click")
  this.eventProcessor()
}
```

## Triggering Events

Calling `createEvent` will create two properties in your component, `handleClick` and `waitForClick`. The former one is typically to be used in your `render()` function:

```html
<button onClick={() => this.handleClick()} />
```

## Handling Events

The latter (`waitForClick`) is to be used in the `eventProcessor` function that
we would define to process events as they come:

```js
async eventProcessor() {
  while (true) {
    await this.waitForClick
    await this.setStateAndWait({clicked: true})
  }
}
```

In the above example, we will wait for the button to be clicked and update
the state to reflect that click, indefinitely.

Of course, this is not very different from the traditional approach and adds
some ceremony. The elegance of this approach reveals itself when the workflows
become more complicated:

```js
async eventProcessor() {
  while (true) {
    await this.waitForClick
    await this.setStateAndWait({clicked: true})
    const value = await this.waitForInput
    await this.setStateAndWait({clicked: false, value})
  }
}
```

In the above example we will wait for some data input before recognizing another
button click, therefore significantly simplifying handling this workflow. And it
doesn't stop there.
If you use a Promise library like [bluebird](http://bluebirdjs.com), you can do interesting things, like waiting for an event *or* a timeout:

```js
const Timeout = Symbol("timeout")
while (true) {
  const waitForTimeout = new Promise(resolve =>
    setTimeout(() => resolve(Timeout), 2000))
  const result = await Promise.any([this.waitForClick, waitForTimeout])
  if (result === Timeout) {
  // ...
```

(Actually, `Timeout` and a generic version of `waitForTimeout` are also provided
by this library)

It is worth mentioning that it is unlikely to be a good practice to try to jam
all possible events into one event processor per component. It'll become rather
complicated. Instead, a number of small processors can be used and when their
proceedings are ready to be aggregated, they can trigger aggregation events
themselves.

# License

Reactuate Events is licensed under the terms of the Apache 2.0 license.

[npm]: https://www.npmjs.org/package/reactuate-events
[npm-badge]: https://badge.fury.io/js/reactuate-events.svg
[david-dm]: https://david-dm.org/reactuate/reactuate-events.svg
[david]: https://david-dm.org/reactuate/reactuate-events

repository: reactuate/reactuate-events

gha_language: JavaScript

repo_name: reactuate/reactuate-events


text:
EmPOWER: Mobile Networks Operating System
=========================================

### What is EmPOWER?
EmPOWER is a new network operating system designed for heterogeneous mobile networks.

### Top-Level Features
* Supports both LTE and WiFi radio access networks
* Northbound abstractions for a global network view, network graph, and
  application intents.
* REST API and native (Python) API for accessing the Northbound abstractions
* Support for Click-based Lightweight Virtual Networks Functions
* Declarative VNF chaning on precise portion of the flowspace
* Flexible southbound interface supporting WiFi APs LTE eNBs

Checkout out our [website](http://empower.create-net.org/) and our [wiki](https://github.com/5g-empower/empower-runtime/wiki)

This repository includes the Ryu Controller with the EmPOWER Intent-based backhauling interface.

Code is released under the Apache License, Version 2.0.


text:
# louds-rs

High performance LOUDS (Level-Order Unary Degree Sequence) library.

[Master API Docs](https://laysakura.github.io/louds-rs/louds_rs/)
|
[Released API Docs](https://docs.rs/crate/louds-rs)
|
[Benchmark Results](https://laysakura.github.io/louds-rs/criterion/report/)
|
[Changelog](https://github.com/laysakura/louds-rs/blob/master/CHANGELOG.md)

[![Build Status](https://travis-ci.com/laysakura/louds-rs.svg?branch=master)](https://travis-ci.com/laysakura/louds-rs)
[![Crates.io Version](https://img.shields.io/crates/v/louds-rs.svg)](https://crates.io/crates/louds-rs)
[![Crates.io Downloads](https://img.shields.io/crates/d/louds-rs.svg)](https://crates.io/crates/louds-rs)
[![Minimum rustc version](https://img.shields.io/badge/rustc-1.33+-lightgray.svg)](https://github.com/laysakura/louds-rs#rust-version-supports)
[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/laysakura/louds-rs/blob/master/LICENSE-MIT)
[![License: Apache 2.0](https://img.shields.io/badge/license-Apache_2.0-blue.svg)](https://github.com/laysakura/louds-rs/blob/master/LICENSE-APACHE)

## Quickstart

To use louds-rs, add the following to your `Cargo.toml` file:

```toml
[dependencies]
louds-rs = "0.1"  # NOTE: Replace to latest minor version.
```

### Usage Overview
Say we want to hold the following tree structure in minimum length of bits.

```
(1)
 |
 |---+---+
 |   |   |
(2) (3) (4)
 |       |
 |       |---+-----+
 |       |   |     |
(5)     (6) (7)   (8)
             |     |
             |     |----+
             |     |    |
            (9)   (10) (11)
```

This tree has NodeNum (node number of 1-origin, assigned from left node to right & top to bottom) and edges.
With LOUDS, this tree is represented as the following LBS (LOUDS Bit String).

```
NodeNum       | 0 (virtual root) | 1          | 2    | 3 | 4          | 5 | 6 | 7    | 8       | 9 | 10 | 11 |
LBS           | 1  0             | 1  1  1  0 | 1  0 | 0 | 1  1  1  0 | 0 | 0 | 1  0 | 1  1  0 | 0 | 0  | 0  |
Child NodeNum | 1  -             | 2  3  4  - | 5  - | - | 6  7  8  - | - | - | 9  - | 10 11 - | - | -  | -  |
Index         | 0  1             | 2  3  4  5 | 6  7 | 8 | 9  10 11 12| 13| 14| 15 16| 17 18 19| 20| 21 | 22 |
```

The same tree is represented as follows using index.

```
<0>
 |
 |---+---+
 |   |   |
<2> <3> <4>
 |       |
 |       |---+-----+
 |       |   |     |
<6>     <9> <10>  <11>
             |     |
             |     |----+
             |     |    |
            <15>  <17> <18>
```

Then, create this tree structure with `Louds` and call operations to it.

```rust
use louds_rs::{Louds, LoudsIndex, LoudsNodeNum};

// Construct from LBS.
let s = "10_1110_10_0_1110_0_0_10_110_0_0_0";
let louds = Louds::from(s);

// LoudsNodeNum <-> LoudsIndex
let node8 = LoudsNodeNum(8);
let index11 = louds.node_num_to_index(node8);
assert_eq!(louds.index_to_node_num(index11), node8);

// Search for children.
assert_eq!(louds.parent_to_children(node8), vec!(LoudsIndex(17), LoudsIndex(18)));

// Search for parent.
assert_eq!(louds.child_to_parent(index11), LoudsNodeNum(4));
```

### Constructors

```rust
use louds_rs::Louds;

// Most human-friendly way: Louds::from::<&str>()
let louds1 = Louds::from("10_1110_10_0_1110_0_0_10_110_0_0_0");

// Simple way: Louds::from::<&[bool]>()
let mut arr = vec![
    true, false,
    true, true, true, false,
    true, false,
    false,
    true, true, true, false,
    false,
    false,
    true, false,
    true, true, false,
    false,
    false,
    false,
];
let louds2 = Louds::from(&arr[..]);
```

## Features
- **Arbitrary length support with minimum working memory**: louds-rs provides virtually _arbitrary size_ of LOUDS. It is carefully designed to use as small memory space as possible.
- **Based on [fid-rs](https://crates.io/crates/fid-rs)**, which is fast, parallelized, and memory efficient. It provides fast construction (`Louds::from()`).
- **Latest benchmark results are always accessible**: louds-rs is continuously benchmarked in Travis CI using [Criterion.rs](https://crates.io/crates/criterion). Graphical benchmark results are published [here](https://laysakura.github.io/louds-rs/criterion/report/).

### Complexity
When the number of nodes in the tree represented as LOUDS is _N_:

| Operation | Time-complexity | Space-complexity |
|-----------|-----------------|------------------|
| [Louds::from::<&str>()](https://laysakura.github.io/louds-rs/louds_rs/louds/struct.Louds.html#implementations) | _O(N)_ | _N + o(N)_ |
| [Louds::from::<&[bool]>()](https://laysakura.github.io/louds-rs/louds_rs/louds/struct.Louds.html#implementations) | _O(N)_ | _N + o(N)_ |
| [node_num_to_index()](https://laysakura.github.io/louds-rs/louds_rs/louds/struct.Louds.html#method.node_num_to_index) | _O()_ | _N + o(N)_ |
| [index_to_node_num()](https://laysakura.github.io/louds-rs/louds_rs/louds/struct.Louds.html#method.index_to_node_num) | _O(1)_ | _O(1)_ |
| [child_to_parent()](https://laysakura.github.io/louds-rs/louds_rs/louds/struct.Louds.html#method.child_to_parent) | _O(1)_ | _O(1)_ |
| [parent_to_children()](https://laysakura.github.io/louds-rs/louds_rs/louds/struct.Louds.html#method.parent_to_children) | _O( max(log N, max num of children a node has) )_ | _O( max(log N, max num of children a node has) )_ |

(`node_num_to_index()` and `child_to_parent()` use [Fid::select()](https://laysakura.github.io/fid-rs/fid_rs/fid/struct.Fid.html#method.select). `index_to_node_num()` and `parent_to_children()` use [rank()](https://laysakura.github.io/fid-rs/fid_rs/fid/struct.Fid.html#method.rank)).

## Versions
louds-rs uses [semantic versioning](http://semver.org/spec/v2.0.0.html).

Since current major version is _0_, minor version update might involve breaking public API change (although it is carefully avoided).

## Rust Version Supports

louds-rs is continuously tested with these Rust versions in Travis CI:

- 1.33.0
- Latest stable version

So it expectedly works with Rust 1.33.0 and any newer versions.

Older versions may also work, but are not tested or guaranteed.

## Contributing

Any kind of pull requests are appreciated.

### Guidelines

- `README.md` is generated from `$ cargo readme` command. Do not manually update `README.md` but edit `src/lib.rs` and then `$ cargo readme > README.md`.
- Travis CI automatically does the following commit & push to your pull-requests:
    - `$ cargo readme > README.md`
    - `$ cargo fmt --all`

## License

MIT OR Apache-2.0

repository: laysakura/louds-rs

gha_language: Rust

gha_license_id: NOASSERTION

repo_name: laysakura/louds-rs


text:
# Next chord prediction

Given a stream of audio signal and previous chords predict the next chord.

It can be useful when playing eg. on guitar.

The model could be trained via CharRNN.

repository: bzamecnik/ideas

repo_name: bzamecnik/ideas


text:
---
layout: layout.njk
title: Parcel v2.9.0
eleventyNavigation:
  key: blog-parcel-2-9-0
  title: Parcel v2.9.0
date: 2023-05-26
---

Parcel v2.9.0 includes many long requested features, including a brand new resolver with support for package.json "exports" and tsconfig.json features, support for ESM plugins and configs, and local Parcel plugins. It also improves performance with a new default JS minifier powered by SWC, incremental symbol propagation, and improved bundler data structures, and includes a new build performance tracing feature. This is a big release – let's dive in!

## New resolver

Parcel's resolver is responsible for finding a file path for a dependency such as `import "react"`. This may seem simple, but as the JavaScript ecosystem has developed over the years, it has become more and more complex. Parcel's current resolver implementation was originally written [way back in 2018](https://medium.com/@devongovett/parcel-v1-7-0-9aac0c505837), and is missing some modern features like package.json "exports" and "imports".

Parcel v2.9.0 includes a brand new resolver implementation written from scratch in Rust. It supports all of the existing Parcel resolution features, while adding support for package.json "exports" and "imports", and tsconfig.json "baseUrl", "paths", and "moduleSuffixes".

Unfortunately, enabling support for package.json "exports" is a breaking change. When a package declares "exports", consumers can no longer import files that are not exported. In addition, due to exports conditions like "import" and "require", there is a possibility of a [dual package hazard](https://nodejs.org/api/packages.html#dual-package-hazard). For these reasons, exports support is currently opt-in and must be explicitly enabled in your project. This can be done by adding the following to your project root package.json:

```json
{
  "@parcel/resolver-default": {
    "packageExports": true
  }
}
```

Check out the documentation for [package.json exports](/features/dependency-resolution/#package-exports) and [tsconfig.json](/features/dependency-resolution/#tsconfig) to learn more about the new features!

## ESM plugins and configs

Parcel now supports plugins and config files written as native ES modules in addition to the existing support for CommonJS. This means that plugins can be published to npm using the `.mjs` format, or use `"type": "module"` in their package.json to enable ESM syntax in `.js` files. Config files such as `postcss.config.mjs` are also now supported.

This was surprisingly difficult to implement, which is why it has taken us so long. Parcel supports granular caching for everything it does to improve development performance. For this to work, it needs to track every file that is involved with your build. This includes all of the dev dependencies such as plugins, compilers, and config files that influenced the output. If any of these change, Parcel recompiles only the necessary files.

Internally, this has relied on patching Node's `require` implementation so that we can track all of the dev dependencies that are loaded. But this only works for CommonJS modules. With native ESM, there is currently no stable way to tap into the module loader in Node, which meant we couldn't track what files were imported.

To track ESM dependencies, Parcel now uses a fork of the excellent [es-module-lexer](https://github.com/guybedford/es-module-lexer) project, which is an extremely fast parser written in C, specifically designed to analyze ES module import and export syntax. We've integrated this with a Rust library that resolves those dependencies using our new resolver implementation, and collects all of the files used by an ESM plugin or config file. This allows us to invalidate the cache whenever one of these dependencies changes.

We do our best to statically analyze as much as we can, but some syntax like `import(someVariable)` isn't supported and will result in the cache being invalidated every build. You'll see a warning in those cases.

ESM support is experimental in this release. If you have feedback, please open an issue or discussion [on Github](https://github.com/parcel-bundler/parcel).

## Local plugins

Historically, Parcel v2 plugins have been required to be npm packages. Local plugins within your project were possible if you were using a monorepo, but we always encourage plugins to be published to npm or to an internal company registry so they can be reused by others. However, we heard feedback that this made building and prototyping plugins harder for projects not using a monorepo setup.

In Parcel v2.9.0, plugins can be referenced as relative paths from your `.parcelrc` config. They don't need to have their own package.json – you can reference a JavaScript file directly. Plugins hot reload when you make changes, so you don't even need to restart Parcel as you develop. While we still encourage publishing plugins to npm, this should make it easier to prototype new plugins.

You can learn more about local plugins in [the docs](/features/plugins/#local-plugins).

## SWC minifier

Parcel was one of the first tools to switch to the [SWC](https://swc.rs) JavaScript compiler, and it helped us improve performance [by 10x](/blog/beta3/) back in 2021. In Parcel v2.9.0, we are switching the default minifier from Terser to SWC as well.

The SWC minifier is around [7x faster](https://github.com/privatenumber/minification-benchmarks) than Terser, while producing comparable to even smaller output size. Most Terser configuration options are also supported by SWC, so if you have a `.terserrc` it should continue to work.

Huge thanks to the SWC team for their fantastic work improving minification performance for the whole ecosystem!

## Incremental symbol propagation

One of the main goals for Parcel from the beginning was to make rebuilds scale based on the size of the changes rather than the size of the entire project. This means it should be fast to rebuild if your project is 1 file or 100,000.
That's why we have implemented granular caching since the very first version in 2017, and why we have continued to introduce new features like [incremental bundling](/blog/v2-8-0/#hmr-rebuild-performance).

Symbol propagation is an algorithm that walks the full dependency graph of your project, and determines which exports of each module are actually used and which ones can be tree shaken away. In Parcel v2.9.0, this algorithm is now incremental. Instead of traversing over the full graph every time you make a change, it tracks what dependencies have been modified in the files you changed, and surgically updates the existing graph in place. For very large projects, this helps significantly reduce the amount of work that needs to be done each time you save a file.

Symbol propagation now also runs in development rather than only in production builds. This enables us to emit proper errors during development when you try to import something that isn't exported from a module, which can be helpful when debugging.

## Build performance tracing

Parcel now includes a `--trace` CLI flag, which will track how much time is spent in each phase of your build, which plugins were called into, and how long is spent in each. A Parcel trace can help you to optimize your build by answering questions such as, "Which plugin is taking the most time during my build?" or "Which file in my project takes the longest to transform?".

Parcel has supported a `--profile` flag for a while, which runs V8's sampling CPU profiler. `--trace` is much higher level, making it easier to see performance data at a plugin level instead of a function level. Both output data in the Chrome Tracing Format, which you can load into the Chrome Dev Tools or other more advanced analysis tools such as [Perfetto](https://ui.perfetto.dev/). There you can run SQL queries against the data to answer questions like the ones listed above.

Check out the [documentation](/features/profiling/) to learn more.

## And more!

In addition to the major features above, there were a ton more smaller features and bug fixes in this release. Check out the [full release notes](https://github.com/parcel-bundler/parcel/releases/tag/v2.9.0) for details.

Thanks to everyone who contributed to this release!

- [GitHub](https://github.com/parcel-bundler/parcel)
- [Discord community](https://discord.gg/XSCzqGRuvr)
- [Support us on Open Collective](https://opencollective.com/parcel)

repository: parcel-bundler/website

repo_name: parcel-bundler/website


text:
---
layout: default
---

# 1993-11-20 - Encryption: A Testimonial

## Header Data

From: Eric Blossom<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 2da7e52506f7091365204f7900f5b258087bc3c887ddb638ad4f829cd1427b20

Message ID<EMAIL_ADDRESS>Reply To<EMAIL_ADDRESS>UTC Datetime: 1993-11-20 07:47:01 UTC

Raw Date: Fri, 19 Nov 93 23:47:01 PST

## Raw message

```
{% raw  %}From: Eric Blossom<EMAIL_ADDRESS>Date: Fri, 19 Nov 93 23:47:01 PST
To<EMAIL_ADDRESS>Subject: Encryption: A Testimonial
In-Reply-To<EMAIL_ADDRESS>Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

> > Actually, you could fool a lot of people by creating a hidden disk
> > partition.  Nobody would know there was anything hidden unless they did
...
> this is very easy in unix:  put your secret stuff in a directory,
> then mount a file system on that directory.

Another nice way is to remove the dev files for the disk at
shutdown time.  Then at reboot, you'd have to manually create dev
files (knowing the major and minor numbers) and manually mount the
file system.  There'd be no trace.  This would work real well with big
disks... Is that a 1.0, 1.1 or 1.2G filesystem?  How much swap is
allocated, anyway?  You could also use a litte steganography and spare
out a set of ``bad'' sectors.  Some controllers will do the sector sparing
for you (transparently to the OS)...  All sorts of opportunities ;-)

	Eric Blossom

{% endraw %}
```

## Thread

+ Return to [November 1993](/archive/1993/11)

+ Return to "[Eric Blossom <eb@srlr14.sr.hp.com>](/authors/eric_blossom_eb_at_srlr14_sr_hp_com_)"
+ Return to "[peter honeyman <honey@citi.umich.edu>](/authors/peter_honeyman_honey_at_citi_umich_edu_)"

+ 1993-11-19 (Fri, 19 Nov 93 06:06:52 PST) - [Re: Encryption: A Testimonial](/archive/1993/11/3ed3a958d77013911114ffb545465c5f624cf41f4270e6521e8e9631dc415652) - _peter honeyman<EMAIL_ADDRESS>  + 1993-11-20 (Fri, 19 Nov 93 23:47:01 PST) - Encryption: A Testimonial - _Eric Blossom<EMAIL_ADDRESS>


text:
# Ethereum Ropsten Docker miner
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)

Setup Ethereum Ropster miner using Docker. You can customize the resources used by the container.

## Requirements
You only need:
* [Docker](https://docs.docker.com/)
* Make

If you have `Ubuntu`, to install make simply use:

```bash
$ sudo apt-get install make
```

## Build params
You can customize multiple params. See next table.

| Param         	| Description                                                         	| Default value                                	|
|---------------	|---------------------------------------------------------------------	|----------------------------------------------	|
| `ETHER_BASE`  	| Public address for block mining rewards                             	| `0x33C425D7E08aa105a4520f78b750b30AC6FF85CD` 	|
| `MEMORY`      	| The maximum amount of memory the container can use                  	| `4g`                                         	|
| `SWAP_MEMORY` 	| The amount of memory this container is allowed to swap to disk      	| `6gb`                                        	|
| `CPUS`        	| Specify how much of the available CPU resources a container can use 	| `2`                                          	|

>Note: Swap memory is equal to `$SWAP_MEMORY` - `$MEMORY`. Using the default values, the swap memory is 2g.

## Tasks
You can execute these tasks:

| **Name** 	| **Description**                       	|
|----------	|---------------------------------------	|
| `build`  	| Pull the Docker image                 	|
| `start`  	| Start the node in the Ropsten network 	|
| `shell`  	| Open an interactive Geth console      	|

## Start miner
You can start the miner with the default values

```bash
$ make start
```

This command downloads the image `client-go` and start it to mine in the `Ropsten network`. For more detail see the [Makefile](Makefile). If you want to
customize the container resources, you just have to overwrite the variables. For example, if you want to limit the cpu to 4, then:

```bash
$ CPUS=4 make start
```

repository: fooock/ropsten-miner-docker

gha_language: Makefile

repo_name: fooock/ropsten-miner-docker


text:
CloudASR
========

CloudASR is a software platform and a public ASR webservice. Its three strong features are:
 - automatic scalability with increased workload
 - ease of deployment
 - state-of-the-art incremental speech recognition performance

Platform’s API supports both batch and incremental speech recognition. The batch version is compatible with Google Speech API. New ASR engines can be added onto the platform and work simultaneously.

### Installation
In order to be able to run CloudASR Docker has to be installed on the host machine.
You can follow the instructions for your distribution at [http://docs.docker.com/installation/](http://docs.docker.com/installation/).
Additionally it is necessary to download docker images. You can do that by typing `make pull` - be aware that the images has several GBs.

### Running CloudASR locally
Just type `make run_locally` and everything will be running in a while.
You can open [http://localhost:8001](http://localhost:8001) to see which workers are running.
Additionally, you can open [http://localhost:8000](http://localhost:8000) and try out our interactive web demo.

### Running CloudASR on Mesos cluster
In order to be able to run the CloudASR on Mesos cluster, you have to update `marathon_url` and `master_ip` in the `mesos.json` configuration:
```json
{
    "domain": "cloudasr.com",
    "marathon_url": "localhost:8080",
    "master_ip": "<IP_ADDRESS> - IP of the mesos-slave where the CloudASR master should run",
    "workers": [
        {"image": "ufaldsg/cloud-asr-worker-en-voxforge", "instances": 1},
        {"image": "ufaldsg/cloud-asr-worker-en-wiki", "instances": 1},
        {"image": "ufaldsg/cloud-asr-worker-en", "instances": 1},
        {"image": "ufalgsg/cloud-asr-worker-cs", "instances": 1},
        {"image": "ufaldsg/cloud-asr-worker-cs-alex", "instances": 1}
    ]
}
```
> Note that the suffix of the worker image name corresponds to `lang` parameter used in Batch and Online APIs. For `example ufaldsg/cloud-asr-worker-en` will handle requests with parameter `lang=en`.

After that you can type `make run_mesos` and you should see running instances in the Marathon console in a while. After that you should start a load-balancer on a server associated with the domain specified in the `mesos.json`. You can do that by typing:
```
docker run -p 80:80 -e MARATHON_URL=localhost:8080 -d choko/haproxy
```
After that you should be able to see the demo page on [http://demo.cloudasr.com](http://demo.cloudasr.com) and the monitor page on [http://monitor.cloudasr.com](http://monitor.cloudasr.com).

## How to use CloudASR
CloudASR provides two modes of speech recognition: online recognition and batch recognition.
In the following text we will describe how you can use them.

### Batch API
Batch API is compatible with Google Speech API, but it supports only wav files and json output at this moment.
Users can use parameter `lang` to specify which language they want to use for speech recognition. These language models are available now:
  - **en-voxforge** - English (Voxforge AM+Wikipedia LM)
  - **en-wiki** - English (TED AM+Wikipedia LM)
  - **en-towninfo** - English (VYSTADIAL TownInfo AM+LM)
  - **cs** - Czech (VYSTADIAL AM + Wikipedia LM)
  - **cs-alex** - Czech (VYSTADIAL AM + PTIcs LM)

If you want to transcribe english speech in a `recording.wav` file you can send following curl request:
```
curl -X POST --data-binary @recording.wav --header 'Content-Type: audio/x-wav; rate=16000;' 'http://localhost:8000/recognize?lang=en-towninfo'
```

and you should get a response similiar to this:
```json
{
  "result": [
    {
      "alternative": [
        {
          "confidence": 0.5549500584602356,
          "transcript": "I'M LOOKING FOR A BAR"
        },
        {
          "confidence": 0.14846260845661163,
          "transcript": "I AM LOOKING FOR A BAR"
        },
        {
          "confidence": 0.08276544511318207,
          "transcript": "I'M LOOKING FOR A RESTAURANT"
        },
        {
          "confidence": 0.06668572872877121,
          "transcript": "I AM LOOKING FOR A RESTAURANT"
        }
      ],
      "final": true
    }
  ],
  "result_index": 0
}
```

### Online API
Online API uses Sockets.io for transfering PCM chunks to the CloudASR server. Messages have following format:

#### From Client to Server
  - First we have to start recognition by sending information about used language.
    ```javascript
    socketio.emit('begin', {'lang': 'en-GB'})
    ```
  - After that we can send PCM chunks to the server. Every chunk is a 16 bit PCM array.
    ```javascript
    socketio.emit('chunk',  {'chunk': [128, 123, 15,..., 25], 'frame_rate': 16000})
    ```

  - Finally we end the recognition by sending following message
    ```javascript
    socketio.emit('end', {})
    ```

#### From Server to Client
Server responds to every chunk with a message with interim results:
```json
{
    "status": 0,
    "final": false,
    "result": {
        "hypotheses": [
            {"transcript": "I AM LOOKING"}
        ]
    }
}
```

At the end of the recognition server sends final hypothesis in the following format:
```json
{
    "result": [
        {
            "alternative": [
                {"confidence": 0.5364137887954712, "transcript": "I AM LOOKING FOR A MY"},
                {"confidence": 0.46358612179756165, "transcript": "I'M LOOKING FOR A MY"}
            ],
            "final": true
        }
    ],
    "result_index": 0
}
```

> Note that the Online API will switch from SocketsIO to binary Websockets to decrease the traffic in the near future.

#### Using CloudASR's SpeechRecognition.js library
If you want to use speech recegnition on your website, you can use our javascript library. Please add these scripts to your html:
```html
<script src="http://www.cloudasr.com/js/socket.io.js"></script>
<script src="http://www.cloudasr.com/js/Recorder.js"></script>
<script src="http://www.cloudasr.com/js/SpeechRecognition.js'"></script>
```

Then you can use SpeechRecognition in following manner:
```javascript
var speechRecognition = new SpeechRecognition();
speechRecognition.onStart = function() {
    console.log("Recognition started");
}

speechRecognition.onEnd = function() {
    console.log("Recognition ended");
}

speechRecognition.onError = function(error) {
    console.log("Error occured: " + error);
}

speechRecognition.onResult = function(result) {
    console.log(result);
}

var lang = "en-wiki";
$("#button_start").click(function() {
    speechRecognition.start(lang);
});

$("#button_stop").click(function() {
    speechRecognition.stop()
});
```

You can also take a look at source code of our demo page ([index.html](https://github.com/UFAL-DSG/cloud-asr/blob/master/cloudasr/frontend/templates/index.html), [main.js](https://github.com/UFAL-DSG/cloud-asr/blob/master/cloudasr/frontend/static/js/main.js)).

## Privacy & Terms
All data, including audio recording, is stored for the purpose of ASR quality improvement.
Note that the data can be shared with third parties for both research and commercial purposes.
All collected data will be made available to the ASR community; therefore, do not say anything you do not want
anyone to know about.

The service is available for free. As a result, no guarantees are given regarding the quality of
ASR results. As of now, it is a beta product; thus, things may break and the service may not be
available for large periods of time.

## Contact us
The CloudASR platform is developed by the Dialogue Systems Group at [UFAL](http://ufal.mff.cuni.cz) and the work is funded by the Ministry of Education, Youth and Sports of the Czech Republic under the grant agreement LK11221, by the core research funding of Charles University in Prague. The language resources presented in this work are stored and distributed by the LINDAT/CLARIN project of the Ministry of Education, Youth and Sports of the Czech Republic (project LM2010013).

If you have any questions regarding CloudASR you can reach us at our mailinglist: [cloudasr@googlegroups.com](cloudasr@googlegroups.com).

repository: oplatek/cloud-asr

repo_name: oplatek/cloud-asr


text:
#### Package deprecation notice

As of 2019-11-18, the team is deprecating this component library because of a newly emergent reliance on internal libraries. With this in mind, the package has been renamed and published internally. All further development of this library, including new features and bug fixes, will continue in the new repository. Thus, this repository will no longer be maintained.

You are welcome to migrate to `@cimpress-technology/react-cimpress-tagliatelle`, sourcing it from the internal repository.

##### What will happen if I do nothing?

You will be using an unmaintained version of the library, which means that no support will be offered.

##### I am an external user without access to the internal repository. What can I do?

Unfortunately, at the time we are unable to provide you with a replacement component library. You may continue using the unmaintained library, albeit at your own risk.

# react-cimpress-tagliatelle

TBD

## Development

1. Clone the repository

        git clone https://github.com/Cimpress/react-cimpress-tagliatelle

3. Run the following command to download the language translations files.

        npm run build

4. For developing, we use [Storybook](https://github.com/storybooks/storybook). You can run and see
the stories with:

        npm run storybook

5. Make sure your code passes the linting rules

        npm run code-check

6. Make sure to update **package.json** with the new version of the package (please follow
[semantic versioning](https://semver.org/). After, please also update **CHANGELOG.md** file
with short info for the changes in this new version.

7. Don't forget to enjoy!

repository: Cimpress/react-cimpress-tagliatelle

repo_name: Cimpress/react-cimpress-tagliatelle


text:
###Synopsis

`#include <math.h>`

`double asin(double x);`
`float asinf(float x);`
`long double asinl(long double x);`

###Description

The functions return the principal value of the arc sine of x, expressed in radians.

Arguments:
x - value whose arc sine is computed, in the interval [`-1`,`+1`].

###Return value
Upon successful completion, the functions return the arc sine of x, in the range [-π/2,π/2] radians.

For finite values of x  not in the range [`-1`,`1`], a domain error occurs and a `NaN` is returned.

If x is `NaN`, a `NaN` is returned.

If x is `0`, x is returned.

If x is `Inf`, a domain error occurs, and a `NaN` is returned.

If x is subnormal, a range error occurs and x is returned.

###Errors
`[EDOM]` (Domain Error) -     The x argument is finite and is not in the range [`-1,1`] or is `Inf`.
            If the integer expression (`math_errhandling` & `MATH_ERRNO`) is non-zero, then `errno` is set to [`EDOM`]. If the integer expression (`math_errhandling` & `MATH_ERREXCEPT`) is non-zero, then the invalid floating-point exception is raised.

`[ERANGE]` (Range Error) - The value of x is subnormal.
            If the integer expression (`math_errhandling` & `MATH_ERRNO`) is non-zero, then `errno` is set to [`ERANGE`]. If the integer expression (`math_errhandling` & `MATH_ERREXCEPT`) is non-zero, then the underflow floating-point exception is raised.

repository: Yetam/PhoenixRTOS

repo_name: Yetam/PhoenixRTOS


text:
# Creating an Instance

Before we are able to start using Vulkan, we must first create an instance. A `VkInstance` is an object that contains all the information the implementation needs to work. Unlike OpenGL, Vulkan does not have a global state. Because of this, we must instead store our states in this object. In this chapter, we'll be beginning a class we'll use for the rest of the book. Here are the headers we will need to include:

```cpp
#include <stdio.h>
#include <stdlib.h>
#include <vulkan/vulkan.h>
#include <vector>
```

We'll be storing all of our variables in a class we'll call `VulkanExample` for now. The code will start out looking like:

```cpp
class VulkanExample {
 private:
  void initInstance();
  VkInstance instance;
 public:
  VulkanExample();
  virtual ~VulkanExample();
};
```

In this chapter, we'll be focusing on the constructor and the `initInstance` method. We'll also define a `VulkanTools` class which will contain an `exitOnError` method we'll write later in this chapter. Here are the headers we'll include:

```cpp
#include <stdio.h>
#if defined(_WIN32)
#include <Windows.h>
#endif
```

Here is the `namespace` that will house our methods:

```cpp
#define APPLICATION_NAME "Vulkan Example"
#define ENGINE_NAME "Vulkan Engine"

namespace VulkanTools {
void exitOnError(const char *msg);
}
```

## Application Information

Before we can use `VkInstanceCreateInfo`, we need to use another type to describe our application. The `VkApplicationInfo` contains the name of the application, application version, engine name, engine version, and API version. Like OpenGL, if the driver does not support the version we request, we most likely will not be able to recover.

**Definition for `VkApplicationInfo`**:

```cpp
typedef struct VkApplicationInfo {
  VkStructureType    sType;
  const void*        pNext;
  const char*        pApplicationName;
  uint32_t           applicationVersion;
  const char*        pEngineName;
  uint32_t           engineVersion;
  uint32_t           apiVersion;
} VkApplicationInfo;
```

**[Documentation](https://www.khronos.org/registry/vulkan/specs/1.0/xhtml/vkspec.html#VkApplicationInfo) for `VkApplicationInfo`**:

- `sType` is the type of this structure.
- `pNext` is `NULL` or a pointer to an extension-specific structure.
- `pApplicationName` is a pointer to a null-terminated UTF-8 string containing the name of the application.
- `applicationVersion` is an unsigned integer variable containing the developer-supplied version number of the application.
- `pEngineName` is a pointer to a null-terminated UTF-8 string containing the name of the engine (if any) used to create the application.
- `engineVersion` is an unsigned integer variable containing the developer-supplied version number of the engine used to create the application.
- `apiVersion` is the version of the Vulkan API against which the application expects to run (encoded). If `apiVersion` is `0` the implementation must ignore it, otherwise if the implementation does not support the requested `apiVersion` it must return `VK_ERROR_INCOMPATIBLE_DRIVER`.

**Usage for `VkApplicationInfo`**:

```cpp
VkApplicationInfo appInfo = {};
appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
appInfo.pNext = NULL;
appInfo.pApplicationName = applicationName;
appInfo.pEngineName = engineName;
appInfo.apiVersion = VK_MAKE_VERSION(1, 0, 3);
```

You'll notice that for `apiVersion`, I am using `VK_MAKE_VERSION`. This allows the developer to specify a targeted Vulkan version. We'll see later that if the version we try to get is unsupported, we'll get an error called `VK_ERROR_INCOMPATIBLE_DRIVER`.

## Instance Create Information

`VkInstanceCreateInfo` will be used to inform Vulkan of our application info, layers we'll be using, and extensions we want.

**Definition for `VkInstanceCreateInfo`**:

```cpp
typedef struct VkInstanceCreateInfo {
  VkStructureType             sType;
  const void*                 pNext;
  VkInstanceCreateFlags       flags;
  const VkApplicationInfo*    pApplicationInfo;
  uint32_t                    enabledLayerCount;
  const char* const*          ppEnabledLayerNames;
  uint32_t                    enabledExtensionCount;
  const char* const*          ppEnabledExtensionNames;
} VkInstanceCreateInfo;
```

**[Documentation](https://www.khronos.org/registry/vulkan/specs/1.0/xhtml/vkspec.html#VkInstanceCreateInfo) for `VkInstanceCreateInfo`**:

- `sType` is the type of this structure.
- `pNext` is `NULL` or a pointer to an extension-specific structure.
- `flags` is reserved for future use.
- `pApplicationInfo` is `NULL` or a pointer to an instance of `VkApplicationInfo`. If not `NULL`, this information helps implementations recognize behavior inherent to classes of applications.
- `enabledLayerCount` is the number of global layers to enable.
- `ppEnabledLayerNames` is a pointer to an array of `enabledLayerCount` null-terminated UTF-8 strings containing the names of layers to enable for the created instance.
- `enabledExtensionCount` is the number of global extensions to enable.
- `ppEnabledExtensionNames` is a pointer to an array of `enabledExtensionCount` null-terminated UTF-8 strings containing the names of extensions to enable.

**Usage for `VkInstanceCreateInfo`**:

```cpp
VkInstanceCreateInfo createInfo = {};
createInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
createInfo.pNext = NULL;
createInfo.flags = 0;
createInfo.pApplicationInfo = &appInfo;
```

However, we're missing platform specific extensions. We'll need these later when we approach rendering and get started with swap chains. Basically, Vulkan as an API does not make us render to a surface. But if you're rendering a scene, you'll most likely want to display something. Retrieving a surface is platform specific and requires extensions. Let's look at how to get the extension for a surface:

```cpp
std::vector<const char*> enabledExtensions = { VK_KHR_SURFACE_EXTENSION_NAME };

#if defined(_WIN32)
	enabledExtensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
#elif defined(__ANDROID__)
	enabledExtensions.push_back(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME);
#elif defined(__linux__)
	enabledExtensions.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
#endif
```

Now we should be able to go back to our `createInfo` variable and add these lines:

```cpp
createInfo.enabledExtensionCount = enabledExtensions.size();
createInfo.ppEnabledExtensionNames = enabledExtensions.data();
```

## Creating an Instance

Finally we're ready to create our instance. A Vulkan instance is similar, in concept, to an OpenGL rendering context. Like I alluded to before, we'll store the engine state here including layers and extensions. To create an instance, we'll be using the `vkCreateInstance` function.

**Definition for `vkCreateInstance`**:

```cpp
VkResult vkCreateInstance(
  const VkInstanceCreateInfo*                 pCreateInfo,
  const VkAllocationCallbacks*                pAllocator,
  VkInstance*                                 pInstance);
```

**[Documentation](https://www.khronos.org/registry/vulkan/specs/1.0/xhtml/vkspec.html#initialization-instances) for `vkCreateInstance`**:

- `pCreateInfo` points to an instance of `VkInstanceCreateInfo` controlling creation of the instance.
- `pAllocator` controls host memory allocation.
- `pInstance` points a `VkInstance` handle in which the resulting instance is returned.

You'll want to note two things. First, we're not going to use `pAllocator`. Instead, we'll pass in `NULL` for this argument. Second, the call to this function returns a `VkResult`. This value is used for many function calls in Vulkan. It will tell us if we were successful, failed, or if something else happened. In this case, the value will tell us if the instance creation was successful or if it failed.

**Usage for `vkCreateInstance`**:

```cpp
VkResult result = vkCreateInstance(&createInfo, NULL, &instance);
```

After we've made the call, we should first check if our driver compatible. If it is not, we need to exit. We cannot recover. However, we should provide some sort of useful error. This error is extremely common in my experience. Second, we'll check if our call to `vkCreateInstance` successful. Again, if it was not, we need to exit. We cannot continue. These checks can be made with the following code:

```cpp
if (result == VK_ERROR_INCOMPATIBLE_DRIVER) {
  exitOnError(
      "Cannot find a compatible Vulkan installable client "
      "driver (ICD). Please make sure your driver supports "
      "Vulkan before continuing. The call to vkCreateInstance failed.");
} else if (result != VK_SUCCESS) {
  exitOnError(
      "The call to vkCreateInstance failed. Please make sure "
      "you have a Vulkan installable client driver (ICD) before "
      "continuing.");
}
```

## Termination on Error

Our `exitOnError` method is very simple. It will:

- Display a pop-up for Windows users (less people run from the terminal / powershell)
- Output to `stdout` for other platforms such as Linux

```cpp
void VulkanTools::exitOnError(const char *msg) {
#if defined(_WIN32)
  MessageBox(NULL, msg, ENGINE_NAME, MB_ICONERROR);
#else
  printf(msg);
  fflush(stdout);
#endif
  exit(EXIT_FAILURE);
}
```

## Cleaning Up (Destructor)

Exiting should be graceful if possible. In the case that our destructor is called, we will destroy the instance we created. Afterwards, the program will exit. The destructor looks like this:

```cpp
VulkanExample::~VulkanExample() {
  vkDestroyInstance(instance, NULL);
}
```

repository: ojasgarg/Vulkan-API-Book

repo_name: ojasgarg/Vulkan-API-Book


text:
Show that for every n the constant function lambdax(n) is TM computable. (Hint: Modify Example 1. Does your modification also
calculate lambdaxlambday(n)?)

It is TM computable, because we can write a code for a TM to compute it.

q1 1 R q2
q1 0 1 q1...
q(n-1) 1 R qn
q(n-1) 0 1 q(n-1)
qn 1 0 q(n+1)
q(n+1) 0 R qn
qn 0 L q(n+2)
q(n+2) 1 L q(n+2)
q(n+2) 0 R q(n+3)

No, it does not.


text:
# Cafeteria

Online Food Ordering System (OFOS) for restaurant with multiple branches.

## Recommended Helper Tools

* Meld - Git conflict resolving tool
* Trello - Manage team tasks
* React Developer Tools and JSON Viewer - Chrome Extension

## Technologies

* Server - nginx (while hosting)
* Backend Controller - Django (will be packed with Docker)
* Database - ?
* Frontend - ReactJS + Flux as dataflow architecture

## Important Links

* To edit standards doc click [here](https://docs.google.com/document/d/1GGlN-1dTA6Y5NTQy-bCTqPsA1pYeWLTQdxcTwxaXusg/edit?usp=sharing)

repository: azuraka/Cafeteria

repo_name: azuraka/Cafeteria


text:
# Wenture App
<!---
One Paragraph of project description goes here
--->
![Wenture App](https://cloud.githubusercontent.com/assets/24566763/26265609/749f1abc-3cea-11e7-9638-d00990dd2136.png)

## Getting Started

These instructions will get you a copy of the project up and running on your local machine for development and testing purposes.

### Prerequisites

What you need to install:
* Node.js
* NativeScript CLI
* iOS and Android requirements

You can find a quick-setup instructions from here: http://docs.nativescript.org/start/quick-setup

### Installing

After executing the following commands on the command line you will have a working copy of the application on your local environment. You will also have all the dependencies installed and Wenture App up and running on your emulator.

```
$ git clone https://github.com/rennehir/Wenture.git
$ cd Wenture
$ npm install
$ tns run ios | tns run android
```

## Built With

* [NativeScript](https://www.nativescript.org) - Open source framework for building truly native mobile apps with Angular, TypeScript or JavaScript.
* [nativescript-google-maps-sdk](https://github.com/dapriett/nativescript-google-maps-sdk) - a cross-platform (iOS & Android) Nativescript plugin for the Google Maps API
* [ROME](https://rometools.github.io/rome/) - Used to generate RSS Feeds

## Contributing

If you feel like contributing to our project, fork it and send a pull request!

## Authors

* **Renne Hirsimäki** - [rennehir](https://github.com/rennehir)
* **Joel Kataja** - [macleee](https://github.com/macleee)
* **Miiro Korhonen** - [mibetti](https://github.com/mibetti)
* **Jani Kuhno** - [Nisse95](https://github.com/Nisse95)
* **Paavo Väänänen** - [papivaan](https://github.com/papivaan)

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details

repository: rennehir/Wenture

repo_name: rennehir/Wenture


text:
---
layout: markdown
hero-image: url(/assets/images/about-us/work-in-progress.jpg)
hero-message: Kit Resources
---

Smart Sensor
==========

# SmartSensor

A multipurpose board that interfaces with a line-following array, potentiometers, and limit switches.

As an interface with various sensors, the Smart Sensor Board connects the Arduino Pro Micro to a five-pin screw terminal. One Smart Sensor Board board can connect to up to three sensors, provided they are of the same type and require only one I/O line.

---

## The Sensors

### List of Available Sensors

##### Limit Switch

A Limit Switch is a button. It is a passive component, so it requires a [pull up network](#pullUp). The level acts as a button to connect the two terminals.

##### Potentiometer

##### Line Follower

The Line Follower is the only active sensor. This means it requires 5 Volts power. It works by shining Infrared light downwards, and then reading how much is reflected back. The tape we use is very reflective, so the line following will only work right on top of the tape.

### Active vs. Passive Sensor

Active sensors require power to operate. There is some regulated output and sensed input that runs the sensor.

Passive means that it does not require dedicated power, and runs off [pull up networks](#pullUp).

* **The 5V Jumper on the board is necessary for the passive sensors.**

A jumper looks like this:

### What is a Pull Up Network?

A Pull Up Network is a part of a circuit that pull up the voltage at a node to a "High" Voltage so the Arduino can read the input as a Voltage.

![](http://www.seattlerobotics.org/encoder/mar97/basics1.gif)

---

##Wiring

Passive:
![Block Diagram](https://github.com/pioneers/SmartSensors/blob/master/Boards/TwistIt/pass_sensor.png?raw=true)

Active Sensor-interface setup:
![Block](https://github.com/pioneers/SmartSensors/blob/master/Boards/TwistIt/sens_interface.png?raw=true)
Examples:

#### Screw Terminal:

![screw terminal](http://i.imgur.com/gwrf49H.jpg)
For the screw terminal: going from right to left: 5V, A1, A2, A3, GND.

repository: pioneers/website

repo_name: pioneers/website


text:
# Behavioral Cloning Project

[![Udacity - Self-Driving Car NanoDegree](https://s3.amazonaws.com/udacity-sdc/github/shield-carnd.svg)](http://www.udacity.com/drive)

Overview
---
This repository contains important files for the Behavioral Cloning Project:
* model.py (script used to create and train the model)
* drive.py (script to drive the car - feel free to modify this file)
* model.h5 (a trained Keras model)
* writeup_report.md (a report writeup file (either markdown or pdf)
* run.mp4 (a video recording of your vehicle driving autonomously around the track for at least one full lap)

In this project, the training dataset was collected from a Unity simulation driving game. The driving environment is only one lane on the road. There are two lane road which can be trained in further works. I used deep neural networks and convolutional neural networks to clone driving behavior. I also trained, validated and tested a model using Keras. In the testing simulation, the model can output a steering angle to an autonomous vehicle.

Udacity has provided a simulator where I can steer a car around a track for data collection. I used image data and steering angles to train a neural network and then use this model to drive the car autonomously around the track. It would be good to play with joystick so that the driving behaviour will be more appropriate with smoother steering angles and the speed change.

The goals / steps of this project are the following:
* Use the simulator to collect data of good driving behavior
* Build, a convolution neural network in Keras that predicts steering angles from images
* Train and validate the model with a training and validation set
* Test that the model successfully drives around track one without leaving the road
* Summarize the results with a written report

[//]: # (Image References)

[image1]: ./report_images/model_architecture.jpeg "Model Architecture Reference"
[image2]: ./report_images/center_drive.jpg "Center Lane Drive"
[image3]: ./report_images/left_recovery1.jpg "Recovery Image"
[image4]: ./report_images/left_recovery2.jpg "Recovery Image"
[image5]: ./report_images//left_recovery3.jpg "Recovery Image"
[image6]: ./report_images/loss_result.png  "Loss Result"

## Rubric Points
### Here I will consider the [rubric points](https://review.udacity.com/#!/rubrics/432/view) individually and describe how I addressed each point in my implementation.

---
### Files Submitted & Code Quality

#### 1. All required files and can be used to run the simulator in autonomous mode

My project includes the following files:
* model.py containing the script to create and train the model
* drive.py for driving the car in autonomous mode
* model.h5 containing a trained convolution neural network
* writeup_report.md summarizing the results

#### 2. Functional code
Using the Udacity provided simulator and my drive.py file, the car can be driven autonomously around the track by executing
```sh
python drive.py model.h5
```

The autonomous driving video can be recorded by
```sh
#record the autonomous mode in 'run1' folder
python drive.py model.h5 run1
#generate the recording video as 'run1.mp4'
python video.py run1
```

#### 3. Submission code is usable and readable

The model.py file contains the code for training and saving the convolution neural network.
The file shows the pipeline I used for training and validating the model, and it contains comments to explain how the code works.

### Model Architecture and Training Strategy

#### 1. An appropriate model architecture has been employed
[1]: https://images.nvidia.com/content/tegra/automotive/images/2016/solutions/pdf/end-to-end-dl-using-px.pdf "Nvidia reference link"

My model is based on the architecture by NVIDIA's paper [End-to-End Learning for Self-Driving Cars][1]. This is a
model example:
![alt text][image1]

My model consists 10 layers including normalization, cropping, convolutions, and fully connected layers. I first
normalized the data using a Keras lambda layer （model.py lines 96) to set the values between -0.5 and 0.5, which can
also speed up the GPU processing. The second layer is the cropping （model.py lines 98), thus only the road part is
remained, and the input information is more targeted. Then I set 3 convolution layers （model.py lines 101-103) with 5x5
filters and 2x2 strides, followed by 2 convolution layers （model.py lines 104-105) with 3x3 filters and
non-strides. These are utilized to extract the features. The depth of the convolution layers increases from 3 to 64,
and the ELU activation instead of RELU is used to make the result more robust. As demonstrated in the NVIDIA's paper,
 the layers number is chosen empirically and ends up with a good simulation result. After the convolution layers, there
are 3 fully connected layers （model.py lines 109-112) which seems acted like a controller.

#### 2. Attempts to reduce overfitting in the model

The model contains dropout layers in order to reduce overfitting (model.py lines 106).

The model was trained and validated on different data sets to ensure that the model was not overfitting (code line
90). The training and validation images were generated by random batches with size 126. The images were flipped to
get more data and reduce the bias of the steering angles distribution.

The model was tested by running it through the simulator and ensuring that the vehicle could stay on the track.

#### 3. Model parameter tuning

The model used an adam optimizer, so the learning rate was not tuned manually (model.py line 120).

#### 4. Creation of the Training Set & Training Process

Training data was chosen to keep the vehicle driving on the road. When collecting the data, I mainly kept the car in
the center lane. Three images from left, center, and right cameras were taken to augment the training data as
well as the driving situation. The steering angles corresponding to images taken by the left and right cameras are
modified a bit, so that the model can learn to steer the car back to the center.

To capture good driving behavior, I first recorded two laps on track one using center lane driving. Here is an example
image of center lane driving:

![alt text][image2]

I also recorded the vehicle recovering from the left side and right sides of the road back to center so that the
vehicle would learn to recover from the side to the lane center and prevent driving off the road. These images show what a
recovery looks like starting from the right side :

![alt text][image3]
![alt text][image4]
![alt text][image5]

After the collection process, I then preprocessed this data by randomly modifying the
 images brightness. In addition, I flipped all the images and angles, added them to the dataset, which can augment
 the data. Thus, I had 43590 number of data points

I finally randomly shuffled the data set and put 20% of the data into a validation set.

I used this training data for training the model. The validation set helped determine if the model was over or under fitting.
The generator is used to only get a batch of data during each training iteration, to save the memory. The batch size
input into the model is actually 126, while the input into the generator is 22, because each sample in csv file
contains 3 images, and the flipping process in the generator function will twice the size of the data. The ideal number of epochs was 8 as it shows a good result
and also save training time. I used an adam optimizer so that manually training the learning rate was not necessary.

The training and validation loss for each epoch is shown as below:
![alt text][image6]

### Autonomous Mode Simulation

The result of training model can be tested and visualized by an autonomously drive by:
```sh
python drive.py model.h5
```
If the speed is set to be 10 mph, the car can keep on the lane center and drive smoothly. This simulation video is
shown in 'run.mp4'. When I set the speed to be 20 mph, the car will still keep inside the lane, but sometimes will
steer too much so that it will drive left and right when go advance. I think this issue may be due to the lack of
training data in high speed and with smooth steering angles. I do not have a joystick to control the car, and by the
keyboard it is hard to control the steering angle in high speed as well as keep it in the lane. Therefore, the data is collected
mainly under a speed of 12mph.

For the further improvement, the training on track two can be implemented and the model can be tested and modified. A
 joystick can be bought to control the car, which can reach a better result when driving in higher speed.


text:
AtoumBundle
===========

[![Build Status](https://secure.travis-ci.org/atoum/AtoumBundle.png)](http://travis-ci.org/atoum/AtoumBundle)

This bundle provides a (very) simple integration of [atoum](https://github.com/atoum/atoum), the unit testing framework, from [mageekguy](https://github.com/mageekguy) into Symfony2.

## Installation

### All with composer

```json
{
    "require": {
        "atoum/atoum-bundle": "dev-master"
    }
}
```

## Simple Usage

Make your test class extends the `atoum\AtoumBundle\Test\Units\Test` class of the bundle.

Don't forget to load this class with your favorite method (require, autoload, ...).

``` php
<?php

//if you don't use a bootstrap file, you need to require the autoload
require __DIR__ . '/../../../../../../../vendor/autoload.php';

// use path of the atoum.phar as bello if you don't want to use atoum via composer
//require_once __DIR__ . '/../../../../../vendor/mageekguy.atoum.phar';

use atoum\AtoumBundle\Test\Units;

class helloWorld extends Units\Test
{
}
```

## Web test case

You can create easily a kernel environment:

``` php
<?php

require __DIR__ . '/../../../../../../../vendor/autoload.php';

use atoum\AtoumBundle\Test\Units;

class helloWorld extends Units\WebTestCase
{
    public function testMyTralala()
    {
        $client = self::createClient();
    }
}
```

### Known issues

- The path of the AppKernel cannot be find, override the method `getKernelDirectory` and add the path to your `app` directory.

## Test a controller

You can test your controller with the ControllerTest class (it extends WebTestCase):

``` php
<?php

namespace vendor\FooBundle\Tests\Controller;

use atoum\AtoumBundle\Test\Units\WebTestCase;
use atoum\AtoumBundle\Test\Controller\ControllerTest;

class BarController extends ControllerTest
{
    //test a json api method
    public function testGet()
    {
        $client   = static::createClient();
        $crawler  = $client->request('GET', '/api/foobar');
        $response = $client->getResponse();

        $this
            ->integer($response->getStatusCode())
                ->isEqualTo(200)

            ->string($response->headers->get('Content-Type'))
                ->isEqualTo('application/json')
        ;
    }
}
```

repository: jeremyFreeAgent/AtoumBundle

repo_name: jeremyFreeAgent/AtoumBundle