text:
SymBlog
=======

Continued [Symfony](http://symfony.com/ "Symfony") 2.5 Tutorial completion based on the [blog](http://tutorial.symblog.co.uk/ "Symfony2 Tutorial").

#### Install

To install the project you need to have the PHP dependency manager called [Composer](https://getcomposer.org/ "Composer").

```Bash
$> mkdir /var/www/lh.symblog && cd /var/www/lh.symblog
$> git clone https://github.com/gergelykovacs/symblog.git .

.... [ clones the repo into lh.symblog ]

$> composer install

... [ installs all the requirements and finally please fill these ]

Creating the "app/config/parameters.yml" file
Some parameters are missing. Please provide them.
database_driver (pdo_mysql):
database_host (<IP_ADDRESS>):
database_port (null):
database_name (symfony): symblog
database_user (root): symblog
database_password (null): passwd123
mailer_transport (smtp):
mailer_host (<IP_ADDRESS>):
mailer_user (null):
mailer_password (null):
locale (en):
secret (ThisTokenIsNotSoSecretChangeIt):
debug_toolbar (true):
debug_redirects (false):
use_assetic_controller (true):
```

Create the *MySQL* database and user you have set `$> mysql -u root -h <IP_ADDRESS> -p`.

```SQL
CREATE DATABASE IF NOT EXISTS `symblog`
DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;

CREATE USER 'symblog'@'%' IDENTIFIED BY 'passwd123';

GRANT ALL PRIVILEGES ON symblog.* TO 'symblog'@'%';

FLUSH PRIVILEGES;
```

Build the table schema and load test data into the new database.

```Bash
$> bin/console doctrine:schema:create
$> bin/console doctrine:fixtures:load
```

Eventually, you should set up the local web service as follows and you are done.

#### Host configuration

Here and now please note that *.lh* refers to your localhost so the `$> vim /etc/hosts` file should contain the following line.

```Bash
<IP_ADDRESS>    prod.symblog.lh    test.symblog.lh    dev.symblog.lh
```

#### Nginx configuration

You can access the project's different states by the URIs

- **Production** http://prod.symblog.lh
- **Testing** http://test.symblog.lh
- **Development** http://dev.symblog.lh

and it is for convenience only *(NOT FOR PRODUCTION SERVICE)*.

*Please be aware of [Nginx IfEvil](http://wiki.nginx.org/IfIsEvil "Nginx IfIsEvil") when you read the configuration below.*

```Nginx
#
# @file: /etc/nginx/sites-available/lh.symblog.conf
# symlink: /etc/nginx/sites-enabled/lh.symblog.conf -> @file
#
server {
    listen 80;
    server_name ~^(?<symenv>prod|test|dev).symblog.lh$;
	root /var/www/lh.symblog/web;

        access_log  /var/log/nginx/lh.symblog/access-80.log main;
        error_log  /var/log/nginx/lh.symblog/error-80.log warn;

	set $web_script "app_$symenv.php";

	if ($symenv ~ "^prod$") {
		set $web_script "app.php";
	}

	location / {
		index $web_script;
		try_files $uri /$web_script/$args;
	}

	location ~ ^/(app|app_dev|app_test|config)\.php(/|$) {
		fastcgi_pass <IP_ADDRESS>:9000;
		fastcgi_split_path_info ^(.+\.php)(/.*)$;
		include fastcgi_params;
		fastcgi_param  SCRIPT_FILENAME $document_root$fastcgi_script_name;
	}

        location ~ /\.ht {
		deny all;
        }

        location = /favicon.ico {
                access_log off;
                log_not_found off;
        }
}
```

#### Test

To run all the PHPUnit tests:

```Bash
$> cp php phpunit.xml.dist phpunit.xml
$> phpunit --stderr --debug
```

#### Further

The tutorial and functionalities will be extended later.

The *YUI Compressor* is added (.jar) for Assetic support but will be removed later.

repository: gergelykovacs/symblog

branch_name: refs/heads/master

extension: md

license_type: permissive

repo_name: gergelykovacs/symblog


text:
# Contributing to Gogs

> This guidelines sheet is forked from [CONTRIBUTING.md](https://github.com/drone/drone/blob/master/CONTRIBUTING.md).

Gogs is not perfect and it has bugs, or incomplete features for rare cases. You're welcome to tell us or contribute some code. This document describles details about how can you contribute to Gogs project.

## Contribution guidelines

Depends on the situation, you will:

- Find bug, create an issue
- Need more functionality, make a feature request
- Want to contribute code, open a pull request
- Run into issue, need help

### Bug Report

If you find or consider something is a bug, please create a issue on [GitHub](https://github.com/gogits/gogs/issues). To reduce unnecessary time wasting of interacting and waiting with team members, please use following form as template in the first place:

```
- **Bug Description**:
- **Gogs Version**:
- **Git Version**:
- **System Type**:
- **Error Log**:
- **Other information**:
```

Please take a moment to check that an issue on [GitHub](https://github.com/gogits/gogs/issues) doesn't already exist documenting your bug report or improvement proposal. If it does, it never hurts to add a quick "+1" or "I have this problem too". This will help prioritize the most common problems and requests.

#### Bug Report Example

- **Bug Description**: Crash when create repository with license|
- **Gogs Version**: `v<IP_ADDRESS>1`
- **Git Version**: `1.9.0`
- **System Type**: `Ubuntu 12.04`
- **Error Log**:

```
2014/09/01 07:21:49 [E] nil pointer
```

- **Other information**: Use SQLite3 as database

### Feature Request

There is no standard form of making a feature request, just try to describle the feature as clear as possible because team members may not have experience with the functionality you're talking about.

### Pull Request

Pull requests are always welcome, but note that **ALL PULL REQUESTS MUST SEND TO `DEV` BRANCH**.

We are always thrilled to receive pull requests, and do our best to process them as fast as possible. Not sure if that typo is worth a pull request? Do it! We will appreciate it.

If your pull request is not accepted on the first try, don't be discouraged! If there's a problem with the implementation, hopefully you received feedback on what to improve.

We're trying very hard to keep Gogs lean and focused. We don't want it to do everything for everybody. This means that we might decide against incorporating a new feature.

### Ask For Help

Before open any new issue, please check your problem on [Troubleshooting](http://gogs.io/docs/intro/troubleshooting.md) and [FAQs](http://gogs.io/docs/intro/faqs.html) pages.

## Things To Notice

Please take a moment to check that an issue on [GitHub](https://github.com/gogits/gogs/issues) or card on [Trello](https://trello.com/b/uxAoeLUl/gogs-go-git-service) doesn't already exist documenting your bug report or improvement proposal. If it does, it never hurts to add a quick "+1" or "I have this problem too". This will help prioritize the most common problems and requests.

### Discuss your design on the mailing list

We recommend discussing your plans [on the mailing list](https://groups.google.com/forum/#!forum/gogits) before starting to code - especially for more ambitious contributions. This gives other contributors a chance to point you in the right direction, give feedback on your design, and maybe point out if someone else is working on the same thing.

We may close your pull request if not first discussed on the mailing list. We aren't doing this to be jerks. We are doing this to prevent people from spending large amounts of time on changes that may need to be designed or architected in a specific way, or may not align with the vision of the project.

repository: basilfx/gogs

repo_name: basilfx/gogs


text:
# New Relic Datasource - Custom Grafana Plugin
You can use New Relic Datasource plugin to integrate New Relic metrics into Grafana using New Relic APM API.

## Supported Grafana versions
Grafana version 3.0.0-beta7 and 3.0.1 stable and higher.

## Adding the data source to Grafana

1. Add the contents of this repository to your grafana plugins directory and then restart the grafana server.
- Plugin directory:
  - /var/lib/grafana/plugins (default)
  - /usr/local/var/lib/grafana/plugins (if installed with brew on mac)

2. Open the side menu by clicking the Grafana icon in the top header and select *Data Sources*.

3. Click the *+ Add data source* button in the top header.

4. Select *NewRelic* from the Type dropdown.

5. Enter the datasource *Name* and *API Key* that can be found New Relic account settings under Integrations->API Keys.

## Query editor
Open a graph in edit mode by click the *Title > Edit* (or by pressing *e* key while hovering over panel).

### Adding single metric to a graph
- Select *Application*, *Metric Namespace*, and *Metric Value* from the dropdown lists.
- Set the operator to *none*.
- Provide *Series Alias* if needed. If left blank, series will be aliased as "MetricNamespace:MetricValue". MetricValue can be accessed as $value when defining the alias.

![Query Editor - Simple Metric](misc/query-editor-simple-metric.png)

- The query outputs a graph.

![Graph - Simple Metric](misc/graph-simple-metric.png)

### Adding an expression based on 2 metrics to a graph
- Select *Application*, *Metric Namespace*, and *Metric Value* from the dropdown lists.
- Choose the *Operator*. 4 operators are supported (+, -, *, /).
- Select *Metric Namespace*, and *Metric Value* for the 2nd operand from the dropdown lists.
- Provide *Series Alias* if needed.

![Query Editor - Expression](misc/query-editor-expression.png)

- The query outputs a graph.

![Graph - Expression](misc/graph-expression.png)

### Adding multiple series to a graph
- Add more metrics to the graph by adding another query in the panel editor. Provide meaningful aliases for clarity.

![Query Editor - 2 metrics](misc/query-editor-2-metrics.png)

- The graph will have both metrics superimposed.

![Graph - 2 metrics](misc/graph-2-metrics.png)

- Use *Mixed* datasource if you're trying to superimpose metrics from different datasources.

## A note on large result sets from New Relic
New Relic APIs, by default, return 200 results (see https://docs.newrelic.com/docs/apis/rest-api-v2/requirements/pagination-api-output). Paging has been added to the query for Applications, with an arbitrary limit hardcoded at 10 pages.
- The hardcoded limit is arbitrary. If you need more than 2000 results (200 per page over 10 pages), increasing the *finalPageNumber* default value in *NewRelicQueryCtrl.prototype.getApplications* is all that would need to be done.
- Although paging has been implemented for Applications, the same can not yet be said for Metrics. This means that Metrics are currently limited to 200 results maximum.

gha_language: TypeScript


text:
**Invisible双手简谱** 和五线谱完全对应。

_Invisible_ 是美国油管流行女歌手Anna Clendening演唱的歌曲。Anna
Clendening，最初活动在现已解散的视频共享服务平台Vine上，后来参加了美国达人秀第九季。现专注于她的音乐，截止2019年3月她的YouTube超过8900万次浏览。

歌词下方是 _Invisible钢琴谱_ ，大家可以免费下载学习。

### Invisible歌词：

Avoiding this disaster
Seemed impossible
My heart is beating faster
Fast as it can go
'Cause I'm overthinking every word
That was never said or heard
Happy ever after
I don't think so
I'm in love with someone
Who doesn't know I exist exist
I stare from afar in my hand-broken heart while I play pretend
I'm in love with someone
Who doesn't know I exist wheres the
And it's you yes it's true
You don't even know it I can't ever win
Am I invisible
Should I let it go
Would you ever know
Am I just another crazy laying on the low
Low low low low
Am I invisible
Will you ever see what you do to me
Breaking hearts in the dark so easily
Low
Am I invisible
Tangled up and tongue-tied
What have I become
Always got you on my mind
Got me feeling dumb
And I'm tripping over my own feet
And I'm mad you got the best of me
Falling for you slowly
From a distance
I'm in love with someone
Who doesn't know I exist exist
I stare from afar in my hand-broken heart while
I play pretend
I'm in love with someone
Who doesn't know I exist wheres the
And it's you yes it's true
You don't even know it I can't ever win
Am I invisible
Should I let it go
Would you ever know
Am I just another crazy laying on the low low low low low
Am I invisible
Will you ever see what you do to me
Breaking hearts in the dark so easily
Am I invisible
Am I invisible
Am I invisible
I'm in love with someone who doesn't know
I exist
And it's you yes it's true you don't even know
It I can't ever win
Am I invisible
Should I let it go would you ever know
Am I just another crazy laying on the low low low
Am I invisible invisible invisible
Hey yeah
Will you ever see what you do to me
Breaking hearts in the dark so easily
Am I invisible

license: MIT

path: /流行/Invisible-Anna Clendening/README.md

branch_name: refs/heads/main


text:
# Format1 - Protostar Challenge

We are given the following binary and its source code:

![image](https://user-images.githubusercontent.com/24576987/30565430-3a61bede-9c96-11e7-8f13-900c8765a995.png)

The program itself is a classic printf vulnerability, however the challenge notes that "objdump -t" is recommended, and that the input string is placed high up (or I suppose very below) the stack.

Lets do as they say and check out the dump of the binary:

![image](https://user-images.githubusercontent.com/24576987/30565507-8c7e28e2-9c96-11e7-9d01-b6df1f6d8f39.png)

The source code suggests that if the value of the ```target``` variable is changed to anything other than 0, then the program is successfully compromised. Fair enough, let's keep note of it's memory address while we probe for the actual stack location.

The challenge noted that the input string was placed very high up, so let's see what happens when we check 150 pointers on the stack:

![image](https://user-images.githubusercontent.com/24576987/30565589-de5dbd4e-9c96-11e7-9f2d-c8c26d9a621b.png)

As it turns out, I found the location after a good estimate. I had to do some padding in order to confirm the exact location of my exploit, but I eventually found it at the 130th position.

Changing my code a bit, I was able to successfully compromise the program:

![image](https://user-images.githubusercontent.com/24576987/30565630-13be2e60-9c97-11e7-81ee-76fd265fcca8.png)

repository: CookieComputing/netsecnoobie

repo_name: CookieComputing/netsecnoobie


text:
# TensorRTx

TensorRTx aims to implement popular deep learning networks with tensorrt network definition APIs. As we know, tensorrt has builtin parsers, including caffeparser, uffparser, onnxparser, etc. But when we use these parsers, we often run into some "unsupported operations or layers" problems, especially some state-of-the-art models are using new type of layers.

So why don't we just skip all parsers? We just use TensorRT network definition APIs to build the whole network, it's not so complicated.

I wrote this project to get familiar with tensorrt API, and also to share and learn from the community.

All the models are implemented in pytorch first, and export a weights file xxx.wts, and then use tensorrt to load weights, define network and do inference. Some pytorch implementations can be found in my repo [Pytorchx](https://github.com/wang-xinyu/pytorchx), the remaining are from polular open-source pytorch implementations.

## Getting Started

There is a guide for quickly getting started, taking lenet5 as a demo. [Getting_Started.](./getting_started)

## Test Environment

1. Jetson TX1 / Ubuntu16.04 / cuda9.0 / cudnn7.1.5 / tensorrt4.0.2 / nvinfer4.1.3 / opencv3.3

2. GTX1080 / Ubuntu16.04 / cuda10.0 / cudnn7.6.5 / tensorrt7.0.0 / nvinfer7.0.0 / opencv3.3

Currently, TX1/TX2 and x86 GTX1080 were tested. trt4 api were using, some APIs are deprecated in trt7, but still can compile successfully.

## How to run

Each folder has a readme inside, which explains how to run the models inside.

## Models

Following models are implemented.

|Name | Description |
|-|-|
|[lenet](./lenet) | the simplest, as a "hello world" of this project |
|[alexnet](./alexnet)| easy to implement, all layers are supported in tensorrt |
|[googlenet](./googlenet)| GoogLeNet (Inception v1) |
|[inception](./inceptionv3)| Inception v3 |
|[mnasnet](./mnasnet)| MNASNet with depth multiplier of 0.5 from the paper |
|[mobilenetv2](./mobilenetv2)| MobileNet V2 |
|[mobilenetv3](./mobilenetv3)| V3-small, V3-large. |
|[resnet](./resnet)| resnet-18, resnet-50 and resnext50-32x4d are implemented |
|[senet](./senet)| se-resnet50 |
|[shufflenet](./shufflenetv2)| ShuffleNetV2 with 0.5x output channels |
|[squeezenet](./squeezenet)| SqueezeNet 1.1 model |
|[vgg](./vgg)| VGG 11-layer model |
|[yolov3](./yolov3)| darknet-53, weights from yolov3 authors, pytorch implementation from [ayooshkathuria/pytorch-yolo-v3](https://github.com/ayooshkathuria/pytorch-yolo-v3) |
|[yolov3-spp](./yolov3-spp)| darknet-53, weights from [ultralytics/yolov3](https://github.com/ultralytics/yolov3) |
|[yolov4](./yolov4)| CSPDarknet53, weights from [AlexeyAB/darknet](https://github.com/AlexeyAB/darknet#pre-trained-models), pytorch implementation from [ultralytics/yolov3](https://github.com/ultralytics/yolov3) |
|[retinaface](./retinaface)| resnet-50, weights from [biubug6/Pytorch_Retinaface](https://github.com/biubug6/Pytorch_Retinaface) |

## Tricky Operations

Some tricky operations encountered in these models, already solved, but might have better solutions.

|Name | Description |
|-|-|
|BatchNorm| Implement by a scale layer, used in resnet, googlenet, mobilenet, etc. |
|MaxPool2d(ceil_mode=True)| use a padding layer before maxpool to solve ceil_mode=True, see googlenet. |
|average pool with padding| use setAverageCountExcludesPadding() when necessary, see inception. |
|relu6| use `Relu6(x) = Relu(x) - Relu(x-6)`, see mobilenet. |
|torch.chunk()| implement the 'chunk(2, dim=C)' by tensorrt plugin, see shufflenet. |
|channel shuffle| use two shuffle layers to implement `channel_shuffle`, see shufflenet. |
|adaptive pool| use fixed input dimension, and use regular average pooling, see shufflenet. |
|leaky relu| I wrote a leaky relu plugin, but PRelu in `NvInferPlugin.h` can be used, see yolov3. |
|yolo layer v1| yolo layer is implemented as a plugin, see yolov3. |
|yolo layer v2| three yolo layers implemented in one plugin, see yolov3-spp. |
|upsample| replaced by a deconvolution layer, see yolov3. |
|hsigmoid| hard sigmoid is implemented as a plugin, hsigmoid and hswish are used in mobilenetv3 |
|retinaface output decode| implement a plugin to decode bbox, confidence and landmarks, see retinaface. |
|mish| mish activation is implemented as a plugin, mish is used in yolov4 |

## Speed Benchmark

| Models | Device | BatchSize | Mode | Input Shape(HxW) | FPS |
|-|-|:-:|:-:|:-:|:-:|
| YOLOv3(darknet53) | Xavier | 1 | FP16 | 320x320 | 55 |
| YOLOv3-spp(darknet53) | Xeon E5-2620/GTX1080 | 1 | FP32 | 256x416 | 94 |
| YOLOv4(CSPDarknet53) | Xeon E5-2620/GTX1080 | 1 | FP32 | 256x416 | 59 |
| YOLOv4(CSPDarknet53) | Xeon E5-2620/GTX1080 | 4 | FP32 | 256x416 | 74 |
| YOLOv4(CSPDarknet53) | Xeon E5-2620/GTX1080 | 8 | FP32 | 256x416 | 83 |
| RetinaFace(resnet50) | TX2 | 1 | FP16 | 384x640 | 15 |
| RetinaFace(resnet50) | Xeon E5-2620/GTX1080 | 1 | FP32 | 928x1600 | 15 |

Detection net FPS test including inference and nms time, excluding image preprocess time.

Help wanted, if you got speed results, please add an issue or PR.

Thanks @Kmarconi for yolov3(darknet53) speed test.

## Acknowledgments & Contact

Currently, This repo is funded by Alleyes-THU AI Lab([aboutus in Chinese](http://www.alleyes.com.cn/aboutus.html)). We are based in Tsinghua University, Beijing, and seeking for talented interns for CV R&D. Contact me if you are interested.

Any contributions, questions and discussions are welcomed, contact me by following info.

E-mail<EMAIL_ADDRESS>
WeChat ID: wangxinyu0375

repository: cayek/tensorrtx

gha_license_id: MIT

repo_name: cayek/tensorrtx


text:
# CustomUnitRanges

[![Build Status](https://travis-ci.org/JuliaArrays/CustomUnitRanges.jl.svg?branch=master)](https://travis-ci.org/JuliaArrays/CustomUnitRanges.jl)

[![codecov.io](http://codecov.io/github/JuliaArrays/CustomUnitRanges.jl/coverage.svg?branch=master)](http://codecov.io/github/JuliaArrays/CustomUnitRanges.jl?branch=master)

This Julia package supports the creation of array types with
"unconventional" indices, i.e., when the indices may not start at 1.
With this package, each custom array type can have a corresponding
`axes` range type, consequently providing a means for consistency
in allocation by `similar`.

See https://docs.julialang.org/en/v1/devdocs/offset-arrays/ for
more information about defining and using array types with non-1
indices.

# What's in this package

Currently this package defines two `AbstractUnitRange` types:

- `ZeroRange`, where `ZeroRange(n)` is the equivalent of `0:n-1`, except that
  Julia's type system knows that the lower bound is 0. (This is
  analogous to `Base`'s `OneTo` type.) This is useful for defining
  arrays that are indexed starting with 0.

- `URange`, a parallel to `UnitRange`, for defining arbitrary range indices.

# Usage

This package has a somewhat atypical usage: you should `include` files
from this repository at the source level. The reason is that this
package's range types should be **private** to the module that needs
them; consequently you don't want to define a module in the global
namespace.

Instead, suppose you're defining an array type that supports arbitrary
indices. In broad terms, your module might look like this:

```julia
module MyArrayType

using CustomUnitRanges: filename_for_urange
include(filename_for_urange)

struct MyArray{T,N} <: AbstractArray{T,N}
    ...
end

Base.axes(A::MyArray) = Base.Slice.(map(URange, #=starting indices=#, #=ending indices=#))

...

end
```

Here,
```
using CustomUnitRanges: filename_for_urange
```

brings a non-exported string, `filename_for_urange`, into the scope of
`MyArrayType`. The key line is the `include(filename_for_urange)`
statement, which will load (at source-level) the code for the `URange`
type into your `MyArrayType` module.  We chose `"URange.jl"` because
here we want arbitrary indices; had we wanted zero-based indices, we
would have chosen `"ZeroRange.jl"` instead. Second, note that the
output of `axes` is a `Slice` containing a `URange` type. More specifically, it's
creating a tuple of slices with `MyArrayType.URange`---there is no "global"
`URange` type, so the indices-tuple is therefore *specific to this
package*.

The important result is that two packages, defining `MyArray` and
`OtherArray`, can independently exploit `URange`.  If `MyArrayType`
includes the specialization

```jl
function Base.similar(f::Union{Type,Function}, shape::Tuple{URange,Vararg{URange}}
    MyArray(f(map(length, shape)), #=something for the offset=#)
end
```

and similarly for `OtherArrayType`. Then, if `A` is a `MyArray` and
`B` is an `OtherArray`,

- `similar(Array{Int}, axes(A))` will create another `MyArray`
- `similar(Array{Int}, axes(B))` will create another `OtherArray`

despite the fact that they both use `URange`.

gha_language: Julia

gha_license_id: NOASSERTION


text:
#Charles by the grace of God King of England, Scotland, France and Ireland, Defender of the Faith,&c. To all parsons, vicars and curates, and also to all justices of the peace, majors, shreiffes, bailiffes, constables, church-wardens, headburroughs, and to all officers of cities, burroughs and townes corporate, and to all others, our officers, ministers, and subjects whatsoever they be,... that the upper town of Bridgnorth aforesaid, was set on fire, within a few days after, the forces raised by the said Lords and Commons under the command of the said Committee of safety for the said county had entered the said towne,...#

##England and Wales. Sovereign (1625-1649 : Charles I)##
Charles by the grace of God King of England, Scotland, France and Ireland, Defender of the Faith,&c. To all parsons, vicars and curates, and also to all justices of the peace, majors, shreiffes, bailiffes, constables, church-wardens, headburroughs, and to all officers of cities, burroughs and townes corporate, and to all others, our officers, ministers, and subjects whatsoever they be,... that the upper town of Bridgnorth aforesaid, was set on fire, within a few days after, the forces raised by the said Lords and Commons under the command of the said Committee of safety for the said county had entered the said towne,...
England and Wales. Sovereign (1625-1649 : Charles I)

##General Summary##

**Links**

[TCP catalogue](http://www.ota.ox.ac.uk/tcp/)  •
[HTML](http://tei.it.ox.ac.uk/tcp/Texts-HTML/free/B19/B19233.html)  •
[EPUB](http://tei.it.ox.ac.uk/tcp/Texts-EPUB/free/B19/B19233.epub) •
[Page images (Historical Texts)](https://historicaltexts.jisc.ac.uk/eebo-99888954e)

**Availability**

This keyboarded and encoded edition of the work described above is co-owned by the
    institutions providing financial support to the Early English Books Online Text Creation
    Partnership. This text is available for reuse, according to the terms of  Creative Commons 0 1.0 Universal
    licence. The text can be copied, modified, distributed and performed, even for commercial
    purposes, all without asking permission.

**Major revisions**

1. __2014-02 __ __SPi Global__ *Keyed and coded from ProQuest page images *
1. __2014-08 __ __Colm MacCrossan __ *Sampled and proofread *
1. __2014-08 __ __Colm MacCrossan__ *Text and markup reviewed and edited *
1. __2015-03 __ __pfs__ *Batch review (QC) and XML conversion *
1. __2021-05 __ __lb__ *TEI P5 conversion *

##Content Summary##

#####Body#####

1. crowned blazon or coat of arms of Charles IIC. R.DIEV ET MON DROITHONI SOIT QVI MAL Y PENSE

**Types of content**

  * Oh, Mr. Jourdain, there is **prose** in there!

**Character listing**

|Text|string(s)|codepoint(s)|
|---|---|---|
|General Punctuation|—|8212|

##Tag Usage Summary##

###Header Tag Usage###

|No|element name|occ|attributes|
|---|---|---|---|
|1.|__author__|4||
|2.|__availability__|1||
|3.|__biblFull__|1||
|4.|__change__|5||
|5.|__date__|7| @__when__ (1) : 2016-02 (1)|
|6.|__editorialDecl__|1||
|7.|__encodingDesc__|1||
|8.|__extent__|2||
|9.|__fileDesc__|1||
|10.|__idno__|8| @__type__ (8) : DLPS (1), EEBO-CITATION (1), VID (1), EEBO-PROQUEST (1), STC (3), PROQUEST (1)|
|11.|__keywords__|1| @__scheme__ (1) : http://authorities.loc.gov/ (1)|
|12.|__label__|5||
|13.|__langUsage__|1||
|14.|__language__|1| @__ident__ (1) : eng (1)|
|15.|__listPrefixDef__|1||
|16.|__note__|6||
|17.|__notesStmt__|2||
|18.|__p__|11||
|19.|__prefixDef__|2| @__ident__ (2) : tcp (1), char (1)  •  @__matchPattern__ (2) : ([0-9\-]+):([0-9IVX]+) (1), (.+) (1)  •  @__replacementPattern__ (2) : http://eebo.chadwyck.com/downloadtiff?vid=$1&page=$2 (1), https://raw.githubusercontent.com/textcreationpartnership/Texts/master/tcpchars.xml#$1 (1)|
|20.|__profileDesc__|1||
|21.|__projectDesc__|1||
|22.|__pubPlace__|2||
|23.|__publicationStmt__|2||
|24.|__publisher__|2||
|25.|__ref__|4| @__target__ (4) : https://creativecommons.org/publicdomain/zero/1.0/ (1), http://www.textcreationpartnership.org/docs/. (1), https://textcreationpartnership.org/faq/#faq05 (1), https://github.com/textcreationpartnership (1)|
|26.|__relatedItem__|1| @__type__ (1) : facs (1)  •  @__target__ (1) : https://data.historicaltexts.jisc.ac.uk/view?pubId=eebo-99888954e (1)|
|27.|__revisionDesc__|1||
|28.|__seriesStmt__|1||
|29.|__sourceDesc__|1||
|30.|__term__|3| @__type__ (3) : topical_term (1), geographic_name (2)|
|31.|__textClass__|1||
|32.|__title__|3||
|33.|__titleStmt__|2||

###Text Tag Usage###

|No|element name|occ|attributes|
|---|---|---|---|
|1.|__body__|1||
|2.|__closer__|1||
|3.|__date__|1||
|4.|__dateline__|1||
|5.|__div__|1| @__type__ (1) : proclamation (1)|
|6.|__figDesc__|1||
|7.|__figure__|1||
|8.|__g__|9| @__ref__ (9) : char:EOLhyphen (9)|
|9.|__head__|2| @__type__ (1) : illustration (1)|
|10.|__hi__|18||
|11.|__opener__|1||
|12.|__p__|1||
|13.|__pb__|1| @__facs__ (1) : tcp:194020:1 (1)|
|14.|__q__|2||
|15.|__salute__|1||
|16.|__seg__|1| @__rend__ (1) : decorInit (1)|
|17.|__signed__|1||


text:
YCSB-C
======

Yahoo! Cloud Serving Benchmark in C++, a C++ version of YCSB (https://github.com/brianfrankcooper/YCSB/wiki)

pre-requisite: libtbb-dev
Dynamically linked libtbb-dev

For hyperdex support, check out the website for installation http://hyperdex.org
	Clients: install libhyperdex-client-dev-warp, python-hyperdex-client-warp
	Server: install hyperdex-warp

	To start hyperdex servers, follow the steps here
	1. start coordinator at server1
		hyperdex coordinator -f -l <IP_ADDRESS> -p 7777 &> hyperdex.coord &
	2. start all daemons in all servers
		hyperdex daemon -f --listen=<IP_ADDRESS> --listen-port=7776 --coordinator=<IP_ADDRESS> --coordinator-port=7777 --data=./hyperdex.db &> hyperdex.daemon &
	3. initialize database
		3.1 Add space "ning" using python in coordinator
				import hyperdex.admin
				a = hyperdex.admin.Admin('<IP_ADDRESS>', 7777)
				a.add_space('''
  					space ning
  					key keystr
  					attributes value
  					''')
		3.2 create hashkey file by running HashGenerator.cc program
				./a.out > hashkeys
		3.3 Run InitializeHyperdex.py and feed it with hashkey file
				python InitializeHyperdex.py hashkeys

Build
1. Build the project
	make
2. Build unit tests
	make unit
3. Run unit tests
	./Test/UnitTest/test

Maintained by Ning Gao
University of Colorado Boulder


text:
# Cask for Alfred

Manage [casks](https://github.com/phinze/homebrew-cask) with [Alfred](http://www.alfredapp.com) like a boss.

![Screenshot of "Cask for Alfred"](screenshot.png)

[Download](Cask.alfredworkflow?raw=true)

repository: pstadler/alfred-cask

gha_language: Shell

repo_name: pstadler/alfred-cask


text:
Benchmark Sample
===================================

This sample project shows how to use the Jetpack Benchmark library.

It includes multiple simple benchmark samples:

* [AutoBoxingBenchmark](benchmark/src/androidTest/java/com/example/benchmark/AutoBoxingBenchmark.kt)
measures the cost of allocating Integer() objects.

* [BitmapBenchmark](benchmark/src/androidTest/java/com/example/benchmark/BitmapBenchmark.kt)
measures the cost of accessing Bitmap pixels, showing the overhead of many JNI
calls versus one in the underlying Android platform code.

As well as one more complex UI benchmark:

* [RecyclerViewBenchmark](benchmark/src/androidTest/java/com/example/benchmark/RecyclerViewBenchmark.kt)
measures the cost of scrolling a RecyclerView UI defined in another UI library
module.

### Running

Open the project in Android Studio 3.4 or later, and run benchmarks as you
usually would run tests: Ctrl-Shift-F10 (Mac: Ctrl-Shift-R)

### Locking Clocks

If you have a rooted device you can benchmark on, use `./gradlew lockClocks` to
lock the CPU clocks of the device to stable values. To unlock clocks, use
`./gradlew unlockClocks`, or reboot your device. This feature is provided by the
`androidx.benchmark` gradle plugin.

License
-------

Copyright 2019 The Android Open Source Project, Inc.

Licensed to the Apache Software Foundation (ASF) under one or more contributor
license agreements.  See the NOTICE file distributed with this work for
additional information regarding copyright ownership.  The ASF licenses this
file to you 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: nyctonio/performance-samples

repo_name: nyctonio/performance-samples


text:
# Design decisions
1. regexes alone were found to be unreliable or even buggy for performing replacements,
particularly where leading whitespace is present. To mitigate this, the tool:
    - tracks start and end of non-whitespace on a given line
    - attempts the regex substitution within only the non-whitespace content
    - finally, substitutes that replacement back into the line, retaining existing whitespace
2. in-line replacement was chosen over parsing/comprehending the file format
 as many parsers lose comments and file structure in doing so, which would be
 unacceptable for this project. It should leave the files exactly as found,
 just with a different version number (or other explicitly designated variable).

repository: ARMmbed/autoversion

gha_language: Python

repo_name: ARMmbed/autoversion


text:
# Doubly linked list

# A doubly linked list is a collection of nodes where each node has three properties:
1. val -> value of the list item.
2. next -> reference to the next list item.
3. prev -> reference to the previous list item.

# A doubly linked list has to maintain the following:
1. A head pointer: Refers to the first item in the list. It is necessary to have the head pointer for a doubly linked list.
2. A length variable: Specifies the number of elements in the list. On initializing an empty new list, length is zero.
3. A tail pointer: Refers to last element in the list. It is necessary to have the tail pointer for a doubly linked list.

# Time complexities:
1. Insertion: O(1)
2. Deletion: O(1)
3. Search: O(n)
4. Access: O(n)

# Comparison with array
# 1. Insertion
For insertion, doubly linked list are either similar or better than arrays, since if we insert at the beginning, or end, doubly linked list has a time complexity of O(1), whereas arrays only have time complexity of O(1) when pushing to the end, not at the beginning.
# 2. Deletion/Removal
For deletion, doubly linked list are either similar or better than arrays, since if we insert at the beginning, or end, doubly linked list has a time complexity of O(1), whereas arrays only have time complexity of O(1) when deleting the last element, not the first.
# 3. Accessing elements at index
Arrays have a constant time complexity with accessing the elements due to each element having specific index, so they are better than doubly linked list in that aspect.
# 4. Searching for specific element (value)
Arrays also a O(n) time complexity for searching an elements of particular value, so they are the same as doubly linked list in that aspect.

path: /5) doubly-linked-list/README.md

gha_language: JavaScript


text:
## Current route info
From every child component you can access current
route state. There are two ways to do this:

### 1. useCurrentRoute hook
In any component wrapped with `<EasyrouteProvider>`,
on any level of nesting, you can use `useCurrentRoute`
hook. It is a custom implementation of Observable
pattern, so you can "subscribe" to current route
object. It goes like this:

```html
<script>
    // Component.svelte

    import { useCurrentRoute } from "svelte-easyroute"
    import { onDestroy } from "svelte"

    const unsubscribe = useCurrentRoute((currentRoute) => {
        console.log(currentRoute)
    })

    onDestroy(unsubscribe)
</script>
```
**Don't forget** to `unsibscribe` when leaving your component!
If you will not, it can cause memory leak.

### 2. Export variable in outlet's child component
> **Warning!** This is a deprecated method and will be removed in version 3.1.0.
> I recommend that you use the useCurrentRoute hook as it is more reliable and available within the entire application.

If your component is direct child of `<RouterOutlet>`,
ust put in the <script> tag:
```javascript
export let currentRoute
```
That's it!

#### Example:
```javascript
{
  "fullPath": "/test/value?name=Alex&age=23",
  "params": {
    "param1": "value"
  },
  "query": {
    "name": "Alex",
    "age": "23"
  },
  "meta": {
    "pageTitle": "Title!"
  }
}
```

repository: fabien/svelte-easyroute

repo_name: fabien/svelte-easyroute


text:
# HotSwap
Code hotswapping utility for the RimWorld game

Thanks to Pardeike for making [Harmony](https://github.com/pardeike/Harmony)

repository: notfood/RimWorld-HotSwap

repo_name: notfood/RimWorld-HotSwap


text:
## [Unreleased]
  - Fixed an issue in which users would receive an error message for missing SEC headers.

## [19.8.0] - 2019-08-06
  - Fixed an issue in which the fetch incidents function would fail when there were non-ASCII characters in the data.
  - Fixed an issue in which the fetch incidents function would ignore the filter if the maximum number of offenses set in the instance configuration were fetched in a single fetch.
  - Improved error messages for fetch-incidents.
  - Added the *Required Permissions* information in the detailed description section.


text:
# Fuzziac

A utility for on-line approximate string matching

Fuzziac.js is Javascript class for on-line approximate string matching. It was originally intended for use with auto-complete, but it's really just a plain Javascript class, so use it as you see fit.

This is started as a research project for an undergraduate algorithms class which I took way back in 2011. We had to complete a term project on an algorithm, and Dr. Duan made dynamic programming look cool, so I though I would look for an application of dynamic programming outside the realm of DNA sequencing.

If you would like to know the full story on how I came to develop this solution you can read the post I wrote about the [history of fuzziac.js](http://christopherstoll.org/2014/01/24/fuzziac-javascript-string-matching.html), or you can read my [original research paper](analysis/2011-11_FinalProjectReport.pdf).

## Installation

To use fuzziac in your Node app:

### npm

```bash
npm install --save fuzziac
```

### yarn

```bash
yarn add fuzziac
```

## Usage

### Calculate the Match Score of Two Strings

```javascript
const Fuzziac = require('fuzziac');
const fuzziac = new Fuzziac()
fuzziac.score("Joe", "Moe")
```

### Find the Best Matches from an Array

```javascript
const Fuzziac = require('fuzziac');
const fuzziac = new Fuzziac([
    "Larry",
    "Curly",
    "Moe"
], false)
const searchResults = fuzziac.search("Joe");
```

### Search Sessions

Fuzziac is best when it is used with an automcomplete for a large dataset, but it operates in linear time (something like O(nm)). So, large datasets could mean unacceptably long runtimes. One way to improve performance is to progressively reduce the size of the dataset as subsequent searches are performed. To enable this behavior a session is started after the first string longer than 2 characters is searched for. When the search session is over it must be manually closed. From a practical perspective, when a user is typing into a search box the resulting strings should be passed to Fuzziac, and when the user selects the result they want the Fuzziac search should be closed.

```javascript
const Fuzziac = require('fuzziac');
const fuzziac = new Fuzziac([
    "Larry",
    "Curly",
    "Moe"
])

let searchResults = [];

// for "J" the entire dataset is searched
searchResults = fuzziac.search("J")
// [ 'Curly', 'Larry' ]

// for "Jo" the entire dataset is searched
searchResults = fuzziac.search("Jo")
// [ 'Moe' ]

// for "Joe" the dataset filtered by "Jo" is searched
searchResults = fuzziac.search("Joe")
// [ 'Moe' ]

fuzziac.closeSearchSession();

// now for "Joe" the entire dataset is searched
searchResults = fuzziac.search("Joe")
// [ 'Moe', 'Curly', 'Larry' ]
```


text:
You’ll need an operation to fix a hernia.

You may not need an operation straight away. Your hernia won’t get better
without surgery, but it doesn’t always get worse. You can discuss with your
doctor whether or not you need surgery. They’ll consider:

* the type of hernia you have - some are more prone to complications
* if your hernia is causing problems, such as pain
* your health - surgery may be a risk in some cases

repository: nhsuk/betahealth

branch_name: refs/heads/develop

repo_name: nhsuk/betahealth


text:
# Resource order item Data Model

## Domain

The  schema is part of the  Domain

## Description

An identified part of the order. A resource order is decomposed into one or more order items.

## Data model

A JSON Schema corresponding to this data model can be found
[here](https://github.com/tmforum-rand/schemas/blob/candidates/Resource/ResourceOrderItem.schema.json).

The Data model is defined as shown below:

- `action` : Can be "add" / "modify" / "no_change"/ "delete"

  - Optional

- `id` : Identifier of the line item (generally it is a sequence number 01, 02, 03, ...)

  - Optional

- `quantity` : Quantity ordered

  - Optional

- `state` : State of the order item : described in the state machine diagram

  - Optional

## TMForum APIs that use this schema

Taking into consideration the snapshot of 04/02/2020 04:59:17 UTC the list of [TMForum Open APIs](https://www.tmforum.org/open-apis/) that uses this schemas is:

Coming soon

repository: tmforum/DataModelDocumentation

repo_name: tmforum/DataModelDocumentation


text:
# TransactionMail
Transactional Email Service

[![Build Status](https://travis-ci.org/guyradford/TransactionMail.svg?branch=master)](https://travis-ci.org/guyradford/transactionMail) [![Coverage Status](https://coveralls.io/repos/github/guyradford/transactionMail/badge.svg?branch=master)](https://coveralls.io/github/guyradford/transactionMail?branch=master)

##Feature Table

|          | Void | Mandrill | SendInBlue | AmazonSES |
|---------:|:----:|:--------:|:----------:|:---------:|
| Template |  Yes |    Yes   |      Yes   |     No    |
|          |      |          |            |           |
|          |      |          |            |           |

##SendInBlue

https://apidocs.sendinblue.com/tutorial-sending-transactional-email/

```
$mailin = new Mailin("https://api.sendinblue.com/v2.0","your access key");
$adapter = new SendInBlue($mailin);
$transationMail = new TransactionMail($adapter);

$email = (new EmailTemplatedMessage())
<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>    ->setSubject('Special Offer') // see note 1
    ->addMergeField('firstname', 'John') // see note 2
    ->addHeader('Content-Type', 'text/html;charset=iso-8859-1');

$response = $transationMail->sendTemplate($email);

```

Notes
---

1) Subject is passed to SendInBlue as an attribute called 'SUBJECT'. A merge field with the same name will overwrite this.
2) the case of the field name does not matter but will be changed to UPPER before being sent to SendInBlue.

##Mandril

https://mandrillapp.com/api/docs/messages.php.html

```
$mandrill = new Mandrill('YOUR_API_KEY');
$adapter = new SendInBlue($mandrill);
$transatioMail = new TransactionMail($adapter);

##Inspired By

https://github.com/gabrielbull/omnimail

repository: guyradford/transactiomail

repo_name: guyradford/transactiomail


text:
[<- readme](../README.md)

# Installation

## Prerequisites

- **Xilution Account(s)** -
  The Xilution CLI interfaces with the Xilution API.
  Most Xilution API endpoints require a Xilution Account to function properly.
  Furthermore, many Xilution API endpoints require Xilution Product activation.
  You can create a Xilution account through our [Registration](https://register.xilution.com) site.
  Once registered, some API endpoints will require activation.
  You can active Xilution products through our [Account Admin Portal](https://portal.xilution.com).
- **Node.js** -
  The Xilution CLI requires Node.js version 10.16.3 or newer to be installed on your system.
  We recommend using the [Node Version Manager (NVM)](https://github.com/nvm-sh/nvm) to manage your Node.js installation(s).
  See the NVM site for installation instructions.

## Install

- To install the latest version of the Xilution CLI, run `npm install -g @xilution/xilution-cli@latest`.

- To install the Xilution CLI to a specific version, run `npm install -g @xilution/xilution-cli@{version}`.
  For example, run `npm install -g<EMAIL_ADDRESS>to install to version 1.3.0.

## Verify

- To verify your installation, run `xln-cli --version`.

## Configure

- Once you have installed the Xilution CLI, you will want to set up your configuration.
  See [Config](./config.md) for Xilution CLI configuration details.

## Upgrade

- To upgrade the Xilution CLI to the latest version, run `npm update -g @xilution/xilution-cli@latest`.

The Xilution CLI changes frequently as we add more and more products to [our portfolio of APIs](https://products.xilution.com).
If your version of the CLI does not include something you expect, try upgrading.
If after upgrading, if your version still doesn't meet your expectations, send an email to [support<EMAIL_ADDRESS>and let us know.
See [our releases](https://github.com/xilution/xilution-cli/releases) for the latest and older versions of the Xilution CLI.

## Uninstall

- To uninstall the Xilution CLI, run `npm install -g @xilution/xilution-cli`.

---

Copyright 2019-2021 Teapot, LLC.
Xilution is a DBA of Teapot, LLC.

repository: xilution/xilution-cli

repo_name: xilution/xilution-cli


text:
---
title: "Telemedicine"
description: "Telemedicine Best Practices"
lead: "coming soon..."
date: 2021-09-13T14:00:00.000Z
lastmod: 2021-09-13T14:00:00.000Z
draft: true
contributors: ["Soichi Hayashi"]
menu:
  bplp:
    parent: "bp"
weight: 220
toc: true
---

> Who is this for? I'd like to target end-users, everyday people. hospital / clinic picks e-health vendor / technologies and patient doesn't have much say in that.. but we can catalog different hostpitals / clinics and show if (and which?) telemedicine capabilities are offered .. so they can pick which clinic to use? (do they have options?)

>

Telehealth (also called e-health or mobile-health) is a broader terminology used to describe not just patient and doctor interaction but cases such as doctors exchanging medical information between them, or augmenting capabilities of a clinic by connecting patients to doctors else where.

e-health is essentially the use of communication technologies and data transfer for the delivery of remote healthcare.

# Technologies

Telehealth is the use of digital information and communication technologies, such as computers and mobile devices, to access health care services remotely and manage your health care.

* Make health care accessible to people who live in rural or isolated communities.
* Make services more readily available or convenient for people with limited mobility, time or transportation options.
* Provide access to medical specialists.
* Improve communication and coordination of care among members of a health care team and a patient.
* Provide support for self-management of health care.

Technology has the potential to improve the quality of health care and to make it accessible to more people. Telehealth may provide opportunities to make health care more efficient, better coordinated and closer to home.

Research about telehealth is still relatively new, but it's growing. For example, studies have shown that both telephone-based support and telemonitoring of vital signs of people with heart failure reduced the risk of death and hospitalization for heart failure and improved quality of life.

## On-site Kiosks / Patient Portal

Some telehealth providers offer on-site telehealth kiosks that can be placed in a retail clinic, community center, or job site.
Your primary care clinic may have an online patient portal.

Capabilities are..

* Communicate with your doctor or a nurse through computer interface.
* may provide a single point of communication for any specialists you may see.
* More secure than phone / email with pre-configured (convenient / tested) connection.
* Request prescription refills.
* Review test results and summaries of previous visits.
* Schedule appointments or request appointment reminders.
* May equipped with medical monitoring devices (to take vital signs, for example)

## Virtual Appointment

* Enable you to see your doctor or a nurse virtually to receive ongoing care from your regular doctor when an in-person visit isn't required or possible.

>? Remote assistance for teleconsultations, diagnosis, follow-up checks and continuous treatment plans

## Web-based "Visits"

* These services are generally for minor illnesses, similar to the services available at a drop-in clinic. Some large companies provide access to virtual doctors' offices as a part of their health care offerings. When you log into a web-based service, you are guided through a series of questions. The doctor or nurse practitioner can prescribe medications, suggest home care strategies or recommend additional medical care.
* Similarly, a nursing call center is staffed with nurses who use a question-and-answer format to provide advice for care at home. A nursing call center doesn't diagnose an illness or prescribe medications.
* Websites like WebMD and Mayoclinic have turned the internet into an online medical encyclopedia, a place to get information on health conditions. With a simple wi-fi connection, people can look-up medical symptoms, take a public health course, join an online support chat group, or even chat with a medical professional.

## Remote Monitoring

Telemonitoring services facilitate continued care of patients at home. This reduces hospital stays and also provides them more control over the management of their diseases.

A variety of technologies enable your doctor or health care team to monitor your health remotely. These technologies include:

* Web-based or mobile apps for uploading information, such as blood glucose readings, to your doctor or health care team

* Devices that measure and wirelessly transmit information, such as blood pressure, blood glucose or lung function. Some of these devices can also assist in prediction of impending diseases based on the overall health of the user. Wearable devices that automatically record and transmit information, such as heart rate, blood glucose, gait, posture control, tremors, physical activity or sleep patterns

* Hospitals may install IoT sensors on wheelchairs, nebulizers, defibrillators and other medical equipment so that these can be tracked in real time. The location of medical practitioners associated with the hospital can also be monitored this way.

* Home monitoring devices for older people or people with dementia that detect changes in normal activities such as falls

* Cloud application – The data collected by healthcare devices may be sent to an IoT cloud platform from where the information is consolidated by the healthcare provider. This data can subsequently be transmitted to IoT applications used by healthcare facilities for patient monitoring purposes. This information yields valuable insights for the future treatment of patients.

## Doctors talking to doctors

Doctors can also take advantage of technology to provide better care for their patients. One example is a virtual consultation that allows primary care doctors to get input from specialists when they have questions about your diagnosis or treatment.

The primary care doctor sends exam notes, history, test results, X-rays or other images to the specialist to review. The specialist may respond electronically, conduct a virtual appointment with you at your doctor's office, or request a face-to-face meeting.

These virtual consultations may prevent unnecessary in-person referrals to a specialist, reduce wait times for specialist input and eliminate unnecessary travel.
## Hospital administrative services

such as laboratory testing, billing, resolution of issues, etc.

## Personal Health Records (PHR)

An electronic personal health record system — often called a PHR system — is a collection of information about your health that you control and maintain. A PHR app is accessible to you anytime via a web-enabled device, such as your computer, laptop, tablet or smartphone.

In an emergency, a personal health record can quickly give emergency personnel vital information, such as current diagnoses, medications, drug allergies and your doctor's contact information.

## Mobile App

Mobile health apps can be as sophisticated as tracking and reporting a patient’s health information to their healthcare provider, to as simple as providing daily health education tips.

* Store personal health information to track their weight, monitor their sleep patterns, record vital signs, Calculate and track caloric intake. Record physical activity, such as your daily step count.
* see a on-call doctor remotely via 2-way video,
* learn about an illness,
* get tips for preventing infection
* get medication reminder text messages, Schedule reminders for taking medicine.
* stay connected to an online support group

## Telephone

Many healthcare providers use the phone to consult with other specialists on patient cases, discuss medication requirements with a pharmacist, and even provide a diagnosis to a patient in urgent cases (sometimes called teletriage).

## Secure Email

With the recent adoption of patient portals and electronic health records, more healthcare providers and patients are using secure email messaging systems to communicate about lab results and their medical conditions.

## Risks of Telehealth

* could fragment health care and create gasp in care, inappropriate/unnecessary use of medications.
* benefit by limited by patient's ability to pay; insurance reimbursement for telehealth still varies by state and type of insurance.
* care maybe limited because of regional internet availability or cost of mobile devices.

## Robotics

* **Telehealth Robots** Robotics in healthcare can assist in remote patient monitoring and allow specialists to consult on cases in rural hospitals. For example, autonomous telehealth robots can navigate to patients in exam or hospital rooms, allowing clinicians to interact with patients from afar.

## Companies

**eVisit** telehealth platform connects healthcare providers with their existing patients through secure, high-resolution video — in real-time.  https://evisit.com/

## Considerations for Telemedicine deployment

The most important to consider

* cost
* sustainability
* scalability
* HIPPA-compliance (with existing technologies - not by itself); data encryption, login control, auditing capability.

TM are commonly used for ...

## 1. Remote Monitoring

Patient monitoring/population health management platforms focus on taking periodic, biomedical measurements from the
patients on a tablet, smartphone, or computer web browser, often with the aid of very low cost, basic medical devices like
blood pressure cuffs, thermometers, and digital scales

## 2. Consultative Visits

Consultative visits involve both sides of a conversation being present by video after which an opinion is offered. This type of visit can be divided into teleconsultation in which one clinician consults with another clinician regarding a patient [5] or direct to consumer in which a clinician provides medical advice to a patient.

No diagnostic tools are used during the visit.

Technologies

* Polycom,
* Cisco,
* Vidyo,
* Zoom
* etc..

Most video conferencing services offer business agreements that allow the service to be used in health care where HIPPA is a concern. An advantage of these types of systems is that they can do double duty if your organization needs to use video conferencing for administrative or business purposes in addition to the telemedicine program.

## Direct to consumer (DTC)

Direct to consumer TM is a quickly growing segment of the industry. These platforms offer apps that the patient can download to their smart devices or use on a home PC to schedule and have appointments directly. Many of the platforms also offer the ability to schedule visits.

Companies

* American Well,
* TelaDoc,
* MDLIVE,
* Doctor on Demand.

## 3. Facilitated Visits / Provider Access Software (PAS)

For visits that require a physical exam, it is necessary to use a platform that integrates Medical Devices into the live visit. During a visit that requires a physical exam, it is necessary for a facilitator or clinician to be with the patient to operate the medical devices

These platforms allow integration of class 1 (devices that have a low to moderate risk to the patient and/or user) and sometimes class 2 (devices that have a moderate to high risk to the patient and/or user) medical devices into the live video stream.

These platforms aim to increase access to convenience or frequency of diagnostic, specialty, or follow-up care and to reduce avoidable hospital readmissions.

Due to favorable CMS reimbursement policies regarding the types of places that can serve as “originating sites,” these platforms are most widely used in rural access hospitals, physician offices, federally qualified health centers, schools, corrections institutions, and skilled nursing facilities outside of metropolitan statistical areas (MSAs).

Companies

* AGNES by AMD Telemedicine,
* Intouch Health,
* Avizia telemedicine.

Many allergy practices use TM to perform facilitated virtual visits [9•]. A facilitated virtual visit requires the patient to travel to a medical facility, usually more conveniently located than where the provider is situated, where a healthcare professional assists with the visit.

The site where the patient is located is referred to as the “originating site.”

## Challenges

Stakeholder engagement – It is found that people are, more often than not, resistant to a change in the conventional mode of providing/obtaining healthcare services. The absence of an emotional bond formation between the healthcare expert and patient and unfamiliarity with the advancements in eHealth technology are some factors that contribute to this resistance.

Organizational limitations – In order to implement a telemedicine model, it is necessary to redesign the existing models in healthcare organizations. There may also be a need to redefine roles and responsibilities. Implementation costs and funding needs are other factors that fall under this category.

Technological factors – It is found that the lack of infrastructure and skills for managing the technology for telemedicine is a key barrier to its implementation. In this context, it is important for healthcare organizations to collaborate with a reliable IoT partner company with experience in the domain.

## Interstate licensing? Does it have emergency declarations?

## clinitians needed? equipment needed?

## Sources

* {{<cite "Baker 2018">}}
* https://www.mayoclinic.org/healthy-lifestyle/consumer-health/in-depth/telehealth/art-20044878
* https://evisit.com/resources/telehealth-telemedicine-technology/
* https://www.embitel.com/blog/embedded-blog/detailed-guide-on-enabling-telemedicine-through-iot

{{< bibliography cited >}}

repository: akferrara/tla

gha_language: HTML

repo_name: akferrara/tla


text:
This repo was built with examples from ff links:
* https://developers.eos.io/eosio-nodeos/docs/getting-the-code

* https://steemit.com/devs/@eos-asia/eos-smart-contracts-part-1-getting-started-ping-equivalent-in-eos

* https://medium.com/@TeaSea1/how-to-install-eos-on-windows-ac1b6c7d8369

# Instructions:

* this is not the only way to install an eos node and may be outdated by the time you read this. Do checkout other tutorials if you get stuck.
* For Windows (using Ubuntu CLI), create a directory in C://. The path for this directory in Ubuntu CLI is /mnt/c/<DirectoryName>.

### Setup EOS Node (follow: https://developers.eos.io/eosio-nodeos/docs/install-nodeos or https://medium.com/@TeaSea1/how-to-install-eos-on-windows-ac1b6c7d8369)

1. git clone https://github.com/EOSIO/eos --recursive

2. cd eos

3. ./eosio_build.sh

On Windows: ./eosio_build.sh ubuntu full

4. Validate Build

On Linux platforms:
~/opt/mongodb/bin/mongod -f ~/opt/mongodb/mongod.conf &

On MacOS:
/usr/local/bin/mongod -f /usr/local/etc/mongod.conf &

Followed by this on all platforms:
cd build
make test

5. Build nodeos (https://developers.eos.io/eosio-nodeos/docs/local-single-node-testnet)
cd build/programs/nodeos ./nodeos -e -p eosio --plugin eosio::chain_api_plugin --plugin eosio::history_api_plugin

### Clone EOS Spore contract, marvel at the code/get confused

7. Open new terminal

8. mkdir eos-contract

9. cd eos-contract

10. git clone https://github.com/MNLBlockDevs/eos-simplepacman-contract

11. cd eos-simplepacman-contract/eosspore/contracts

### Compile (generate ABI and WAST files)

12. eosiocpp -o ./spore/spore.wast spore.cpp

13. eosiocpp -g ./spore/spore.abi spore.cpp

### Create your wallet on the EOS node, so we can test it out!

14. cleos wallet create -n TEXT=chris

15. cleos wallet unlock -n TEXT=chris

16. cleos create key

17. store the password, public key and private keys

18. cleos wallet import [private key]

### Deploy to the single node test net

19. cleos create account eosio spore.ctr [public key] [public key]

20. cleos set contract spore.ctr ./spore -p spore.ctr

21. cleos create account eosio tester [public key] [public key]

### Try it out!

22. cleos push action spore.ctr createentity '["tester", 0, "blue", 0]' -p tester

23. cleos push action spore.ctr moveentity '["tester", 0, 10, 10]' -p tester

24. cleos push action spore.ctr killentity '["tester", 0, 0]' -p tester

## Next: Build the web app!

### Notes:
* Python 2.7
* Latest Node

### cd back to eosspore
cd ..

### install dependencies
npm install

### serve with hot reload at localhost:8080
npm run dev

### build for production with minification
npm run build

### serve your production build at localhost:5000
npm run serve

repository: abdupio/eos-simplepacman-contract

gha_language: WebAssembly

repo_name: abdupio/eos-simplepacman-contract


text:
`d3-convention`
===============

D3 [Margin Convention](http://bl.ocks.org/mbostock/3019563) encoded as an npm package. Idea "forked" from [1wheel/d3-starterkit](https://github.com/1wheel/d3-starterkit)

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

`d3-convention` depends on `d3` as a peer dependency

```bash
npm install d3 d3-convention
```

Example
-------

```js
var c = require('d3-convention')()

c.svg.append('rect')
    .attr({
      width: c.x(0.5), // 50% wide
      height: c.y(0.5), // 50% high

      x: c.x(0.25), // Center horizontally
      y: c.y(0.75) // Center vertically
    })
    .style('fill', 'steelblue')
```

Reference
---------

All options have sane defaults, however `d3Convention([opts])` accepts:

```js
var c = d3Convention({
  margin: Number || {top: Number, right: Number, bottom: Number, left: Number},
  width: Number,
  height: Number,

  parent: DOMElement || String || d3.select,
  svg: SVGElement || String || d3.select // preferably SVGSVGElement
})
```

It will mutate the originally passed `opts` Object, with these properties:

* `c.margin` is an Object with the properties `{top, right, bottom, left}` either
  the originally passed `opts.margin` object, an object expanded from the Number
  passed or the default `{top: 20, right: 10, bottom: 20, left: 10}`
* `c.width` is the "scene" width **excluding** margin on the left and
  right side. Defaults to `960 - margin.left - margin.right = 940`
* `c.height`, under the same constraints as `c.width`. Defaults to `460`
* `c.outerWidth` the width of the SVG element. Calculated from
  `c.width + c.margin.left + c.margin.right`. Default resolves to `960`
* `c.outerHeight` the actual height of the "drawing scene". Calculated from
  `c.height + c.margin.top + c.margin.bottom`. Default resolves to `500`
* `c.parent` is either the passed `opts.parent` or a D3 selection with the `body`
  element. This is where the `c.svg` element is inserted, unless `opts.svg` is passed, in which case this property is ignored
* `c.svg` is a newly inserted `<g>` element which is `translate`d. We will try
  to set the `width` and `height` attrs of this, as well as appending a `<g>`
  element which is translated.  It maps `[0, 1] -> [opts.innerHeight, 0]` (note the upside-downness)

```js
{
  margin: {top: Number, right: Number, bottom: Number, left: Number},
  width: opts.width || 960,
  height: opts.height || 500,

  innerWidth: Number,
  innerHeight: Number,

  parent: d3.select(opts.parent || HTMLBodyElement),
  svg: s3.select(SVGGElement),

  x: d3.scale.linear,
  y: d3.scale.linear
}
```

Notable Differences
-------------------

`d3-convention` was inspired by [Block #3019563](http://bl.ocks.org/mbostock/3019563)
and [1wheel/d3-starterkit](https://github.com/1wheel/d3-starterkit).

It differs from `d3-starterkit` in several ways:

* `margin` is subtracted, where `d3-starterkit` adds `margin` to your specified
  `width` and `height`
* This does not return the same breadth of scales by default
* This does not return any axis
* `parentSel` is `parent`. This lets you pass whatever `d3.select` accepts, it
  being `Element`, selector or an existing `d3.select`ion

License
-------

[ISC](LICENSE)

license: ISC


text:
PHP Doozer extension
==========

A [Doozer](https://github.com/ha/doozerd) extension for PHP

Dependencies
============

[PHP 5.3.0 and above](http://www.php.net)

[Protobuf-C](http://code.google.com/p/protobuf-c/)

Usage
=====

```php
// Get a new instance
$doozer = new Doozer();
// Connect to the specified doozer server
$doozer->connect('<IP_ADDRESS>', 8046, array(DZ_SEND_TIMEOUT => 3000, DZ_RECEIVE_TIMEOUT => 3000));
// Get the current revision
$rev = $doozer->getRev();
// Get on a directory will cause an exception
try {
    echo $doozer->get('/');
} catch(DoozerException $e) {
    echo "Can not call get() with a dir.\n";
}
// Set a string to a file
echo $doozer->set('/test', 'foobar');
// Get some words form a file
echo $doozer->get('/test');
// Remove a file
echo $doozer->delete('/test');
// Get the subpath from a directory by a offset
echo $doozer->getDir('/', 1);
// check the sate for a path
// if the path is a file, return an array with revision and length
var_dump($doozer->getStat('/ctl/cal/0'));
// if the path is a directory, return length
var_dump($doozer->getStat('/ctl'));
// if the path does not exist, throw an exception
try {
    echo $doozer->getStat('/not/exists');
} catch(DoozerException $e) {
    echo "The path is not exist.\n"
}
// Access doozer with a token
echo $doozer->access('foobar');
// Get all of available hosts
var_dump($doozer->getHosts());
// Walk through a path
var_dump($doozer->walk('/'));
// Close the connection
$doozer->close();
```

Authors
=======
Xing Xing<EMAIL_ADDRESS>
Open Source - MIT Software License
==================================
Copyright (c) 2012 Xing Xing

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.


text:
  What to eat at EPFL.

---

Install
-------

Install this globally and you'll have access to the `eat-at-epfl` command
anywhere on your system.

```bash
npm i eat-at-epfl -g
```

Usage
-----

```console
eat-at-epfl -h
Usage: eat-at-epfl [options]

Options:
  -a, --all               List all restaurants
  -d, --date              A date. Example: 18/04/2019            [string]
  -e, --evening           Evening menus
  -l, --language          Show menus in "en" or "fr"             [string]
  -p, --pick-random-menu  Pick a random menu
  -r, --restoId           Restaurant ID                          [number]
  -t, --tags              A comma separated list of menu types   [string]
  -h, --help              Show help                             [boolean]
  -v, --version           Show version number                   [boolean]

Examples:
  eat-at-epfl
  eat-at-epfl -e -l fr
  eat-at-epfl -t Pizza,Fish
  eat-at-epfl -d 04/05/2019
```

Screenshot
----------

![command line screenshot](https://raw.githubusercontent.com/innovativeinnovation/eat-at-epfl/master/docs/readme/screenshot.png)

See also
--------

* [epfl-menu-api](https://github.com/innovativeinnovation/epfl-menu-api)
* [epfl-menu](https://github.com/gcmalloc/epfl-menu)

Contributing
------------

Contributions are always welcome.

See [Contributing](CONTRIBUTING.md).

Developer
---------

* [William Belle](https://github.com/williambelle)

License
-------

Apache License 2.0

(c) William Belle, 2019-2021.

See the [LICENSE](LICENSE) file for more details.

repository: innovativeinnovation/eat-at-epfl

repo_name: innovativeinnovation/eat-at-epfl


text:
### Title: SUPER-RESOLUTION WITH DEEP CONVOLUTIONAL SUFFICIENT STATISTICS

### Publication: ICLR

### Author：Joan Bruna et al.

### Paper Review
- Research Background

  Data-driven approaches can lead to convincing results regarding inverse problems, but there are optimization problems because of non-explicit form of estimator.

- Problem to Solve

  Solve inverse problems in a non-linear representation space and thus provide a valid approach on image super-resolution problem.

- Key Design and Algorithm Proposed

  1. Use a conditional model defined by a Gibbs energy form and consider the corresponding Gibbs distribution.
  2. Conditional model contains a discriminative model and a predictive model.
  3. Use CNN in the proposed conditional model.

- Major Contribution

  1. Propose a method to solve inverse problem.
  2. Propose an algorithm to fine-tune the generative model.
  3. Illustrate a valid approach on image super-resolution problem.

- Major limitation

  When using on very fine textures, their method can result in some unnatural textures.

- Something you don’t understand

  I don't know what is the warping field $\tau$.

- Your view on the research domain/topic/approach/data/solution  (positive or negative)

  1. I think generating high-resolution images from low-resolution images is promising.
  2. I think their combination of Gibbs equation and GAN is innovative.
  3. They use a common dataset ImageNet to experiment their method and algorithm.

repository: guansLab/PaperReading

repo_name: guansLab/PaperReading


text:
## Sensu-Plugins-rabbitmq

[![Build Status](https://travis-ci.org/sensu-plugins/sensu-plugins-rabbitmq.svg?branch=master)](https://travis-ci.org/sensu-plugins/sensu-plugins-rabbitmq)
[![Gem Version](https://badge.fury.io/rb/sensu-plugins-rabbitmq.svg)](http://badge.fury.io/rb/sensu-plugins-rabbitmq)
[![Code Climate](https://codeclimate.com/github/sensu-plugins/sensu-plugins-rabbitmq/badges/gpa.svg)](https://codeclimate.com/github/sensu-plugins/sensu-plugins-rabbitmq)
[![Test Coverage](https://codeclimate.com/github/sensu-plugins/sensu-plugins-rabbitmq/badges/coverage.svg)](https://codeclimate.com/github/sensu-plugins/sensu-plugins-rabbitmq)
[![Dependency Status](https://gemnasium.com/sensu-plugins/sensu-plugins-rabbitmq.svg)](https://gemnasium.com/sensu-plugins/sensu-plugins-rabbitmq)
[![Sensu Bonsai Asset](https://img.shields.io/badge/Bonsai-Download%20Me-brightgreen.svg?colorB=89C967&logo=sensu)](https://bonsai.sensu.io/assets/sensu-plugins/sensu-plugins-rabbitmq)

## Sensu Asset
The Sensu assets packaged from this repository are built against the
Sensu Ruby runtime environment. When using these assets as part of a
Sensu Go resource (check, mutator or handler), make sure you include
the corresponding Sensu Ruby runtime asset in the list of assets
needed by the resource.  The current ruby-runtime assets can be found
[here](https://bonsai.sensu.io/assets/sensu/sensu-ruby-runtime) in the
[Bonsai Asset Index](bonsai.sensu.io).

## Functionality

## Files
 * bin/check-rabbitmq-alive.rb
 * bin/check-rabbitmq-amqp-alive.rb
 * bin/check-rabbitmq-cluster-health.rb
 * bin/check-rabbitmq-consumers.rb
 * bin/check-rabbitmq-consumer-utilisation.rb
 * bin/check-rabbitmq-messages.rb
 * bin/check-rabbitmq-network-partitions.rb
 * bin/check-rabbitmq-node-health.rb
 * bin/check-rabbitmq-node-usage.rb
 * bin/check-rabbitmq-queue-drain-time.rb
 * bin/check-rabbitmq-queue.rb
 * bin/check-rabbitmq-queues-synchronised.rb
 * bin/check-rabbitmq-stomp-alive.rb
 * bin/metrics-rabbitmq-overview.rb
 * bin/metrics-rabbitmq-queue.rb
 * bin/metrics-rabbitmq-exchange.rb

## Usage

## Installation

[Installation and Setup](http://sensu-plugins.io/docs/installation_instructions.html)

## Permissions

In order to run these checks you need the following permissions set:
```
:conf => '^aliveness-test$',
:write => '^amq\.default$',
:read => '.*'
```
You must also add the `monitoring` tag.

This can be done like this:
```
rabbitmqctl add_user sensu_monitoring $MY_SUPER_LONG_SECURE_PASSWORD
rabbitmqctl set_permissions  -p / sensu_monitoring "^aliveness-test$" "^amq\.default$" "^(amq\.default|aliveness-test)$"
rabbitmqctl set_user_tags sensu_monitoring monitoring
```

**It is highly recommended that you do not give administrator access! and use minimum permissions!**

## Notes

repository: hanynowsky/sensu-plugins-rabbitmq

repo_name: hanynowsky/sensu-plugins-rabbitmq


text:
---
layout:     post
title:      "昆雅语学习/复习笔记（1）"
subtitle:   "发音 复数 介词"
date:       2017-10-12
author:     "Anar"
header-img: "img/Namarie.jpg"
header-color: ""
tags:
    - 昆雅语
---
# Lesson One： Pronunciation and Accentuation
## Vowels

**a**,**e**,**i**,**o**,**u**

**á**，**é**，**í**，**ó**，**ú**

Quenya vowels are pure. (don't blur it) In Quenya *all* vowels, in *all* positions, must be clearly and distictly pronounced.

Quenya has *long* and *short* vowels.

**-a** and **-ë** need to be pronounced as a full vowel at the *end* of words

## Dipthongs
**ai**,**au**,**eu**,**iu**,**oi** and **ui**

## Consonants
**C** is always prnounced **K**

In the groups **hw,hy,hl,hr**, the letter **h** is not to be pronounced separately.

At the begining of words(before a vowel), the letter **h** is to pronounced like English h, but in the middle of words, **h** is to be pronounced [x]. (**h** before **t** and the vowels **a,o,u** is pronounced [x] and **h** before the vowels **i** and **e** turns into a sound similar to German ich-Laut)

gha_language: CSS


text:
---
title: "Jirka Prazan"
layout: splash
permalink: /about/
# hidden: true
header:
  overlay_color: "#000"
  overlay_filter: "0.5"
  overlay_image: /assets/images/home1.jpg
#   actions:
    # - label: " Contact me!"
    #   url<EMAIL_ADDRESS>excerpt:

Hi! 👋 I'm a data analyst/scientist, currently exploring new opportunities in tech, ideally working on products I feel passionate about. 🔥 I specialise in exploratory analyses and data visualisations. 📊

  I currently live in Prague, Czechia, but am keen to travel after the global pandemic subsides. ✈
intro:
  - image_path: /assets/images/about.jpg
    title: "About Me"
    excerpt: "I grew up in Prague 🏤, but have since lived in the USA, Scotland, and Australia. At university, I studied Economics 💸 and Psychology 🧠. During my final year, I was introduced to R (the programming language) and realised what a superpower it is to understand data. So I started diving deeply into the mathematics and computer science necessary to apply machine learning. 🤖\n
    \n
    As well as taking online courses alongside full-time work, I started competing on [kaggle](https://www.kaggle.com/zaefir) and [Analytics Vidhya](https://www.analyticsvidhya.com). After going through 30+ competitions, I recognised that most of them fit a certain pattern. 📈\n
    \n
    Therefore, to speed up anyone's start in the tabular ML comps world, I decided to publish a few Python-based 🐍 templates for different competition types, that show how to explore relationships between variables, fill null values, or do basic transformations. The templates also establish a simple model baseline, which is useful to set as early as possible, to be able to benchmark future scripts. No feature engineering, hyper parameter tuning or deep learning is included (that's secret sauce for now). 💩\n
    \n
    Czech out 😉 the posts section for those ipynbs (they are directly runnable in Google Colab)!\n
    \n
    Cheers! 🍻"
---

{% include feature_row id="intro" type="left" %}

gha_language: Jupyter Notebook


text:
# Reactive WebStorage for Angular 4 / 5

RxJS powered Reactive storage with the feature of synchronization between `LocalStorage API`.

This library is inspired by the idea from [@ngrx/store](https://github.com/ngrx/platform). The scope of the @ngrx/store has been narrowed to simple add/remove operations for the sake of the quick implementation and less boilerplate.
All the methods from WebStorage API has been preserved within the library. (`setItem`,`getItem`,`removeItem`)
## Setup
Install via [npm](http://npmjs.com) :

```
npm install ngx-reactive-webstorage --save
```

ReactiveWebStorageModule should be imported in app.module.ts.
```typescript
import { ReactiveWebStorageModule } from 'ngx-reactive-webstorage';

@NgModule({
  imports: [
    BrowserModule,
    ReactiveWebStorageModule,
    ...
  ]
  ...
})
export class AppModule {}
```

If LocalStorage are to be used, localstorage keys that will be used should be defined to synchronize localstorage and reactive Store at startup.

```typescript
import { ReactiveWebStorageModule } from 'ngx-reactive-webstorage';

// set localstorage keys to sync with at startup
export const storageKeys = ["user", "token"];

@NgModule({
  imports: [
    BrowserModule,
    ReactiveWebStorageModule.setLocalStorageKeys(keys),
    ...
  ]
  ...
})
export class AppModule {}
```

## Usage

Now you just have to inject the service where you need it :

```typescript
import { LocalStorage, SessionStorage } from 'ngx-reactive-webstorage';

@Component({
...
})
export class AppComponent {
  user: Observable<string>;
  constructor(private localStorage: LocalStorage, private sessionStorage: SessionStorage) {
    this.user = this.localStorage.getItem("user"); // { name:"Thomas", surname: "Anderson" }
  }

  saveUser(user: any) {
    this.localStorage.setItem("user", user);
  }

  removeUser() {
    this.localStorage.removeItem("user");
  }

}
```
```html
<p *ngIf="user | async as user">Welcome {{ user.name }}</p>
```

repository: Teebo/ngx-reactive-webstorage

repo_name: Teebo/ngx-reactive-webstorage


text:
### [CVE-2008-1387](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2008-1387)
![](https://img.shields.io/static/v1?label=Product&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Version&message=n%2Fa&color=blue)
![](https://img.shields.io/static/v1?label=Vulnerability&message=n%2Fa&color=brighgreen)

### Description

ClamAV before 0.93 allows remote attackers to cause a denial of service (CPU consumption) via a crafted ARJ archive, as demonstrated by the PROTOS GENOME test suite for Archive Formats.

### POC

#### Reference
No PoCs from references.

#### Github
- https://github.com/Hwangtaewon/radamsa
- https://github.com/StephenHaruna/RADAMSA
- https://github.com/nqwang/radamsa
- https://github.com/sambacha/mirror-radamsa
- https://github.com/sunzu94/radamsa-Fuzzer

repository: trickest/cve

repo_name: trickest/cve


text:
Week04: Numerical Methods and Numerical Linear Algebra
======================================================

This week, Prof. C. David Sherrill (our workshop organizer!) discussed specific
challenges and details to keep in mind when designing, implementing, and
utilizing numerical approaches to solving problems (numerical methods), as well
as introducing several practical concerns when performing linear algebra
routines on a computer (numerical linear algebra, NLA).  Slides from Prof.
Sherrill's lecture are available within this directory as `lecture.pdf`, and
the recorded lecture will be posted [here](https://b.gatech.edu/2LtIzHR) as
soon as possible.

In our recitation session this week, we will expand on our discussion of NLA
and apply a few new techniques to reduce data dimensionality by selecting the
"important" dimensions using a method called Principal Component Analysis
(PCA).


text:
---
layout: "unit"
title: "Guide Entry to 19.03.11"
path: "/curriculum/guides/2019/3/19.03.11.x.html"
unitTitle: "How Our Skeleton Helps Us"
unitAuthor: "Carol Boynton"
keywords: ""
recommendedFor: "Developed for Science/STEAM, grade K; recommended for Science/STEM/STEAM, grades K-2"
---

Young students seem fascinated by how their bodies work. This unit serves as an introduction for young students to begin their fundamental understanding of human biology.

The focus in this six-week curriculum unit is for primary-grade scientists to build some conceptual knowledge of the human skeletal system. The use of inquiry allows students at all levels to learn in an inherently differentiated environment, learning new concepts and experiencing laboratory experiments and classroom demonstrations throughout this unit on how our skeleton helps us.

The learning begins with the primary mentor texts, the picture book, The Skeleton Inside You by Philip Balestrino and Bones by Stephen Krensky. Classroom activities include creating models of bones, viewing x-rays, brainstorming design solutions for damaged or missing bones, measuring bones and determining structure features and taking a field trip to the local museum to view and draw skeletons. Students will maintain a science journal throughout the unit.

(Developed for Science/STEAM, grade K; recommended for Science/STEM/STEAM, grades K-2)


text:
---
layout: post
title: Blog Post 3
---

9/13

I finished up the first assignment that downing gave us earlier this week, and haven't quite started the second. Earlier this week, Downing
brought in a software engineer from Bloomberg, who was quite interesting to listen to. I quite enjoyed the talk that he gave, and it's nice to
see the perspective of someone whose actuallly working in the CS industry. He really helped emphasise what's important in our current college
careers, and overall, was worth paying attenton to. A few points I managed to take away from him: it's okay that you don't know every progrmaming
language; it's okay to be confused about what's going on at work; and it's okay to forget some stuff from college, since a lot of stuff in the real
job industry is quite different from what we're learning in school. What he said really reflected on my own internship experience too. OOP tries to
bridge the gap between the theoretical side of class and the practical side of an internship by introducing lots of industry standards, such as git
and travis, but there's nothing quite like working in an actual internship itself.

We still haven't learned much about acctual object oriented prorgrammming itself yet. It's mostly been a C++ course so far, but I feel like this
second assignment will be a little more challenging than the first. Honestly, the first assignment was rather simple once you get git, travis, and sphere
set up. Now that I know how to do that, I should be able to do more actual programming this time around instead of just messing around wtih setting up my
code. Also, paired programming should prove to be a useful experience. I have done a little paired programming with other interns and past mentors before,
and the ability to explain your code to another person while they're looking over your shoulder is invaluable. Not only is that useful in the workforce
but it should prove really useful during interviews too, when you're asked to explain what you're doing/what your thought processs is to your interviewer!

Lyee Chong

Tip of the week: Make sure you check everything in your assignment again before submitting it. I didn't add my html/ folder to my git repository,
so I had to suffer a late grade for my assignment. Easily avoidable mistake!


text:
# RankIQA: Learning from Rankings for No-reference Image Quality Assessment

The paper will appear in ICCV 2017. An [arXiv pre-print](https://arxiv.org/abs/1707.08347) version and the [supplementary material](./pdf/Xialei_IQA_ICCV.pdf) are available.

ICCV 2017 open access is [available](http://openaccess.thecvf.com/content_ICCV_2017/papers/Liu_RankIQA_Learning_From_ICCV_2017_paper.pdf) and the poster can be found [here](./pdf/poster_ICCV_2017.pdf).

The updated version is accepted at IEEE Transactions on Pattern Analysis and Machine Intelligence. Here is [arXiv pre-print version](https://arxiv.org/abs/1902.06285).

## Citation

Please cite our paper if you are inspired by the idea.

```
@InProceedings{Liu_2017_ICCV,
author = {Liu, Xialei and van de Weijer, Joost and Bagdanov, Andrew D.},
title = {RankIQA: Learning From Rankings for No-Reference Image Quality Assessment},
booktitle = {The IEEE International Conference on Computer Vision (ICCV)},
month = {Oct},
year = {2017}
}
```
and

```
@ARTICLE{8642842,
author={X. {Liu} and J. {Van De Weijer} and A. D. {Bagdanov}},
journal={IEEE Transactions on Pattern Analysis and Machine Intelligence},
title={Exploiting Unlabeled Data in CNNs by Self-supervised Learning to Rank},
year={2019},
pages={1-1},
doi={10.1109/TPAMI.2019.2899857},
ISSN={0162-8828}, }
```

## Authors

Xialei Liu, Joost van de Weijer and Andrew D. Bagdanov

## Institutions

[Computer Vision Center, Barcelona, Spain](http://www.cvc.uab.es/lamp/)

Media Integration and Communication Center, University of Florence, Florence, Italy

## Abstract

We propose a no-reference image quality assessment
  (NR-IQA) approach that learns from rankings
  (RankIQA). To address the problem of limited IQA dataset size, we
  train a Siamese Network to rank images in terms of image quality by
  using synthetically generated distortions for which relative image
  quality is known. These ranked image sets can be automatically
  generated without laborious human labeling. We then use
  fine-tuning to transfer the knowledge represented in the trained
  Siamese Network to a traditional CNN that estimates absolute image
  quality from single images. We demonstrate how our approach can be
  made significantly more efficient than traditional Siamese Networks
  by forward propagating a batch of images through a single network
  and backpropagating gradients derived from all pairs of images in
  the batch. Experiments on the TID2013 benchmark show that we improve the state-of-the-art by over 5%. Furthermore, on the LIVE benchmark we show that our approach is superior to existing NR-IQA techniques and that we even outperform the state-of-the-art in full-reference IQA (FR-IQA) methods without having to resort to high-quality reference images to infer IQA.

## Models

The main idea of our approach is to address the problem of limited IQA dataset size, which allows us to train a much deeper CNN without overfitting.

![Models](./figs/models.png )

## Framework

All training and testing are done in [Caffe](http://caffe.berkeleyvision.org/) framework.

## Pre-trained models

The pre-trained [models](./pre-trained) are available to download.

## Datasets

### Ranking datasets

Using an arbitrary set of images, we synthetically generate deformations of these images over a range of distortion intensities. In this paper, the reference images in [Waterloo](https://ece.uwaterloo.ca/~zduanmu/cvpr16_gmad/) and the validation set of the [Places2](http://places2.csail.mit.edu/) are used as reference images. The details of generated distortions can be found in [supplementary material](./pdf/Xialei_IQA_ICCV.pdf). The source code can be found in this [folder](./data/rank_tid2013).

### IQA datasets

We have reported experimental results on different IQA datasets including [TID2013](http://www.ponomarenko.info/tid2013.htm), [LIVE](http://live.ece.utexas.edu/research/quality/subjective.htm), [CSIQ](http://vision.eng.shizuoka.ac.jp/mod/page/view.php?id=23), [MLIVE](http://live.ece.utexas.edu/research/quality/live_multidistortedimage.html).

## Training

The details can be found in [src](./src).

### RankIQA

Using the set of ranked images, we train a Siamese network and demonstrate how our approach can be made
significantly more efficient than traditional Siamese Networks by forward propagating a batch of images through
a single network and backpropagating gradients derived from all pairs of images in the batch. The result is a
Siamese network that ranks images by image quality.

### RankIQA+FT

Finally, we extract a single branch of the Siamese network (we are interested at this point in the representation learned in the network, and not in the ranking itself), and fine-tune it on available IQA data. This effectively calibrates the network to output IQA measurements.


text:
Webglue — Command line tool to build static websites
-------------------------------------------------------------------------------
%%VERSION%%

Webglue is a command line tool to build static websites.

The website's URIs and their content are defined by maps. Maps are
uniquely identified sets of data bindings. Data bindings are defined
by a uniform s-expression syntax. They support localization and inter
map data sharing.

The format of a map determines how the data bindings are consulted to
define URIs and their content. The distribution provides formats for
URIs containing XML, HTML, CSS, UTF-8 text, search engine sitemaps and
raw files. New formats can be defined by dynamically loaded plugins
via the webglue API.

Webglue is distributed under the ISC license.

Home page: http://erratique.ch/repo/webglue
Contact: Daniel Bünzli `<daniel.buenzl<EMAIL_ADDRESS>
Dogfooding: http://erratique.ch

## Installation

**Warning** webglue is an experiment, it is unsupported software.

Webglue can be installed with `opam`

    opam pin add webglue http://erratique.ch/repos/webglue.git
    opam install webglue

## Getting started

The webglue command line tool and formats are largely self-documented
in the built-in help system. Type :

    webglue

to get help pointers.

The `share` directory of the distribution contains an emacs mode to
edit map files and an ocamlbuild plugin for that handles the
incremental construction of a website with ocamlbuild and webglue. The
`doc` directory has the documentation of the API to define new map
formats.

## Bugs and ideas

The following could be implemented in future versions of webglue.
Comments and suggestion are welcome.

* All UTF-8 output should be normalized for the web (i.e. NFC).
  http://www.w3.org/TR/charmod-norm/

* Automatic localized data generation for certain categories (day of
  week, month names) based on CLDR and/or locale(1).
  E.g. webglue localize days en fr de | webglue set localized month-name

* For now the sort-key of the w.seq directive uses binary comparison on
  UTF-8 data. The Unicode collation algorithm could be used.
  Tailoring according to locale ?

* Memoization, however this wouldn't help for ocamlbuild.

* Case directives. w.uppercase, w.lowercase, w.titlecase, w.casefold.
  See Unicode default case algorithms (sections 3.13 and 4.2, 5.18 in
  v5.0.0).  Tailoring according to locale ?  Or shouldn't we just
  leave that to CSS's text-transform property ?

* Better validity checks for generated data (e.g. HTML, CSS).

* Not everything is tail-recursive in there, especially the data language
  evaluator.

* w.xmlt format, generate a s-expression template and provide a lib to
  substitute. This allows to reuse the map definitions to generate a
  template for a dynamic part of the site.

* Finer dependency tracking, experimental implementation seems to indicate
  that this is overkill.

* Link checker format. E.g. see in erratique website the link.map

repository: dbuenzli/webglue

repo_name: dbuenzli/webglue


text:
2.43 - John Henry Thompson - Invent Your Future

[Yoga](../../../yoga.md) > [Patanjali's Yoga Sutras - A Comparison](../../patanjani.md) > [Book 2](../book-2.md) >

### 2.43

**कायेन्द्रियसिद्धिरशुद्धिक्षयात् तपसः ॥४३॥**
kāyendriya-siddhir-aśuddhi-kṣayāt tapasaḥ ||43||

[\[RS\] 2.43 Through self discipline (tapas), mental impurities are destroyed and the body and senses take on supernatural powers.](http://www.ashtangayoga.info/philosophy/yoga-sutra-patanjali/chapter-2/item/kayendriya-siddhir-ashuddhi-kshayat-tapasah/)

[\[JW\] 2.43 Perfection in the body and in the organs after impurity has dwindled as a result of self-castigation.](http://books.google.com/books?id=YzFImjtOxUwC&pg=PA189&ci=95%2C723%2C771%2C51&source=bookclip)

[\[SS\]](http://www.amazon.com/Yoga-Sutras-Patanjali-Commentary-Satchidananda/dp/0932040381) 2.43 By austerity, impurities of the body and senses are destroyed and occult powers gained. \[p146\]

[\[EB\]](http://www.amazon.com/Yoga-Sutras-Patanjali-Translation-Commentary/dp/0865477361/ref=sr_1_1?ie=UTF8&s=books&qid=1250508322&sr=1-1) 2.43 From austerity, on account of the removal of impurities, the perfection of the senses and body manifests. \[p272\]

[<Page 2.42](242.md)  [Page 2.44>](244.md)

(**काय**, kāya) = the physical body
(**इन्द्रिय**, indriya) = senses; organs of perception
(**सिद्धिः**, siddhiḥ) = supernatural power
(**अशुद्धि**, aśuddhi) = impurities
(**क्षयात्**, kṣayāt) = removal, destruction, elimination
(**तपः**, tapaḥ) = self-discipline; ascesis


text:
# Amazon ML Challenge 2021

Dataset: https://s3-ap-southeast-1.amazonaws.com/he-public-data/dataset52a7b21.zip

## Product Browse Node Classification

Amazon catalog consists of billions of products that belong to thousands of browse nodes (each browse node represents a collection of items for sale). Browse nodes are used to help customer navigate through our website and classify products to product type groups. Hence, it is important to predict the node assignment at the time of listing of the product or when the browse node information is absent.

As part of this hackathon, you will use product metadata to classify products into browse nodes. You will have access to product title, description, bullet points etc. and labels for ~3MM products to train and test your submissions. Note that there is some noise in the data - real world data looks like this!!

## Data Description

### Full Train/Test dataset details:

- Key column – PRODUCT_ID
- Input features – TITLE, DESCRIPTION, BULLET_POINTS, BRAND
- Target column – BROWSE_NODE_ID
- Train dataset size – 2,903,024
- Number of classes in Train – 9,919
- Overall Test dataset size – 110,775

### Important Note:

In case you are using pandas to read the csv train and test datasets, use escapechar = "\\" and quoting = csv.QUOTE_NONE options with read_csv to avoid errors during import.

### Evaluation Criteria

This contest uses Accuracy as the evaluation metric to measure submissions quality. Since this is a multiclass classification problem, we are interested in subset accuracy: the set of labels predicted for a sample must exactly match the corresponding set of ground truth labels.

### Submission File

For each PRODUCT_ID in the test data set, you are required to provide a browse node id prediction. The submission file should be a csv and contain a header followed by pairs of PRODUCT_ID, BROWSE_NODE_ID.

### Approach

1. Used Label Encoder to create Label column

2. Replaced all the null values with an empty string

3. Dropped Bullet Points, Brand and Description columns

4. Created a Bar Graph to see the correlation amongst all the features

5. Removed punctuations from the data

6. Used TfidVectorizer on the Title Column

7. Used Logistic Regression as the model

8. Finally got an accuracy of 53.95

repository: aryanndhir/Amazon-ML-Challenge

repo_name: aryanndhir/Amazon-ML-Challenge


text:
### initializeApp()

[Index](/docs/README.md) | [Objects in Globular](/docs/objects/README.md) | [Framework](/docs/objects/framework/README.md) | initializeApp()

Initializes a new Globular application.

**Signature**

    initializeApp(applicationName *[, { persistency, api }]*)

**Parameters**

`applicationName`

*(mandatory)* String to identify application under Globular namespace.

`{ persistency, api}`

*(optional)* A configuration object to define persistency and/or API adapters for application. If omitted, only framework instantiated API Adapter will be available in application, by default. If application requires persistency, it **must be** passed to application via configuration object.

For further details about requirements against adapters, see [Persistency Adapter](/docs/interface/PersistencyAdapter.md) and [API Adapter](/docs/interface/ApiAdapter.md) sections below.

**Return value**

An application object. See details in [Application](/docs/objects/application/README.md) section.

**Example**

    const myApplication = globular.initializeApp('weather-app', { persistency:localStorage })

repository: peppierre/globular

repo_name: peppierre/globular


text:
# Package snd [![GoDoc](https://godoc.org/dasa.cc/snd?status.svg)](https://godoc.org/dasa.cc/snd)

Package snd provides methods and types for sound processing and synthesis.

```
go get dasa.cc/snd
```

## Windows

Tested with msys2. Additional setup required due to how gomobile currently links to openal on windows. This should go away in the future stepping away from gomobile's exp/al package.

```
pacman -S mingw-w64-x86_64-openal
cd /mingw64/lib
cp libopenal.a libOpenAL32.a
cp libopenal.dll.a libOpenAL32.dll.a
```

## Tests

In addition to regular unit tests, there are plot tests that produce images
saved to a plots/ folder. This depends on package gonum/plot and requires an
additional tag flag to enable as follows:

```
go get github.com/gonum/plot
go test -tags plot
```

## SndObj

This package was very much inspired by Victor Lazzarini's [SndObj Library](http://sndobj.sourceforge.net/)
for which I spent countless hours enjoying, and without it I may never have come to program.

repository: dskinner/snd

repo_name: dskinner/snd


text:
[![npm version](https://badge.fury.io/js/directory-module-webpack-plugin.svg)](https://badge.fury.io/js/directory-module-webpack-plugin)
[![Build Status](https://travis-ci.org/Perlmint/directory-module-webpack-plugin.svg?branch=master)](https://travis-ci.org/Perlmint/directory-module-webpack-plugin)
[![Coverage Status](https://coveralls.io/repos/github/Perlmint/directory-module-webpack-plugin/badge.svg?branch=master)](https://coveralls.io/github/Perlmint/directory-module-webpack-plugin?branch=master)
[![Maintainability](https://api.codeclimate.com/v1/badges/79466958384dd05c69d3/maintainability)](https://codeclimate.com/github/Perlmint/directory-module-webpack-plugin/maintainability)
[![GitHub license](https://img.shields.io/github/license/Perlmint/directory-module-webpack-plugin.svg)](https://github.com/Perlmint/directory-module-webpack-plugin/blob/master/LICENSE)

# directory-module-webpack-plugin
Generate module based on directory contents

## Usage

### Configuration
```javascript
import DirectoryModulePlugin from "directory-module-webpack-plugin";

export = {
    entry: "./index.js",
    plugins: [
        new DirectoryModulePlugin({
            object: "json-object",
            array: "json-array",
            ts_object: "ts-object",
        }),
    ],
};
```

### Source code
```javascript
import object_directory_contents from "./object";
```