text:
# Results on Running Time : Float, Row-Major

## Overview

### Legend

* **CPP_BLOCK 1 1** : C++ implementation - baseline

* **CPP_BLOCK 1 8** : C++ implementation with 8 threads

* **NEON 1 1** : NEON** intrinsics no loop unrolling, single thread

* **NEON 8 1** : NEON intrinsics loop unrolling of factor 8, single thread

* **NEON 8 8** : NEON intrinsics loop unrolling of factor 8, 8 threads

* **BLAS 1 1** : BLAS cblas_sgemv()

* **VDSP 1 1** : vDSP vDSP_mmul()

* **METAL MPS 0 0** : Metal MPSMatrixVectorMultiplication

* **METAL THREADS_OVER_ROWS 0 0** : Metal shader,  threads over rows, loop over columns

* **METAL THREADS_OVER_COLUMNS 0 0** : Metal shader, threads over columns, reduction per row per threadgroup

### Remarks

* vDSP/BLAS shows the best running time for the size up to *(1K, 1K)*.

* NEON with the loop unrolling factor of 8 with 8 threads shows the best running time for the sizes from
*(2K, 2K)* to *(4K, 4K)*.

* Beyond the size *(4K, 4K)*, METAL THREADS_OVER_COLUMNS and MPS perform best.

The plots for BLAS and VDSP are completely overlapped and only the lines for VDSP is shown above.
This implies that the two implementations are identical.

## Comparison Among C++ Multithreaded

### Legend

* **CPP_BLOCK 1 1** : C++ implementation - baseline

* **CPP_BLOCK 1 2** : C++ implementation with 8 threads

* **CPP_BLOCK 1 4** : C++ implementation with 8 threads

* **CPP_BLOCK 1 8** : C++ implementation with 8 threads

### Remarks
This shows the effectiveness of threadding for the plain C++ implementation.
The cost of synchronizing the threads are quickly amortized already around the size of *(256, 256)*.

## Comparison Among NEON with loop unrolling

### Legend

* **CPP_BLOCK 1 1** : C++ implementation - baseline

* **NEON 1 1** : NEON intrinsics no loop unrolling, single thread

* **NEON 2 1** : NEON intrinsics loop unrolling of factor 8, single thread

* **NEON 4 1** : NEON intrinsics loop unrolling of factor 8, single thread

* **NEON 8 1** : NEON intrinsics loop unrolling of factor 8, single thread

### Remarks
NEON intrinsics make it run faster more than 400% than the plain implementation.
The loop unrolling also improves the performance, and the sweet spot for the loop unrolling seems to be around the factor 4.

## Comparison Among NEON with Multithreads

### Legend

* **NEON 8 1** : NEON intrinsics with loop unrolling of factor 8, single thread - baseline

* **NEON 8 8** : NEON intrinsics with loop unrolling of factor 8, 8 threads - baseline

### Remarks

The overhead of the synchrnization of threads is amortized around *(1K, 1K)* and use of multithread is beneficial, though the benefit is not as dramatic as the case for the col-major.

## Comparison Among Metal Implementations

### Legend

* **METAL THREADS_OVER_ROWS 0 0** : Metal shader, threads over rows, loop over columns - baseline

* **METAL THREADS_OVER_COLUMNS 0 0** : Metal shader, threads over columns, reduction per row per threadgroup

* **METAL MPS 0 0** : Metal MPSMatrixVectorMultiplication

### Remarks
Since this is for the row-major, THREADS_OVER_COLUMNS reads in the threadgroup one row ideally coalesced, and the reduction is very effective.

On the other hand, THREAD_OVER_ROWS reads one columns per threadgroup and the loop in the threadgroup iterates over the columns.
The memory load by the threads for one column is uncoalesced, and it increases the cache misses as the size of the column becomes larger, and it makes the execution less effective.
The chart above shows it.

It seems MPS takes the similar approach as THREAD_OVER_COLUMNS, as two plots are similar.


text:
# js-angusj-clipper
#### *Polygon and line clipping and offsetting library for Javascript/Typescript*

*a port of Angus Johnson's clipper to WebAssembly/Asm.js*

