text:
# Laravel Bank BNI

[![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square)](LICENSE.md)
[![Latest Version on Packagist](https://img.shields.io/packagist/v/aslam/laravel-bank-bni.svg?style=flat-square)](https://packagist.org/packages/aslam/laravel-bank-bni)
[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2FAslam97%2Flaravel-bank-bni.svg?type=small)](https://app.fossa.com/projects/git%2Bgithub.com%2FAslam97%2Flaravel-bank-bni?ref=badge_small)

The Laravel Bank BNI package is meant to integrate your Application with Bank BNI (Bank Negara Indonesia) API. For clearer and more complete documentation, please visit the official website [Developer BNI](https://digitalservices.bni.co.id)

## Features

This package provides tools for the following, and more:

- Get Token
- H2H

## Documentation

Please refer to our extensive [Wiki documentation](https://github.com/Aslam97/laravel-bank-bni/wiki) for more information.


text:
# `ResourceMetering` Invariants

## The base fee should increase if the last block used more than the target amount of gas.
**Test:** [`ResourceMetering.t.sol#L162`](../test/invariants/ResourceMetering.t.sol#L162)

If the last block used more than the target amount of gas (and there were no empty blocks in between), ensure this block's baseFee increased, but not by more than the max amount per block.

## The base fee should decrease if the last block used less than the target amount of gas.
**Test:** [`ResourceMetering.t.sol#L171`](../test/invariants/ResourceMetering.t.sol#L171)

If the previous block used less than the target amount of gas, the base fee should decrease, but not more than the max amount.

## A block's base fee should never be below `MINIMUM_BASE_FEE`.
**Test:** [`ResourceMetering.t.sol#L179`](../test/invariants/ResourceMetering.t.sol#L179)

This test asserts that a block's base fee can never drop below the `MINIMUM_BASE_FEE` threshold.

## A block can never consume more than `MAX_RESOURCE_LIMIT` gas.
**Test:** [`ResourceMetering.t.sol#L187`](../test/invariants/ResourceMetering.t.sol#L187)

This test asserts that a block can never consume more than the `MAX_RESOURCE_LIMIT` gas threshold.

## The base fee can never be raised more than the max base fee change.
**Test:** [`ResourceMetering.t.sol#L197`](../test/invariants/ResourceMetering.t.sol#L197)

After a block consumes more gas than the target gas, the base fee cannot be raised more than the maximum amount allowed. The max base fee change (per-block) is derived as follows: `prevBaseFee / BASE_FEE_MAX_CHANGE_DENOMINATOR`

## The base fee can never be lowered more than the max base fee change.
**Test:** [`ResourceMetering.t.sol#L207`](../test/invariants/ResourceMetering.t.sol#L207)

After a block consumes less than the target gas, the base fee cannot be lowered more than the maximum amount allowed. The max base fee change (per-block) is derived as follows: `prevBaseFee / BASE_FEE_MAX_CHANGE_DENOMINATOR`

## The `maxBaseFeeChange` calculation over multiple blocks can never underflow.
**Test:** [`ResourceMetering.t.sol#L216`](../test/invariants/ResourceMetering.t.sol#L216)

When calculating the `maxBaseFeeChange` after multiple empty blocks, the calculation should never be allowed to underflow.

license: MIT

repository: ethereum-optimism/optimism

branch_name: refs/heads/develop

extension: md

gha_language: Go

gha_license_id: MIT

license_type: permissive

repo_name: ethereum-optimism/optimism


text:
# RNACI

* **Version:** 0.4.0
* **License:** [![License](http://img.shields.io/badge/license-BSD%202--Clause-orange.svg?style=flat)](http://opensource.org/licenses/BSD-2-Clause)
* **Author:** Drew Schmidt and Wei-Chen Chen

RNACI is a set of tools to aid in dealing with R's native C interface.

If you are interfacing R to C or Fortran, bringing C++ into the mix can
be a recipe for headaches and disaster.  Also, C++ takes much longer to
compile than C, so if you aren't really using the features of C++, then
this is a fruitless way to complicate development.  This package
tries to fill the "wrapper gap" for C/Fortran programmers interfacing
compiled code to R.

Currently, the package is very young.  At this time, most of the
proper improvements are in the form of SEXP allocation (and
automatic gc counting), and the creation/management of lists and
dataframes (by making extensive use of VA_ARGS).

## Installation

Using the devtools package:

```r
devtools::install_github("wrathematics/RNACI")
```

The package vignette explains how to use RNACI and how to link
an R package with RNACI.  See `RNACI/src/zzz_tests.c` and
`RNACI/src/zzz_examples.c` for example usage.  For example usage
in real packages, see pbdBASE (especially), pbdDMAT, and memuse.

repository: wrathematics/RNACI

branch_name: refs/heads/master

gha_language: TeX

repo_name: wrathematics/RNACI


text:
---
# Display name
name: Matthew Pugh

# Username (this should match the folder name)
authors:
- admin

# Is this the primary user of the site?
superuser: true

# Role/position
role: Principal Member of Technical Staff

# Organizations/Affiliations
organizations:
- name: Sandia National Laboratories
  url: "https://www.sandia.gov"

# Short bio (displayed in user profile at end of posts)
bio:  Think and wonder, wonder and think.
      — Dr. Suess

interests:
- Mathematics
- Signal Processing
- Information Theory
- Optimization
- Programming
- Algorithms
- Deep Learning

education:
  courses:
  - course: PhD in Electrical and Computer Engineering Specializing in Communication Theory and Systems
    institution: University of California, San Diego
    year: 2011
  - course: MS in Electrical and Computer Engineering
    institution: University of California, San Diego
    year: 2008
  - course: BS in Electrical Engineering
    institution: University of California, Los Angeles
    year: 2005
  - course: BS in Applied Mathematics
    institution: University of California, Los Angeles
    year: 2005

# Social/Academic Networking
# For available icons, see: https://sourcethemes.com/academic/docs/widgets/#icons
#   For an email link, use "fas" icon pack, "envelope" icon, and a link in the
#   form<EMAIL_ADDRESS>or "#contact" for contact widget.
social:
- icon: envelope
  icon_pack: fas
  link<EMAIL_ADDRESS>#'#contact'  # For a direct email link, use<EMAIL_ADDRESS>#- icon: twitter
#  icon_pack: fab
#  link: https://twitter.com/GeorgeCushen
#- icon: google-scholar
#  icon_pack: ai
#  link: https://scholar.google.co.uk/citations?user=sIwtMXoAAAAJ
- icon: github
  icon_pack: fab
  link: https://github.com/mopugh
- icon: linkedin
  icon_pack: fab
  link: https://www.linkedin.com/in/mopugh/
# Link to a PDF of your resume/CV from the About widget.
# To enable, copy your resume/CV to `static/files/cv.pdf` and uncomment the lines below.
- icon: file-pdf
  icon_pack: fas
  link: files/pugh_resume.pdf

# Enter email to display Gravatar (if Gravatar enabled in Config)
email: ""

# Organizational groups that you belong to (for People widget)
#   Set this to `[]` or comment out if you are not using People widget.
user_groups:
- Researchers
- Visitors
---

Matthew Pugh is a principal member of the technical staff at Sandia National Laboratories in Livermore, California. His early career focused on research in signal processing, algorithm design and communications. More recently he leads teams of engineers to execute critical laboratory programs.

*"The purpose of computation is insight, not numbers."*

— Richard Hamming

repository: mopugh/website

repo_name: mopugh/website


text:
---
layout: default
title: Circle Approximation
nav_order: 3
parent: Odometry
permalink: odometry/circle-approximation/
---

# Circle Approximation
Although the line approximation is relatively accurate, we can make it more precise by assuming that the robot drives in an arc, which, in reality, is closer to what the robot is really doing.

![Circle Approximation]({{site.baseurl}}/assets/images/odometry/circle-approximation.png "Circle Approximation")

## Deriving the equations
The robot moved in an arch, the left encoder measured a distance $$l$$ and the right wheel a distance $$r$$. It was previously at an angle $$\theta$$ and is now at an angle $$\theta + \omega$$. We want to calculate, what the new position of the robot is after this move.

The way to calculate the new coordinates is to find the radius $$R$$ of [ICC](https://en.wikipedia.org/wiki/Instant_centre_of_rotation) (*Instantaneous Center of Curvature* -- the point around which the robot is turning) and then rotate $$x_0$$ and $$y_0$$ around it.

### Calculating R
Let's start by finding the formula for calculating $$R$$. We will derive it from the formulas for calculating $$l$$ and $$r$$:

$$l = \omega \cdot \left(R - \frac{c}{2}\right) \qquad r = \omega \cdot \left(R + \frac{c}{2}\right)$$

Combining the equations and solving for R gives us:

$$R = \left(\frac{r+l}{\omega \cdot 2} \right)$$

From our previous article about [Heading from Encoders]({{site.baseurl}}/odometry/heading-from-encoders/), we know that $$\omega = \frac{r - l}{c}$$. If we don't have a gyro, we can just plug that into our newly derived formula and get:

$$R = \frac{r+l}{\frac{r - l}{c} \cdot 2} = \frac{r+l}{r - l} \cdot \frac{c}{2}$$

### Rotating $$(x_0, y_0)$$ around ICC
For this section, we will assume that you know how to rotate a point around the origin by a certain angle. If not, here is a [video](https://www.khanacademy.org/partner-content/pixar/sets/rotation/v/sets-8) from Khan Academy deriving the equations.

First of, we will need the coordinates of the $$ICC$$. Since it's perpendicular to the left of the robot, we can calculate it by first calculating a point that is distance $$R$$ in front of the robot:

$$ICC_x=x_0+R \; cos(\theta) \qquad ICC_y=y_0+R \cdot sin(\theta)$$

We will then turn the point 90 degrees to place it at distance $$R$$ perpendicular to the robot by switching $$x_0$$ and $$y_0$$ and negating the first coordinate (using [simple vector algebra](https://stackoverflow.com/questions/4780119/2d-euclidean-vector-rotations)):

$$ICC_x=x_0-R \; sin(\theta) \qquad ICC_y=y_0+R \cdot cos(\theta)$$

To rotate $$(x_0, y_0)$$ around ICC (and therefore find $$(x, y)$$), we will first translate ICC to the origin, then rotate, and then translate back:

$$x = (x_0 - ICC_x) \cdot cos(\omega) - (y_0 - ICC_y) \cdot sin(\omega) + ICC_x$$

$$y = (x_0 - ICC_x) \cdot sin(\omega) + (y_0 - ICC_y) \cdot cos(\omega) + ICC_y$$

Plugging in the values for $$ICC_x$$, $$ICC_y$$ and simplifying:

$$x = R \; sin(\theta) \cdot cos(\omega) + R \cdot cos(\theta) \cdot sin(\omega) + x_0 - R \; sin(\theta)$$

$$y = R \; sin(\theta) \cdot sin(\omega) - R \cdot cos(\theta) \cdot cos(\omega) + y_0 + R \; cos(\theta)$$

Using trigonometric rules, the equations can be further simplified to:

$$x = x_0 + R \; sin(\theta + \omega) - R \; sin(\theta)$$

$$y = y_0 - R \; cos(\theta + \omega) + R \; cos(\theta)$$

### Edge cases
There is one noteworthy case of values $$l$$ and $$r$$ where our circle approximation method won't work.

If $$r=l$$ (if we are driving straight), then the radius cannot be calculated, because it would be "infinite". For this reason, our method can't be used on its own, because if the robot drove in a straight line, the code would crash.

We can, however, still employ or line approximation method, since in this case, it really is driving in a straight line! It is also a good idea to apply the line approximation method for very small angles, since it's almost like driving straight, and it's less computationally intensive to the circle approximation method.

## Implementation
Here is the implementation, combining both of the approximation methods:

```python
{% include code/algorithms/odometry/circle-approximation.py %}
```

repository: xiaoxiae/Robotics-Simplified-Website

gha_language: CSS

repo_name: xiaoxiae/Robotics-Simplified-Website


text:
# C-Plus-Plus-Template

C++ project boilerplate

# Simple C++ project with Makefile

Makefile that can be used by Eclipse CDT to create an Eclipse project.

Targets:
* all   - build $(PGM)
* test  - build and run unit tests.
* clean - delete all generated files.

The Makefile is a "calling stub". It defines variables PGM, INCS,
MY_CFLAGS, and MY_LDFLAGS. It also defines target "run".

File Makefile.inc is the generic part of the build, and could be used with
little or no change in any project that generates an executable. It
could be readily tweadked for projects that generate libraries.

Source C++ files are expected to end in "*.cpp" and reside in
directory "src".

repository: rstinejr/C-Plus-Plus-Template

repo_name: rstinejr/C-Plus-Plus-Template


text:
# Stock Exchange Observer - by Daniel Cintra

## To build project container:

```sh
rake build_container
```

## To run project in development mode:

```sh
rake run_dev
```

## To build project

```sh
rake run_build
```

## To run tests

```sh
rake run_test
```

## To list all commands available

```sh
rake
```

#### Obs: If your terminal doesn't support $(), you will need to update the rake file changing the commands removing the '$' and then will work fine. Like the example down here:

```sh
docker container run -it -p 3000:3000 -p 35729:35729 -v (pwd):/app react:app
```

## Utilized Libraries

To develop the project were used:

* React
* Redux
* React Router
* Lodash
* Axios
* Moment
* Docker
* Rake

license: Unlicense


text:
# Mdindicator

`mdindicator` provides a facility to watch a markdown file, and serve it as an HTML.

## Install

To install, use `go get`:

```bash
$ go get -u github.com/elpinal/mdindicator
```

-u flag stands for "update".

## Examples

Basic usage:

```bash
$ mdindicator README.md
```

then, see http://localhost:9999.

To change port:

```bash
$ mdindicator -http :8888 README.md
```

To get the verbose output:

```bash
$ mdindicator -verbose README.md
```

## Contribution

1. Fork ([https://github.com/elpinal/mdindicator/fork](https://github.com/elpinal/mdindicator/fork))
1. Create a feature branch
1. Commit your changes
1. Rebase your local changes against the master branch
1. Run test suite with the `go test ./...` command and confirm that it passes
1. Run `gofmt -s`
1. Create a new Pull Request

## Author

[elpinal](https://github.com/elpinal)

repository: elpinal/mdindicator

repo_name: elpinal/mdindicator


text:
# diff-so-fancy  [![Circle CI build](https://circleci.com/gh/stevemao/diff-so-fancy.svg?style=svg)](https://circleci.com/gh/stevemao/diff-so-fancy)

diff-so-fancy builds on the good-lookin' output of [git contrib](https://github.com/git/git/tree/master/contrib)'s [diff-highlight](https://github.com/git/git/tree/master/contrib/diff-highlight) to upgrade
your diffs' appearances.

* Output will not be in standard patch format, but will be readable.
* No pesky `+` or `-` at line-stars, making for easier copy-paste.

## Screenshot

*`git diff` vs `git diff --color | diff-so-fancy`*

![diff-highlight vs diff-so-fancy](https://cloud.githubusercontent.com/assets/39191/10000682/8e849130-6052-11e5-9bd9-bd4505cd24d6.png)

## Usage

You can do one-off fanciness:
```shell
git diff --color | diff-so-fancy
```

**But**, you'll probably want to fancify all your diffs. Run this so `git diff` and `git show` will use it:
```shell
git config --global pager.diff "diff-so-fancy | less --tabs=1,5 -RFX"
git config --global pager.show "diff-so-fancy | less --tabs=1,5 -RFX"
```

Or, create a git alias  in your `~/.gitconfig` for shorthand fanciness:
```shell
dsf = "!git diff --color $@ | diff-so-fancy"
```

## Install

For convenience, the recommended installation is via NPM:
```shell
npm install -g diff-so-fancy
```
This will install and link the `diff-so-fancy` and `diff-highlight` scripts.

### Manual installation alternative

If you want, you can choose to install manually:

* Grab the two scripts (`diff-highlight` and `diff-so-fancy`) via either downloading or cloning the repo.
* If you download `diff-highlight` from the official git repo, make sure it's executable.
* Symlink or place them in a location that is in your `PATH`.
* Set up the git `pager.diff` and `pager.show` configs, as described above.

Note: The `diff-highlight` dependency is an [official git-contrib script](https://github.com/git/git/tree/master/contrib/diff-highlight), duplicated here for convenience.

### Install GNU `sed`

You'll need GNU sed. On Mac, it's easy to install with Homebrew.
```shell
brew install gnu-sed
```

### Improved colors for the highlighted bits

`diff-highlight` has default colors that are arguably a little nasty. They'll work fine, but you can try some fancier colors:
```shell
git config --global color.diff-highlight.oldNormal "red bold"
git config --global color.diff-highlight.oldHighlight "red bold 52"
git config --global color.diff-highlight.newNormal "green bold"
git config --global color.diff-highlight.newHighlight "green bold 22"
```
You may also want to configure [general diff colors](https://github.com/paulirish/dotfiles/blob/63cb8193b0e66cf80ab6332477f1f52c7fbb9311/.gitconfig#L23-L36).

## Opting-out

Sometimes you will want to bypass diff-so-fancy. Use `--no-pager` for that:

```shell
git --no-pager diff
```

## Credit

Originated from https://github.com/paulirish/dotfiles/blob/master/bin/diff-so-fancy

## Contributing

Pull requests quite welcome.

## Hacking and Testing

```sh
# fork and clone the repo. then…

git submodule update --init
brew install entr coreutils
# install bats: github.com/sstephenson/bats#installing-bats-from-source
```

```sh
# Run the test suite once:
bats test/diff-so-fancy.bats

# Run it on every change with `entr`
ls --color=never diff-so-fancy test/*.bats | entr bats test/*.bats
```

## License

MIT

repository: yongheng-wyh/diff-so-fancy

repo_name: yongheng-wyh/diff-so-fancy


text:
## C API

The environment phase of the compiler packs the converted Céu program and
additional files in the order as follows:

1. type declarations    (option `--env-types`)
2. thread declarations  (option `--env-threads`, optional)
3. a callback prototype (fixed, see below)
4. Céu program          (option `--env-ceu`, auto generated)
5. main program         (option `--env-main`)

The Céu program uses standardized types and calls, which must be previously
mapped from the host environment in steps `1-3`.

The main program depends on declarations from the Céu program.

### Types

The type declarations must map the types of the host environment to all
[primitive types](../types/#primitives) of Céu.

Example:

```c
#include <stdint.h>
#include <sys/types.h>

typedef unsigned char bool;
typedef unsigned char byte;
typedef unsigned int  uint;

typedef ssize_t  ssize;
typedef size_t   usize;

typedef int8_t    s8;
typedef int16_t  s16;
typedef int32_t  s32;
typedef int64_t  s64;

typedef uint8_t   u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;

typedef float    f32;
typedef double   f64;
```

### Threads

If the user program uses [threads](../statements/#thread) and the option
`--ceu-features-thread` is set, the host environment must provide declarations
for types and functions expected by Céu.

Example:

```c
#include <pthread.h>
#include <unistd.h>
#define CEU_THREADS_T               pthread_t
#define CEU_THREADS_MUTEX_T         pthread_mutex_t
#define CEU_THREADS_CREATE(t,f,p)   pthread_create(t,NULL,f,p)
#define CEU_THREADS_CANCEL(t)       ceu_dbg_assert(pthread_cancel(t)==0)
#define CEU_THREADS_JOIN_TRY(t)     0
#define CEU_THREADS_JOIN(t)         ceu_dbg_assert(pthread_join(t,NULL)==0)
#define CEU_THREADS_MUTEX_LOCK(m)   ceu_dbg_assert(pthread_mutex_lock(m)==0)
#define CEU_THREADS_MUTEX_UNLOCK(m) ceu_dbg_assert(pthread_mutex_unlock(m)==0)
#define CEU_THREADS_SLEEP(us)       usleep(us)
#define CEU_THREADS_PROTOTYPE(f,p)  void* f (p)
#define CEU_THREADS_RETURN(v)       return v
```

`TODO: describe them`

### Céu

The converted program generates types and constants required by the main
program.

#### External Events

For each [external input and output event](../statements/#external-events)
`<ID>` defined in Céu, the compiler generates corresponding declarations as
follows:

1. An enumeration item `CEU_INPUT_<ID>` that univocally identifies the event.
2. A `define` macro `_CEU_INPUT_<ID>_`.
3. A struct type `tceu_input_<ID>` with fields corresponding to the types in
   of the event payload.

Example:

Céu program:

```ceu
input (int,u8&&) MY_EVT;
```

Converted program:

```c
enum {
    ...
    CEU_INPUT_MY_EVT,
    ...
};

#define _CEU_INPUT_MY_EVT_

typedef struct tceu_input_MY_EVT {
    int _1;
    u8* _2;
} tceu_input_MY_EVT;
```

#### Data

The global `CEU_APP` of type `tceu_app` holds all program memory and runtime
information:

```
typedef struct tceu_app {
    bool end_ok;                /* if the program terminated */
    int  end_val;               /* final value of the program */
    bool async_pending;         /* if there is a pending "async" to execute */
    ...
    tceu_code_mem_ROOT root;    /* all Céu program memory */
} tceu_app;

static tceu_app CEU_APP;
```

The struct `tceu_code_mem_ROOT` holds the whole memory of the Céu program.
The identifiers for global variables are preserved, making them directly
accessible.

Example:

```ceu
var int x = 10;
```

```
typedef struct tceu_code_mem_ROOT {
    ...
    int  x;
} tceu_code_mem_ROOT;
```

### Main

The main program provides the entry point for the host platform (i.e., the
`main` function), implementing the event loop that senses the world and
notifies the Céu program about changes.

The main program interfaces with the Céu program in both directions:

- Through direct calls, in the direction `main -> Céu`, typically when new input is available.
- Through callbacks, in the direction `Céu -> main`, typically when new output is available.

#### Calls

The functions that follow are called by the main program to command the
execution of Céu programs:

- `void ceu_start (void)`

    Initializes and starts the program.
    Should be called once.

- `void ceu_stop  (void)`

    Finalizes the program.
    Should be called once.

- `void ceu_input (tceu_nevt evt_id, void* evt_params)`

    Notifies the program about an input `evt_id` with a payload `evt_params`.
    Should be called whenever the event loop senses a change.
    The call to `ceu_input(CEU_INPUT__ASYNC, NULL)` makes
    [asynchronous blocks](../statements/#asynchronous-block) to execute a step.

- `int ceu_loop (void)`

    Implements a simple loop encapsulating `ceu_start`, `ceu_input`, and
    `ceu_stop`.
    On each loop iteration, make a `CEU_CALLBACK_STEP` callback and generates
    a `CEU_INPUT__ASYNC` input.
    Should be called once.
    Returns the final value of the program.

#### Callbacks

The Céu program makes callbacks to the main program in specific situations:

```c
tceu_callback_ret ceu_callback (int cmd, tceu_callback_arg p1, tceu_callback_arg p2);

enum {
    CEU_CALLBACK_START,                 /* once in the beginning of `ceu_start`             */
    CEU_CALLBACK_STOP,                  /* once in the end of `ceu_stop`                    */
    CEU_CALLBACK_STEP,                  /* on every iteration of `ceu_loop`                 */
    CEU_CALLBACK_ABORT,                 /* whenever an error occurs                         */
    CEU_CALLBACK_LOG,                   /* on error and debugging messages                  */
    CEU_CALLBACK_TERMINATING,           /* once after executing the last statement          */
    CEU_CALLBACK_ASYNC_PENDING,         /* whenever there's a pending "async" block         */
    CEU_CALLBACK_THREAD_TERMINATING,    /* whenever a thread terminates                     */
    CEU_CALLBACK_ISR_ENABLE,            /* whenever interrupts should be enabled/disabled   */
    CEU_CALLBACK_ISR_ATTACH,            /* whenever an "async/isr" starts                   */
    CEU_CALLBACK_ISR_DETACH,            /* whenever an "async/isr" is aborted               */
    CEU_CALLBACK_ISR_EMIT,              /* whenever an "async/isr" emits an innput          */
    CEU_CALLBACK_WCLOCK_MIN,            /* whenever a next minimum timer is required        */
    CEU_CALLBACK_WCLOCK_DT,             /* whenever the elapsed time is requested           */
    CEU_CALLBACK_OUTPUT,                /* whenever an output is emitted                    */
    CEU_CALLBACK_REALLOC,               /* whenever memory is allocated/deallocated         */
};
```

`TODO: payloads`

The main program must implement the `ceu_callback` prototype above to handle
the enumerated commands.

<!--
WCLOCK_DT uses `CEU_WCLOCK_INACTIVE`
- `CEU_FEATURES_ISR`
- `CEU_FEATURES_LUA`
- `CEU_FEATURES_THREAD`

            tceu_evt_id_params evt;

    static volatile tceu_isr isrs[_VECTORS_SIZE];
-->

#### Example

Suppose the environment supports the events that follow:

```
input  int I;
output int O;
```

The `main.c` implements an event loop to sense occurrences of `I` and a
callback handler for occurrences of `O`:

```
#include "types.h"      // as illustrated above in "Types"

int ceu_is_running;     // detects program termination

tceu_callback_ret ceu_callback (int cmd, tceu_callback_arg p1, tceu_callback_arg p2) {
    tceu_callback_ret ret = { .is_handled=1 };
    switch (cmd) {
        case CEU_CALLBACK_TERMINATING:
            ceu_is_running = 0;
            break;
        case CEU_CALLBACK_OUTPUT:
            if (p1.num == CEU_OUTPUT_O) {
                printf("output O has been emitted with %d\n", p2.num);
            }
            break;
        default:
            ret.is_handled = 0;
    }
    return ret;
}

int main (void) {
    ceu_is_running = 1;

    ceu_start();

    while (ceu_is_running) {
        if detects(CEU_INPUT_A) {
            int v = <...>;
            ceu_input(CEU_INPUT_A, &v);
        }
        ceu_input(CEU_INPUT__ASYNC, NULL);
    }

    ceu_stop();
}
```

repository: ceremcem/ceu

gha_license_id: NOASSERTION

repo_name: ceremcem/ceu


text:
<%= slug %>.js
_____________________________
<%= description %>

# Install

```
npm install
bower install
bundle install
gulp
````

## Building with [gulp](http://gulpjs.com/)

run `gulp -T` for a list of available tasks

`gulp` by itself, will run the default task

- src files are built to the `./dist` directory by default.
- watches and compiles coffee for specs and src
- builds your final rjs package at dist/<%= slug %>

## [RequireJS Build + Config](http://requirejs.org/docs/api.html#config)
`./node_modules/requirejs/bin/r.js -o require.build.js optimize=none` - runs automatically with gulp when changes are detected.

- `./dist/require.config.js`
  - used to configure `examples/index.html` and specs, not used outside of package
  - external dependencies amended to bower.json can be automatically added to the config by running `grunt`
  - internal dependencies must be added manually
- `require.build.js`
  - similar to require.config, but is instead used to build the final bower component
  - external + internal depencies must be manually added

## Versioning
See [gulp-release-tasks](https://www.npmjs.org/package/gulp-release-tasks) for additional release tasks.

# Testing
```
bundle exec rake jasmine
```


text:
# Ultimate ASI Loader

## DESCRIPTION

This is a DLL file which adds ASI plugin loading functionality to any game, which uses any of the following libraries:

- d3d8.dll
- d3d9.dll (x86 and x64)
- d3d10.dll (x86 and x64)
- d3d11.dll (x86 and x64)
- d3d12.dll (x86 and x64)
- ddraw.dll
- dinput.dll
- dinput8.dll (x86 and x64)
- dsound.dll (x86 and x64)
- msacm32.dll
- msvfw32.dll
- version.dll (x86 and x64)
- wininet.dll (x86 and x64)
- winmm.dll
- xlive.dll

- bink2w64.dll (rename original to bink2w64Hooked.dll)
- vorbisFile.dll (rename original to vorbisHooked.dll, optional)
- binkw32.dll (rename original to binkw32Hooked.dll, optional)

With the last two, it is possible to load the original dll by renaming it to 'vorbisHooked.dll' or 'binkw32Hooked.dll'.
Usually it is not required and you can simply replace the dll. Always make a backup before replacing any files.

## INSTALLATION

In order to install it, you just need to place DLL into game directory. Usually it works as dinput8.dll, but if it's not, there is a possibility to rename it(see the list of supported names above).

## USAGE

Put ASI files in game root directory, 'scripts' or 'plugins' folder.
If configuration is necessary, global.ini file can be placed to 'scripts' or 'plugins' folder. It can be used alongside the chosen dll and if so, it is also possible to use dll name for ini file, e.g. version.dll/version.ini.
[See example of global.ini here](https://github.com/ThirteenAG/Ultimate-ASI-Loader/blob/master/data/scripts/global.ini).

## ADDITIONAL WINDOWED MODE FEATURE

ASI loader have built-in wndmode.dll, which can be loaded, if you create empty wndmode.ini in the folder with asi loader's dll. It will be automatically filled with example configuration at the first run of the game. Settings are not universal and should be changed in every specific case, but usually it works as is.

## D3D8TO9

Some mods, like [SkyGfx](https://github.com/aap/skygfx_vc) require [d3d8to9](https://github.com/crosire/d3d8to9). It is also a part of ASI loader, so in order to use it, create global.ini inside scripts folder with the following content:

```
[GlobalSets]
UseD3D8to9=1
```

[See example of global.ini here](https://github.com/ThirteenAG/Ultimate-ASI-Loader/blob/master/data/scripts/global.ini#L6).

## CrashDumps

ASI loader is now capable of generating crash minidumps and crash logs. To use this feature, create a folder named `CrashDumps` in the folder with asi loader's dll. You can disable that via `DisableCrashDumps=1` ini option.

repository: ALEHACKsp/Ultimate-ASI-Loader

repo_name: ALEHACKsp/Ultimate-ASI-Loader


text:
# Stack

By [Phil Worthington](https://github.com/philworthington).

## Description
A simple Last In First Out stack. Tested with rspec.

## Authors

* Phil Worthington (https://github.com/philworthington)

## License

MIT: http://philworthington.mit-license.org

repository: philworthington/stack

repo_name: philworthington/stack


text:
# NodeRestAPI
A Rest API written using Node.js and Express

## Running the Server
* "node app.js" will run it normally
* "node --inspect app.js" will run it with debugging
* "npm start" is set to the debugging command

## Debugging Steps
1. Start the server
2. Open "about:inspect" in the chrome url
3. Click the "Open dedicated DevTools for Node" link. This opens dev-tools in a separate window
4. Open "localhost:8000/api/movies" in a new chrome tab

repository: CodeBuddiesGKS/NodeRestAPI

gha_language: JavaScript

repo_name: CodeBuddiesGKS/NodeRestAPI


text:
[![Build Status](https://travis-ci.org/briancurtin/gd.svg?branch=master)](https://travis-ci.org/briancurtin/gd)

# About gd

Tools for working with http://gd2.mlb.com/components/game/mlb/

This is definitely a work in progress. Right now it consists of a scraper,
parser, and database storage. Building a REST API and analysis tools on
top of that is an end goal.

# Development

## Requirements

* [Python 3.4](https://www.python.org/download/releases/3.4.0)
* [tox](http://tox.readthedocs.org/en/latest/)

## Getting Setup

Development is easiest when you use
[virtualenv](http://www.virtualenv.org/en/latest/)

```
git clone git@github.com:yourusername/gd.git && cd gd/
virtualenv -p python3.4 ../envs/gd
source ../envs/gd/bin/activate
pip install tox
tox
...
Ran 51 tests in 0.038s
...
```


text:
# TTN Listener

## inleiding

The sensor sends data to the TTN, the TTN wil be filtered and generate a JSON String.
This Json String will send with the integrated MQTT of The things network to the listener (this project).
This Json string wil send all the incoming data filtered to the HTTP

![roadmap](/pictures/roadmap.jpg)

## Installation

`git clone git@github.com:Projectwerk2-2018/smart-campus-ttn-backend.git`

Installing the dependencies:

`npm install`

## Configuration

Make a copy of the `.env.example` file and name it `.env`. This can be done with the following command as well: `cp .env.example .env`.

Then update the changes in the file according to your setup.

```bash
TTN_APPID=
TTN_ACCESSKEY=ttn-account-v2.

HTTP_HOST=localhost
HTTP_PORT=8000
HTTP_PATH=/
HTTP_HTTP=http
```

Or you can change the setting in your terminal:

`TTN_APPID=test TTN_ACCESSKEY=ttn-account-v2 HTTP_HOST... node server.js`

## Running the application

`node server.js`

or

`npm start`

## testing the application

set the localhost_test.js file in a new project.

run the project

`node localhost_test.js`

if the hardware is online you will have automaticly respons

other whise you can _simulate uplink_

test with payload `00D71B0049`

![payload](/pictures/payload.png)

this wil send `{"humidity":109,"movement":125,"temperature":11.7,"dev_eui":"00D9E55A84BCE66B"}` to the Listiner. End to the backand

# dockerizing

build your **Docker image**

`docker build -t <name>/listener .`

test of the images has been build

`docker image ls`

now you can run the application

`docker run -p 4000:80 <name>/listener`

# referenties


text:
## :only-child

### Summary

The `:only-child` CSS [pseudo-class][0] represents any element which is the only child of its parent. This is the same as `:first-child:last-child` or `:nth-child(1):nth-last-child(1)`, but with a lower specificity.

### Syntax

    parent child:only-child {
      property: value;
    }

### Examples

### Basic example

    span:only-child {
      color: red;
    }

      This span is the only child of its father

      This span is one of the two children of its father
      This span is one of the two children of its father

#### Result

### A list example

    li li {
      list-style-type: disc;
    }
    li:only-child {
      color: #6699ff;
      font-style: italic;
      list-style-type: square;
    }

First

This is only child element

Second

This list has two elements

This list has two elements

Third

This list has three elements

This list has three elements

This list has three elements

#### Result

[0]: https://developer.mozilla.org/en/docs/CSS/Pseudo-classes "Pseudo-classes"


text:
# AnsiToUtf8

Totally based on https://github.com/dongri/convert-to-utf8.

AnsiToUTF8 package for editing and saving files encoded in ANSI (win1252) etc.

![A screenshot of your spankin' package](https://c1.staticflickr.com/9/8837/18564513601_0f8c37a057_b.jpg)

![A screenshot of your spankin' package](https://c1.staticflickr.com/1/273/18374714378_89e16f3cab_b.jpg)


text:
---
sidebar_position: 6
slug: /ecosystem/
sidebar_label: Ecosystem
---

# 🌱 Ecosystem

Bring additional capabilities to fast-check by leveraging its rich ecosystem of extensions and plugins

:::warning Stability
This page provides a list of packages available in the fast-check ecosystem. It includes both official and third-party packages. While we can ensure the stability, usage, and maintenance of the official packages, we cannot provide any specific details or guarantees regarding the non-official packages.

Follow the emojis — last update May 2023

- ⭐ official package
- 🌗 official package with limited support
- 🥇 active1 non-official package with many downloads2
- 🥈 active1 non-official package
- ⚠ others

1: The package has been updated in the last twelve months
2: The package has been downloaded more than 1k times per month

In each section, packages marked with ⭐ and 🥇 will come first in alphabetical order, followed by 🥈 and then 🌗 and ⚠.

:::

## Connectors

Create arbitraries based on other libraries.

For instance:

- Many data validators enable you to define and sometimes validate runtime values and obtain accurate TypeScript types. With these packages, they can also be utilized to derive arbitraries that can be seamlessly plugged within fast-check.
- Many fake data libraries come with powerful random and seeded generators, why don't you use them as arbitraries to ease migration path to full property-based testing?

### `zod-fast-check` 🥇

![npm version](https://badge.fury.io/js/zod-fast-check.svg)
![monthly downloads](https://img.shields.io/npm/dm/zod-fast-check)
![last commit](https://img.shields.io/github/last-commit/DavidTimms/zod-fast-check)
![license](https://img.shields.io/npm/l/zod-fast-check.svg)
![third party package](https://img.shields.io/badge/-third%20party%20package-%2300abff.svg)

Convert [zod validators](https://zod.dev/) into arbitraries for fast-check.

```js
import * as z from 'zod';
import * as fc from 'fast-check';
import { ZodFastCheck } from 'zod-fast-check';

const User = z.object({ firstName: z.string(), lastName: z.string() });
const userArbitrary = ZodFastCheck().inputOf(User);

test("User's full name always contains their first and last names", () => {
  fc.assert(
    fc.property(userArbitrary, (user) => {
      const parsedUser = User.parse(user);
      const fullName = `${parsedUser.firstName} ${parsedUser.lastName}`;
      expect(fullName).toContain(user.firstName);
      expect(fullName).toContain(user.lastName);
    }),
  );
});
```

More details on the [package itself](https://www.npmjs.com/package/zod-fast-check)!

### `fast-check-io-ts` ⚠

![npm version](https://badge.fury.io/js/fast-check-io-ts.svg)
![monthly downloads](https://img.shields.io/npm/dm/fast-check-io-ts)
![last commit](https://img.shields.io/github/last-commit/giogonzo/fast-check-io-ts)
![license](https://img.shields.io/npm/l/fast-check-io-ts.svg)
![third party package](https://img.shields.io/badge/-third%20party%20package-%2300abff.svg)

Convert [io-ts validators](https://gcanti.github.io/io-ts/) into arbitraries for fast-check.
More details on the [package itself](https://www.npmjs.com/package/fast-check-io-ts)!

### `graphql-codegen-fast-check` ⚠

![npm version](https://badge.fury.io/js/graphql-codegen-fast-check.svg)
![monthly downloads](https://img.shields.io/npm/dm/graphql-codegen-fast-check)
![last commit](https://img.shields.io/github/last-commit/danieljharvey/graphql-codegen-fast-check)
![license](https://img.shields.io/npm/l/graphql-codegen-fast-check.svg)
![third party package](https://img.shields.io/badge/-third%20party%20package-%2300abff.svg)

Convert [GraphQL schemas](https://graphql.org/) into arbitraries for fast-check.
More details on the [package itself](https://www.npmjs.com/package/graphql-codegen-fast-check)!

### `json-schema-fast-check` ⚠

![npm version](https://badge.fury.io/js/json-schema-fast-check.svg)
![monthly downloads](https://img.shields.io/npm/dm/json-schema-fast-check)
![last commit](https://img.shields.io/github/last-commit/meeshkan/json-schema-fast-check)
![license](https://img.shields.io/npm/l/json-schema-fast-check.svg)
![third party package](https://img.shields.io/badge/-third%20party%20package-%2300abff.svg)

Convert [JSON Schemas](https://json-schema.org/) into arbitraries for fast-check.
More details on the [package itself](https://www.npmjs.com/package/json-schema-fast-check)!

### `jsverify-to-fast-check` 🌗

![npm version](https://badge.fury.io/js/jsverify-to-fast-check.svg)
![monthly downloads](https://img.shields.io/npm/dm/jsverify-to-fast-check)
![last commit](https://img.shields.io/github/last-commit/dubzzz/jsverify-to-fast-check)
![license](https://img.shields.io/npm/l/jsverify-to-fast-check.svg)
![official package](https://img.shields.io/badge/-official%20package-%23ffcb00.svg)

Ease your migration path to fast-check by easily converting the arbitraries you defined for [jsverify](http://jsverify.github.io/) into some for fast-check. While still maintained, we do not work actively on this project given the current state of jsverify: last released in 2018.

```js
import { jsc2fc } from 'jsverify-to-fast-check';
import * as jsc from 'jsverify';
import * as fc from 'fast-check';

// Here is an old arbitrary you prefer not to migrate for the moment
const jscArbitrary = jsc.bless({
  generator: jsc.generator.bless(() => {
    switch (jsc.random(0, 2)) {
      case 0:
        return 'foo';
      case 1:
        return 'bar';
      case 2:
        return 'quux';
    }
  }),
});

// It can easily converted into an arbitrary for fast-check using jsc2fc
const fcArbitrary = jsc2fc(jscArbitrary);
```

More details on the [package itself](https://www.npmjs.com/package/jsverify-to-fast-check)!

### `mock-data-gen` ⚠

![npm version](https://badge.fury.io/js/mock-data-gen.svg)
![monthly downloads](https://img.shields.io/npm/dm/mock-data-gen)
![last commit](https://img.shields.io/github/last-commit/kaeluka/mock-data-gen)
![license](https://img.shields.io/npm/l/mock-data-gen.svg)
![third party package](https://img.shields.io/badge/-third%20party%20package-%2300abff.svg)

Convert [io-ts validators](https://gcanti.github.io/io-ts/) into arbitraries for fast-check.
More details on the [package itself](https://www.npmjs.com/package/mock-data-gen)!

## Test runners

Although not designed for any particular test runners, some users prefer to have complete integration of fast-check within their preferred test runner. To meet these needs, we have compiled a list of packages that serve as the bridge between your favorite test runner and fast-check.

### `@fast-check/ava` ⭐

![npm<EMAIL_ADDRESS>![monthly downloads](https://img.shields.io/npm/dm/@fast-check%2Fava)
![last commit](https://img.shields.io/github/last-commit/dubzzz/fast-check)
<EMAIL_ADDRESS>![official package](https://img.shields.io/badge/-official%20package-%23ffcb00.svg)

Bring support for property-based testing into [ava](https://www.npmjs.com/package/ava) with [@fast-check/ava](https://www.npmjs.com/package/@fast-check/ava).

```js
import { testProp, fc } from '@fast-check/ava';

testProp('should detect the substring', [fc.string(), fc.string(), fc.string()], (t, a, b, c) => {
  t.true((a + b + c).includes(b));
});
```

More details on the [package itself](https://www.npmjs.com/package/@fast-check/ava)!

### `@fast-check/jest` ⭐

![npm<EMAIL_ADDRESS>![monthly downloads](https://img.shields.io/npm/dm/@fast-check%2Fjest)
![last commit](https://img.shields.io/github/last-commit/dubzzz/fast-check)
<EMAIL_ADDRESS>![official package](https://img.shields.io/badge/-official%20package-%23ffcb00.svg)

Bring support for property-based testing into [jest](https://www.npmjs.com/package/ava).

In addition to offering enhanced versions of `test` and `it` functions, this package seamlessly synchronizes the timeouts of fast-check with those of jest. You no longer need to worry about setting separate timeouts for fast-check when you have already defined one in jest. This package handles the integration effortlessly, ensuring everything gets wired out-of-the-box.

```js
import { test, fc } from '@fast-check/jest';

test.prop([fc.string(), fc.string(), fc.string()])('should detect the substring', (a, b, c) => {
  return (a + b + c).includes(b);
});

test.prop({ a: fc.string(), b: fc.string(), c: fc.string() })('should detect the substring', ({ a, b, c }) => {
  return (a + b + c).includes(b);
});
```

More details on the [package itself](https://www.npmjs.com/package/@fast-check/jest)!

### `@fast-check/vitest` ⭐

![npm<EMAIL_ADDRESS>![monthly downloads](https://img.shields.io/npm/dm/@fast-check%2Fvitest)
![last commit](https://img.shields.io/github/last-commit/dubzzz/fast-check)
<EMAIL_ADDRESS>![official package](https://img.shields.io/badge/-official%20package-%23ffcb00.svg)

Bring support for property-based testing into [vitest](https://www.npmjs.com/package/vitest).

```js
import { test, fc } from '@fast-check/vitest';

test.prop([fc.string(), fc.string(), fc.string()])('should detect the substring', (a, b, c) => {
  return (a + b + c).includes(b);
});

test.prop({ a: fc.string(), b: fc.string(), c: fc.string() })('should detect the substring', ({ a, b, c }) => {
  return (a + b + c).includes(b);
});
```

More details on the [package itself](https://www.npmjs.com/package/@fast-check/vitest)!

## Superpowers

Although fast-check already includes an extensive set of capabilities, some features have been kept aside and have not been included within the core package. These additional packages offer some extra capabilities, such as more powerful checks or new runners.

### `@fast-check/poisoning` ⭐

![npm<EMAIL_ADDRESS>![monthly downloads](https://img.shields.io/npm/dm/@fast-check%2Fpoisoning)
![last commit](https://img.shields.io/github/last-commit/dubzzz/fast-check)
<EMAIL_ADDRESS>![official package](https://img.shields.io/badge/-official%20package-%23ffcb00.svg)

Prototype poisoning is a commonly exploited vulnerability that can lead to various security weaknesses. Historical vulnerabilities in the ecosystem have been linked to prototype poisoning but detecting and addressing them is not always straightforward. The [@fast-check/poisoning](https://www.npmjs.com/package/@fast-check/poisoning) package has been specifically designed to address this need.

By utilizing this package in conjunction with fast-check, you can effectively safeguard against inadvertently modifying global prototypes when your code interacts with specially crafted inputs. Using both packages together unlocks their full potential and pushes your testing capabilities a step forward.

```js
import fc from 'fast-check';
import { assertNoPoisoning, restoreGlobals } from '@fast-check/poisoning';

const ignoredRootRegex = /^(__coverage__|console)$/;
function poisoningAfterEach() {
  try {
    assertNoPoisoning({ ignoredRootRegex });
  } catch (err) {
    restoreGlobals({ ignoredRootRegex });
    throw err;
  }
}
fc.configureGlobal({ afterEach: poisoningAfterEach });

test('should detect the substring', () => {
  fc.assert(
    fc.property(fc.string(), fc.string(), fc.string(), (a, b, c) => {
      expect(isSubstring(a + b + c, b)).toBe(true);
    }),
  );
});
```

More details on the [package itself](https://www.npmjs.com/package/@fast-check/poisoning)!

### `@fast-check/worker` ⭐

![npm<EMAIL_ADDRESS>![monthly downloads](https://img.shields.io/npm/dm/@fast-check%2Fworker)
![last commit](https://img.shields.io/github/last-commit/dubzzz/fast-check)
<EMAIL_ADDRESS>![official package](https://img.shields.io/badge/-official%20package-%23ffcb00.svg)

By default fast-check does not change where the code runs: everything run within the original process. [@fast-check/worker](https://www.npmjs.com/package/@fast-check/worker) package allows you to delegate the execution of predicates to dedicated worker threads. It brings several advantages, including the ability to stop synchronously running predicates.

```js
import { test, expect } from '@jest/globals';
import fc from 'fast-check';
import { isMainThread } from 'node:worker_threads';
import { assert, propertyFor } from '@fast-check/worker';

const property = propertyFor(new URL(import.meta.url)); // or propertyFor(pathToFileURL(__filename)) in commonjs
const isSubstringProperty = property(fc.string(), fc.string(), fc.string(), (a, b, c) => {
  expect(isSubstring(a + b + c, b)).toBe(true);
});

if (isMainThread) {
  test('should detect the substring', async () => {
    await assert(isSubstringProperty, { timeout: 1000 });
  });
}
```

:::info Integration with Jest runner
`@fast-check/worker` is directly integrating with `@fast-check/jest`. Checkout the [official documentation of `@fast-check/jest`](https://www.npmjs.com/package/@fast-check/jest) for more details.
:::

More details on the [package itself](https://www.npmjs.com/package/@fast-check/worker)!

## Validators

External libraries leveraging fast-check, its properties and predicates to validate userland extensions.

### `fp-ts-laws` ⚠

![npm version](https://badge.fury.io/js/fp-ts-laws.svg)
![monthly downloads](https://img.shields.io/npm/dm/fp-ts-laws)
![last commit](https://img.shields.io/github/last-commit/gcanti/fp-ts-laws)
![license](https://img.shields.io/npm/l/fp-ts-laws.svg)
![third party package](https://img.shields.io/badge/-third%20party%20package-%2300abff.svg)

Make sure your [fp-ts](https://gcanti.github.io/fp-ts/) constructs are properly configured.
More details on the [package itself](https://www.npmjs.com/package/fp-ts-laws)!

## Other stacks

Wanna run fast-check in non-JavaScript environments? The following packages offer some bindings making it possible.

### `rescript-fast-check` 🥈

![npm version](https://badge.fury.io/js/rescript-fast-check.svg)
![monthly downloads](https://img.shields.io/npm/dm/rescript-fast-check)
![last commit](https://img.shields.io/github/last-commit/TheSpyder/rescript-fast-check)
![license](https://img.shields.io/npm/l/rescript-fast-check.svg)
![third party package](https://img.shields.io/badge/-third%20party%20package-%2300abff.svg)

Run fast-check from [ReScript](https://rescript-lang.org/) code.

```re
open FastCheck
open Arbitrary
open Property.Sync

describe("properties", () => {
  it("should detect the substring", () =>
    assert_(
      property3(string(), string(), string(), (a, b, c) =>
        contains(a ++ b ++ c, b)
      ),
    )
  )
})
```

More details on the [package itself](https://www.npmjs.com/package/rescript-fast-check)!

repository: dubzzz/fast-check

branch_name: refs/heads/main

gha_language: TypeScript

repo_name: dubzzz/fast-check


text:
## BitTorrent :smiley:  :exclamation: Fa18-523-73

|          |                |
| -------- | -------------- |
| title    | BitTorrent     |
| status   | 10             |
| section  | Data Transport |
| keywords | Data Transport |

BitTorrent refers to that method of data transfer which allows large
data files to be broken down into smaller ones for efficient data
sharing[@fa18-523-73-Cohen2002]. The smaller files with the data can be
downloaded from several sources simultaneously. It is indeed the most
common protocol that enables peer to peer file sharing with ease and
most efficiently.

This technology works by allowing users to create a small file,
referred to as torrent, which contains information about the files
and the computers that manage the distribution of those files. To
download a file, one needs to find and open the torrent created and
start downloading files piece by piece. The peers can also share the
pieces with any other interested party trying to download the same
files. This sharing enhances easy file downloads as more pieces of
data can be found in multiple sources. BitTorrent provides faster
download speeds at a significantly low bandwidth as a result of
breaking down files into smaller pieces.

:o: This is not the only reason for faster download

:o: This is a summary not a personal oppiniom

I do not feel comfortable using BitTorrent mainly due to the security
issues associated with them. When downloading files from multiple
sources, the computers and the network are at risk of getting infected
with viruses, malware, and spyware programs. Another major security
concern is the directive on the torrent website to leave the computer
running so that files can be shared with other peers. This renders the
computer prone to numerous types of cyber-attacks, regardless of
whether or not one has anti-virus protection on one's computer.
Additionally, I feel uncomfortable with BitTorrent because it does not
offer anonymity to my IP address, which means anybody can view my IP
address while I am downloading files using the BitTorrent platform.

Having used BitTorrent extensively and having done an in-depth study
about its security systems,

:o: refernce missing

I conclude that it is too risky to be
used, because the drawbacks in the system far outweigh the benefits.
Though, there have been advancements, such as seed boxes, to promote
anonymity and to solve some system irregularities, full and reliable
integration with the current technology has not yet been achieved.

repository: Sohan-Rai/technologies

repo_name: Sohan-Rai/technologies


text:
# Provide Task Scenarios, Reasoning And Pre Training Model Files Supported By The Model:
| Model name | Introduction to the model | Model Size | Download address |
| ---- | ---- | ---- |---- |
| ERNIE-LayoutX-Base | Original pre training model | 1.13GB | [Pre training model](https://bj.bcebos.com/paddlenlp/models/transformers/ernie_layout/ernie_layoutx_base_uncased.pdparams) |
| Docprompt | Docprompt is a question and answer model for document extraction, which is based on the fine-tuning of the document visual question and answer task by ERNIE-Layout | 2.16GB | [Reasoning model](https://bj.bcebos.com/paddlenlp/taskflow/document_intelligence/docprompt/docprompt_params.tar)|

repository: PaddlePaddle/models

gha_language: Python

repo_name: PaddlePaddle/models


text:
# Multi-objective evolutionary-based heat exchanger network retrofit for multi-period processes
Copyright 2023 Jan Stampfli

[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0) [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4441114.svg)](https://doi.org/10.5281/zenodo.4441114)

## Description

   This algorithm is developed to solve the multi-objective heat exchanger network retrofit problem for multi-period processes. The customized two-level algorithm consists of a genetic algorithm for the topology optimization of the network and a differential evolution for the heat load optimization.
## License

   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.

## Requirements
The algorithm requires Python 3.8. The following Python modules are used:
- pandas 1.0.3
- xlrd 1.2.0 (newer versions do not support xlsx files)
- numpy 1.18.1
- scipy 1.5.0
- deap 1.3.1
## Data input
Case study data and algorithm parameters are stored in Excel spreadsheets under data. Two examples for case studies (Zweifel.xlsx and JonesP3.xlsx) as well as an algorithm parameter file (AlgorithmParameter) are provided.
## Related publications
-  Stampfli J.A., Olsen D.G., Wellig B., Hofmann R., 2020. Heat Exchanger Network Retrofit for Processes with Multiple Operating Cases: a Metaheuristic Approach, in: Proceedings of the 30th European Symposium on Computer Aided Process Engineering. Elsevier B.V., Amsterdam. volume 48, pp. 781-786. doi:[10.1016/B978-0-12-823377-1.50131-2](https://doi.org/10.1016/B978-0-12-823377-1.50131-2).
- Stampfli J.A., Ong B.H.Y., Olsen D.G., Wellig B., Hofmann R., 2022. Applied heat exchanger network retrofit for multi-period processes in industry: A hybrid evolutionary algorithm. Computers and Chemical Engineering 161, 107771. doi:[10.1016/j.compchemeng.2022.107771](https://doi.org/10.1016/j.compchemeng.2022.107771).
- Stampfli J.A., Olsen D.G., Wellig B., Hofmann R., 2022. A parallelized hybrid genetic algorithm with differential evolution for heat exchanger network retrofit. MethodsX 9, 101711. doi:[10.1016/j.mex.2022.101711](https://doi.org/10.1016/j.mex.2022.101711).
- Stampfli J.A, Ong B.H.Y., Olsen D.G., Wellig B., Hofmann R., 2023. Multi-objective evolutionary optimization for multi-period heat exchanger network retrofit. Energy 281, 128175. doi:[10.1016/j.energy.2023.128175](https://doi.org/10.1016/j.energy.2023.128175).


text:
# Report

Authors: Julius, Shaowei

## Program Design

This train simulation is implemented in OpenMP. Primary design considerations are:

- Each train is simulated by one thread as required in the specifications.
  - This is achieved by calling `omp_set_num_threads(num_trains)`
- Each train stores its next state, and when it will enter that state.
- Each train will generate the time at which it will open its doors when it starts waiting at a station.

### Assumptions

- Only one train can open its doors at each at any one time, regardless of direction.
- Train stations have infinite capacity for waiting trains.
- Time units are discrete and can have no subdivisions
  - Implication: It is sufficient to store all time units as integers instead of floating point numbers
- Trains must open their doors for at least 1 unit of time.
  - Implication: We round every randomly generated door open time up to the nearest integer

## Points to note / Implementation details

- Current simulation time needs to be shared across all threads. In addition, time can only be advanced after all threads have completed the actions to be done in the current tick.
  - Each train keeps track of its next action time, and actions to be completed within the current tick are performed in a `while` loop.
  - There is a `#pragma omp barrier` to ensure that all threads exit the `while` loop before time is advanced.
  - The advancement of time is done in a `#pragma omp single` block to ensure that it is only performed by one thread. In addition, `#pragma omp single` has an implicit barrier at the end of the block so this prevents other threads from entering the next iteration of the `while` loop until the advancement of time is complete.
- Certain resources i.e. train tracks, door-opening rights are limited, and only one train may access them at any time.
  1. One way to implement this is to have threads block when waiting to access such resources. However, this would interfere with the way we have chosen to implement time within this simulation. Blocked threads would prevent code after a `#pragma omp barrier` statement from being executed. We therefore decided **not** to go with this implementation.
  2. An alternative way to implement is to have a queue of trains requesting access to such resources. At each tick, each train would check whether it is at the head of the queue, and if so, it will be able to access the resource. We realised that it will also be necessary to store the time at which a train would be able to gain access to the resource, since our simulation time advances in integer increments, but door open time may have a fractional value. Upon further consideration, we realised that this design could be simplified.
  3. The key insight we arrived at is that any train waiting for access to a resource only needs to know the next time said resource will be available. Since this system does not permit a train to give up waiting for a resource, this can be implemented simply with a thread-safe timekeeper object. When a train requests access to a resource, it tells the timekeeper how much time it will occupy the resource for. The timekeeper will then inform the train of the time when the train can access the resource, and update its internal next available time. This is the implementation we decided to go with.
- The next consideration is ensuring that system statistics are reported correctly. Since we assume that trains cannot open its doors for 0s, only one train can open its doors at each station per tick. There is therefore no potential race condition in the update of statistics.
- Since print statements are not atomic, we wrapped them in a `#pragma omp critical` block to ensure that only one print operation executes at any one time.

## Execution time & analysis

Note: To facilitate more accurate execution time analysis, we disabled per-tick status output for the following tests.

## Discussion

## Bonus


text:
# com.0x82.dropbox.Session

## Description

A dropbox object that represents a dropbox session with the server.

## Reference

### dropbox.session.isLinked()

Returns a bool (true, false) if the current session is linked to the Dropbox
API. If it's not, you should call the [link]() method, to
authenticate the user.

### dropbox.session.unlink()

Unlinkes the current session from this device.

### dropbox.session.link({...})

Shows a modal dropbox authentication window on both iPhone and iPad.

Takes one argument, a dictionary containing the following properties:

- success[callback]: a callback which is called if the authentication succeeds. The callback method takes one argument containing the following properties:
> client[object]: a [dropbox.Client](client.html) instance you should use to make your requests from this momment on

- cancel[callback]: a callback which is called if the user cancels the authentication / signup process. There is no need to close the modal window.

repository: caspahouzer/titanium-dropbox

repo_name: caspahouzer/titanium-dropbox


text:
---
layout: navpage
sidebar: references
title: "Trace Reference"
permalink: /reference/trace
tags: [repodb, class, trace, orm, hybrid-orm, sqlserver, sqlite, mysql, postgresql]
---

# Trace

This page contains the recommended way of implementing a trace object.

#### Class Creation

Create an interface that implements the [ITrace](/interface/itrace) to support the dependency injections.

```csharp
public interface INorthwindTrace : ITrace
{ }
```

Then, create a class that implements the custom interface.

```csharp
public class NorthwindTrace : INorthwindTrace
{
    public void AfterQuery(TraceLog log)
    {
        Console.WriteLine(log.Statement);
    }

    public void BeforeQuery(CancellableTraceLog log)
    {
        Console.WriteLine(log.Statement);
    }

    ...
}
```

> Implement all the [ITrace](/interface/itrace) methods manually.

#### Usability

Create a factory class.

```csharp
public static class TraceFactory
{
    private static object m_syncLock = new object();
    private static ITrace m_trace = null;

    public static ITrace CreateTracer()
    {
        if (m_trace == null)
        {
            lock (m_syncLock)
            {
                if (m_trace == null)
                {
                    m_trace = new NorthwindTrace();
                }
            }
        }
        return m_trace;
    }
}
```

Or inject it as Singleton.

```csharp
public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();

    // Registration
    services.AddSingleton<INorthwindTrace, NorthwindTrace>();
}
```

> Please refer to our [SerilogTrace](/reference/serilogtrace) (In-Progress) page for for more information.


text:
# Telegram Message Copy (TeMeCo)

[![EO principles respected here](https://www.elegantobjects.org/badge.svg)](https://www.elegantobjects.org)
[![Build Status](https://travis-ci.org/monomonedula/temeco.svg?branch=master)](https://travis-ci.org/monomonedula/temeco)
[![codecov](https://codecov.io/gh/monomonedula/temeco/branch/master/graph/badge.svg)](https://codecov.io/gh/monomonedula/temeco)
[![PyPI version](https://badge.fury.io/py/temeco.svg)](https://badge.fury.io/py/temeco)

`temeco` is a simple Telegram message entities to html translator.
Telegram Bot API makes it cumbersome for bots to copy a user's message
preserving its entities, since it is currently impossible for a bot to send
entities directly along with a message,
so it needs to translate a message with entities into HTML or Markdown.

This little package solves this problem and provides a convenient way
to translate a message with entities to HTML.

`TelegramUTF16Text` class is also aware of the fact that Telegram calculates
 offsets for entities using UTF-16 encoding.
 This comes into play when text being copied contains symbols which have different lengths
 in UTF-8 and UTF-16 code units, like emojis.

 ## Installation
 `pip install temeco`

 ## Usage:
 ```python
from temeco.temeco import BasicEntity, TelegramUTF16Text, HtmlFromMsg

text = (
    "dolorem ipsum, quia dolor sit, 🔥🚒 amet, consectetur, adipisci velit, sed quia 🙃 non numquam eius modi"
    " tempora incidunt, 🙊\nut labore et dolore magnam aliquam quaerat voluptatem."
)
# The offsets correspond to the utf-16 version of the original text,
#   because telegram calculates the offsets in utf-16 code-units

HtmlFromMsg(
    msg_txt=TelegramUTF16Text(text),
    entities=[
        BasicEntity(
            type="bold", offset=8, length=5, msg_text=TelegramUTF16Text(text)
        ),
        BasicEntity(
            type="code", offset=55, length=8, msg_text=TelegramUTF16Text(text)
        ),
        BasicEntity(
            type="text_link",
            offset=64,
            length=5,
            data={"url": "http://google.com/"},
            msg_text=TelegramUTF16Text(text),
        ),
        BasicEntity(
            type="italic",
            offset=153,
            length=7,
            msg_text=TelegramUTF16Text(text),
        ),
    ],
).as_str()

# returns
# 'dolorem <b>ipsum</b>, quia dolor sit, 🔥🚒 amet, consectetur, <code>adipisci</code> <a href="http://google.com/">velit</a>, sed quia 🙃 non numquam eius modi tempora incidunt, 🙊
#  ut labore et dolore magnam <i>aliquam</i> quaerat voluptatem.'
```

 ## Note:
 `BasicEntity` class supports the following types of entities:
 - `bold`
 - `italic`
 - `text_link`
 - `code` (monospace text)
 - `pre` (preformatted text)

Entities like hashtags and usernames are copied as is, since Telegram recognizes them
without extra code.

You may create your own class implementing `Entity` interface and use it instead of
BasicEntity.

repository: monomonedula/temeco

repo_name: monomonedula/temeco


text:
# Logminer Kafka Connect

Logminer Kafka Connect is a CDC Kafka Connect source for Oracle Databases (tested with Oracle <IP_ADDRESS>).

Changes are extracted from the Archivelog using [Oracle Logminer](https://docs.oracle.com/cd/B19306_01/server.102/b14215/logminer.htm).

- [Logminer Kafka Connect](#logminer-kafka-connect)
  * [Features](#features)
  * [Installation](#installation)
    + [Docker](#docker)
    + [Oracle Database Configuration Requirements](#oracle-database-configuration-requirements)
  * [Initial Import](#initial-import)
  * [Change Types](#change-types)
    + [Value Struct](#value-struct)
    + [Source struct](#source-struct)
  * [Configuration](#configuration)
  * [Limitations](#limitations)

## Features

Stable features:
- Insert, Update and Delete changes will be tracked on configured tables
- Logminer without "CONTINUOUS_MINE", thus in theory being compatible with Oracle 19c (not tested)
- Initial import of the current table state
- Only based on Oracle features that are available in Oracle XE (and thus available in all Oracle versions). No
Oracle GoldenGate license required!
- Reading schema changes from the Online Dictionary. See
https://docs.oracle.com/cd/B19306_01/server.102/b14215/logminer.htm#i1014687 for more information.

Unstable features:
- Reading schema changes from the Archive-Log

Planned features:
- More documentation :)

## Installation
You can install this Kafka Connect component into Kafka Connect using the [Confluent Hub Client](https://docs.confluent.io/current/connect/managing/confluent-hub/client.html). Additionally, you need to download the Oracle
JDBC driver and put it on the classpath of Logminer Kafka Connect. The JDBC driver can't be included in the Logminer Kafka Connect release
as its license does not allow this.

The following script will install Logminer Kafka Connect into an existing Kafka Connect installation:
```shell script
wget https://github.com/thake/logminer-kafka-connect/releases/download/0.4.0/thake-logminer-kafka-connect-0.4.0.zip
confluent-hub install ./thake-logminer-kafka-connect-0.4.0.zip --no-prompt
rm ./thake-logminer-kafka-connect-0.4.0.zip
wget https://repo1.maven.org/maven2/com/oracle/database/jdbc/ojdbc8/<IP_ADDRESS>/ojdbc8-<IP_ADDRESS>.jar -o /usr/share/confluent-hub-components/thake-logminer-kafka-connect/lib/ojdbc8-<IP_ADDRESS>.jar
```
### Docker
If you plan to run Logminer Kafka Connect as a container, you can also have a look at the docker image at https://github.com/thake/logminer-kafka-connect-image

### Oracle Database Configuration Requirements
In order for Logminer Kafka Connect to work, the database needs to be in ARCHIVELOG mode and Supplemental Logging needs to be
enabled with all columns. Here are the commands that need to be executed in sqlplus:
```oraclesqlplus
prompt Shutting down database to activate archivelog mode;
shutdown immediate;
startup mount;
alter database archivelog;
prompt Archive log activated.;
alter database add supplemental log data (all) columns;
prompt Activated supplemental logging with all columns.;
prompt Starting up database;
alter database open;
```

## Initial Import
If the start SCN is not set or set to 0, logminer kafka connect will query
the configured tables for an initial import. During the initial import, no
DDL statements should be executed against the database. Otherwise the initial import will
fail.

To support initial import, database flashback queries need to be enabled on the source database.

All rows that are in the table at time of initial import will be treated as "INSERT" changes.

## Change Types
The change types are compatible to change types published by the debezium (https://debezium.io/) project.
Thus it is easy to migrate to the official debezium Oracle plugin ones it reaches a stable state.
The key of the kafka topic will be filled with a struct containing the primary key values of the changed row.

### Value Struct
The value is a structure having the following fields:
  -  `op`
      Operation that has been executed.
        - Type: string
        - Possible values:
            - 'r' - Read on initial import
            - 'i' - Insert
            - 'u' - Update
            - 'd' - Delete
  - `before`
     Image of the row before the operation has been executed. Contains all columns.
       - Type: struct
       - Only filled for the following operations:
           - Update
           - Delete
  - `after`
     Image of the row after the operation has been executed. Contains all columns.
       - Type: struct
       - Only filled for the following operations:
           - Insert
           - Read
           - Update
  - `ts_ms`
     Timestamp of import as millis since epoch
       - Type: Long
  - `source`
     Additional information about this change record from the source database.
       - Type: source

### Source struct

The following source fields will be provided:
  - `version`
     Version of this component
       - Type: string
       - Value: '1.0'
  - `connector`
     Name of this connector.
       - Type: string
       - Value: 'logminer-kafka-connect'
  - `ts_ms`
     Timestamp of the change in the source database.
       - Type: long
       - Logical Name: org.apache.kafka.connect.data.Timestamp
  - `scn`
     SCN number of the change. For the initial import this is the scn of the las update to the row.
       - Type: long
  - `txId`
     Transaction in which the change occurred in the source database. For the initial import, this field is always null.
       - Type: string (optional)
  - `table`
     Table in the source database for which the change was recorded.
       - Type: string
  - `schema`
     Schema in the source database in which the change was recorded.
      - Type: string
  - `user`
     The user that triggered the change
       - Type: string (optional)

## Configuration
You can find an example configuration under [logminer-kafka-connect.properties](logminer-kafka-connect.properties).

The following configuration parameter are available:
  - `db.hostname`
    Database hostname

      - Type: string
      - Importance: high

  - `db.name`
    Logical name of the database. This name will be used as a prefix for
    the topic. You can choose this name as you like.

      - Type: string
      - Importance: high

  - `db.port`
    Database port (usually 1521)

      - Type: int
      - Importance: high

  - `db.sid`
    Database SID

      - Type: string
      - Importance: high

  - `db.user`
    Database user

      - Type: string
      - Importance: high

  - `db.user.password`
    Database password

      - Type: string
      - Importance: high

  - `db.logminer.dictionary`
    Type of logminer dictionary that should be used.
    Valid values: ONLINE, REDO_LOG

      - Type: string
      - Default: ONLINE
      - Importance: low
  - `db.timezone`
    The timezone in which TIMESTAMP columns (without any timezone information) should be interpreted as. Valid values are all values that can be passed to https://docs.oracle.com/javase/8/docs/api/java/time/ZoneId.html#of-java.lang.String-

      - Type: string
      - Default: UTC
      - Importance: high

  - `batch.size`
    Batch size of rows that should be fetched in one batch

      - Type: int
      - Default: 1000
      - Importance: high

  - `start.scn`
    Start SCN, if set to 0 an initial intake from the tables will be
    performed.

      - Type: long
      - Default: 0
      - Importance: high

  - `table.whitelist`
    Tables that should be monitored, separated by ','. Tables have to be
    specified with schema. Table names are case-sensitive (e.g. if your table name is an unquoted identifier, you'll need to specify it in all caps).
    You can also just specify a schema to indicate
    that all tables within that schema should be monitored. Examples:
    'MY\_USER.TABLE, OTHER\_SCHEMA'.

      - Type: string
      - Default: ""
      - Importance: high

  - `tombstones.on.delete`
    If set to false, no tombstone records will be emitted after a delete operation.

      - Type: boolean
      - Default: true
      - Importance: high

  - `db.fetch.size`
    JDBC result set prefetch size. If not set, it will be defaulted to
    batch.size. The fetch should not be smaller than the batch size.

      - Type: int
      - Default: null
      - Importance: medium

  - `db.attempts`
    Maximum number of attempts to retrieve a valid JDBC connection.

      - Type: int
      - Default: 3
      - Importance: low

  - `db.backoff.ms`
    Backoff time in milliseconds between connection attempts.

      - Type: long
      - Default: 10000
      - Importance: low

  - `poll.interval.ms`
    Positive integer value that specifies the number of milliseconds the
    connector should wait after a polling attempt didn't retrieve any
    results.

      - Type: long
      - Default: 2000
      - Importance: low

## Limitations
- Due to limitations of Oracle Logminer, it is not possible to track the UPDATE statements to existing records that are implicitly performed whenever a new
not null column with a default value will be added to a table.

  However you can change the way you add these columns in order to correctly record the UPDATE statements.
Instead of doing everything in one command, one could separate it into the following steps:
  1. Adding new nullable column
  1. Adding a trigger on insert that automatically inserts the default value for the new nullable column if it is not specified.
  1. Updating the column with the default value for all existing rows
  1. Changing the definition of the column to be NOT NULL with the default value.
  1. Dropping trigger on insert
Performing the DDL in this way would guarantee that the change log will be readable by logminer.

repository: thake/logminer-kafka-connect

gha_language: Kotlin

repo_name: thake/logminer-kafka-connect


text:
# nephelaiio.unifi-controller

[![Build Status](https://github.com/nephelaiio/ansible-role-unifi-controller/workflows/CI/badge.svg)](https://github.com/nephelaiio/ansible-role-unifi-controller/actions)
[![Ansible Galaxy](http://img.shields.io/badge/ansible--galaxy-nephelaiio.unifi_controller-blue.svg)](https://galaxy.ansible.com/nephelaiio/unifi_controller/)

An [ansible role](https://galaxy.ansible.com/nephelaiio/unifi-controller) to install and configure [Ubiquiti Unifi Controller](https://www.ubnt.com/enterprise/software/)

## Role Variables

Please refer to the [defaults file](/defaults/main.yml) for an up to date list of input parameters

## Example Playbook

Unifi installation on regular x86_64 hardware

```
- hosts: unifi
  roles:
     - role: unifi-controller
```

Unifi installation on raspberry pi 3
```
- hosts: unifi
  roles:
     - role: unifi-controller
  vars:
    unifi_java_packages: openjdk-8-jre-headless
    unifi_java_home: /usr/lib/jvm/java-8-openjdk-armhf/jre
```

## Testing

Please make sure your environment has [docker](https://www.docker.com) installed in order to run role validation tests. Additional python dependencies are listed in the [requirements file](https://github.com/nephelaiio/ansible-role-requirements/blob/master/requirements.txt)

Role is tested against the following distributions (docker images):
  * Ubuntu Focal
  * Ubuntu Bionic

You can test the role directly from sources using command ` molecule test `

## License

This project is licensed under the terms of the [MIT License](/LICENSE)


text:
YCP Killer
==========

YCP Killer is a tool that manages translation of
[YCP](http://doc.opensuse.org/projects/YaST/SLES10/tdg/Book-YCPLanguage.html)
code in [YaST](http://en.opensuse.org/Portal:YaST) into Ruby. Once complete, it
will be used to translate the whole YaST codebase into Ruby, which will allow us
to get rid of YCP completely.

Description
-----------

YCP Killer translates YaST code into Ruby module by module. The translation is
driven by files in the `data` directory, which describe which files in each
module need to be translated and also contain some other metadata. To perform
the actual translation, YCP Killer uses [Y2R](https://github.com/yast/y2r).

Before the actual translation, modules can be patched using patches in the
`patches` directory. This makes it possible e.g. to rewrite parts of module code
that contain constructs that Y2R can't handle.

**Note:** YCP Killer is work in progress and translation of many modules
currently fails with errors.

Installation
------------

YCP Killer is tested only on [openSUSE
12.3](http://en.opensuse.org/Portal:12.3). It probably won't work in other
openSUSE versions, other Linux distributions, or other operating systems.

The following steps will make YCP Killer run on a vanilla openSUSE 12.3 system.
They are somewhat complex, but we will hopefully simplify them over time as
things get gemified, packaged, etc.

  1. **Install Git**

         $ sudo zypper in git

  2. **Update `ycpc` (yast-core package)**

     Updated `ycpc` is needed because Y2R relies on some features that
     are not present in `ycpc` bundled with openSUSE 12.3.

     Install prebuilt RPM packages from **YaST:Head:ruby** OBS repository.

         $ sudo zypper ar -f http://download.opensuse.org/repositories/YaST:/Head:/ruby/openSUSE_12.3/ YaST:Head:ruby
         $ sudo zypper in -f -r YaST:Head:ruby yast2-core

  3. **Install basic Ruby environment**

         $ sudo zypper in ruby ruby-devel rubygem-bundler

  4. **Clone the Y2R repository and install Y2R's dependencies**

         $ sudo zypper in gcc-c++ make                  # Needed by Nokogiri
         $ sudo zypper in libxml2-devel libxslt-devel   # Needed by Nokogiri
         $ git clone git://github.com/yast/y2r.git
         $ cd y2r
         $ bundle install
         $ cd ..

  5. **Create a directory for compiled YaST modules**

         $ mkdir yast

  6. **Clone the YCP Killer repository and install YCP Killer's dependencies**

         $ sudo zypper in yast2-ycp-ui-bindings   # Implements UI::*
         $ sudo zypper in yast2-pkg-bindings      # Implements Pkg::*
         $ sudo zypper in yast2-perl-bindings     # Makes Perl modules work

         $ sudo zypper in cracklib-devel          # Needed by users
         $ sudo zypper in limal-perl              # Needed by bootloader
         $ sudo zypper in perl-Date-Calc          # Needed by ca-management
         $ sudo zypper in perl-Digest-SHA1        # Needed by ftp-server,
                                                  # phone-services,
                                                  # profile-manager and s390
         $ sudo zypper in perl-JSON               # Needed by crowbar
         $ sudo zypper in perl-NetxAP             # Needed by mail
         $ sudo zypper in perl-X500-DN            # Needed by ldap-server
         $ sudo zypper in perl-camgm              # Needed by ca-management
         $ sudo zypper in sablotron               # Needed by storage
         $ sudo zypper in suseRegister            # Needed by registration
         $ sudo zypper in yast2-ldap              # Needed by dns-server and
                                                  # dhcp-server (they need Perl
                                                  # modules which are not
                                                  # available otherwise as we
                                                  # don't translate ldap)
         $ sudo zypper in yast2-storage           # Needed by storage (it needs
                                                  # a C part, so let's use
                                                  # already built one)
         $ git clone git://github.com/yast/ycp-killer.git
         $ cd ycp-killer
         $ bundle install

  7. **Configure YCP Killer**

     Copy the `config.yml.example` file to `config.yml` and fill in the
     settings as described by comments in the file.

  8. **Done!**

     You can now start killing YCP.

 It is convenient to use the translation occasion to also move
files to a more logical and uniform scheme, to enable exporting the working
directory via `Y2DIR` and to unify Makefiles.

The following tree shows what gets installed where:

```
tictactoe-server
└── src
    ├── bin            ->  /usr/lib/YaST2/bin       (lib, even if lib64 exists)
    ├── servers_non_y2 ->  /usr/lib/YaST2/servers_non_y2
    ├── clients        ->  /usr/share/YaST2/clients
    ├── data           ->  /usr/share/YaST2/data
    ├── include        ->  /usr/share/YaST2/include
    ├── modules        ->  /usr/share/YaST2/modules
    ├── scrconf        ->  /usr/share/YaST2/scrconf
    ├── autoyast-rnc   ->  /usr/share/YaST2/schema/autoyast/rnc
    ├── control-rnc    ->  /usr/share/YaST2/schema/control/rnc
    ├── desktop        ->  /usr/share/applications/YaST2
    └── fillup         ->  /var/adm/fillup-templates
```

Other directories, like `doc` and `testsuite`, are not restructured now
and keep their existing Makefiles.

Usage
-----

YCP Killer is a command line tool. It's entry point is the `yk` script, which
accepts subcommands (like `git` or `bundler`). Each subcommand can be applied to
a set of YaST modules passed as arguments. A special value `all` will apply a
command to all YaST modules.

```
$ ./yk help
Tasks:
  yk clone <module>...        # Clone module(s)
  yk compile <module>...      # Compile module(s)
  yk convert <module>...      # Convert module(s)
  yk genpatch <module>...     # Store changes from work directory of module(s) into a patch
  yk help [TASK]              # Describe available tasks or one specific task
  yk patch <module>...        # Patch module(s)
  yk reset <module>...        # Revert module(s) work directory to clean state
  yk restructure <module>...  # Change module(s) work directory structure to fit the Y2DIR scheme
```

### Commands

The commands operate on two distinct directory trees: the *working* tree and
the *result* tree.

The module name can be omitted if it is the current working directory in the
*working* tree.

#### yk convert

Does everything at once: `clone`, `restructure`, `patch`, `compile`, `makefile`, `package`.

#### yk clone

Clones repositories of specified modules into subdirectories of a directory
specified by the `yast_dir` setting in `config.yml`.

**Removes the working tree for the module beforehand.**

```
$ ./yk clone testsuite
[1/1] Processing testsuite:
  * Cloning...                                                        OK
```

#### yk reset

Reverts the working directory to a clean state.
It is a local variant of `yk clone`
in that it **removes all modifications in the working tree**.
Use `yk genpatch` beforehand to save them.

```
$ ./yk reset testsuite
[1/1] Processing testsuite:
  * Resetting...                                                      OK
```

#### yk restructure

Changes the working directory structure to fit the Y2DIR scheme.
See [`moves`](#module-metadata) in Module Metadata below.

Results of the operation are saved into git index.
This means you can use `git status` or `git diff --cached`
inside the work directory to see what moved where.
The main purpose however is
to ensure that `yk genpatch` diffs properly against the new structure.

```
$ ./yk restructure testsuite
[1/1] Processing testsuite:
  * Restructuring...                                                  OK
```

#### yk patch

Applies patches for specified modules from the `patches` directory to their
checkouts. If a module doesn't have a patch, this command does not do anything.

```
$ ./yk patch testsuite
[1/1] Processing testsuite:
  * Patching...                                                       OK
```

#### yk compile

Compiles YCP files of specified modules to Ruby, placing the result in the
*result* tree.
The compilation is driven by
module descriptions stored in the `data` directory. It uses `ycpc` and `y2r`
binaries specified by the `ycpc` and `y2r` setting in `config.xml`.

The compilation of each file may finish in one the following states:

  * **OK** – the compilation was successful
  * **ERROR(ybc)** – the compilation failed when running `ycpc`
    on the module code
  * **ERROR(y2r)** – the compilation failed when running `y2r`
    on the module code
  * **ERROR(ruby)** – the compilation failed because it produced a result which
    was invalid Ruby (as determined by `ruby -c`)
  * **ERROR(other)** – the compilation failed for some other reason

If the compilation is successful, all YCP files defined in the module
description will be compiled by `ycp` and will have an eqivalent Ruby file
created by their side (e.g. compiling `Sysconfig.ycp` will produce
`Sysconfig.ybc` and `Sysconfig.rb` in the same directory).

In case of `ERROR(y2r)` and `ERROR(ruby)`, details of the error are logged into
the `error.log` file in the YCP Killer directory.

```
$ ./yk compile testsuite
[1/1] Compiling testsuite...
  * devel/src/bench.ycp                                               ERROR(y2r)
  * devel/src/debug.ycp                                               ERROR(y2r)
  * devel/src/devel.ycp                                               ERROR(y2r)
  * devel/testsuite/tests/bench.ycp                                   ERROR(y2r)
  * devel/testsuite/tests/debug.ycp                                   ERROR(y2r)
  * src/Pkg.ycp                                                       OK
  * src/Testsuite.ycp                                                 OK
  * src/testsuite.ycp                                                 OK
  * testsuite/test.ycp                                                ERROR(y2r)

-----

Total OK:           3
Total EXCLUDED:     0
Total ERROR(ybc):   0
Total ERROR(y2r):   6
Total ERROR(ruby):  0
Total ERROR(other): 0
```

#### yk genpatch

Stores changes from the working directory
into a patch in the `patches` directory.

**Any existing patch for the module is removed**.

```
[1/1] Processing testsuite:
  * Generating patch...                                               OK
```

#### yk makefile

Generates Makefile.am for exported directories of module(s)

#### yk package

Creates packages for module(s) in the build service directory, which is a
third tree alongside the *working* and *result* ones.

### Module Metadata

Modules have metadata files placed in `data/foo.yml`, in the [YAML][yaml]
format.

[yaml]: http://en.wikipedia.org/wiki/YAML

```
# A list of modules this one depends on to compile ycp code to ybc. Only direct
# dependencies need to be stated here (the indirect ones are computed
# automatically when needed).
# Default: []
ybc_deps:
  - yast2

# A list of modules this one additionally depends on to convert  ycp code to
# ruby. It needs to specify even indirect dependencies opposed to previous list.
# It is useful when client or testsuite depends on additional modules as
# ybc_deps are automatically merged.
# Default: []
ruby_deps:
  - testsuite

# A list of operations used by the `restructure` command
# to make the working tree better fit the Y2DIR scheme.
# Default: []
moves:
    # A glob in the original structure
    # (use quotes because of YAML syntax).
  - from: src/NfsServer.ycp
    # A directory path in the new structure.
    # Missing directories will be created.
    to: src/modules
  - from: "src/nfs[-_]server*.ycp"
    to: src/clients
    # The list is ordered, so we can glob the rest of the files:
  - from: "src/*.ycp"
    to: src/include/nfs_server

# A list of file paths (in the new structure, see 'moves')
# to exclude from compilation.
# A reason for the exclusion should be supplied in a comment.
# Default: []
excluded:
  # include stuff for testsuite
  - library/sequencer/testsuite/tests/Wizard.yh
  # agreed to exclude doc from automatic translation
  - library/sequencer/doc/examples/example1.ycp
  - library/sequencer/doc/examples/example2.ycp
  # include files that is not complete
  - library/packages/src/include/packages/common.ycp

# A list of paths (in the new structure, see 'moves')
# that users of this module should add to their `Y2DIR`.
# (Only mess^W complex modules like `yast2` should need this.
# Default: ["src"]
exports:
  - src
  - library/sequencer/src
  - library/packages/src
```

repository: kobliha/ycp-killer

repo_name: kobliha/ycp-killer


text:
# Covid-Face-MasK-Detection.
Face mask detection using local camera frame by frame and classifies the frame with mask or without mask with probability and boundary box.

* Detect faces and determine whether they are wearing mask.
* The code is implemented for face mask detection models with five mainstream deep learning frameworks （PyTorch、TensorFlow、Keras、MXNetcaffe） open sourced, and the corresponding inference codes.

# Dataset.
* We trained the face mask detection models with five mainstream deep learning frameworks （PyTorch、TensorFlow、Keras、MXNetcaffe） open sourced, and the corresponding inference codes.
* We used 7959 images to train the models. The dataset is composed of WIDER Face (http://shuoyang1213.me/WIDERFACE/) and MAFA(http://www.escience.cn/people/geshiming/mafa.html).

# Implementation.

* We used the structure of SSD. However, in order to make it run quickly in the browser, the backbone network is lite. The total model only has 1.01M parametes.

* Input size of the model is 260x260, the backbone network only has 8 conv layers. The total model has only 24 layers with the location and classification layers counted.

# Implementation in MacOs
* Step 1: Open terminal. $ git clone https://github.com/swaroop9ai9/Covid-Face-MasK-Detection
* Step 2: $ cd desktop/Covid-Face-MasK-Detection
* Step 3: For individual Image: $ python pytorch_infer.py  --img-path /path/to/your/img
* Step 4: For Live Feed (Frame by Frame): python pytorch_infer.py --img-mode 0 --video-path 0
* Step 5: For Video Path: python pytorch_infer.py --img-mode 0 --video-path /path/to/video

# Implementing it in [TensorFlow/Keras/MXNet/Caffe]
* The other four frameworks running method is similar to pytorch, just replace pytorchwith tensorflow, keras,caffe，mxnet, if you want to use tensorflow, just run:
 $ python tensorflow_infer.py  --img-path /path/to/your/img

 # Output.

 * With Out Mask with probability and bounding box
 ![](images/withoutmask.png)

 * With Mask with probability and bounding box
 ![](images/withmask.png)


text:
# PDFtoPrinter

[![License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/DarqueWarrior/generator-team/blob/master/LICENSE)
[![NuGet](https://img.shields.io/nuget/dt/PDFtoPrinter.svg)](https://www.nuget.org/packages/PDFtoPrinter/)
[![Build status](https://vishnevsky.visualstudio.com/PDFtoPrinter/_apis/build/status/PDFtoPrinter%20Build)](https://vishnevsky.visualstudio.com/PDFtoPrinter/_build/latest?definitionId=1)

The PDFtoPrinter project Allows to print PDF files uses [PDFtoPrinter](http://www.columbia.edu/~em36/pdftoprinter.html) util. The package contains PDFtoPrinter.exe and copys it to the output folder before build event. Also it provides PDFtoPrintWrapper class that runs PDFtoPrinter.exe inside of a "Print" method in a separate process with default timeout 1 minute (the timeout can be overrited by 3rd argument). The "Print" method runs new PDFtoPrinter.exe instance per call. By default new printing will not start while the previous from the same PDFtoPrintWrapper instance isn't completed. But you can use set concurrency level using constructor with arguments.

*Note: Concurrency level works inside PDFtoPrintWrapper instance.*

Sample usage:

USe local printer
```C#
var filePath = "c:\path\to\pdf\file.pdf";
var printerName = "Vendor Color Printer Name";
var printWrapper = new PDFtoPrintWrapper();
printWrapper.Print(filePath, printerName);
```

Use network printer with timeout
```C#
var filePath = "c:\path\to\pdf\file.pdf";
var networkPrinterName = "\\myprintserver\printer1";
var printTimeout = new TimeSpan(0, 30, 0);
var printWrapper = new PDFtoPrintWrapper();
printWrapper.Print(filePath, networkPrinterName, printTimeout);
```

Use network printer with 5 concurrency printings. In this case up to 5 instances of PDFtoPrinter.exe will be started simultaneously
```C#
var filePath = "c:\path\to\pdf\file.pdf";
var networkPrinterName = "\\myprintserver\printer1";
var allowedCocurrentPrintings = 5;
var printWrapper = new PDFtoPrintWrapper(allowedCocurrentPrintings);
for (var i = 0; i < 10; i++)
{
    wrapper.Print(filePath, networkPrinterName);
}
```

repository: diopisemou/PDFtoPrinter

repo_name: diopisemou/PDFtoPrinter


text:
### [d3panels](https://kbroman.org/d3panels): D3-based graphic panels

[![NPM badge](https://img.shields.io/npm/v/d3panels.svg)](https://npmjs.org/package/d3panels)
[![zenodo DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.5418277.svg)](https://doi.org/10.5281/zenodo.5418277)

[Karl W Broman](https://kbroman.org)

This is a set of [D3](https://d3js.org)-based graphic panels, to
be combined into larger multi-panel charts.  They were developed for
the [R/qtlcharts](https://kbroman.org/qtlcharts) package.

Note that d3panels uses
[D3 version 7](https://github.com/d3/d3/blob/main/API.md).
(It should also work with version 6.)

There are other libraries with similar goals that are of more general
use (e.g., [C3.js](https://c3js.org)); see
[this list of javascript chart libraries](https://blog.webkid.io/javascript-chart-libraries/)),
but I wanted charts that were a bit _less_ general and flexible, but
rather more specific to my particular applications (and style).

For snapshots and live tests, see <https://kbroman.org/d3panels>.

#### Documentation

For documentation, see <https://github.com/kbroman/d3panels/tree/main/doc>.

#### Usage

All of the functions are called as `d3panels.blah()`.  And for each
chart, you first call the chart function with a set of options, like
this:

```coffeescript
mychart = d3panels.lodchart({height:600, width:800})
```

And then you call the function that's created with some selection and
the data:

```coffeescript
mychart(d3.select("div#chart"), mydata)
```

There are three exceptions to this:
[`add_lodcurve`](add_lodcurve.md), [`add_curves`](add_curves.md), and [`add_points`](add_points.md).
For these functions, you first need to call another function that
creates a panel
(for example, [`lodchart`](lodchart.md) or [`chrpanelframe`](chrpanelframe.md) in
the case of [`add_lodcurve`](add_lodcurve.md), or
[`panelframe`](panelframe.md) in the case of
[`add_curves`](add_curves.md) or [`add_points`](add_points.md)).  You
then use the chart function created by
that first call in place of a selection. For example:

```coffeescript
myframe = d3panels.panelframe({xlim:[0,100],ylim:[0,100]})
myframe(d3.select("body"))

addpts = d3panels.add_points()
addpts(myframe, {x:[5,10,25,50,75,90], y:[8,12,50,30,80,90], group:[1,1,1,2,2,3]})
```

#### Links

You'll need to link to the `d3panels.js` and `d3panels.css` files (or
to `d3panels.min.js` and `d3panels.min.css`):

```html
<script type="text/javascript" src="https://rawgit.com/kbroman/d3panels/main/d3panels.js"></script>
<link rel=stylesheet type="text/css" href="https://rawgit.com/kbroman/d3panels/main/d3panels.css">
```

You'll also want to link to [D3.js](https://d3js.org):

```html
<script charset="utf-8" type="text/javascript" src="https://d3js.org/d3.v5.min.js"></script>
```

#### Build

To build the javascript (and CSS) files from the coffeescript source,
you first need to install [npm](https://www.npmjs.com/get-npm).

Then use npm to install [yarn](https://yarnpkg.com/en/), [coffeescript](https://coffeescript.org), [uglify-js](https://github.com/mishoo/UglifyJS2)
[uglifycss](https://github.com/fmarcia/UglifyCSS), and [babel-core](https://github.com/babel/babel/tree/main/packages/babel-core)

```script
npm install -g yarn coffeescript uglifycss uglify-js babel-core
```

Then install the dependency, [d3](https://d3js.org):

```script
yarn install
```

Finally, run make to create the compiled javascript code.

```script
make
```

#### License

Licensed under the
[MIT license](LICENSE.md). ([More information here](https://en.wikipedia.org/wiki/MIT_License).)

gha_language: CoffeeScript