[![npm version](https://badge.fury.io/js/js-angusj-clipper.svg)](https://badge.fury.io/js/js-angusj-clipper)

---

Install it with ```npm install --save js-angusj-clipper```

*Note:* If you want to use the WebAssembly version you will also need to copy the ```clipper-wasm.wasm``` file found in
```node_modules/js-angusj-clipper/dist/wasm``` as a resource file and then reference the folder
containing it inside the init function. Eventually (hopefully) this requirement will be dropped in the future once
EMScripten supports embedding WASM file contents inside js files.

__To support this project star it on [github](https://github.com/xaviergonz/js-angusj-clipper)!__

---

### What is this?

A library to make polygon clipping (boolean operations) and offsetting **fast** on Javascript thanks
to WebAssembly / Asm.js, based on the excellent Polygon Clipping (also known as Clipper) library by
Angus Johnson.

---

### Why?

Because sometimes performance does matter and I could not find a javascript library
as fast or as rock solid as the C++ version of [Clipper](https://sourceforge.net/projects/polyclipping/).

As an example, the (totally unscientific) benchmarks on my machine for offsetting a big polygon are:
* Pure JS port of the Clipper library: **~11 seconds**
* This library (*Asm.js*): **~7.3 seconds** (mostly due to the lack of support for 64-bit integers)
* This library (*WebAssembly*): **~2.8 seconds**

---

### Getting started

```js
// import it with
import * as clipperLib from 'js-angusj-clipper'; // es6 / typescript
// or
const clipperLib = require('js-angusj-clipper'); // nodejs style require

async function mainAsync() {

  // create an instance of the library (usually only do this once in your app)
  const clipper = await clipperLib.loadNativeClipperLibInstanceAsync(

    // let it autodetect which one to use, but also available WasmOnly and AsmJsOnly
    clipperLib.NativeClipperLibRequestedFormat.WasmWithAsmJsFallback,

    // path were the clipper-wasm.wasm resource file is located (should be copied from
    // node_modules/js-angusj-clipper/dist/wasm/clipper-wasm.wasm - only required with
    // the WASM version)
    '../wasm'

  );

  // create some polygons (note that they MUST be integer coordinates)
  const poly1 = [
    {x: 0, y: 0},
    {x: 10, y: 0},
    {x: 10, y: 10},
    {x: 0, y: 10},
    {x: 0, y: 0}
  ];

  const poly2 = [
    {x: 10, y: 0},
    {x: 20, y: 0},
    {x: 20, y: 10},
    {x: 10, y: 10},
    {x: 10, y: 0}
  ];

  // get their union
  const polyResult = clipper.clipToPaths({
    clipType: clipperLib.ClipType.Union,

    subjectInputs: [
      { data: poly1, closed: true },
      { data: poly2, closed: true }
    ],

    subjectFillType: clipperLib.PolyFillType.EvenOdd
  });

  /* polyResult will be:
  [
    [
      { x: 0, y: 0 },
      { x: 20, y: 0 },
      { x: 20, y: 10 },
      { x: 0, y: 10 }
    ]
  ]
 */
}

mainAsync();

```

---

For an in-depth description of the library see:

* [Overview](./docs/overview/index.md)
* [API Reference](./docs/apiReference/index.md)
* [FAQ](./docs/faq/index.md)

license: MIT

repository: bloessberlin/js-angusj-clipper

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: bloessberlin/js-angusj-clipper


text:
# AndroidRTC

## WebRTC Live Streaming

An Android client for [WebRTC-Android](https://github.com/balwant108/WebRTC-Android).

It is designed to demonstrate WebRTC video calls between androids and/or desktop browsers, but WebRtcClient could be used in other scenarios.

- WebRTC-Android
- [iOS client](https://github.com/balwant108/WebRTC-iOS)
- [server](https://github.com/balwant108/WebRTC-Server)

Build with Android Studio 1.1.0. The Intellij IDEA version is in the master branch.
You can import the webrtc-client module in your own app if you want to work with it.

## How To

You need [WebRTC-Server](https://github.com/balwant108/WebRTC-Server) up and running, and it must be somewhere that your android can access. (You can quickly test this with your android browser). Modify the host string (in res/values/strings.xml) to the server IP.

When you launch the app, you will be given several options to send a message : "Call someone".
Use this menu to send a link of your stream. This link can be opened with a WebRTC-capable browser or by another WebRTC-Android.
The video call should then start.

## Libraries

### [libjingle peerconnection](https://code.google.com/p/webrtc/)
### [socket.io-client](https://github.com/nkzawa/socket.io-client.java)


text:
# barbie-flux

A script to allow the inkbird iBBQ units to log data to influxDB from a Raspberry Pi. Great for smoking, roasting and trivial oven based data science.

__This is based on the work already done here: https://github.com/zewelor/bt-mqtt-gateway/blob/2a7e7abe3c401badf0225babefd5c4bc58e6d525/LICENSE. I just simplified it for the purpose of logging to influxDB.__

## Usage
* Install on a Raspberry Pi (3B+ for Bluetooth) via `git clone`.
* Create a virtual environment if desired.
* Install the requirements.txt file with `python3 -m pip install -r requirements.txt`.
* Copy the example configuration file and complete with appropriate values. `cp example-config.py config.py; nano config.py`. Enter the MAC address of your thermometer, the influx host and the influx database name.
* Install as a systemd service if desired, a service file will be included at a later date.
* Either start and enable the service, or run via `./barbie-flux.py`.

## Database Structure
The created fields in influx are somewhat self explanatory: `battery_percent`, `channel_1`, `channel_2`,  `channel_3` and `channel_4`.

## Notes
This is hacky and kind of untested. It's run for a few weeks robustly when run as a systemd service. It will start logging if the thermometer is turned on and stop logging if the thermometer is turned off. It's not production code!

## Known Issues
The results are a bit weird whilst it's charging. I suspect there is a bit flag to indicate this in the unpacked battery charge information. If you work it out, please let me know!

repository: ozonejunkieau/barbie-flux

branch_name: refs/heads/main

repo_name: ozonejunkieau/barbie-flux


text:
### Bihar

### Details

URL = http://<IP_ADDRESS>:8880/

Year = Draft Roll for 2017

### Running Scripts

1. `conda env create -f tools/environment.yml` to install working environment and
    `source activate erolls`
2.  Or, `pip install -r requirements.txt` if not using a conda environment
3. `tools/utils.py` is a helper function for downloading files, and sanity checks
4. `python bihar.py` to downloads all the pdfs to directory `../data/Bihar/`
5. `python bihar_SanityCheck.py` for doing a sanity check on the files downloaded

### Note
1. Total Number of files =  61837
2. The downloaded files are of form FinalRoll_ACNo_{assembly constituency number}PartNo_{part number}.pdf
3. Files not available can be found in 'bihar3.txt''

gha_language: HTML


text:
[![npm (scoped)](https://img.shields.io/npm/v/@forgerock/javascript-sdk?color=%23f46200&label=Version&style=flat-square)](CHANGELOG.md)

ForgeRock SDK UI for JavaScript

    Change Log
    ·
    Support
    ·
    Docs

The ForgeRock JavaScript SDK with UI contains the [Core SDK](https://github.com/ForgeRock/forgerock-javascript-sdk) and adds UI rendering capability. This project greatly reduces the effort to quickly prototype and demonstrate the use of the Core SDK in a more real-word scenario.

## Requirements

* ForgeRock Identity Platform
    * Access Management (AM) 6.5.2+

* Browsers:
    * Chrome 87
    * Firefox 84
    * Safari 14
    * Edge 87 (Chromium)
    * Edge 44 (Legacy): requires one polyfill for TextEncoder, [`fast-text-encoding` is recommended](https://www.npmjs.com/package/fast-text-encoding)

> **Tip**: Older browsers (like IE11) may require multiple [polyfills, which can be found in our documentation](https://sdks.forgerock.com/javascript/polyfills/).

## Installation

```
npm install @forgerock/javascript-sdk-ui
```

## Getting Started

To try out the ForgeRock JavaScript SDK UI, perform these steps:

1. Setup CORS support in an Access Management (AM) instance.

   See [Enabling CORS Support](https://sdks.forgerock.com/js/01_prepare-am/#enabling-cors-support) in the Documentation.

2. Create an authentication tree in AM.

   See [Creating a User Authentication Tree](https://sdks.forgerock.com/js/01_prepare-am/#creating-a-user-authentication-tree) in the Documentation.

3. Clone this repo:

    ```
    git clone https://github.com/ForgeRock/forgerock-javascript-sdk-ui.git
    ```

4. In the root folder of the repo, use NPM to install dependencies:

    ```
    npm install
    ```

5. Build the ForgeRock JavaScript SDK:

    ```
    npm run build
    ```

6. Open `samples/basic/index.html` and edit the configuration values to match your AM instance.

7. This SDK requires HTTPS (secure protocol) which means security (SSL/TLS) certificates are necessary. For local testing and development, it's common to generate your own self-signed certificates. You're free to use any method to do this, but if you need assistance in generating your own certs, the following can be helpful:

    - Using [this utility (`mkcert`) can help simplify the process of creating trusted certs](https://github.com/FiloSottile/mkcert)
    - After following `mkcert`'s installation guide and simple example of creating certs, you should have two files: `example.com+5.pem` & `example.com+5-key.pem`

        (Ensure these two files are in the root of this project)

    > **Warning: Self-signed certificates or certificates not from an industry-recognized, certificate authority (CA) should never be used in production.**

8. Serve the `samples` directory by using a simple HTTP server.

   - If you used the `mkcert` utility from above, followed their tutorial, and the files are in the root of this project, simply run `npm run start:samples`
   - Or, if you generated certs using a different method, you will need to run the below with your certificate and key file names you created:

       ```
       http-server samples -c1 -p 8443 --ssl --cert <your_certificate> --key <your_private_key>
       ```

9. Edit your `/etc/hosts` file to point your localhost (e.g. `<IP_ADDRESS>`) to `sdkapp.example.com`

10. In a [supported web browser](#requirements), navigate to `https://sdkapp.example.com:8443`, and then click
 **Custom UI**.

## Documentation

Documentation for the SDKs is provided at **<https://sdks.forgerock.com>**, and includes topics such as:

* Introducing the SDK Features
* Preparing AM for use with the SDKS
* API Reference documentation

## ForgeRock JS SDK UI in More Detail

The two key concepts in the SDK are **Step Handlers** and **Callback Renderers**. Step handlers control how a given step in an authentication tree is handled, and callback renderers control how each callback in that step is rendered.

For example, a single authentication tree might use a Choice Collector in different ways:

- To ask if the user wants to register a security device
- To ask how the user wants to receive a one-time password

In the first scenario, simple yes/no buttons aligned horizontally may suffice. But you might want to render a vertical list with custom icons for each option in the second scenario. You could create custom step handlers to invoke the correct custom callback renderer (buttons vs list).

This SDK includes two UI step handlers: Basic and Express.

### Basic

This is the default UI and can be used with any OpenAM installation version 6.5.2 or greater. It can render all of the [supported callbacks](https://sdks.forgerock.com/getting-started/compatibility/) with generic styling based on Bootstrap 4. You can optionally add your own CSS to customize or brand the user experience.

The out-of-box integration is extremely simple:

```js
const frui = new forgerock.FRUI();
const result = await frui.getSession();
```

### Taking More Control

If you need deeper customization, you can override built-in behavior at both the step and callback levels by providing factory functions.

The following example overrides the rendering of the callback produced by the "Platform Username" tree node:

```js
// Define a factory that returns the custom callback renderer
const myRendererFactory = (cb, index, step, onChange) => {
  if (cb.getType() === 'ValidatedCreateUsernameCallback') {
    return {
      render: () => {
        // Render the custom UI here
        const div = document.createElement('div');
        div.innerHTML = 'This is a custom UI for capturing username';
        return div;
      },
    };
  }

  // Return `undefined` to defer to the SDK for other callback types
  return undefined;
};

// Define a factory that returns the step handler
const myHandlerFactory = (target, step) => {
  return new forgerock.BasicStepHandler(target, step, myRendererFactory);
};

// Use the step handler factory when instantiating FRUI
const frui = new forgerock.FRUI({ handlerFactory: myHandlerFactory });
const result = await frui.getSession();
```

## Support

If you encounter any issues, be sure to check our **[Troubleshooting](https://backstage.forgerock.com/knowledge/kb/article/a83789945)** pages.

Support tickets can be raised whenever you need our assistance; here are some examples of when it is appropriate to open a ticket (but not limited to):

* Suspected bugs or problems with ForgeRock software.
* Requests for assistance - please look at the **[Documentation](https://sdks.forgerock.com)** and **[Knowledge Base](https://backstage.forgerock.com/knowledge/kb/home/g32324668)** first.

You can raise a ticket using **[BackStage](https://backstage.forgerock.com/support/tickets)**, our customer support portal that provides one stop access to ForgeRock services.

BackStage shows all currently open support tickets and allows you to raise a new one by clicking **New Ticket**.

## Version History

[Our version history can be viewed by visiting our CHANGELOG.md](https://github.com/ForgeRock/forgerock-javascript-sdk/blob/master/CHANGELOG.md).

## Contributing

If you would like to contribute to this project you can fork the repository, clone it to your machine and get started.

Be sure to check out our [Coding Style and Guidelines](https://wikis.forgerock.org/confluence/display/devcom/Coding+Style+and+Guidelines) page.

## Disclaimer

> **This code is provided by ForgeRock on an “as is” basis, without warranty of any kind, to the fullest extent permitted by law. ForgeRock does not represent or warrant or make any guarantee regarding the use of this code or the accuracy, timeliness or completeness of any data or information relating to this code, and ForgeRock hereby disclaims all warranties whether express, or implied or statutory, including without limitation the implied warranties of merchantability, fitness for a particular purpose, and any warranty of non-infringement. ForgeRock shall not have any liability arising out of or related to any use, implementation or configuration of this code, including but not limited to use for any commercial purpose. Any action or suit relating to the use of the code may be brought only in the courts of a jurisdiction wherein ForgeRock resides or in which ForgeRock conducts its primary business, and under the laws of that jurisdiction excluding its conflict-of-law provisions.**

## License

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

---

© Copyright 2020 ForgeRock AS. All Rights Reserved.

[forgerock-logo]: https://www.forgerock.com/themes/custom/forgerock/images/fr-logo-horz-color.svg "ForgeRock Logo"

repository: spetrov/forgerock-javascript-sdk-ui

gha_license_id: MIT

repo_name: spetrov/forgerock-javascript-sdk-ui


text:
# Get Started with ECS on Elastigroup

## Introduction

This Quick Start deploys Spot Elastigroup for Amazon Elastic Container Service (Amazon ECS) on the Amazon Web Services (AWS) Cloud.

Spot Elastigroup enables the use of production-grade Spot Instances by leveraging a prediction algorithm to predict the Spot Instance interruption 15 minutes ahead of time. Elastigroup then immediately spins up a new node in a different Spot capacity pool. As soon as that new node is healthy, Elastigroup starts to drain the instance that is marked for an interruption. Elastigroup then terminates the instance after draining is completed.

This Quick Start is for organizations that want to use Spot Elastigroup's capabilities to ensure availability and to efficiently scale Amazon ECS clusters that are running as Spot Instances at a discount of roughly 80% compared to On-Demand Instances, with additional savings from automatic task-based scaling.

You can also import an existing ECS cluster – this action will fetch all the data needed in order to create a new ECS cluster on Elastigroup based on the configuration of the imported ECS cluster.Elastigroup for ECS is available via the [Amazon QuickStart](https://aws.amazon.com/quickstart/architecture/spotinst-elastigroup/) guides.

With this Quick Start, Spot Elastigroup deployment takes about 7 minutes. The deployment is automated by AWS CloudFormation templates.

## Prerequisite: Create an ECS IAM Role

- Before the Amazon ECS agent can register container instance into a cluster, the agent must have IAM Role with appropriate account credentials.
- If you haven't done this already, here's how to create an ECS IAM Role.
  1. Navigate to your IAM console
  2. Go to – Roles.
  3. Create a new Role and name it `ECS-ContainerInstance`
  4. Under `AWS Service Roles` choose: `Amazon EC2 Role for EC2 Container Service`
  5. Attach the policy and create the Role.
  6. On the Elastigroup setup, you should specify the newly created IAM Role under `Launch Specification`

## Step 1: Select your ECS Optimized AMI

1. Enter the Elastigroup [Creation Wizard](https://console.spotinst.com/#/aws/ec2/elastigroup/create/setup) and select Amazon ECS.
2. Amazon ECS provides [ECS Optimized AMIs](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_container_instance.html) which contain an Amazon ECS agent that automatically registers new instances to your desired ECS cluster. In the Compute tab under Launch Specifications enter the ID of your preferred ECS Optimized AMI based on your region.

## Step 2: Set IP Configuration for your Elastigroup Instances

In order to register to your ECS cluster, each instance in your Elastigroup needs to be associated with a public IP.

1. Under the Compute tab go to Additional Configurations.
2. Under Public IP choose one of the following:
   - Associate public IP
   - Subnet default

## Step 3: Update your User Data (Startup Script) to import the ECS Cluster

By default, your container instances will launch into your default cluster. If you want to launch into a different cluster, use the following script for the User Data field in the Additional Configurations section of the Compute tab, replacing `CLUSTER_NAME` with the name of your desired cluster.

### Linux:

```
#!/bin/bash
echo ECS_CLUSTER=CLUSTER_NAME >> /etc/ecs/ecs.config
```

### Windows:

```
<powershell>

Import-Module ECSTools

Initialize-ECSAgent -Cluster CLUSTER_NAME -EnableTaskIAMRole -LoggingDrivers '["json-file","awslogs"]'

</powershell>
```

## Step 4: Set the ECS Integration

- In the Compute tab, under the Integrations section, select ECS and provide your Cluster Name.
- Continue with the Creation Wizard and create your Elastigroup.

## What's Next?

Now that you have created an ECS-integrated Elastigroup, learn more about the [ECS Auto-Scaler](elastigroup/features/amazon-ecs/automatic-autoscaler-for-ecs.md) and how it efficiently and automatically scales your cluster.


text:
---
layout: post
title: "OsCUL3a"
description: ""
category: genes
tags: [resistance, magnaporthe oryzae, cell death, immunity, lesion, lesion mimic, reactive oxygen species]
---

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

* **Publication**
    + [OsCUL3a Negatively Regulates Cell Death and Immunity by Degrading OsNPR1 in Rice.](http://www.ncbi.nlm.nih.gov/pubmed?term=OsCUL3a Negatively Regulates Cell Death and Immunity by Degrading OsNPR1 in Rice.%5BTitle%5D), 2017, Plant Cell.

* **Genbank accession number**

* **Key message**
    + The rice lesion mimic mutant oscul3a displays a significant increase in the accumulation of flg22- and chitin-induced reactive oxygen species, and in pathogenesis-related gene expression as well as resistance to Magnaporthe oryzae and Xanthomonas oryzae pv
    + OsCUL3a Negatively Regulates Cell Death and Immunity by Degrading OsNPR1 in Rice.
    + Here, we show that rice OsCUL3a is important for the regulation of cell death and immunity
    + Strikingly, OsCUL3a interacts with and degrades OsNPR1, which acts as a positive regulator of cell death in rice
    + Our data demonstrate that OsCUL3a negatively regulates cell death and immunity by degrading OsNPR1 in rice
    + We cloned the OsCUL3a gene via a map-based strategy and found that the lesion mimic phenotype of oscul3a is associated with the early termination of OsCUL3a protein
    + Furthermore, the oscul3a osnpr1 double mutant does not exhibit the lesion mimic phenotype of the oscul3a mutant

* **Connection**
    + __OsCUL3a__, __OsNPR1~NH1__, [OsCUL3a Negatively Regulates Cell Death and Immunity by Degrading OsNPR1 in Rice.](http://www.ncbi.nlm.nih.gov/pubmed?term=OsCUL3a Negatively Regulates Cell Death and Immunity by Degrading OsNPR1 in Rice.%5BTitle%5D), OsCUL3a Negatively Regulates Cell Death and Immunity by Degrading OsNPR1 in Rice.
    + __OsCUL3a__, __OsNPR1~NH1__, [OsCUL3a Negatively Regulates Cell Death and Immunity by Degrading OsNPR1 in Rice.](http://www.ncbi.nlm.nih.gov/pubmed?term=OsCUL3a Negatively Regulates Cell Death and Immunity by Degrading OsNPR1 in Rice.%5BTitle%5D), Strikingly, OsCUL3a interacts with and degrades OsNPR1, which acts as a positive regulator of cell death in rice
    + __OsCUL3a__, __OsNPR1~NH1__, [OsCUL3a Negatively Regulates Cell Death and Immunity by Degrading OsNPR1 in Rice.](http://www.ncbi.nlm.nih.gov/pubmed?term=OsCUL3a Negatively Regulates Cell Death and Immunity by Degrading OsNPR1 in Rice.%5BTitle%5D), Accumulation of OsNPR1 protein is greater in the oscul3a mutant than in the wild type
    + __OsCUL3a__, __OsNPR1~NH1__, [OsCUL3a Negatively Regulates Cell Death and Immunity by Degrading OsNPR1 in Rice.](http://www.ncbi.nlm.nih.gov/pubmed?term=OsCUL3a Negatively Regulates Cell Death and Immunity by Degrading OsNPR1 in Rice.%5BTitle%5D), Furthermore, the oscul3a osnpr1 double mutant does not exhibit the lesion mimic phenotype of the oscul3a mutant
    + __OsCUL3a__, __OsNPR1~NH1__, [OsCUL3a Negatively Regulates Cell Death and Immunity by Degrading OsNPR1 in Rice.](http://www.ncbi.nlm.nih.gov/pubmed?term=OsCUL3a Negatively Regulates Cell Death and Immunity by Degrading OsNPR1 in Rice.%5BTitle%5D), Our data demonstrate that OsCUL3a negatively regulates cell death and immunity by degrading OsNPR1 in rice

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


text:
# node-red-contrib-netatmo-dashboard
[Node-RED](http://nodered.org/docs/getting-started/installation) node to fetch all data (temperature, pressure, humidity, co2, noise, etc) from a NetAtmo device.

Returns a payload which is split up into to parts:

* a compact object which contains the most relevant information
* a detailed object which contains the complete return from the netatmo api

__Attention: The reachable status of the complete station seems not to changefor at least a
couple of hours. While the reachable status of devices change after approximately 1h,
the station itselve will shown as reachable even if this is not the case__

An Example:

```
{
    "compact":
        {
            "outdoor":
                {
                    "reachable": true,
                    "temperature":15.1,
                    "humidity":86,
                    "temperatureTrend":"down",
                    "battery_percent":15,
                    "rf_status":47
                },
             "rain":
                {
                    "reachable": true,
                    "rain":0,
                    "sum_rain_24":0.4,
                    "sum_rain_1":0.101,
                    "battery_percent":45,
                    "rf_status":40
                },
                modules:
                   [ {
                        name: 'wohnzimmer',
                        data_type: [ 'Temperature', 'CO2', 'Humidity' ],
                        "battery_percent": 14,
                        "rf_status": 80,
                        "reachable": true,
                        "dashboard_data":
                        {
                            "time_utc":<PHONE_NUMBER>,
                            "Temperature": 23.1,
                            "CO2": 1555,
                            "Humidity": 50,
                            "min_temp": 22.7,
                            "max_temp": 23.6,
                            "date_min_temp":<PHONE_NUMBER>,
                            "date_max_temp":<PHONE_NUMBER>,
                            "temp_trend": 'stable'
                        },
                        "temperature": 23.1,
                        "Humidity": 50,
                        "CO2": 1555,
                        "min_temp": 22.7,
                        "max_temp": 23.6,
                        "date_min_temp":<PHONE_NUMBER>,
                        "date_max_temp":<PHONE_NUMBER> },
                    {
                        "name": 'Kinderzimmer',
                        "data_type": [ 'Temperature', 'CO2', 'Humidity' ],
                        "battery_percent": 45,
                        "rf_status": 70,
                        "reachable": true,
                        "dashboard_data":
                        {
                            "time_utc":<PHONE_NUMBER>,
                            "Temperature": 23.2,
                            "CO2": 1258,
                            "Humidity": 48,
                            "min_temp": 23,
                            "max_temp": 23.6,
                            "date_min_temp":<PHONE_NUMBER>,
                            "date_max_temp":<PHONE_NUMBER>,
                            "temp_trend": 'stable'
                        },
                        "temperature": 23.2,
                        "Humidity": 48,
                        "CO2": 1258,
                        "min_temp": 23,
                        "max_temp": 23.6,
                        "date_min_temp":<PHONE_NUMBER>,
                        "date_max_temp":<PHONE_NUMBER>
                    },
                     {
                        "name": 'Schlafzimmer',
                        "data_type": [ 'Temperature', 'CO2', 'Humidity'],
                        battery_percent: 80,
                        "rf_status": 68,
                        "reachable": true,
                        "dashboard_data":
                        {
                            "time_utc":<PHONE_NUMBER>,
                            "Temperature": 22.7,
                            "CO2": 1497,
                            "Humidity": 56,
                            "min_temp": 22.5,
                            "max_temp": 22.8,
                            "date_min_temp":<PHONE_NUMBER>,
                            "date_max_temp":<PHONE_NUMBER>,
                            "temp_trend": 'stable'
                        },
                        "temperature": 22.7,
                        "Humidity": 56,
                        "CO2: 1497",
                        "min_temp": 22.5,
                        "max_temp": 22.8,
                        "date_min_temp":<PHONE_NUMBER>,
                        "date_max_temp":<PHONE_NUMBER>
                    },
            "temperature":28.9,
            "co2":704,
            "humidity":43,
            "noise":43,
            "pressure":1021.3,
            "pressureTrend":"down",
            "station_name":"Netatmo#Main",
            "last_status_store":1536857210,
            "reachable": true,
        },
    "detailed":
        [
            {
                "_id":"70:ee:50:02:be:56",
                "cipher_id":"{your_cypher}",
                "date_setup":1397226153,
                "last_setup":1397226153,
                "type":"NAMain",
                "last_status_store":1536857210,
                "module_name":"Office",
                "firmware":132,
                "last_upgrade":1440050083,
                "wifi_status":26,
                "co2_calibrating":false,
                "station_name":"Netatmo#Main",
                "data_type":["Temperature","CO2","Humidity","Noise","Pressure"],
                "place":{"altitude":36,"city":"Berlin","country":"DE","timezone":"Europe/Berlin","location":[{lat},{long}]},
                "dashboard_data":
                    {
                        "time_utc":1536857196,
                        "Temperature":28.9,
                        "CO2":704,
                        "Humidity":43,
                        "Noise":43,
                        "Pressure":1021.3,
                        "AbsolutePressure":1017,
                        "min_temp":27.2,
                        "max_temp":31.9,
                        "date_min_temp":1536821144,
                        "date_max_temp":1536813686,
                        "temp_trend":"up",
                        "pressure_trend":"down"
                    },
                    "modules":
                        [
                            {
                                "_id":"03:00:00:00:db:38",
                                "type":"NAModule4",
                                "module_name":"wohnzimmer",
                                "data_type":["Temperature","CO2","Humidity"],
                                "last_setup":1397227514,
                                "dashboard_data":
                                    {
                                        "time_utc":1536856881,
                                        "Temperature":26,
                                        "CO2":680,
                                        "Humidity":44,
                                        "min_temp":25.4,
                                        "max_temp":26.8,
                                        "date_min_temp":1536828835,
                                        "date_max_temp":1536791560,
                                        "temp_trend":"stable"
                                    },
                                    "firmware":44,
                                    "last_message":1536857208,
                                    "last_seen":1536856881,
                                    "rf_status":89,
                                    "battery_vp":5196,
                                    "battery_percent":55
                                },
                            {
                                "_id":"02:00:00:02:cb:2e",
                                "type":"NAModule1",
                                "module_name":"Outdoor",
                                "data_type":["Temperature","Humidity"],
                                "last_setup":1397226241,
                                "dashboard_data":
                                    {
                                        "time_utc":1536857170,
                                        "Temperature":15.1,
                                        "Humidity":86,
                                        "min_temp":13.4,
                                        "max_temp":17.6,
                                        "date_min_temp":1536818729,
                                        "date_max_temp":1536846917,
                                        "temp_trend":"down"
                                    },
                                    "firmware":44,
                                    "last_message":1536857208,
                                    "last_seen":1536857170,
                                    "rf_status":47,
                                    "battery_vp":3968,
                                    "battery_percent":15
                                },
                            {
                                "_id":"03:00:00:01:0a:a4",
                                "type":"NAModule4",
                                "module_name":"Kinderzimmer",
                                "data_type":["Temperature","CO2","Humidity"],
                                "last_setup":1399312524,
                                "dashboard_data":
                                    {
                                        "time_utc":1536857157,
                                        "Temperature":26.4,
                                        "CO2":721,
                                        "Humidity":42,
                                        "min_temp":25.4,
                                        "max_temp":27.6,
                                        "date_min_temp":1536829474,
                                        "date_max_temp":1536789645,
                                        "temp_trend":"stable"
                                    },
                                    "firmware":44,
                                    "last_message":1536857208,
                                    "last_seen":1536857208,
                                    "rf_status":60,
                                    "battery_vp":5313,
                                    "battery_percent":62
                            }
                        ]
            }
        ]
    }
```

## Authentication
NetAtmo changed the authentication scheme in October 2022, in order to authenticate with your device you will need to create an application in [Netatmo Connect](https://dev.netatmo.com/) and obtain: *client_id*, *client_secret* and *refresh_token*.
To get the refresh_token a OAuth2 client is needed (i.e. [Paw](https://paw.cloud/) for MacOS): use these params

* client_id: from your app in Netatmo Connect
* client_secret: from your app in Netamo Connect
* Authorization URL: https://api.netatmo.com/oauth2/authorize
* Access URL: https://api.netatmo.com/oauth2/token
* Redirect URL: http://localhost

![Paw Refresh Token](https://raw.githubusercontent.com/guidone/node-red-contrib-netatmo-dashboard/e34cb8ae88fe5fd5c42f55742d74f6b950f6716d/images/refresh-token.png)

Click on **Get token** and then on the input box of *Refresh token*.

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

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

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

gha_language: JavaScript


text:
# Data pack with inline icon

`@data_pack pack.png`

![](lectern.png)

Now this one with a folded section:

`@texture foo:hello`

<details>

![](lectern.png)

</details>

And completely folded:

<details>

`@texture bar:hello`

![](lectern.png)

</details>

The last directive is hidden:

<!-- @texture baz:hello -->

![](lectern.png)

repository: RitikShah/lectern

repo_name: RitikShah/lectern


text:
# Neural Networks from Scratch in Python
Repo to follow along sentdex's Neural Networks from Scratch Course
---
If want to see all the videos of sentdex's course go to this playlist at his youtube channel:
* [Neural Networks from Scratch in Python](https://www.youtube.com/playlist?list=PLQVvvaa0QuDcjD5BAw2DxE6OF2tius3V3)


text:
---
{
  "title": "Unsupervised Graph-basedWord Sense Disambiguation Using Measures of Word Semantic Similarity",
  "authors": [
    "R. Sinha",
    "R. Mihalcea"
  ],
  "abstract": "This paper describes an unsupervised graph-based method for word sense disambiguation, and presents comparative evaluations using several measures of word semantic similarity and several algorithms for graph centrality. The results indicate that the right combination of similarity metrics and graph centrality algorithms can lead to a performance competing with the state-of-the-art in unsupervised word sense disambiguation, as measured on standard data sets.",
  "links": [
    {
      "resource": "PDF",
      "icon": "pdf",
      "url": "http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=4338370"
    },
    {
      "resource": "Semantic Scholar",
      "icon": "semanticscholar",
      "url": "https://www.semanticscholar.org/paper/b4913261ce9d870873413d4d3100f7a79045b9d3"
    }
  ],
  "supervision": [],
  "tasks": [],
  "methods": [],
  "thumbnail": "unsupervised-graph-based-word-sense-disambiguation-using-measures-of-word-semantic-similarity-thumb.jpg",
  "card": "unsupervised-graph-based-word-sense-disambiguation-using-measures-of-word-semantic-similarity-card.jpg",
  "s2_paper_id": "b4913261ce9d870873413d4d3100f7a79045b9d3"
}
---

repository: virtualgraham/unsupervisedpapers

repo_name: virtualgraham/unsupervisedpapers


text:
# Intro

This repository contains a research-prototype implementation and examples for the [SQuOpt research project](http://www.informatik.uni-marburg.de/~pgiarrusso/SQuOpt/) and the relevant paper:

P. G. Giarrusso, K. Ostermann, M. Eichberg, R. Mitschke, T. Rendel, and C. Kästner. Reify your collection queries for modularity and speed! In *Proceedings of AOSD*, pages 1–12. ACM, 2013. Extended version available from http://www.informatik.uni-marburg.de/~pgiarrusso/SQuOpt/giarrusso-techrep.pdf, Official Version from https://dl.acm.org/citation.cfm?id=2451438.

This is intended as a proofresearch prototypes, and further maintenance work is not planned. See [this blog post](http://matt.might.net/articles/crapl/) for general info on research prototypes (although this software has a 3-clause BSD license).

# Code examples
An example of the optimization abilities of the framework is available in
[`src/test/scala/ivm/tests/PaperTutorial.scala`](src/test/scala/ivm/tests/PaperTutorial.scala). When run as a test, it verifies
that the optimizer on the given query produces the same code as one gets by
manual optimization.

# Compilation instructions
To compile this project, you can use SBT.

## Using SBT
The project uses SBT 0.12.0; later versions of SBT will download the right one.

1. To install SBT, follow instructions on this page:

  <https://github.com/harrah/xsbt/wiki/Getting-Started-Setup>

  Modify the SBT setup to use up to 2G of RAM by adding `-Xmx2048M` to the `java`
  command line. Otherwise, compilation might be slower or run out of memory.
2. After installing SBT, cd into this folder and launch `sbt`. It will find the build instructions in `build.sbt`. During the first execution SBT will auto-download various dependencies needed for itself (including the Scala compiler).
3. Then, at the SBT prompt, give the `package` command (simply `package` followed by newline) to compile and package the library as a JAR file under the `target` folder. Compilation will require around 5-10 minutes on a recent machine.
4. You can similarly run commands such as `compile` (for compilation), `test:compile` (which also compiles tests) and `test` (which additionally _runs_ the tests - they include performance tests and take some time). I usually run tests using IntelliJ IDEA to specify which one I am interested in, even if I do not use it for compilation.
In particular, tests in the `performancetests` package take considerable time.

Note: this project incorporates `lib/bat-1.6.0.RC1.jar`, a compiled snapshot of
BAT from <https://github.com/Delors/BAT>.

## Supported IDEs
You can edit the project using IntelliJ IDEA 11 with the Scala and SBT plugins
installed, beyond SBT itself. We supply IDEA project files, but it is probably
best to regenerate them locally via SBT through the `gen-idea` command.

Integrated compilation with IDEA is not supported; it is anyway too slow
to be useful, therefore I would not recommend it.

There are also Eclipse project files (requiring the Scala plugin), but no active
development uses Eclipse, therefore they are likely to be out-of-date.

We stopped using Eclipse because the Scala plugin was too buggy when we last
tried (as I last tested it).

23 Apr 2012

repository: ps-mr/LinqOnSteroids

repo_name: ps-mr/LinqOnSteroids


text:
---
title: Getting Started
author: Gabriel Cardona
publishedAt: 2018-07-06
updatedAt: 2018-07-06
---

The popularity of Bitcoin Cash is on the rise and BITBOX SDK aims to channel all the interest in to amazing applications. In this post we'll go over the basics needed to get started creating amazing applications with BITBOX SDK and Bitcoin Cash.

### Goal

BITBOX is an incredibly powerful and intuitive SDK which lets developers build world class applications quickly. It’s built with modern web tech which is familiar to developers all over the world. We launched [developer.bitcoin.com](https://developer.bitcoin.com/) to help beginners and old pros hone their blockchain dev skills. The goal of this article is to show the first steps needed to set up your development environment and start playing around with the BITBOX SDK.

In this post we’ll cover the following:

- Prerequisites
- Setting up your development environment
- Installing BITBOX SDK
- Running your first BITBOX code samples

### Prerequisites

BITBOX SDK is built around modern web technology. To hit the ground running you should have some basic HTML, CSS and Javascript skills. These technologies are cornerstones of the Modern Web and at the core of BITBOX SDK. If you’re unfamiliar with any of these technologies start by first going through these tutorials on [HTML](https://www.w3schools.com/htmL/), [CSS](https://www.w3schools.com/css/) and [Javascript](https://www.w3schools.com/jS/default.asp).

#### Development Environment

BITBOX SDK is a javascript framework built on nodeJS. To get started head to the [NodeJS](https://nodejs.org/en/) homepage and download their Long Term Support (LTS) release. Currently that is v8.3.11.

![nodejs download version](/images/node-version.png)

This also comes bundled with `npm` which is the “Node Package Manager”. You can confirm everything downloaded correctly by opening your terminal and running `node --version` and `npm --version`.

![node and npm versions](/images/npm-version.png)

Next you’ll need a text editor to edit code. For that we suggest [Atom.io](http://atom.io/). It’s an open-source editor built and maintained by GitHub. It too is built with web tech so you can extend it with HTML, CSS and Javascript plugins and themes.

![atomIO logo](/images/atomio.png)

Finally you’re ready to install BITBOX SDK. You can do that with `npm install bitbox-sdk --global`. This will give you access to BITBOX scaffolds, console, paper wallet generator and more. To confirm it worked run `bitbox --version`. At the time of writing the latest version of BITBOX SDK is v1.4.4.

![bitbox version](/images/bitbox-version.png)

It should be noted that all of the above tools, NodeJS, NPM, AtomIO and BITBOX SDK all work on MacOS, Windows and Linux. The screenshots show MacOS but BITBOX SDK works across all platforms.

### Tutorial

#### React Scaffold

Now that you have all the tools installed you’re ready to start playing around with the BITBOX SDK. We want to make it as easy as possible to go from idea to app so we offer scaffolds to bootstrap basic wallets in the popular [Angular](https://github.com/Bitcoin-com/bitbox-scaffold-angular), [React](https://github.com/Bitcoin-com/bitbox-scaffold-react), [Node](https://github.com/Bitcoin-com/bitbox-scaffold-node), [Next](https://github.com/Bitcoin-com/bitbox-scaffold-next) and [Vue](https://github.com/Bitcoin-com/bitbox-scaffold-vue) frameworks. These allow you to scaffold a basic BCH application in under a minute that you can build your app on. To see this in action run `bitbox new sampleApp --scaffold react`.

![react scaffold](/images/react-scaffold.png)

Next to run the app change directories to the newly created `sampleApp` directory and first install all the dependencies with `npm install`. Once that is complete run the app with `npm start`.

![hello bitbox](/images/hello-bitbox2.png)

Our scaffold app first create a 256 mnemonic in one of 8 languages (english, french, italian, spanish, korean, japanese and chinese simplified/traditional). Next it creates the first BIP44 account and generates the first 10 external change addresses for that account. Finally it creates a 1-to-1 Pay-to-PubKeyHash (P2PKH) transaction so you can see how the code flow works. Note that each time your refresh the page a new mnemonic and BIP44 wallet will be created.

#### BITBOX Console

BITBOX SDK also comes bundled with a development console which you can use to test your ideas with no setup involved. The BITBOX Console is a full nodeJS REPL with the entire BITBOX API built in. That means that you can leverage the entire Javascript API and all of BITBOX right from your terminal. To try this out confirm you’re in the `sampleApp` directory and run `bitbox console`.

![bitbox console](/images/bitbox-console.png)

Now that you have a BITBOX Console you can copy and paste any code sample from the [BITBOX SDK documentation](https://developer.bitcoin.com/bitbox/docs/getting-started) and it will work. This is a great way to play around with the SDK and test your ideas quickly with no ovehead.

### Summary

Bitcoin.com’s BITBOX SDK is incredibly powerful and intuitive. It’s built with modern web tech that is familiar to developers all over the world and has everything needed for you to hit the ground running and go from idea to app 10x faster than the competition.


text:
# Delve

### What is Delve?

Delve is a Go debugger, written primarily in Go.

### Building

Currently, Delve requires the following [patch](https://codereview.appspot.com/117280043/), however this change is vendored until Go 1.4 lands, so the project is go get-able.

### Features

* Attach to (trace) a running process
* Ability to launch a process and begin debugging it
* Set breakpoints
* Single step through a process
* Next through a process (step over / out of subroutines)
* Never retype commands, empty line defaults to previous command
* Readline integration

### Usage

The debugger can be launched in three ways:

* Allow it to compile, run, and attach to a program:

	```
	$ dlv -run
	```

* Provide the name of the program you want to debug, and the debugger will launch it for you.

	```
	$ dlv -proc path/to/program
	```

* Provide the pid of a currently running process, and the debugger will attach and begin the session.

	```
	$ sudo dlv -pid 44839
	```

Once inside a debugging session, the following commands may be used:

* `break` - Set break point at the entry point of a function, or at a specific file/line. Example: `break foo.go:13`.

* `continue` - Run until breakpoint or program termination.

* `step` - Single step through program.

* `next` - Step over to next source line.

* `print $var` - Evaluate a variable.

### Upcoming features

* Handle Gos multithreaded nature better
* In-scope variable evaluation
* In-scope variable setting
* Support for OS X

### License

MIT

repository: jackc/delve

repo_name: jackc/delve


text:
# VexRISC-V utils

This directory contains scripts for some utilities when debugging with TFLM
applications.

## log_parser.py

This script is used to analyze the function call stack obtained when a
application is running on Renode with GDB session attached or with Renode's
logging set to true (include the following line in your `*.resc` file of enter
this command in Renode every time you launch an simulator.)

```
sysbus.cpu LogFunctionNames true
```

Also, make sure you check out Antmicro's repo
[antmicro/litex-vexriscv-tensorflow-lite-demo](https://github.com/antmicro/litex-vexriscv-tensorflow-lite-demo)
for the guide to run TensorFlow Lite Micro examples on Renode.

In the following guide with GDB, we will be using the example gdb script
described here
[Cobbled-together Profiler](https://xobs.io/cobbled-together-profiler/)

### Launch Renode console

Include (`include` or `i` for short) the renode script (`*.resc`), DO NOT start
the simulation yet.

The symbol `@` is the path where Renode is installed, you can navigate to
anywhere on the disk as long as you follow the linux syntax (`../` for parent
directory, etc.), here I install Renode under home (`/home/$USER` or `~/`)
directory and I put the demo repository litex-vexriscv-tensorflow-lite-demo
under home directory.

```
i @../litex-vexriscv-tensorflow-lite-demo/renode/litex-vexriscv-tflite.resc
```

### Start GDB server on Renode on port 8833

```
machine StartGdbServer 8833
```

### Launch GDB

First you need to find a proper GDB executable for your target architecture,
here, we will follow Antmicro's repo and use the riscv GDB executable from
zephyr

Usage: `[GDB] -x [GDB_SCRIPT] [TFLM_BINARY]`

Example: `/opt/zephyr-sdk/riscv64-zephyr-elf/bin/riscv64-zephyr-elf-gdb \ -x
profiling.gdb \
../tensorflow/tensorflow/lite/micro/tools/make/gen/zephyr_vexriscv_x86_64/magic_wand/build/zephyr/zephyr.elf`

### Connect GDB to Renode's gdbserver on the same port

```
(gdb) target remote :8833
(gdb) monitor start
(gdb) continue

# Run the function in the GDB script with required parameter
(gdb) poor_profile 1000
```

### Interrupt the gdb script regularly with a shell command

```
for i in $(seq 1000); do echo $i...; killall -INT riscv64-zephyr-elf-gdb; sleep 5; done
```

### Interpreting the log

#### Parse and visualize the log

```
# The following command is used to parse and visualize the log file
# obtained from GDB and only keep top 7 most frequent functions in the
# image, for detail usage of the script, please refer to the source code

python log_parser.py [INPUT] --regex=gdb_regex.json --visualize --top=7 --source=gdb
```

Since we are redirecting the gdb interrupt messages to the file
`<path-you-run-gdb>/profile.txt` (see the gdb script,) we can now parse the log
and visualize it. (set the image title with argument `--title`)

```
python log_parser.py profile.txt --regex=gdb_regex.json --visualize --top=7 --title=magic_wand
```

![image](https://user-images.githubusercontent.com/21079720/91764987-198fec00-eb8d-11ea-8eb1-90355fe4f28c.png)

#### Get the statistic of the function call hierarchy

To get a more detail view of how the entire function call stack looks like and
how many time the function is called with the exact same call stack, we can add
another option `--full-trace` to the script and it will generate a `*.json` file
for the complete call stack trace. `python log_parser.py profile.txt
--regex=gdb_regex.json --visualize --top=7 --full-trace`

```
# In the `*.json` file
root
|-- fcn0
|    |-- [stack0, stack1, ...] # List of function call stacks, see below
|
|-- fcn1
|    |-- [stack0, stack1, ...]
...
```

```
# Each stack* object contains the following information
stack*
|-- counts: 5 # Number of occurrences with the exact same call stack
|-- [list of functions in the call stack]
```

![image](https://user-images.githubusercontent.com/21079720/91755189-8bf9cf80-eb7f-11ea-884c-2354f3470271.png)

### Customizing `*.json` used in the script

The regular expression used in this script is configured with a standard
`*.json` file with the following content:

*   `base`: Base regular expression to clean up the log, this is set to clean up
    the ANSI color codes in GDB
*   `custom`: A series of other regular expressions (the script will run them in
    order) to extract the information from the log

repository: graphcore/tensorflow

repo_name: graphcore/tensorflow


text:
# Introduction

There are at least two idiomatic ways to solve Robot Name.
One approach is to randomly generate each new name and check it against a collection of used names.
If the name has already been used, then keep randomly generating a new name until it does not match a used name.
If the new name has not been used, then add it to the collection of used names.

Another approach is to generate all possible names, randomly shuffle them, and then take from them in sequence.
That approach avoids the collision of new names against used names.
The chance of collision increases as more used names are added.

## General guidance

Regardless of the approach used, one thing to consider is to generate the whole number at once instead of three separate digits.

## Approach: Randomly add to used names

```scala
import scala.annotation.tailrec
import scala.util.Random

class Robot() {
  import Robot.addName
  var name: String = addName
  def reset(): Unit = name = addName
}

object Robot {
  private val randy = Random
  private var savedNames = scala.collection.mutable.Set[String]()

  private object CharType extends Enumeration {
    type CharType = Value
    val Letter, Number = Value
  }
  import CharType._

  private def getNextRandom(base: Int, high: Int): Int =
    base + randy.nextInt(high)

  private def genChar(charType: CharType): Char = {
    charType match {
      case Letter => (getNextRandom(65, 26)).toChar
      case Number => (getNextRandom(48, 10)).toChar
    }
  }

  @tailrec
  private def nameMe(chars: List[Char]): String = {
    chars.length match {
      case len if len < 2 => nameMe(genChar(Letter) :: chars)
      case len if len < 5 => nameMe(genChar(Number) :: chars)
      case _              => chars.reverse.mkString("")
    }
  }

  @tailrec
  private def addName: String = {
    val temp = nameMe(List[Char]())
    temp match {
      case name if savedNames contains name => addName
      case name =>
        savedNames += name
        name
    }
  }
}
```

For more information, check the [randomly add to used names approach][approach-random-add-to-used-names].

## Approach: Sequentially take from shuffled names

```scala
import scala.util.Random

class Robot {

  var name = genName()

  def reset() = name = genName()

  private def genName(): String = Robot.names.next()
}

object Robot {
  val names: Iterator[String] = {
    val seqNames =
      for {
        ltr1 <- ('A' to 'Z')
        ltr2 <- ('A' to 'Z')
        num <- (0 to 999)
      } yield {
        f"$ltr1%c$ltr2%c$num%03d"
      }
    Random.shuffle(seqNames).to(LazyList).iterator
  }
}
```

For more information, check the [sequentially take from shuffled names approach][approach-sequential-take-from-shuffled-names].

## Which approach to use?

Benchmarking is currently outside the scope of this document,
but taking from shuffled names will avoid the collision that happens with checking a new randomly generated name against used names.
One advantage to checking randomly generated names against used names would be if only a few names were ever expected to be generated.
In that case, randomly generating names would use much less processing and memory than creating a collection of all possible names.

The test for "a large number of new instances have unique names" is ignored by default.
If `ignored` is changed to `it`, then the code needs to be efficient enough to allow all 676,000 unique names to be generated
before the tests time out.

[approach-random-add-to-used-names]: https://exercism.org/tracks/scala/exercises/robot-name/approaches/random-add-to-used-names
[approach-sequential-take-from-shuffled-names]: https://exercism.org/tracks/scala/exercises/robot-name/approaches/sequential-take-from-shuffled-names

repository: exercism/scala

gha_language: Scala

repo_name: exercism/scala


text:
# Generation of general molecular tubes

A program to generate structures of molecular tubes (open ended or closed),
consisting of (currently only rectangular) 3D tiles.  You can easily define
tiles of your own choice by adding an entry to `tile-gen.hh`.

## Licensing / Citing

This software is published under a very permissive license to make it as useful
as possible for a variety of usecases.  If it is useful to you, especially in
an academic context, you are encouraged to cite:

A method for designing a novel class of gold-containing molecules,
Christian A. Celaya, Mesías Orozco-Ic, Maria Dimitrova, Lukas N. Wirz, and Dage Sundholm,
Chemical Communications,
DOI: 10.1039/D0CC01227K

Some parts of `geometry3.{hh,cc}` and `auxiliary.hh` have been borrowed from
http://ctcp.massey.ac.nz/index.php?group=&page=fullerenes .

## Compiling

There are two ways to build this little program.  Should work on any Linux and
related systems as well as macOS.

### using the ordinary Makefile

```
make
```

### using CMake (probably more robust)

```
mkdir mybuild
cd mybuild
[CXX=clang++] cmake .. -DCMAKE_BUILD_TYPE=(release|debug)
make
```
## Usage

There are four input parameters:

### tile type

Currently there are 9 tile types defined (indices 1 through 9).  Edit tile-gen.hh to define
your own tiles.

### shape type

Currently there are 5 shapes defined (indices 1 through 5).  1: linear tube, 2:
torus, 3-5:  much less useful, a trefoil, a lemniscate, etc.

### number of tiles per layer

Too few tiles per layer lead to high distortions.

### number of layers

If choosing a shape other than 1, too few layers lead to high distortions.

repository: lnw/general-molecular-tubes

repo_name: lnw/general-molecular-tubes


text:
---
layout: post
title: "SHRD : A ruby interpretation of the Double Precision Shift Right Assembly instruction"
date: 2012-07-31 20:43
comments: true
categories: [Assembly, Ruby]
author: Geoff Tidey
---

Following on from my [last post on Assembly conversion](http://blog.tidey.net/blog/2012/06/07/really-controlling-the-flow-from-assembly-to-ruby/), I also came across the SHRD instruction.

I already knew about the SHR & SHL command, logical shift right & left respectively, which translates rather easily:

    Assembly	Ruby

    {% codeblock lang:nasm %}shr @ax, 5{% endcodeblock %}	{% codeblock lang:ruby %}@ax >>= 5{% endcodeblock %}

    {% codeblock lang:nasm %}shl @ax, 5{% endcodeblock %}	{% codeblock lang:ruby %}@ax <<= 5{% endcodeblock %}

But I was initially stumped when I saw {% codeblock lang:nasm %}shrd ax, dl, cl{% endcodeblock %} in the Assembly code listing.

I'd figured out I needed the following test data, from the debugger

{% codeblock lang:ruby %}
def test_shrd
  assert_equal 12927, shrd(40919, 140, 6)
end
{% endcodeblock %}

And then this [link](https://en.wikibooks.org/wiki/X86_Assembly/Shift_and_Rotate#Extended_Shift_Instructions) gave me the insight I needed to code it up.

Voila:

{% codeblock lang:ruby %}
#see https://en.wikibooks.org/wiki/X86_Assembly/Shift_and_Rotate#Extended_Shift_Instructions for more info on shrd
def shrd(rm16, r16, cl)
  rm16 >>= cl
  r16 <<= (16 - cl)
  rm16 | (r16 & 0xFFFF)
end
{% endcodeblock %}

The test went from red to green :)

"[They will not control us](http://www.artima.com/intv/ruby4.html).  We will be victourious!!!!!!"

{% youtube n2I3_196BpI %}

:D

extension: markdown


text:
# R Reproducibility Challenge

* [Setup](#setup)
* [Challenges](#challenges)
* [Legal](#legal)

For this challenge, imagine you have been given a small project at the start of
your lab rotation. Your first task is to reproduce the results and organize the
project files. The instructions left to you by the former postdoc are below.
What are the main challenges you face in trying to reproduce the code?

---

Email from former postdoc:

> Hi! Welcome to graduate school! I'm a former postdoc in the lab, and now I'm
super busy running my own lab. My former adviser informed me that you're looking
for a rotation project. A few years ago I started investigating if one of our
transgenic mouse lines had a growth phenotype. I measured the weight (in grams)
of 30 wild type mice and 30 transgenic mice (see weights.csv). I tested for a
difference in weight using a t-test (see t-test.Rmd), but I was worried about
the non-normality of the data (see visualization.Rmd). Thus I decided to do
permutations to assess significance (see permutations.Rmd). I got a
permutation-based p-value of 0.011. Could you start by re-running the code to
confirm you get the same result?

## Setup

1. Click [here][zip] to download the project as a zip file

1. Extract the files using `unzip` in the Terminal or using the archival
software available on your computer (e.g. Archive Utility on macOS, 7zip on
Windows). On Windows 10, right-click on the zip file and select "Extract
All...".

1. Double-click on the the file `r-reproducibility-challenge.Rproj` to open
the project in RStudio

1. Install [rmarkdown][]

    ```
    install.packages("rmarkdown")
    ```

[zip]: https://github.com/jdblischak/r-reproducibility-challenge/archive/master.zip
[rmarkdown]: https://rmarkdown.rstudio.com/

## Challenges

### 1. Run the code

Try running the code. You can use the RStudio Knit button or run `render`
directly in the R console:

```
library("rmarkdown")
render("visualize.Rmd")
```

What errors prevented the code from running? How can you fix them?

### 2. Organize the files

Create two new directories: `analysis` and `data` (use `dir.create()`, `mkdir`
in the Terminal, or the RStudio files pane). Move the R Markdown files to
`analysis` and the data file to `data` (use `file.rename()`, `mv` in the
Terminal, or the RStudio files pane). Make sure to update the file paths! Hint:
`..` is the shortcut for the directory up one. Use the RStudio Knit button or
`render()` to confirm you can run the code in each of the files after updating
the file paths.

### 3. Make it a website

Currently the results are 3 separate HTML files that are saved in the same
directory as the source R Markdown files. To improve this, make the results an
interconnected website ([documentation][]).

[documentation]: https://rmarkdown.rstudio.com/rmarkdown_websites.html

First, create a file in `analysis` called `index.Rmd`. This is the main landing
page of your website, so write a brief note about the project. Copy the template
below as a starting point. It uses [Markdown syntax][md] to create hyperlinks to
the other analyses.

[md]: https://guides.github.com/features/mastering-markdown/

```
---
title: "Home"
output: html_document
---

Are transgenic mice bigger or smaller than wild type mice? The weights of 30
wild type and 30 transgenic mice were [visualized](visualize.html) and assessed
for statistically significant differences using a [t-test](t-test.html) and via
[permutations](permutations.html).
```

Second, create a file in `analysis` called `_site.yml` to configure the website.
Save the output in the root of the project in a directory called `docs` (hint:
the path needs to be relative to the location of the `_site.yml`, so you'll need
to use `..`). Also, create links in the navigation bar to the 3 different
analyses. Copy the template below into `analysis/_site.yml`, replacing the ___
with the necessary directory or filename.

```
name: "rotation-project"
output_dir: ___
navbar:
  title: "Rotation Project"
  left:
    - text: "Home"
      href: index.html
    - text: "Visualize"
      href: ___
    - text: "t-test"
      href: ___
    - text: "Permutations"
      href: ___
```

Third, build the website using `render_site` (you can also use the RStudio Knit
button to build one file at a time):

```
library("rmarkdown")
render_site("analysis")
```

Were the files saved where you expected? Do the links in the navigation bar
work?

### 4. Make the permutation-based p-value reproducible

When you run permutations.Rmd, do you get a p-value of 0.011. Why not? How can
you improve the analysis to make the p-value reproducible? Are you able to
obtain the same result each time you re-run the code?

## Legal

The original version of this material was created and taught on 2018-04-17 as
part of the course "Responsible, rigorous and reproducible conduct of research"
at the University of Chicago.

This material is based upon work supported by the National Science Foundation
under Grant Number 1734818.

"Any opinions, findings, and conclusions or recommendations expressed in this
material are those of the author(s) and do not necessarily reflect the views of
the National Science Foundation."

All material in this repository is licensed under the
[CC0](https://creativecommons.org/publicdomain/zero/1.0/legalcode.txt) license,
which means you are free to modify and distribute without any acknowledgement.
See the file `LICENSE` for the full license text.

repository: jdblischak/r-reproducibility-challenge

repo_name: jdblischak/r-reproducibility-challenge


text:
# childcare-calculator-frontend

[![Build Status](https://travis-ci.org/hmrc/childcare-calculator-frontend.svg)](https://travis-ci.org/hmrc/childcare-calculator-frontend) [ ![Download](https://api.bintray.com/packages/hmrc/releases/childcare-calculator-frontend/images/download.svg) ](https://bintray.com/hmrc/releases/childcare-calculator-frontend/_latestVersion)

The Childcare Calculator will help parents quickly self-assess the options for their childcare support, allowing them to
make a decision on which scheme will best suit their needs. The Childcare Calculator will calculate the data input by
the users, inform them of their eligibility and how much support that they could receive for the Tax-Free Childcare (TFC),
Tax Credits (TC) and Employer-Supported Childcare (ESC) schemes.

The Childcare Calculator invokes cc-eligibility microservice([Eligibility documentation](https://github.com/hmrc/cc-eligibility/blob/master/README.md)) and cc-calculator microservice([Calculator documentation](https://github.com/hmrc/cc-calculator/blob/master/README.md)) to get the desired results.

The Childcare Calculator has a feature where in users can do email registration to send the email the calculator invokes cc-email-capture microserive([Email capture documentation](https://github.com/hmrc/cc-email-capture/blob/master/README.md))

The Childcare Calculator Frontend service, collects the data input by the users from the fields on the presented pages.
This data is collated and passed to the Childcare Calculator backend processes. The results are returned to the Childcare
Calculator Frontend service to display to the user.

* **Endpoint URL :** /childcare-calc

* **Port Number :** 9381

### Testing ###

#### Unit Tests
To run the unit tests for the application run the following:

1. `cd $workspace`
2. `sbt test`

To run a single unit test/spec

1. `cd $workspace`
2. `sbt`
3. `test-only */path/to/unitspec/Example*` - Example being the class name of your UnitSpec

#### Test Coverage
To run the test coverage suite `scoverage`

1. `sbt clean scoverage:test`

#### Acceptance Tests

**NOTE:** Cucumber/acceptance tests are available in a private GitHub project at:
`http://github.com/HMRC/childcare-calculator-acceptance-tests`

## Messages

To provide messages files with variables that are passed in then use the following format:

```
@Messages("cc.compare.total.household.spend", totalHouseholdSpend)
cc.compare.total.household.spend = You told us your childcare costs are {0} a month
```

### License

This code is open source software licensed under the [Apache 2.0 License]("http://www.apache.org/licenses/LICENSE-2.0.html")


text:
# Other Puzzle Sources

There are a large number of excellent puzzle resources available
on-line and in print.  Among the best are:

[The Bent of Tau Beta Pi](https://www.tbp.org/pubs/brainTicklers.cfm)

    Four times a year the Engineering honor society publishes a new
    issue.  Each issue contains seven excellent puzzles.  Solutions
    are published in the subsequent issue.  The Bent archives of
    Brain Ticklers extend back to 2000.

    These puzzles are generally among the best found anywhere.

[The Riddler of 538](https://fivethirtyeight.com/tag/the-riddler/)

    Each time puzzles are added to the Riddler there are two
    new opportunities to find bliss.  As each new puzzle set
    is published, the solutions to the previous puzzle set is
    provided.

    New puzzles are published every one or two weeks.

[R-Bloggers Website](https://www.r-bloggers.com/2017/11/le-monde-puzzle-1029)
[Xi'an's Blog Website](https://xianblog.wordpress.com/2017/11/22/le-monde-puzzle-1029/)

    These two sites are linked and explore problems from LeMonde.
    The links here are to particular problems but Xi'an looks at
    many other puzzles as well.


text:
# aws-lambda-overprovisioned-memory
Script to check AWS Lambda functions for over-provisioned memory

Provisioning the exact RAM allocation for AWS Lambda functions is often a trial and error procedure and, it has happened to us that we set a huge catch-all value for development which sometimes forgets been tuned for production and other more usage intensive environments, where inadequate RAM setting might lead to wasted and unnecessary costs.

Using Cloudwatch Log Insights and their provided **Sample Query** to **Determine the amount of overprovisioned memory**, I've built a bash script (tested on OSX only, which actually leads to issues on date handling on other OS) which analyzes or your Lambda related CloudWatch logs (last 7 days by default, based on start_time variable) to scan for usage statistics and report possible allocation overhead.

**NOTE 1**: the reported overprovisioning does NOT necessarily mean that you should lower your setting by that exact amount but, experiment on lowering accordingly.

**NOTE 2**: lowering RAM setting has a direct correlation with assigned CPU resources, so you Lambdas may take longer to execute thus, less RAM does not always mean less cost.

**NOTE 3**: script runs according to your configured environment (account, credentials, profile, and region), so you can tweak what you actually want to scan via [env vars](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html) (AWS_PROFILE, AWS_DEFAULT_REGION, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY)

## Usage

- Download [lambda-overprovision.sh](https://github.com/gvasquez-waypoint/aws-lambda-overprovisioned-memory/blob/master/lambda-overprovision.sh) file
- Customize your script to set both your desired Cloudwatch Namespace and Metric name
- Check the metrics created by graphing them. The highest the value, the most likely you can lower your RAM setting.

## Dependencies

- AWS CLI (tested on aws-cli/1.11.190 Python/2.7.10 Darwin/18.7.0 botocore/1.12.64)
- jq (tested on jq-1.6)

## Example

In the following image, the Lambda Function is ExportReporteEventosAsistenteConduccion is reporting an over-provisioning of about 2 GB:

![Metrics Example](https://raw.githubusercontent.com/gvasquez-waypoint/aws-lambda-overprovisioned-memory/master/cw-example.jpg)

license: Unlicense


text:
---
layout: page
title: Kenneth's Project Portfolio Page
---

## Project: CliniCal

CliniCal is a desktop app that allows doctors to manage patient records and schedule upcoming appointments.

Given below are my contributions to the project.

* **New Feature**: Added the ability to add profile pictures.
  * What it does: Allows the user to add a profile picture to each patient profile.
  * Justification: This feature improves the product significantly because the user can now quickly identify patients using their profile pictures, instead of relying on other forms of identification
                   such as names which can be duplicated.
  * Highlights: User can use their mouse to drag and drop profile pictures onto the patient's profile. This makes it easier for the user to add profile pictures, without having
                to waste time specifying the image's filepath.
  * Credits:
    1. Manipulation of images in JavaFX: [Tutorialspoint](https://www.tutorialspoint.com/javafx/javafx_images.htm)
    2. Implement drag and drop feature: [JavaCodeGeeks](https://examples.javacodegeeks.com/desktop-java/javafx/event-javafx/javafx-drag-drop-example/),
       [GenuineCoder](https://www.genuinecoder.com/drag-and-drop-in-javafx-html/)

* **New Feature**: Added a profile display command.
  * What it does: Displays the patient's profile on a separate window.
  * Justification: Allows user to view the patient's profile and access relevant details such as Blood Type, Address, etc.
  * Highlights: This command displays the patient's profile on a separate popup window, which allows the user to focus on one individual patient. This helps
                to declutter the main window.
  * Credits:
    1. Popup windows: [Quollwriter](https://quollwriter.wordpress.com/2019/04/08/how-to-create-a-popup-pane-in-javafx/), [VISIT Github](https://github.com/AY1920S1-CS2103T-F12-2/main), [Jewelsea Github](https://gist.github.com/jewelsea/1926196)
    2. Populate separate panel with custom list: [Oracle](https://docs.oracle.com/javafx/2/ui_controls/list-view.htm)
    3. Custom list cell: [StackOverflow](https://stackoverflow.com/questions/25246496/javafx-custom-list-cell-updateitem-being-called-a-lot)
    2. Existing AB3 codebase: [AB3 Github](https://github.com/se-edu/addressbook-level3)

* **New Feature**: Added the ability to add a new visitation log.
  * What it does: Adds a new visit for the specified patient.
  * Justification: This features improves the product significantly because the user can now record visitation details (eg. Diagnosis) and store them in CliniCal.
  * Highlights: User can enter relevant details about the visitation in a separate popup window. This helps to declutter the main window.
  * Credits:
    1. Existing AB3 codebase: [AB3 Github](https://github.com/se-edu/addressbook-level3)

* **New Feature**: Enhanced the find command to allow partial matching, and included IC number as an additional search parameter
  * What it does: Locates a patient after the user specifies either the patient's name or IC number.
  * Justification: User can quickly locate a specific patient by searching the patient's unique IC number, instead of using names which can be duplicated.
  * Highlights: Enhanced partial matching functionality allows user to type in the first few digits of the patient's IC number, or the first few characters of the patient's name to
                locate the patient, instead of having to specify the entire IC number or name.
  * Credits: NIL

* **Code contributed**: [RepoSense link](https://nus-cs2103-ay2021s1.github.io/tp-dashboard/#breakdown=true&search=afroneth)

* **Project management**:
  * Managed release `v1.2.1` on GitHub

* **Enhancements to existing features**:
  * Assisted in styling of GUI ([\#149](https://github.com/AY2021S1-CS2103T-W11-4/tp/pull/149), [\#233](https://github.com/AY2021S1-CS2103T-W11-4/tp/pull/233))
  * Wrote additional tests for `ParserUtil`, `CommandResult`, `LogicManager` classes ([\#164](https://github.com/AY2021S1-CS2103T-W11-4/tp/pull/164), [\#168](https://github.com/AY2021S1-CS2103T-W11-4/tp/pull/168), [\#169](https://github.com/AY2021S1-CS2103T-W11-4/tp/pull/169))

* **Documentation**:
  * User Guide:
    * Added documentation for `addpicture`, `addvisit` and `profile` features ([\#148](https://github.com/AY2021S1-CS2103T-W11-4/tp/pull/148))
    * Improve overall styling ([\#255](https://github.com/AY2021S1-CS2103T-W11-4/tp/pull/255))
    * Removed discrepancies on formatting issues ([\#265](https://github.com/AY2021S1-CS2103T-W11-4/tp/pull/265))
  * Developer Guide:
    * Added implementation details for the `addpicture`, `addvisit` and `profile` features ([\#83](https://github.com/AY2021S1-CS2103T-W11-4/tp/pull/83))
    * Added new use cases for `addpicture` and `profile` features ([\#251](https://github.com/AY2021S1-CS2103T-W11-4/tp/pull/251))
    * Added manual testing instructions for `addpicture`, `addvisit` and `profile` features ([\#266](https://github.com/AY2021S1-CS2103T-W11-4/tp/pull/266))
    * Added brief preface to each section ([\#141](https://github.com/AY2021S1-CS2103T-W11-4/tp/pull/141))

* **Community**:
  * Reported bugs and suggestions for other teams in the class (during Practical Dry Run): [Issues link](https://github.com/afroneth/ped/issues)
  * PR reviewed (with non-trivial review comments) ([\#252](https://github.com/AY2021S1-CS2103T-W11-4/tp/pull/252))

* **Tools**:
  * Integrated a third party library (Commons IO) to the project ([\#61](https://github.com/AY2021S1-CS2103T-W11-4/tp/pull/61))

gha_language: Java

gha_license_id: NOASSERTION


text:
ObjectFactory
=============

ObjectFactory example using C++11.

I provided an example to understand how to use it in the main.cpp file.

Don't forget to activate the C++11 option when you compile the class with the flag -std=c++0x

##License

    Copyright (c) 2014 Guillaume Gomez

    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.

repository: GuillaumeGomez/ObjectFactory

repo_name: GuillaumeGomez/ObjectFactory


text:
# scMVP - single cell Multi-View Profiler

scMVP is a python toolkit for joint profiling of scRNA and scATAC data and analysis
with multi-modal self-attention generation model.

## Update logs
- 20220815

Complete the test for GPU version on NVIDA 3090 platform with CUDA version 11.2.

Add  scRNA and scATAC input check in tutorial.

## Installation
**Environment requirements:**

scMVP requires Python3.7.x and [**Pytorch**](http://pytorch.org).

For example, use [**miniconda**](https://conda.io/miniconda.html) to install python and pytorch of CPU or GPU version.
We have tested the GPU version on NVIDA 1080Ti platform with CUDA version 10.2.

```Bash
conda install -c pytorch python=3.7 pytorch
# if you do not have jupyter notebook/ipython notebook, you can also install by conda
conda install jupyter
```

Then you can install scMVP from github repo:

```Bash
# first move to your target directory
git clone https://github.com/bm2-lab/scMVP.git
cd scMVP/
python setup.py install
```

Try ```import scMVP``` in your python console and start your first [**tutorial**](demos/scMVP_tutorial.ipynb) with scMVP!

Jupyter notebooks for other datasets analyzed and benchmarked in our GB paper are deposited in [**folder**](demos/manuscript_analysis/)

### All processed dataset and trained models:

Download link: [baidu cloud disk](https://pan.baidu.com/s/183jLROAUuNfVKCeBY4B4DQ)

Download code: mkij

- pre_trainer.pkl  scRNA pretraining models

- pre_atac_trainer.pkl scATAC pretraining models

- multi_vae_trainer.pkl scMVP training models

## User tutorial

Applying scMVP to sci-CAR cell line mixture. [**demo**](demos/scMVP_tutorial.ipynb)
- Training and visualization with scMVP.
- Pretraining and transferring to scMVP(perform better in large dataset).

### Reference
A deep generative model for multi-view profiling of single-cell RNA-seq and ATAC-seq data. Genome Biology 2022 [**paper**](https://genomebiology.biomedcentral.com/articles/10.1186/s13059-021-02595-6)

### Contact Authors
Prof. Qi Liu: [qiliu@tongji.edu.cn](qiliu@tongji.edu.cn)

Dr. Gaoyang Li: [lgyzngc@gmail.com](lgyzngc@gmail.com)

Shaliu Fu: [adam.tongji@gmail.com](adam.tongji@gmail.com)


text:
---
layout: page
title: Voyager I and II
permalink: /history/voyager
---

The Voyager program was launched in 1977 to explore the further planets from the solar system while the alignments of Jupiter, Saturn, Uranus, and Neptune were efficient for travel. Two probes were launched and are still in operation.

Voyager 1, travelling in deep space.

The Voyager program has 2 probes still in extended mission and are both around 16 billion miles away from earth. Redundancy management was a great theme in the Voyager computers as they each had 3 different computer types with 2 of each kind.


text:
# readable
This is my version of *Readable* project for Udacity React Nano degree.

## Prerequisites

To run this project, you will need to have Node.js and npm installed in your machine.
I'm using *Node v7.5.0* and *npm 4.1.2*

## How to make this code run

First of all, download or clone this repository.

Then, go to project folder using:

```
> cd readable
```

## To install and run backend project

Go to the link

https://github.com/udacity/reactnd-project-readable-starter

## To install and run frontend project

Go to frontend folder and run

```
> cd ReduxSimpleStarter-master;
 npm install
```

This should run for some minutes, be patient. When it finishes, type:

```
> npm start
```

You can use web-broswer with the Link: 'http://localhost:8080/'

## Libraries used

The project uses the following dependencies:

* React
* Redux
* Redux Thunk
* React Router V4
* Material-UI
* moment
* UUID


text:
# Notice: This repository is no longer active. SrDebug is now a [UPM](https://github.com/UnityPluginManager) plugin.
# SrDebug
A debug menu for Slime Rancher

![Screenshot of SrDebug in action](http://i.imgur.com/1nALiAO.png)

# Usage
### Official release
1. Extract the zip to your _Slime Rancher_ game directory
  * usually **SteamApps/common/Slime Rancher/** on Windows
  * usually **Application Support/Steam/steamapps/common/Slime Rancher/Resources** on macOS
2. Run `SrDebug-Patcher.exe`, or `mono SrDebug-Patcher.exe` for non-Windows
3. Wait for the patch tool to complete, then run _Slime Rancher_

### Custom built
1. Create a folder named **SrDebug-Content** in your _Slime Rancher_ game folder
2. Browse to **Source/Assembly-SrDebug/bin/.../\<Build Type\>/** where \<Build Type\> can be *Debug* or *Release*, depending on how you compiled
3. Copy _Assembly-SrDebug.dll_ to the **SrDebug-Content** folder in your _Slime Rancher_ game directory
4. Browse to **Source/SrDebug-Patcher/bin/.../\<Build Type\>/** where \<Build Type\> can be *Debug* or *Release*, depending on how you compiled.
5. Copy _Mono.Cecil.dll_ to the **SrDebug-Content** directory
6. Copy _SrDebug-Patcher.exe_ and _SrDebug-Patcher.exe.config_ to your _Slime Rancher_ game directory
6. Run `SrDebug-Patcher.exe`, or `mono SrDebug-Patcher.exe` for non-Windows
7. Wait for the patch tool to complete, then run _Slime Rancher_

# Building
1. Browse to your _Slime Rancher_ game directory
  * usually **SteamApps/common/Slime Rancher/** on Windows
  * usually **Application Support/Steam/steamapps/common/Slime Rancher/Resources** on macOS
2. Locate the game's _Managed_ folder (SlimeRancher_Data/Managed on Windows & Linux, Content/Resources/Data/Managed on Mac)
3. Copy _UnityEngine.dll_ and _Assembly-CSharp.dll_ into the _Managed_ folder in the _SrDebug_ repository root
4. Run `generate.bat` or `Protobuild --generate` for non-Windows
5. Build the resultant solution file

repository: DaZombieKiller/SrDebug

repo_name: DaZombieKiller/SrDebug


text:
# Contributing guidelines

:+1::tada: First off, thanks for taking the time to contribute! :tada::+1:

The following is a set of guidelines (not rules) for contributing to Kedge.

These are just guidelines, not rules, use your best judgment and feel free to
propose changes to this document in a pull request.

## Submitting a Pull Request
Before you submit your pull request consider the following guidelines:

* Make your changes in a new git branch:

     ```shell
     git checkout -b bug/my-fix-branch master
     ```

* Create your patch, **including appropriate test cases**.
* Include documentation that either describe a change to a behavior of kedge or the changed capability to an end user of kedge.
* Commit your changes using **a descriptive commit message**. If you are fixing an issue please include something like 'this closes issue #xyz'.
* Make sure your tests pass!

    ```shell
    make test
    ```

* Push your branch to GitHub:

    ```shell
    git push origin bug/my-fix-branch
    ```

* In GitHub, send a pull request to `kedge:master`.
* If we suggest changes then:
  * Make the required updates.
   Thank you for your contribution!

### Merge Rules

* Include unit or integration tests for the capability you have implemented
* Include documentation for the capability you have implemented
* If you are fixing an issue within Kedge, include the issue number you are fixing

### After your pull request is merged

After your pull request is merged, you can safely delete your branch and pull the changes
from the upstream repository:

* Delete the remote branch on GitHub either through the GitHub web UI or your local shell as follows:

    ```shell
    git push origin --delete bug/my-fix-branch
    ```

* Check out the master branch:

    ```shell
    git checkout master -f
    ```

* Delete the local branch:

    ```shell
    git branch -D bug/my-fix-branch
    ```

* Update your master with the latest upstream version:

    ```shell
    git pull --ff upstream master

## Git Commit Messages

* Use the present tense ("Add feature" not "Added feature")
* Use the imperative mood ("Move cursor to..." not "Moves cursor to...")
* Reference issues and pull requests liberally

repository: kedgeproject/kedgify

gha_language: Go

repo_name: kedgeproject/kedgify


text:
---
sidebar_position: 2
---

# Integration Tests

:::note Simulation tests are no longer actively supported.
NEAR Simulator was meant to be an in-place replacement of a blockchain environment for the purpose of testing NEAR contracts. However, simulating NEAR ledger turned out to be a much more complex endeavor than was anticipated. Eventually, the idea of workspaces was born - a library for automating workflows and writing tests for NEAR smart contracts using a real NEAR network (localnet, testnet or mainnet). Thus, NEAR Simulator is being deprecated in favor of [`workspaces-rs`](https://github.com/near/workspaces-rs), the Rust edition of workspaces. As the two libraries have two vastly different APIs [this guide](/develop/testing/workspaces-migration) was created to ease the migration process for developers.
:::

## Setup

We place integration tests in JS in a separate directory at the same level as `/src`, called `/integration-tests` ([read more](https://doc.rust-lang.org/cargo/reference/cargo-targets.html#integration-tests)), placing this folder within a `/tests` folder at root-level that contains the unit tests folder would also be plausible. Refer to this folder structure below:

```sh
├── package.json                ⟵ contains `dependencies` for contract and `devDependencies` for workspaces-js tests
├── src
│  └── index.js                 ⟵ contract code
├── node_modules
└── integration-tests           ⟵ integration test directory
   └── tests.js                 ⟵ integration test file
```

A sample configuration for this project's `package.json` is shown below:

```json
{
  "name": "simple-example",
  "version": "0.1.0",
  "description": "Simple json file example",
  "main": "index.js",
  "type": "module",
  "license": "MIT",
  "directories": {
    "test": "test"
  },
  "scripts": {
    "build": "near-sdk-js build",
    "test": "ava"
  },
  "dependencies": {
    "near-sdk-js": "0.6.0"
  },
  "devDependencies": {
    "ava": "^4.3.3",
    "near-workspaces": "^3.2.2"
  },
  "ava": {
    "files": [
      "test/**/*.ava.js"
    ],
    "require": [],
    "failFast": false,
    "timeout": "2m",
    "failWithoutAssertions": true,
    "environmentVariables": {},
    "verbose": true,
    "nodeArguments": []
  }
}
```

The `tests.js` file above will contain the integration tests. These can be run with the following command from the same level as the test `package.json` file:

    npm test

<!-- TODO: add snippets of code, living everywhere spread across docs -->

repository: think-in-universe/docs

gha_language: TypeScript

repo_name: think-in-universe/docs


text:
# Landing page for Wikimedia Commons Mobile App

This is the landing page for the [Wikimedia Commons Mobile App](https://github.com/commons-app/apps-android-commons). You can visit it at: https://commons-app.github.io/

## Contributing

Contributions are welcome. Please make sure your changes work on small screens. Currently Boostrap v4.1 is being used.


text:
---
title: Overview
page_title: Overview
description: Check our "Overview" documentation article for the RadCoverflow {{ site.framework_name }} control.
slug: coverflow-overview
tags: overview
published: True
position: 0
CTAControlName: RadCoverflow
---

# {{ site.framework_name }} CoverFlow Overview

__RadCoverFlow__ is a useful tool that can be used to navigate through a collection of horizontally aligned images. It gives you flexibility to change camera position and reflection opacity. In this article you can find comprehensive HowTo section that gives you real world examples. You can also take a quick look at the Features section that describes all features and important events and properties. Prior to reading this article please check the [Structure]({%slug coverflow-structure%}) section that gives explanation for all terms and concepts relevant to RadCoverFlow.

{% if site.has_cta_panels == true %}
{% include cta-panel-overview.html %}
{% endif %}

![{{ site.framework_name }} RadCoverflow Overview](images/RadCoverFlow.png)

{% if site.site_name == 'Silverlight' %}
In this video, we will look at some of the features and functionality in Telerik RadCoverFlow for Silverlight and how you can start using it in your rich internet applications today.(Runtime: 03:01)
[![{{ site.framework_name }} RadCoverflow Video Thumbnail](images/CoverFlow_Getting_Started.png)](http://tv.telerik.com/watch/silverlight/video/introduction-radcoverflow-silverlight)
{% endif %}

## See Also

 * [Features]({%slug coverflow-offsets%})

 * [Styling and Appearance]({%slug coverflow-styling-and-appearance-overview%})

 * [HowTo]({%slug coverflow-databinding-overview%})

repository: telerik/xaml-docs

repo_name: telerik/xaml-docs


text:
---
title: "Data Preparation: Essential Steps Before & After Analysis"
author: "Martin Monkman"
date: "2020-09-07T17:31:57Z"
tags: [Tidy, Data Science, Visualization, Course]
link: "https://bookdown.org/martin_monkman/DataPreparation_EssentialSteps/"
length_weight: "16.8%"
cover: "https://bookdown.org/martin_monkman/DataPreparation_EssentialSteps/20478450629_50e4c32d23_c.jpg"
repo: "https://github.com/MonkmanMH/data_preparation_with_r"
pinned: false
---

Before you can analyze your data, you need to ensure that it is clean and tidy. [...] Draft It is routinely noted that the Pareto principle applies to data science—80% of one’s time is spent on data collection and preparation, and the remaining 20% on the “fun stuff” like modeling, data visualization, and communication. There is no shortage of material—text books, journal articles, blog posts, online courses, podcasts, etc.— about the 20%. This modest book hopes to serve as an introduction and wayfinder for readers seeking to understand core elements of the other 80%. It is assumed that the ...