text:
# Deep Learning Q-Learning Notes:

**Findings**:

29 Jan:
- Having high epsilon (10%) is usually better than having no epsilon
- Epsilon_min is the probability an agent takes a random action during training
- There exists a sweet spot between the two. The agent must have an exploration incentive.

26 Jan:

- Discount rate refers to how highly the AI values future reward
- Higher discount rate is better
- More layers increase training time
- More layers makes the network more complex
- Increasing input layer is helpful in providing the forward information the agents need
- Increasing number of cars usually yields higher MPH, but makes the road more cluttered
- Decreasing temporal window maeks training faster, and in our case keeping it at 0 is good since the machines are markovian, they keep driving and are not interested in past memories
- Haven't found momentum to be all that useful

repository: lupuleasa-core/deeptraffic

repo_name: lupuleasa-core/deeptraffic


text:
Explanation 3.  If you have to explain it, it’s not that good.

User interface is an area where human interaction with software occurs (e.g. online website form). Well-designed interface should be intuitive and understandable for its users.

Steve Krug, a recognized User Experience Specialist, says that the basic principle when designing user interfaces is „Don’t make me think!”

license: MIT

branch_name: refs/heads/master

extension: md

license_type: permissive


text:
---
jupytext:
  text_representation:
    extension: .md
    format_name: myst
kernelspec:
  display_name: Python 3
  language: python
  name: python3
---

# Control the page layout

```{warning}
Many of the features on this page are experimental and may change at any time.
```

There are a few ways to control the layout of a page with Jupyter Book. Many of these
ideas take inspiration from the [Edward Tufte layout CSS guide](https://edwardtufte.github.io/tufte-css/).

Let's begin with a sample plot. You can click the toggle button to the right
to see the code that generated it.

```{code-cell} ipython3
:tags: [hide-input]

def make_fig(figsize):
    from matplotlib import rcParams, cycler
    import matplotlib.pyplot as plt
    import numpy as np
    plt.ion()

    # Fixing random state for reproducibility
    np.random.seed(19680801)

    N = 10
    data = [np.logspace(0, 1, 100) + .2 * np.random.randn(100) + ii for ii in range(N)]
    data = np.array(data).T
    cmap = plt.cm.coolwarm
    rcParams['axes.prop_cycle'] = cycler(color=cmap(np.linspace(0, 1, N)))

    from matplotlib.lines import Line2D
    custom_lines = [Line2D([0], [0], color=cmap(0.), lw=4),
                    Line2D([0], [0], color=cmap(.5), lw=4),
                    Line2D([0], [0], color=cmap(1.), lw=4)]

    fig, ax = plt.subplots(figsize=figsize)
    lines = ax.plot(data)
    ax.legend(custom_lines, ['Cold', 'Medium', 'Hot'])
make_fig(figsize=(10, 5))
```

(layout/sidebar)=
## Sidebar content

Adding sidebar elements allow you to provide contextual information that doesn't break
up the flow of your main content. It is one of the main patterns recommended in the
[Tufte style guide](https://edwardtufte.github.io/tufte-css/).

There are two kinds of sidebars supported by Jupyter Book. We'll
describe them below.

```{note}
Some sidebar content behaves differently depending on the screen size. If the screen is narrow
enough, the sidebar content will exist in-line with your content. Make the screen
wider and it'll pop out to the right.
```

### Sidebars within content

````{sidebar} Here is some sidebar content
It spans a bit of your main content, as well as the margin, as seen by the
note block below:
```{note}
Here's a note block within the sidebar!
```
````

If you use a sidebar within your content, the sidebar will stay in-line with your page's content. However, it will be
placed to the right, allowing your content to wrap around it. This prevents
the sidebar from breaking up the flow of your content. This is particularly
useful if you've got tall-and-long blocks of content or images that you would
like to provide context to throughout your content.

To add a sidebar to your content, use the following syntax:

````md
```{sidebar} My sidebar title
My sidebar content
```
````

### Margin content

To add content to the margin with MyST Markdown, use this syntax:

````md
```{margin} An optional title
My margin content
```
````

`````{margin} **For example**
Here's some margin content! It was created by using the
````
```{margin}
```
````
directive in a Markdown cell. Jupyter Book automatically converts these
cells into helpful margin content.
`````

Controlling margin content with code cells uses a slightly different syntax,
which we'll cover below.

### Margins with code cells

You can make a code cell move to the right margin by adding `margin` to your
cell's tags.

``````{tab-set}
`````{tab-item} Jupyter Notebook
Here's what the cell metadata for a margin cell looks like:
```json
{
    "tags": [
        "margin",
    ]
}
```
:::{seealso}
[](jupyter-cell-tags)
:::
`````

`````{tab-item} MyST Text File
For a MyST text file these tags can be added to the `code-cell`
````md
```{code-cell} <language>
:tags: [margin]
```
````
`````
``````

For example, we'll re-display the figure above, and add a `margin` tag to the code cell.

```{code-cell} ipython3
:tags: [margin]

make_fig(figsize=(10, 5))
```

This can be combined with other tags like `remove-input` to **only display the figure**.

The [MyST cheat sheet](myst_cheatsheet) provides a [list of `code-cell` tags available](myst_cheatsheet:code-cell:tags)

## Full-width content

Sometimes, you'd like to use **all** of the horizontal space available to you.
This allows you to highlight particular ideas, visualizations, etc.

### Full-width code cells

You can specify that a code cell's inputs and/or outputs should take up all of the horizontal space (including the margin to the right) using the following cell metadata tag:

```json
{
    "tags": [
        "full-width",
    ]
}
```

```{seealso}
For tips on how to add cell metadata to your notebooks, see [](jupyter-cell-tags).
```

For example, let's take a look at the figure in the margin above in a cell with `full-width` set. We'll tell Matplotlib
to make it a bit wider so we can take advantage of the extra space!

```{code-cell} ipython3
:tags: [hide-input, full-width]

make_fig(figsize=(20, 5))
```

### Full-width markdown content

If you'd like to make your markdown content full-width, you cannot do so via cell tags.
Instead, you have a few options:

1. **Use the `{div}` directive with a `full-width` class.**. Any content with a `full-width` class will take up the full width of the screen. For example, the following code:

   `````
   ````{div} full-width
   ```{note}
   Here's a note that will take the full width
   ```
   ````
   `````

   results in:

   ````{div} full-width
   ```{note}
   Here's a note that will take the full width
   ```
   ````

   For more information on `<div>` blocks, see [](custom-div-blocks).
2. **Add a `full-width` class to directives that support classes**. Many directives allow you to directly add a CSS class to them.

   For example, the `{note}` directive above allows for this:

   ````
   ```{note}
   :class: full-width
   Here's a note that will take the full width
   ```
   ````

   results in:

   ```{note}
   :class: full-width
   Here's a note that will take the full width
   ```

   Check the documentation of the directive to see if it supports adding your own classes, or use the `{div}` directive as described above.

```{admonition} **Mixing margins and full-width content**
:class: warning, full-width

Be careful when mixing margins and full-width content.
Sometimes these can conflict with one another in visual space. You should use them relatively sparingly in order for them to have their full effect of highlighting information.
```

repository: executablebooks/jupyter-book

gha_language: Python

repo_name: executablebooks/jupyter-book


text:
---
title:  "Flutter Demo of THETA WebAPI Tester"
tags: theta-tester
date:   2021-02-05
categories: tester
cover: /images/2021_02/theta_tester_flutter.png
author: Craig Oda
license: false
---

I've implemented a small subset of the THETA WebAPI into a [library on
GitHub](https://github.com/codetricity/theta).

![flutter demo](https://raw.githubusercontent.com/codetricity/theta_webapi_flutter_minimal/main/docs/images/android_demo.gif)

The [command line tool](https://github.com/theta360developers/webapi)
and the [Flutter tool](https://github.com/codetricity/theta_webapi_flutter_minimal)
are using the same library.

In the Flutter pubspec.yaml, add the theta package to the dependencies.

```yaml
dependencies:
  flutter:
    sdk: flutter
  theta:
    git:
      url: https://github.com/codetricity/theta
      ref: main
  http: ^0.12.2
```

In `main.dart`, import the `theta` package.

```dart
import 'dart:convert';
import 'package:flutter/material.dart';
import 'package:theta/theta.dart';
```

You can now grab the camera info with `Camera.info`.

Example of code called by button press.

```dart
void _info() async {
    _displayResponse(await Camera.info);
}
```

The `_displayResponse()` method is an utility that
simply formats the Dart map as JSON with indents.

The button is constructed with this code.

```dart
MaterialButton(
    onPressed: _info,
    child: Text('info'),
    color: Colors.lightGreen,
),
```

gha_language: Dart


text:
[![Build][build-badge]][build-url]
[![Issues][issues-badge]][issues-url]
[![Gitter][gitter-badge]][gitter-url]

Repository Archived |
--------------------|
| This repository has been archived. For Device Simulation issues and maintenance, please see [Azure IoT PCS Device Simulation](https://www.github.com/Azure/azure-iot-pcs-device-simulation) |

Azure IoT Device Simulation Web UI
==================================
## Core technologies overview
- [ReactJS](https://reactjs.org/)
- [React-Router v4](https://github.com/ReactTraining/react-router)
- [Redux](https://redux.js.org/)
- [Redux-Observable](https://redux-observable.js.org/)
- [RxJs](http://reactivex.io/rxjs/)
- [SASS](http://sass-lang.com/)

Prerequisites
=============
## Setup Node
1. Install [node.js](https://nodejs.org/)
2. For development, you can use your preferred editor
   - [Visual Studio Code](https://code.visualstudio.com/)
   - [Atom](https://atom.io/)
   - [Sublime Text](https://www.sublimetext.com/)
   - or other preferred editor

Running the app
=============
1. After initially pulling the repo, run `npm install`
2. Run `npm start` to compile and run the app

This project was bootstrapped with [Create React App](https://github.com/facebookincubator/create-react-app). You can find the guide [here](https://github.com/facebookincubator/create-react-app/blob/master/packages/react-scripts/template/README.md).

Contributing to the solution
============================
Please follow our [contribution guidelines](docs/CONTRIBUTING.md) and the [code style](docs/CODE_GUIDELINES.md) conventions.

[build-badge]: https://img.shields.io/travis/Azure/pcs-simulation-webui.svg
[build-url]: https://travis-ci.org/Azure/pcs-simulation-webui
[issues-badge]: https://img.shields.io/github/issues/azure/pcs-simulation-webui.svg
[issues-url]: https://github.com/Azure/pcs-simulation-webui/issues/new
[gitter-badge]: https://img.shields.io/gitter/room/azure/iot-solutions.js.svg
[gitter-url]: https://gitter.im/azure/iot-solutions

repository: Azure/pcs-simulation-webui

gha_language: JavaScript

gha_license_id: MIT

repo_name: Azure/pcs-simulation-webui


text:
# World-Stripper #

World-Stripper is open-source distributed under the [MIT-License](https://github.com/EwyBoy/World-Stripper/blob/master/LICENSE.md).

I encourage you to contribute your ideas, code and problems you may experience while using World-Stripper.
There are several ways for you to contribute to the World-Stripper project.

If you want to contribute have a look at the [Project Table](https://github.com/EwyBoy/World-Stripper/projects/1?fullscreen=true) and look for the `Help Wanted` tag.

* Contribute by shearing your ideas as feature requests [here](https://github.com/EwyBoy/World-Stripper/issues/new?assignees=EwyBoy&labels=Compatibility+Request&template=compatibility-request.md&title=%5BCompatibility%5D+MOD-NAME).
* Contribute by reporting any issues or bugs you may encounter [here](https://github.com/EwyBoy/World-Stripper/issues/new?assignees=EwyBoy&labels=bug&template=bug_report.md&title=%5BBug%5D+Relevant+title+here)
* Contribute by proposing compatibility between World-Stripper and any other mods [here](https://github.com/EwyBoy/World-Stripper/issues/new?assignees=EwyBoy&labels=Compatibility+Request&template=compatibility-request.md&title=%5BCompatibility%5D+MOD-NAME)
* Contribute by developing for World-Stripper by making a pull-request [here](https://github.com/EwyBoy/World-Stripper/pulls)

All help is very much appreciated.
For more info ask in my Discord [here](https://discord.gg/WcwTJAEFam).

-Ewy

repository: EwyBoy/World-Stripper

gha_language: Java

repo_name: EwyBoy/World-Stripper


text:
# ADR 053: State Sync Prototype

This ADR outlines the plan for an initial state sync prototype, and is subject to change as we gain feedback and experience. It builds on discussions and findings in [ADR-042](./adr-042-state-sync.md), see that for background information.

## Changelog

* 2020-01-28: Initial draft (Erik Grinaker)

## Context

State sync will allow a new node to receive a snapshot of the application state without downloading blocks or going through consensus. This bootstraps the node significantly faster than the current fast sync system, which replays all historical blocks.

Background discussions and justifications are detailed in [ADR-042](./adr-042-state-sync.md). Its recommendations can be summarized as:

* The application periodically takes full state snapshots (i.e. eager snapshots).

* The application splits snapshots into smaller chunks that can be individually verified against a chain app hash.

* Tendermint uses the light client to obtain a trusted chain app hash for verification.

* Tendermint discovers and downloads snapshot chunks in parallel from multiple peers, and passes them to the application via ABCI to be applied and verified against the chain app hash.

* Historical blocks are not backfilled, so state synced nodes will have a truncated block history.

## Tendermint Proposal

This describes the snapshot/restore process seen from Tendermint. The interface is kept as small and general as possible to give applications maximum flexibility.

### Snapshot Data Structure

A node can have multiple snapshots taken at various heights. Snapshots can be taken in different application-specified formats (e.g. MessagePack as format `1` and Protobuf as format `2`, or similarly for schema versioning). Each snapshot consists of multiple chunks containing the actual state data, allowing parallel downloads and reduced memory usage.

```proto
message Snapshot {
    uint64 height = 1;   // The height at which the snapshot was taken
    uint32 format = 2;   // The application-specific snapshot format
    uint64 chunks = 3;   // The number of chunks in the snapshot
    bytes metadata = 4;  // Arbitrary application metadata
}

message SnapshotChunk {
    uint64 height = 1;   // The height of the corresponding snapshot
    uint32 format = 2;   // The application-specific snapshot format
    uint64 chunk = 3;    // The chunk index (zero-based)
    bytes data = 4;      // Serialized application state in an arbitrary format
    bytes checksum = 5;  // SHA-1 checksum of data
}
```

Chunk verification data must be encoded along with the state data in the `data` field.

Chunk `data` cannot be larger than 64 MB, and snapshot `metadata` cannot be larger than 64 KB.

### ABCI Interface

```proto
// Lists available snapshots
message RequestListSnapshots {}

message ResponseListSnapshots {
    repeated Snapshot snapshots = 1;
}

// Offers a snapshot to the application
message RequestOfferSnapshot {
    Snapshot snapshot = 1;
}

message ResponseOfferSnapshot {
    bool accepted = 1;
    enum reason {             // Reason why snapshot was rejected
        unknown = 0;          // Unknown or generic reason
        invalid_height = 1;   // Height is rejected: avoid this height
        invalid_format = 2;   // Format is rejected: avoid this format
    }
}

// Fetches a snapshot chunk
message RequestGetSnapshotChunk {
    uint64 height = 1;
    uint32 format = 2;
    uint64 chunk = 3;
}

message ResponseGetSnapshotChunk {
    SnapshotChunk chunk = 1;
}

// Applies a snapshot chunk
message RequestApplySnapshotChunk {
    SnapshotChunk chunk = 1;
    bytes chain_hash = 2;
}

message ResponseApplySnapshotChunk {
    bool applied = 1;
    enum reason {           // Reason why chunk failed
        unknown = 0;        // Unknown or generic reason
        verify_failed = 1;  // Chunk verification failed
    }
}
```

### Taking Snapshots

Tendermint is not aware of the snapshotting process at all, it is entirely an application concern. The following guarantees must be provided:

* **Periodic:** snapshots must be taken periodically, not on-demand, for faster restores, lower load, and less DoS risk.

* **Deterministic:** snapshots must be deterministic, and identical across all nodes - typically by taking a snapshot at given height intervals.

* **Consistent:** snapshots must be consistent, i.e. not affected by concurrent writes - typically by using a data store that supports versioning and/or snapshot isolation.

* **Asynchronous:** snapshots must be asynchronous, i.e. not halt block processing and state transitions.

* **Chunked:** snapshots must be split into chunks of reasonable size (on the order of megabytes), and each chunk must be verifiable against the chain app hash.

* **Garbage collected:** snapshots must be garbage collected periodically.

### Restoring Snapshots

Nodes should have options for enabling state sync and/or fast sync, and be provided a trusted header hash for the light client.

When starting an empty node with state sync and fast sync enabled, snapshots are restored as follows:

1. The node checks that it is empty, i.e. that it has no state nor blocks.

2. The node contacts the given seeds to discover peers.

3. The node contacts a set of full nodes, and verifies the trusted block header using the given hash via the light client.

4. The node requests available snapshots via `RequestListSnapshots`. Snapshots with `metadata` greater than 64 KB are rejected.

5. The node iterates over all snapshots in reverse order by height and format until it finds one that satisfies all of the following conditions:

    * The snapshot height's block is considered trustworthy by the light client (i.e. snapshot height is greater than trusted header and within unbonding period of the latest trustworthy block).

    * The snapshot's height or format hasn't been explicitly rejected by an earlier `RequestOffsetSnapshot` call (via `invalid_height` or `invalid_format`).

    * The application accepts the `RequestOfferSnapshot` call.

6. The node downloads chunks in parallel from multiple peers via `RequestGetSnapshotChunk`, and both the sender and receiver verifies their checksums. Chunks with `data` greater than 64 MB are rejected.

7. The node passes chunks sequentially to the app via `RequestApplySnapshotChunk`, along with the chain's app hash at the snapshot height for verification. If the chunk is rejected the node should retry it. If it was rejected with `verify_failed`, it should be refetched from a different source. If an internal error occurred, `ResponseException` should be returned and state sync should be aborted.

8. Once all chunks have been applied, the node compares the app hash to the chain app hash, and if they do not match it either errors or discards the state and starts over.

9. The node switches to fast sync to catch up blocks that were committed while restoring the snapshot.

10. The node switches to normal consensus mode.

## Gaia Proposal

This describes the snapshot process seen from Gaia, using format version `1`. The serialization format is unspecified, but likely to be compressed Amino or Protobuf.

### Snapshot Metadata

In the initial version there is no snapshot metadata, so it is set to an empty byte buffer.

Once all chunks have been successfully built, snapshot metadata should be serialized and stored in the file system as e.g. `snapshots/<height>/<format>/metadata`, and served via `RequestListSnapshots`.

### Snapshot Chunk Format

The Gaia data structure consists of a set of named IAVL trees. A root hash is constructed by taking the root hashes of each of the IAVL trees, then constructing a Merkle tree of the sorted name/hash map.

IAVL trees are versioned, but a snapshot only contains the version relevant for the snapshot height. All historical versions are ignored.

IAVL trees are insertion-order dependent, so key/value pairs must be stored in an appropriate insertion order to produce the same tree branching structure and thus the same Merkle hashes.

A chunk corresponds to a subtree key range within an IAVL tree, in insertion order, along with the Merkle proof from the root of the subtree all the way up to the root of the multistore (including the Merkle proof for the surrounding multistore.

```go
struct SnapshotChunk {
    Store   string            // Name (key) of IAVL store in outer MultiStore
    Keys    [][]byte          // Snapshotted keys in insertion order
    Values  [][]byte          // Snapshotted values corresponding to Keys
    Proof   []merkle.ProofOp  // Merkle proof from subtree root to MultiStore root
}
```

This chunk structure is believed to be sufficient to reconstruct an identical IAVL tree by applying separate chunks, but this may require the chunks to be ordered in a certain way; further research is needed.

We do not use IAVL RangeProofs, since these include redundant data such as proofs for intermediate and leaf nodes that can be derived from the above data.

Chunks should be built greedily by collecting key/value pairs constituting a complete subtree up to some size limit (e.g. 32 MB), then serialized. Chunk data is stored in the file system as `snapshots/<height>/<format>/<chunk>/data`, along with a SHA-1 checksum in `snapshots/<height>/<format>/<chunk>/checksum`, and served via `RequestGetSnapshotChunk`.

### Snapshot Scheduling

Snapshots should be taken at some configurable height interval, e.g. every 1000 blocks. All nodes should preferably have the same snapshot schedule, such that all nodes can serve chunks for a given snapshot.

Taking consistent snapshots of IAVL trees is greatly simplified by them being versioned: simply snapshot the version that corresponds to the snapshot height, while concurrent writes create new versions. IAVL pruning must not prune a version that is being snapshotted.

Snapshots must also be garbage collected after some configurable time, e.g. by keeping the latest `n` snapshots.

## Open Questions

* Is it possible to reconstruct an identical IAVL tree given separate subtrees in an appropriate order, or is more data needed about the branch structure?

* Should we punish nodes that provide invalid snapshots?

* Is it OK for state-synced nodes to not have historical blocks nor historical IAVL versions?

## Status

Proposed

## References

* [ADR-042](./adr-042-state-sync.md) and its references


text:
---
layout: default
---

# 1996-02-08 - Tell me whats wrong with this

## Header Data

From<EMAIL_ADDRESS>To<EMAIL_ADDRESS>Message Hash: 403552b069c81f7273214dfc7b8be590c3a59938bcb4fb6f4939a96ed2d40eaa

Message ID<EMAIL_ADDRESS>Reply To: _N/A_

UTC Datetime: 1996-02-08 23:14:28 UTC

Raw Date: Fri, 9 Feb 1996 07:14:28 +0800

## Raw message

```
{% raw  %}From<EMAIL_ADDRESS>Date: Fri, 9 Feb 1996 07:14:28 +0800
To<EMAIL_ADDRESS>Subject: Tell me whats wrong with this
Message-ID<EMAIL_ADDRESS>MIME-Version: 1.0
Content-Type: text/plain

Tell me whats wrong with this section of the telecom bill.  I have a six
year old boy I am trying to raise
and it is hard enough to teach him respect and values without explaining why
Ned Beatty is being
bungholed in the woods by Billy Bob or why the Terminator splattered this
guys brains all over the
wall.
        Tell me why parents should not be able to censor their OWN
television so that they may raise their children the way THEY see
fit...................Did your dad give you his old
playboys?.........NOOOOO............
Did he take you down to your grandmothers autopsy before her
funeral?...................I Don't Think So.....

All I'm saying is it's tough to raise a child these days without the added
distortion of modern
programing and parents need not be denied any tool that can help them
achieve success.

 SEC. 551. PARENTAL CHOICE IN TELEVISION PROGRAMMING.
            (a) FINDINGS- The Congress makes the following findings:
                (1) Television influences children's perception of the values
              and behavior that are common and acceptable in society.
                (2) Television station operators, cable television system
              operators, and video programmers should follow practices in
              connection with video programming that take into consideration
              that television broadcast and cable programming has established
              a uniquely pervasive presence in the lives of American children.
                (3) The average American child is exposed to 25 hours of
              television each week and some children are exposed to as much
              as 11 hours of television a day.
                (4) Studies have shown that children exposed to violent video
              programming at a young age have a higher tendency for violent
              and aggressive behavior later in life than children not so
              exposed, and that children exposed to violent video programming
              are prone to assume that acts of violence are acceptable
              behavior.
                (5) Children in the United States are, on average, exposed to
              an estimated 8,000 murders and 100,000 acts of violence on
              television by the time the child completes elementary school.
                (6) Studies indicate that children are affected by the
              pervasiveness and casual treatment of sexual material on
              television, eroding the ability of parents to develop
              responsible attitudes and behavior in their children.
                (7) Parents express grave concern over violent and sexual
              video programming and strongly support technology that would
              give them greater control to block video programming in the
              home that they consider harmful to their children.
                (8) There is a compelling governmental interest in empowering
              parents to limit the negative influences of video programming
              that is harmful to children.
                (9) Providing parents with timely information about the
              nature of upcoming video programming and with the technological
              tools that allow them easily to block violent, sexual, or other
              programming that they believe harmful to their children is a
              nonintrusive and narrowly tailored means of achieving that
              compelling governmental interest.
Charles Donald Smith Jr.

||The government  is my shepherd I need not work. It alloweth me to lie
 down on a good job. It leadeth me beside stilled factories. It destroyeth
 my initiative. It leadeth me in the path of a parasite for politics sake. YEA,
 though I walk through the valley of laziness and deficet spending I shall
 fear no evil, for the government is with me. It prepareth an economic utopia
 for me by appropriating the earnings of my grandchildren. It filleth my head
 with false security. My inefficiency runeth over. Surely, the government
should care for me all the days of my life, and I will dwell in a fools paradise
forever.................AMEN!   || nuke'm if ya got'em||

{% endraw %}
```

## Thread

+ Return to [February 1996](/archive/1996/02)

+ Return to "[avatar@mindspring.com](/authors/avatar_at_mindspring_com)"
+ Return to "[Jim Choate <ravage@ssz.com>](/authors/jim_choate_ravage_at_ssz_com_)"
+ Return to<EMAIL_ADDRESS>(Mike McNally)](/authors/m5_at_dev_tivoli_com_mike_mcnally_)"

+ 1996-02-08 (Fri, 9 Feb 1996 07:14:28 +0800) - Tell me whats wrong with this -<EMAIL_ADDRESS>  + 1996-02-08 (Fri, 9 Feb 1996 07:58:50 +0800) - [Tell me whats wrong with this](/archive/1996/02/c151fd3b13c5f90889201921fc9e02137fb6bc23323ffc6a710487f145c08151) -<EMAIL_ADDRESS>(Mike McNally)_
    + 1996-02-09 (Fri, 9 Feb 1996 08:36:26 +0800) - [Re: Tell me whats wrong with this](/archive/1996/02/73313d177d9f2c35da124355710a0de2112e74f187c91710dc9d33c68c0b9e19) - _Jim Choate<EMAIL_ADDRESS>


text:
---
title: Simulation and Floating Point Numbers
date: 2022-12-14 15:25:00 -0500
categories: [Random]
tags: [blog, tech, random]
math: true
---

# Intro

I probably won't do this often, but I expect I'll learn some interesting things and thought this would be a good place to document it.

> I know little about what I'm about to present as fact. The following information is likely not the full picture.
{: .prompt-warning }

As I'm sitting here procrastination studying for my `Numerical Computing` final, I'm wondering what language I should begin prototyping in. This is somewhat determined by what features I expect needing in this game.

Here's my thinking:
- I know I want to draw to a screen with images, so this shouldn't be a console game.
- I want to be able to prototype this fast, so I should make it a Mac/Windows/Linux game.
- My development will likely be spread across these three platforms, so I should pick a language that works relatively the same independent of platform.

This leads me to Java. Java is special because the code sits in a virtual environment (the JVM, Java Virtual Machine) that then interacts with the host operating system. The reason it does this is so that code doesn't need to be ported to every platform; only the JVM needs to be platform-specific.
This comes with the caveat that different JVMs do slightly different things. These slight differences can compound such that the exact same code on two different machines may produce very different results, especially around floating point numbers.
But, to my knowledge, the JVMs are generally pretty good at doing the same thing. This is almost a non-issue for me if I pick Java (although may create a nasty bug down the road).

 I'd much rather use C++, Lua, and [Raylib](https://www.raylib.com/).
With this in mind, and my Numerical Computing test looming, let's talk about floating point numbers and why different computers would get different answers to the same problem.

# IEEE 754 Floating-Point Arithmetic

The Institute of Electrical and Electronics Engineers (IEEE) have published many standards for how computers should represent floating point numbers -- real, non-integer numbers like `0.5` or `17.38`. The most recent iteration was in 2019 called `IEEE 754-2019`.
There are two common formats: a 32-bit `float32` usually shortened to `float` and a 64-bit format usually named `double`, short for `double float` but also known as `float64`.

## Binary

The challenge with representing floating point numbers is that, ultimately, they need to be represented as a sequence of zeroes and ones. How do we do this? Let's take inspiration from a binary format, and to best understand binary let's first revisit the decimal number system. Let's count.
$$ 01, 02, 03, \cdots, 09, 10 $$. Notice how we incremented the value in the ones-place value/first place value until we ran out of digits. Once we tried to increment $$9$$, we reset the first place value and moved to the second place value, where we incremented the value by one. We can continue this process.
$$ 10, 11, \cdots, 19, 20 $$. Again, we ran out of digits in the first place so we incremented the second place and reset the first place. We are counting in a base-10 system. It's called a base-10 system because there are ten values for every digit, the numbers 0-9.

Let's count in binary. It's almost the same, but now $$1$$ is our last value.
$$ 00, 01, 10 $$. This is a base-2 system, because we only have two values for every digit: $$0$$ and $$1$$. Let's keep counting. $$ 0010, 0011, 0100, 0101, 0110, 0111, 1000 $$. Note that, just like in base-10, we can freely add leading zeroes. It doesn't change the value of the number and doesn't affect the value of the digits before it if placed to the left hand side. The same isn't true if we placed zeroes on the right; that would change the value of later digits. Note that, when using binary, they're no longer technically digits; they're now bits (`bi-` meaning two, `digit` comes from _digiti_ meaning fingers).

How do we convert back and forth? The 'base-2' gives us a hint. In base-10, the difference between $$70$$ and $$7$$ is that the 7 appears in a different place. They both have the same digits, but the 7 in $$70$$ is worth more. Specifically, 10x more, because we are using a base-10 system.

The same is true in binary. The 1 in $$100$$ should be worth 2x as much as the 1 in $$010$$ because it is one place value up. Looking at our counting, we see $$100 = 4$$ and $$010 = 2$$, which we can validate as $$ 4 = 2(2) $$.

To translate simply, we can use the following procedure:

$$
    2^n(b_n) + 2^{n-1}(b_{n-1}) + \cdots 2^{2}(b_2) + 2^{1}(b_1) + 2^{0}(b_0)
$$

Where $$b_n$$ is the value of the digit $$n$$ places to the left.
We are multiplying the value in every place by the base raised to the power of the location of the value. It's not easy to explain, but hopefully some examples will show what we're doing here.
Let's use this to translate $$100$$ from binary.

$$
    2^2(1) + 2^1(0) + 2^0(0) = 4(1) + 2(0) + 1(0) = 4
$$

How about something more complicated now? $$011011$$:

$$
\begin{eqnarray}
    && \phantom{ = 0} 2^5(0) + 2^4(1) + 2^3(1) + 2^2(0) + 2^1(1) + 2^0(1) \\
    && = 32(0) + 16(1) + 8(1) + 4(0) + 2(1) + 1(1) \\
    && = 16 + 8 + 2 + 1 = 27
\end{eqnarray}
$$

Note that we got a value in the base-10 system. That's because we are using the basis of the base-10 system. We could just as easily translate binary back into binary (or a polynomial equation, although this now gets into linear algebra). We can also perform this translation on a base-10 number, like $$193$$:

$$
    10^2(1) + 10^1(9) + 10^0(3) = 100(1) + 10(9) + 1(3) = 100 + 90 + 3 = 193
$$

We got the same thing as we started with.

## Floating point

Now we're ready to talk about floating point numbers. Why don't we continue this pattern? We can simply extend our place values to the right, just like we do with base-10 numbers. Let's try representing $$ 0.5 $$ with this system:

$$
    0.5 = \frac{1}{2} = 2^{-1}
$$

So we would need a binary number that has zeros everywhere _except_ the place value that corresponds to $$2^{-1}$$, where we should have a 1 to select that value. We'll represent this number as $$0.1$$ in binary. We can convert this back:

$$
    2^0(0) + 2^{-1}(1) = 1(0) + 0.5(1) = 0.5
$$

That works! Now, let's represent $$0.3$$ in binary.

$$
    0.3 = 0.25 + 0.05
$$

Not sure how to represent 0.05, but we can represent 0.25 as $$2^{-2}$$! This is when we need to worry about repeating decimals. This is a problem in base-10. How do we represent $$\frac{1}{3}$$? $$0.333333\cdots$$. That's not an exact representation.
Now, if we had a base-3 system, this would be easy! $$\frac{1}{3} = 3^{-1} = 0.1_{3}$$.
But we can't represent this exactly in base-10. We're seeing the same problem in base-2. We can't exactly represent $$0.3$$, an easy problem in base-10 but not for a computer.
Let's ask the computer how it would solve this:

```python
print( 0.1 + 0.2 ) # Output: 0.30000000000000004
```

This right here is the manifestation of that repeating digit.

Let's look at the `IEEE 754 float32` standard. It states that 32 bit floats should reserve one bit as a sign bit, whether the number is positive or negative. Then, 8 exponent bits. We'll get to why that's important. Then, 23 fraction bits, also referred to as the `mantissa`. This will encode the digits of the number.

The exponent works to zoom the number in and out on the number line. The easiest way of seeing why this is important is with an example. Take $$332,041,393,326,771,929,088$$.
This is a huge number, and won't fit within a typical 64-bit number! The largest number we can store in a 64-bit number is $$2^64 - 1 = 18,446,744,073,709,551,615$$.
But our number can be stored exactly with a `float`. That's because our huge number, $$332,041,393,326,771,929,088$$ is actually $$2^{68} + 2^{65}$$. This is where the exponent is useful. We can store this number as $$(2^3 + 2^0) * 2^{65}$$. This lets us store numbers that would otherwise be outside of our range.

This also works for very small numbers. $$0.000000961124897003173828125$$? Oh that's actually $$(2^7 + 2^0) * 2^{-27}$$.

This is the idea behind floating point numbers. The formula for the value of a `float`-encoded number is as follows:

$$
    (-1)^{b_{31}} * 2^{(b_{30}b_{29}\cdots b_{23})_2 - 127} * (1.b_{22}b_{21}\cdots b_{0})_2
$$

Instead of using the bits, lets write our the names for these elements:

$$
    (-1)^{\text{Sign}} * 2^{\text{Exponent} - 127} * (1 + \text{Mantissa})
$$

We use this $$+1$$ trick in the mantissa part to encode a free bit of information. We can safely assume that there's always _at least one 1_ in a number. Otherwise, it's zero!

_To be continued..._

branch_name: refs/heads/main


text:
# Basic usage

After successful installation you can start from register Elements which will be handled by admin bundle.
Element is just object which allow admin panel to handling your website resources.

At this moment we have handle list and batch elements.

## To generate list of our resources we need do following steps:

### 1. Create element

We will create element which allow to list and batch delete users.
In element you can define data grid fields (fields visible on list) and you can define data source
so place when you decide from where element will fetch data. We have two built-in data sources right now:

### Doctrine entity
  We supporting typically doctirne entities with getters and setters
  Example of element for typically **doctrine entity** with setters is [here](doctrine.md)

### Dbal
  We supporting not only entites, but results of custom dbal queries as well.
  To use dbal queries we need to create element which use connection and dbal driver from admin panel.
  Example of element where we fetch data directly from database using **dbal** is [here](dbal.md)

Element id is used in routing so after creating and registering element we are be able to enter `http://example.com/admin/list/admin_users` to see our `admin_users` element list.

### 2. Adding element to menu

You can add element to menu by adding such configuration into your `app/config/config.yml` file:

```yaml
# app/config/config.yml

admin_panel:
    menu:
        - {"id": "admin_users", "name": "Users"}
```

we need to give "id" of the element and "name" which will be shown on the menu as label.

Bundle allows to add menu items which are not elements with custom routes and allows to create submenu as well.
Example:

```yaml
# app/config/config.yml

admin_panel:
    menu:
        - {"id": "admin_users", "name": "Users"}
        - {"route": "my_route", "name": "Custom"},
        -
            "name": "Sub menu",
            "children":
              - {"route": "my_other_route", "name": "Other route"}
```

repository: admin-panel/admin-bundle

gha_language: PHP

repo_name: admin-panel/admin-bundle


text:
flash-messages [![Build Status](https://travis-ci.org/camilosw/flash-messages.svg)](https://travis-ci.org/camilosw/flash-messages)
==============

Package for displaying flash messages to the user. This is based on the chapter 'Creating a Meteorite Package' from the [Discover Meteor Book](http://www.discovermeteor.com/) and the [foundation-flash-messages](https://github.com/datariot/foundation-flash-messages) package.

This package integrates well with [Bootstrap Alerts](http://getbootstrap.com/components/#alerts) styles, but Bootstrap is not a dependency.

You can see a [demo](http://flash-messages-demo.meteor.com/) and their [source code](https://github.com/camilosw/flash-messages-demo).

## Note

The syntax has changed on version 0.2.0

## Usage

Include the template somewhere in your index.html file:
```javascript
  {{> flashMessages}}
```
And then send messages:
```javascript
  FlashMessages.sendWarning("Message");
  FlashMessages.sendError("Message");
  FlashMessages.sendSuccess("Message");
  FlashMessages.sendInfo("Message");
```

**Note:** sendAlert was deprecated, use sendWarning instead.

You can also send a group of messages sending an array of strings. This will be rendered on a `ul` `li` list:
```javascript
  FlashMessages.sendInfo(["Message 1", "Message 2", "Message 3"]);
```

Messages can also contain html:
```javascript
  FlashMessages.sendInfo("You can found <strong>Meteor</strong> <a href='http://meteor.com'>here</a>");
```

To clear messages:
```javascript
  FlashMessages.clear();
```

Only the seen messages will be cleared.

## Configure

You can configure globally the way the messages behave with FlashMessages.configure (the below sample shows the default values):
```javascript
  FlashMessages.configure({
    autoHide: true,
    hideDelay: 5000,
    autoScroll: true
  });
```

- `autoHide`: set to `true` to make flash message fade after `hideDelay` milliseconds, set to `false` to require the user to click the close button on the message to dismiss it.
- `hideDelay`: set the desired number of milliseconds for the flash message to be displayed (when `autoHide` is `true`).
- `autoScroll`: set to `true` to enable auto scroll when a message is displayed, `false` to disable auto scroll. (**Note:** this can be set only globally.)

You can also set individual options on messages. This will override global configuration:
```javascript
  FlashMessages.sendWarning("Message", { autoHide: false });
  FlashMessages.sendError("Message", { hideDelay: 2000 });
  FlashMessages.sendSuccess("Message", { autoHide: true, hideDelay: 8000 });
```

repository: camilosw/flash-messages

repo_name: camilosw/flash-messages


text:
# The Aviator
Demos and game for the tutorial "The Making of 'The Aviator': Animating a Basic 3D Scene with Three.js", by Karim Maaloul. I make modular processing on the basis of the source code

[Article on Codrops](http://tympanus.net/codrops/?p=26501)


text:
# Customer Segmentation Report for Arvato Financial Services

For this project demographics data for customers of a mail-order sales company in Germany was analysed. The customer demographics data was compared against demographics information for the general population. Unsupervised learning techniques to perform customer segmentation as well as identifying the parts of the population that best describe the core customer base of the company was performed. A model is trained to predict which individuals are most likely to convert into becoming customers for the company. A third dataset with demographics information for targets of a marketing campaign for the company is used as a validation set. The data used has been provided by Bertelsmann Arvato Analytics.

## Blog post
A blog post outlining this work is published [here](https://jurgen-strydom.medium.com/customer-segmentation-report-for-arvato-financial-solutions-214ddb46c142).

## Environment
This project uses python. The environment is managed using `pipenv`. [This link](https://realpython.com/pipenv-guide/) will help you get started with `pipenv`.

This project uses `python 3.8` and the following packages:
- jupyter = "*"
- numpy = "*"
- pyarrow = "==2.0.0"
- pandas = "*"
- bokeh = "*"
- scipy = "*"
- scikit-learn = "*"
- tqdm = "*"
- xlrd = "*"
- openpyxl = "*"
- umap-learn = "*"
- pandas-bokeh = "*"

For the most up to date information see Pipfile(s) in the root folder.

## Datasets
The general population and customeres datasets is provided as part of the project, and not included in the repository.
- Path relative to project root folder: `../../data/Term2/capstone/arvato_data/`
- General population filename: `Udacity_AZDIAS_052018.csv`
- Customers filename: `Udacity_CUSTOMERS_052018.csv`
- Mailout validation set: `Udacity_MAILOUT_052018_TRAIN.csv`
- Kaggle submission: `Udacity_MAILOUT_052018_TEST.csv`
In addition to the datasets, as part of the project spreadsheets are provided that describe that dataset. This code utilises the `DIAS Attributes - Values 2017.xlsx` spreadsheet to identify known and unknown columns. This file should be located in the root folder of the project.

## Files
- `.gitignore`: Specifies directories and files in the project that should not be version controlled and excluded from this repository.
- `Arvato Project Workbook.ipynb`: The main contribution of this project.
- `Pipfile`: Pipenv file specifying the proejct requirements.
- `Pipfile.lock`: Pipenv file specifying the installed packages.
- `LICENSE`: MIT. Read for information on re-use and sharing. Usage of this software, analysis or anything else in this repository is subject to the license.
- `README.md`: This file.

## How to run
1. Activate the environment by running `pipenv shell` in the project folder.
2. Run jupyter using the `jupyter notebook` command.
3. Open the notebook `Arvato Project Workbook.ipynb` using jupyter.

# Model Performance
A random forest classifier setup with the default hyperparameters produces an AUC of 0.896 on the test set (20% holdout of the training data), and an AUC of 0.799 on the validation set. The kaggle submission ranks this classifier 3rd out of all submissions.

# Contact
https://github.com/jjstrydom

repository: atabti/udacity-ds-capstone

repo_name: atabti/udacity-ds-capstone


text:
# intergrow
This is a innersource analytical tool to bring up right measurement of it's values

How to run intergrow
=====================

Prerequisite :

    Django latest version 3.0 or above installed
    pyhthon 3.0 and above installed
    Having MySQL server installed
    Having pip3 installed

Clone the source from the following intergrow git repo
------------------------------------------------------

git@github.com:innersourcedo/intergrow.git

Create your local virtual enviorment
-----------------------------------------
Installing Virtual machine

$ pip3 install virtualenv

 Creating your local virtual machine

 $virtualenv innerSourceDo

 Activate your local virtual machine

 $ source innersource/bin/activate

What is needed in local virtual enviorment to ran intergrow ?

        python 3 and above with pip
        Django
        intergrow checked out source code
DB
----------------------------
Start up your mySQL server
 If ubuntu/linux
  $ sudo /etc/init.d/mysql start

 You need to have the viewes created in your  local mySQL

 Follow the readme for the rest of the DB initial creation and migrations

 Start up intergrow
 ---------------------------
 $ python manage.py run server

 Check out http://localhost:8000/admin
 Log in with user name:admin password admin321

repository: innersourcedo/intergrow

repo_name: innersourcedo/intergrow


text:
# cointop

> Coin tracking for hackers

[![License](http://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/miguelmota/cointop/master/LICENSE.md) [![Build Status](https://travis-ci.org/miguelmota/cointop.svg?branch=master)](https://travis-ci.org/miguelmota/cointop) [![Go Report Card](https://goreportcard.com/badge/github.com/miguelmota/cointop?)](https://goreportcard.com/report/github.com/miguelmota/cointop) [![GoDoc](https://godoc.org/github.com/miguelmota/cointop?status.svg)](https://godoc.org/github.com/miguelmota/cointop)

<img src="./assets/screenshot-001.gif" width="880" />

[`cointop`](https://github.com/miguelmota/cointop) is a fast and lightweight interactive terminal based UI application for tracking and monitoring cryptocurrency coin stats in real-time. The interface is inspired by [`htop`](https://en.wikipedia.org/wiki/Htop).

## Features

- Quick sort shortcuts
- Vim style keys
- Pagination
- Color coded

#### Future releases

- Advanced search
- "Favorites" list
- Coin charts
- Currency conversion (i.e. Euro, Yen)
- Markets/Exchanges
- CryptoCompare API

## Install

Make sure to have [go](https://golang.org/) (1.9+) installed, then do:

```bash
go get -u github.com/miguelmota/cointop
```

<!--
#### Alternatively (without go)

```
sudo curl -s "https://raw.githubusercontent.com/miguelmota/cointop/master/install.sh?$(date +%s)" | bash
```
-->

## Usage

```bash
$ cointop
```

### Table commands

List of shortcuts:

|Key|Action|
|----|------|
|`<up>`|navigate up|
|`<down>`|navigate down|
|`<right>`|next page|
|`<left>`|previous page|
|`<enter>`|visit highlighted coin on CoinMarketCap|
|`<esc>`|alias to quit|
|`<space>`|alias to `<enter>`|
|`<ctrl-c>`|alias to quit|
|`<ctrl-d>`|page down|
|`<ctrl-n>`|alias to next page|
|`<ctrl-u>`|page up|
|`<ctrl-p>`|alias to previous page|
|`<ctrl-r>`|force refresh|
|`1`|sort by *[1] hour change*|
|`2`|sort by *[2]4 hour change*|
|`7`|sort by *[7] day change*|
|`a`|sort by *[a]vailable supply*|
|`j`|alias to `<down>`|
|`k`|alias to `<up>`|
|`l`|sort by *[l]ast updated*|
|`m`|sort by *[m]arket cap*|
|`n`|sort by *[n]ame*|
|`p`|sort by *[p]rice*|
|`r`|sort by *[r]ank*|
|`s`|sort by *[s]ymbol*|
|`t`|sort by *[t]otal supply*|
|`v`|sort by *24 hour [v]olume*|
|`q`|[q]uit|

<!--
|`h`|toggle [h]elp|
|`?`|alias to help|
-->

## FAQ

- Q: Where is the data from?

  - A: The data is from [Coin Market Cap](https://coinmarketcap.com/).

- Q: What coins does this support?

  - A: This supports any coin listed on [Coin Market Cap](https://coinmarketcap.com/).

- Q: How often is the data polled?

  - A: Data gets polled once every minute by default.

- Q: I installed cointop without errors but the command is not found.

  - A: Make sure your `GOPATH` and `PATH` is set correctly.
    ```bash
    export GOPATH=$HOME/go
    export PATH=$PATH:$GOPATH/bin
    ```

- Q: What is the size of the binary?

  - A: The executable is only ~1.9MB in size.

## Authors

- [Miguel Mota](https://github.com/miguelmota)

## License

Released under the MIT license.

repository: beaquant/cointop

repo_name: beaquant/cointop


text:
---
title: NextJS simple blog
github: 'https://github.com/lyket-dev/nextjs-simple-blog-theme'
demo: 'https://nextjs-simple-blog.netlify.app/'
author: Lyket
date: 2020-10-21T00:00:00.000Z
github_branch: main
ssg:
  - Next
cms:
  - No CMS
css: null
archetype:
  - Blog
description: >-
  A simple NextJS blog powered by Lyket to support like, clap and like/dislike
  buttons!
stale: false
---

# A simple starter blog for NextJS with feedback buttons

This theme is a simple blog starter kit. It integrates [Lyket](https://lyket.dev)'s like👍, clap👏 and like/dislike 👍/👎 buttons!

repository: styxlab/jamstackthemes

repo_name: styxlab/jamstackthemes


text:
---
title: 'Clay v3: Clay CSS Mixin Updates'
author: [patrickyeo]
---

<div class="nav-toc">

-   [Introduction](#introduction)
-   [Implications](#implications)
-   [Variable Key Names](#variable-key-names)
-   [Unset Properties](#unset-properties)
-   [Conclusion](#conclusion)

</div>

### Introduction

We have begun implementing a new pattern for customizing and generating CSS properties in Clay CSS. It uses the mixin, [clay-css](https://github.com/liferay/clay/blob/01a8e7607608936922df4a994df02cd25adb1cac/packages/clay-css/src/scss/mixins/_globals.scss#L11), that accepts a Sass map as a parameter to generate CSS properties and values for a selector. The valid property names are listed in the link.

### Implications

In the past, we have followed the pattern of mapping a Sass variable to to a single CSS property. We are converting to using maps instead. The name of the Sass map variable will refer to the CSS selector of the component. For example the variables:

```scss{expanded}
$alert-close-font-size: 0.875rem !default;
$alert-close-height: 2rem !default;
$alert-close-line-height: null !default;
$alert-close-opacity: null !default;
$alert-close-margin-left: null !default;
$alert-close-padding-bottom: 0 !default;
$alert-close-padding-left: 0 !default;
$alert-close-padding-right: 0 !default;
$alert-close-padding-top: 0 !default;
$alert-close-position-right: 0.5rem !default;
$alert-close-position-top: 0.75rem !default;
$alert-close-width: $alert-close-height !default;
```

have been combined into a single map:

```scss{expanded}
$alert-close: () !default;
$alert-close: map-deep-merge(
	(
		color: inherit,
		font-size: $alert-close-font-size,
		height: $alert-close-height,
		line-height: $alert-close-line-height,
		margin-left: $alert-close-margin-left,
		opacity: $alert-close-opacity,
		padding-bottom: $alert-close-padding-bottom,
		padding-left: $alert-close-padding-left,
		padding-right: $alert-close-padding-right,
		padding-top: $alert-close-padding-top,
		position: absolute,
		right: $alert-close-position-right,
		top: $alert-close-position-top,
		width: $alert-close-width,
		hover: (
			color: inherit,
		),
	),
	$alert-close
);
```

The variable name will resemble the CSS selector; `$alert-close` maps to `.alert .close`. The main motivation behind this change was to reduce the number of variables we had to define and increase the number of properties we could customize.

We will be deprecating most variables that map to a single CSS property. We encourage updating your variable themes to this new map pattern where ever possible. It will make future upgrades easier and less time consuming.

### Variable Key Names(#variable-key-names)

We are converting key names like `bg`, `bg-image`, `padding-x`, `padding-y`, `margin-x`, and `margin-y` to match the CSS property they are referencing. They are now `background-color` and `background-image`. The keys `padding-x` and `padding-y` have been split into `padding-left`, `padding-right`, `padding-bottom`, and `padding-top`. The same goes for `margin-x` and `margin-y`.

Key names like `hover-bg`, `focus-border-color`, `active-focus-box-shadow`, and `disabled-opacity` have been nested inside maps with keys with the same name as the pseudo classes they represent. An example:

```scss{expanded}
$btn-primary: () !default;
$btn-primary: map-deep-merge(
	(
		// bg,
			background-color: value,
		// bg-image,
			background-image: value,
		// padding-y,
			margin-bottom: value,
		// padding-x,
			margin-left: value,
		// padding-x,
			margin-right: value,
		// padding-y,
			margin-top: value,
		// padding-y,
			padding-bottom: value,
		// padding-x,
			padding-left: value,
		// padding-x,
			padding-right: value,
		// padding-y,
			padding-top: value,
		hover: (
			// hover-bg,
				background-color: value
		),
		focus: (
			// focus-border-color,
				border-color: value
		),
		active: (
			focus: (
				// active-focus-box-shadow,
					box-shadow: value,
			),
		),
		disabled: (
			// disabled-opacity,
				opacity: value
		)
	),
	$btn-primary
);
```

The old key names are still valid and will win over new key names. One quirk that may arise from using the new key names is if you are extending a variable theme that still uses the old keys or if Clay CSS forgot to convert a map to the new keys. The old keys will win even if you did everything right. An example:

```scss{expanded}
// Your extending theme using new keys

$btn-primary: (
	background-color: #3d536b,
	hover: (
		background-color: #34465b,
	),
	focus: (
		background-color: #2b3a4b,
	),
);

// Variable Theme still using old keys

$btn-primary: () !default;
$btn-primary: map-deep-merge(
	(
		bg: #5924eb,
		hover-bg: #4429b3,
		focus-bg: #3c249e,
	),
	$btn-primary
);

// $btn-primary will contain the old values:
//  (
//  	background-color: #5924EB,
//  	hover: (
//  		background-color: #4429B3,
//  	),
//  	focus: (
//  		background-color: #3C249E,
//  	),
//  )
```

### Unset Properties

Properties can be unset in maps by setting the value to `$clay-unset` or `$c-unset`. The variable `$clay-unset` contains the key word `clay-unset`. Clay functions and mixins will return `null` when it encounters that key word. This is a workaround for Sass outputting properties like `background-color: null;`. Example below:

```scss{expanded}
$btn-primary: () !default;
$btn-primary: map-deep-merge(
	(
		background-color: $c-unset,
		border-color: $c-unset,
		color: $c-unset,
	),
	$btn-primary
);

$btn-primary: () !default;
$btn-primary: map-deep-merge(
	(
		background-color: aliceblue,
		border-color: aliceblue,
		color: black,
	),
	$btn-primary
);

// $btn-primary contains nothing:
// ()
```

### Conclusion

We believe these updates will provide more value. It enables a developer to add, remove, and replace CSS properties inside clay.css instead of duplicating and overwriting them. We won't be removing compatibility for any of the old variables or key names any time soon. We understand upgrading is a difficult process and want to make any transitions as smooth as possible.

repository: liferay/clay

gha_language: SCSS

gha_license_id: NOASSERTION

repo_name: liferay/clay


text:
# Hacks

This file is intended to keep track of the hacks in the SSH server library.

## OnHandshakeSuccess handler

We call the `OnHandshakeSuccess` handler from the authentication methods. We do this so the `OnHandshakeSuccess` handler can perform longer initialization methods without sending the auth success message to the client.

We are doing this because immediately after the client receives the auth successful message it will start sending requests which may time out.

We can do this because we know that the Go SSH library doesn't support chained authentication. (e.g. password + keyboard-interactive).

**Remove:** When Go SSH supports multiple chained authentication methods.

repository: ericsmalling/sshserver

repo_name: ericsmalling/sshserver


text:
# xreadback

An attempt to sort out the XPlane 11 default ATC Readback issue, whereby you have to click readback
messages with the mouse. Unless you are close to ambidextrous that means you have to let go of the
joystick in order to grab the mouse to move and click it. For rookies like me flying by hand this is
often a problem. (It is a mystery why this has not been fixed. The default ATC isn't great, but this
makes it so much less irritating).

Installation
============

This has been designed to be cross platform but has only been run on Linux. It may simply not work
on Windows/Mac. The best way to find out is to just try it without XPlane first, clicking on things on the
desktop like icons or menus. It should give a commentary on what's happening in the command prompt.
Please feed back any issues !

Python3 programming language
	(from https://www.python.org/downloads/)
	When installing python click the checkbox to 'add to PATH'

Open a command prompt and install the following Python libraries.

Each should display some progress information and end with "Successfully installed" or
something like that.

pysdl2 Python library
	(Install via "pip install pysdl2")

sdl2 library
	(For Linux, often present or available in installer)
	(For Mac/Windows install with "pip install pysdl2-dll")

pynput Python library
	(Install via "pip install pynput")

If you get errors try adding a -U "pip install -U pynput"

Usage
=====

The app is very simple. Keyboard presses and Joystick button presses are checked against a
list. If a match is found, the mouse cursor is moved to a position on the screen and the left
mouse button is clicked.

(The obvious target is the top menu entry on ATC, which is sometimes "Readback Transmission")

This means that the ATC dialogue will have to be in a specific place and stay there. There
probably is a way internally of figuring out where it is, but I have no idea how.

Probably it is best to anchor it to a side. I tend to have it at the bottom left.

The app is run at a terminal or command prompt.

To see the keyboard and joystick button names try the following:

python xreadback.py events

When a button or key is pressed it will show ** Fired Event 'xxxx' ** where xxxx is the name
of the event, e.g. k:x is the x key, and b:1 is button #1. (Interrupt it with control C)

Joystick buttons do not seem to work on complex setups. I don't know why. Changing
SDL_JoystickOpen(0) currently at line 54 to different numbers might help, but we haven't
managed to get this to work.

To see the mouse position try the following

python xreadback.py mouse

This just prints the current mouse position in the window, as you move it around you will see
the numbers change. Move it to where you want to click and make a note of that screen position.

Now suppose you want button 4 to do the readback, and the centre of the readback button is at
146,810. You would run the app with :

python xreadback.py b:4,146,810

This makes button 4 move the mouse cursor to 146,810 and click it. It will click whatever is at that
location. It's really for in flight, where you may not want to take your hands off the smaller planes
controls at the time, it's especially irritating when it's just to acknowledge a change of heading.

To make the space bar do the same thing

python xreadback.py k:space,146,810

Just leave it running in the background while you run X-Plane. It shouldn't take up many resources.

Notes:

1) these are physical screen positions, so if you run it in Windowed mode and move it about it will
depend where the window is. The top left of the screen is 0,0

2) The install is not trivial. However, this is a good thing. This program is effectively what is called
a "key logger". It monitors what keys you press. The problem with such programs is that you could modify it
to write all the keys you press to a file, which mean passwords could be stolen as you type them in.

Because you can "see" the program in its original programmer form, it is possible to check this does not
do this.

Paul Robson, August 2020
<EMAIL_ADDRESS>
Many thanks to Mark Smolen who helped with Windows testing and several attempts to try to make it work on
complex setups.

repository: paulscottrobson/xreadback

repo_name: paulscottrobson/xreadback


text:
## Using GoogleTest from various build systems

GoogleTest comes with pkg-config files that can be used to determine all
necessary flags for compiling and linking to GoogleTest (and GoogleMock).
Pkg-config is a standardised plain-text format containing

*   the includedir (-I) path
*   necessary macro (-D) definitions
*   further required flags (-pthread)
*   the library (-L) path
*   the library (-l) to link to

All current build systems support pkg-config in one way or another. For all
examples here we assume you want to compile the sample
`samples/sample3_unittest.cc`.

### CMake

Using `pkg-config` in CMake is fairly easy:

```cmake
find_package(PkgConfig)
pkg_search_module(GTEST REQUIRED gtest_main)

add_executable(testapp)
target_sources(testapp PRIVATE samples/sample3_unittest.cc)
target_link_libraries(testapp PRIVATE ${GTEST_LDFLAGS})
target_compile_options(testapp PRIVATE ${GTEST_CFLAGS})

enable_testing()
add_test(first_and_only_test testapp)
```

It is generally recommended that you use `target_compile_options` + `_CFLAGS`
over `target_include_directories` + `_INCLUDE_DIRS` as the former includes not
just -I flags (GoogleTest might require a macro indicating to internal headers
that all libraries have been compiled with threading enabled. In addition,
GoogleTest might also require `-pthread` in the compiling step, and as such
splitting the pkg-config `Cflags` variable into include dirs and macros for
`target_compile_definitions()` might still miss this). The same recommendation
goes for using `_LDFLAGS` over the more commonplace `_LIBRARIES`, which happens
to discard `-L` flags and `-pthread`.

### Help! pkg-config can't find GoogleTest!

Let's say you have a `CMakeLists.txt` along the lines of the one in this
tutorial and you try to run `cmake`. It is very possible that you get a failure
along the lines of:

```
-- Checking for one of the modules 'gtest_main'
CMake Error at /usr/share/cmake/Modules/FindPkgConfig.cmake:640 (message):
  None of the required 'gtest_main' found
```

These failures are common if you installed GoogleTest yourself and have not
sourced it from a distro or other package manager. If so, you need to tell
pkg-config where it can find the `.pc` files containing the information. Say you
installed GoogleTest to `/usr/local`, then it might be that the `.pc` files are
installed under `/usr/local/lib64/pkgconfig`. If you set

```
export PKG_CONFIG_PATH=/usr/local/lib64/pkgconfig
```

pkg-config will also try to look in `PKG_CONFIG_PATH` to find `gtest_main.pc`.

### Using pkg-config in a cross-compilation setting

Pkg-config can be used in a cross-compilation setting too. To do this, let's
assume the final prefix of the cross-compiled installation will be `/usr`, and
your sysroot is `/home/MYUSER/sysroot`. Configure and install GTest using

```
mkdir build && cmake -DCMAKE_INSTALL_PREFIX=/usr ..
```

Install into the sysroot using `DESTDIR`:

```
make -j install DESTDIR=/home/MYUSER/sysroot
```

Before we continue, it is recommended to **always** define the following two
variables for pkg-config in a cross-compilation setting:

```
export PKG_CONFIG_ALLOW_SYSTEM_CFLAGS=yes
export PKG_CONFIG_ALLOW_SYSTEM_LIBS=yes
```

otherwise `pkg-config` will filter `-I` and `-L` flags against standard prefixes
such as `/usr` (see https://bugs.freedesktop.org/show_bug.cgi?id=28264#c3 for
reasons why this stripping needs to occur usually).

If you look at the generated pkg-config file, it will look something like

```
libdir=/usr/lib64
includedir=/usr/include

Name: gtest
Description: GoogleTest (without main() function)
Version: 1.11.0
URL: https://github.com/google/googletest
Libs: -L${libdir} -lgtest -lpthread
Cflags: -I${includedir} -DGTEST_HAS_PTHREAD=1 -lpthread
```

Notice that the sysroot is not included in `libdir` and `includedir`! If you try
to run `pkg-config` with the correct
`PKG_CONFIG_LIBDIR=/home/MYUSER/sysroot/usr/lib64/pkgconfig` against this `.pc`
file, you will get

```
$ pkg-config --cflags gtest
-DGTEST_HAS_PTHREAD=1 -lpthread -I/usr/include
$ pkg-config --libs gtest
-L/usr/lib64 -lgtest -lpthread
```

which is obviously wrong and points to the `CBUILD` and not `CHOST` root. In
order to use this in a cross-compilation setting, we need to tell pkg-config to
inject the actual sysroot into `-I` and `-L` variables. Let us now tell
pkg-config about the actual sysroot

```
export PKG_CONFIG_DIR=
export PKG_CONFIG_SYSROOT_DIR=/home/MYUSER/sysroot
export PKG_CONFIG_LIBDIR=${PKG_CONFIG_SYSROOT_DIR}/usr/lib64/pkgconfig
```

and running `pkg-config` again we get

```
$ pkg-config --cflags gtest
-DGTEST_HAS_PTHREAD=1 -lpthread -I/home/MYUSER/sysroot/usr/include
$ pkg-config --libs gtest
-L/home/MYUSER/sysroot/usr/lib64 -lgtest -lpthread
```

which contains the correct sysroot now. For a more comprehensive guide to also
including `${CHOST}` in build system calls, see the excellent tutorial by Diego
Elio Pettenò: <https://autotools.io/pkgconfig/cross-compiling.html>

repository: google/googletest

repo_name: google/googletest


text:
---
title: I Love These CSS Tricks - Manage your CSS Much Better
url: Some CSS Tricks to get your work done.
date: 2019-10-06T07:40:03.683Z
carn: /
description: >-
  I just featured 3 tricks and they are really useful. You can read the entire Style Guide here
tags:
  - tricks
  - lists
  - css
---
I was a little busy around these days(School HomeWork), But I am writing this article today. These days I learned a lot about Design Systems [(Atomic Design)](https://bradfrost.com/blog/post/atomic-web-design/) I will definitely write a post about this. I was really wasting time choosing different design components but There are lots of [PatternLibraries](https://www.styleguides.io) available. Today I will share some CSS Tricks I am using Right now:
#### Titling the Sections
You can organize your CSS Sections Like This:

```html
\* ------------------------------- *\
      #SECTION-TITLE
  /* ----------------------------- */
```
The title of the section is prefixed with a hash (#) symbol to allow us to perform more targeted searches (e.g. grep, etc.): instead of searching for just SECTION-TITLE—which may yield many results—a more scoped search of #SECTION-TITLE should return only the section in question.

----
####Alignment
You can Align common or related declarations like this :

```css
.foo {
  -webkit-border-radius: 3px;
     -moz-border-radius: 3px;
          border-radius: 3px;
}
```
It can really help you understand properties better and easily readable.

----
#### Organizing Classes
This is not a CSS Trick but it's somehow related to CSS, and it will only work if you are using HTML attributes with quotes (single or double). 95% of coders use quotes for attributes for better support. You can organize CSS Classes by using [ ] Square Brackets.

```html
div class="[ box box-green] [ bio bio-long ]">
```

It will be really helpful to organize Custom Classes and Framework Classes differently.

#### Specificity and Readability
```css
ul.nav{}
/* ul*/.nav {}
```
We use CSS selectors to specify like this `ul.nav` or `div.nav`. But sometimes you can be stuck within the Specific Design. But you can use an approach like this `/*ul*/.nav`. It stills gives you the idea of what element you are using in DOM and improves the readability and increase the Specificity.

---
I just featured 3 tricks and they are really useful. You can read the entire Style Guide here [https://cssguidelin.es/](https://cssguidelin.es/). That's all There are some of The Information about me:
 - I'm kinda active on Twitter : [twitter.com/justaashir](https://twitter.com/justaashir)


text:
# Typescript to Google Apps - Using ts2gas directly

## Build
`npm run build`

## Special Dependencies
 - You need to install TS type definition files:
     - `npm install` based on package.json
     - Not necessary for build to work, but IDE will complain without it
 - ts2gas (in package.json)
 - fs-extra (in package.json)

repository: joshuatz/typescript-to-gas-demos

repo_name: joshuatz/typescript-to-gas-demos


text:
Tools for writing a language server following the [Language Server
Protocol][LSP].

[LSP]: https://github.com/Microsoft/language-server-protocol

Any class implementing `LanguageServer` can be started as a server communicating
over `stdin` and `stdout`. Includes types for all the messages that can be sent
to and from the client.

# Looking for a Dart language server?

The Dart language server implemented in this package is deprecated. Instead, use
the [analysis server][] from the Dart SDK with the `--lsp` flag.

[analysis server]: https://github.com/dart-lang/sdk/blob/master/pkg/analysis_server/tool/lsp_spec/README.md


text:
# Hints

## General

## 1. Creating a List

- `Lists` in python may be [constructed](https://docs.python.org/3/library/stdtypes.html#list) in several ways.
- This function should [return](https://www.w3schools.com/python/ref_keyword_return.asp) a `list`.

## 2. Creating a copy of a List

- `Lists` can be [nested](https://realpython.com/python-lists-tuples/#lists-can-be-nested), this means that a `list` can be an element of another `list`.
- This function should [return](https://www.w3schools.com/python/ref_keyword_return.asp) a `list` containing two `lists`.

## 3. Concatenating Lists

- Sequence types such as `list` already support a few [common operations](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range)
- This function should [return](https://www.w3schools.com/python/ref_keyword_return.asp) a `list`.

## 4. Testing List Membership

- Sequence types such as `list` already support a few [common operations](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range)
- This function should [return](https://www.w3schools.com/python/ref_keyword_return.asp) a `boolean`.

## 5. Accessing List Elements by Index

- Sequence types such as `list` already support a few [common operations](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range)
- To access an element use the square brackets notation.
- Remember that the first element of the `list` is at index 0
- In python, negative indexing starts the count from the end. This mean that you can find the last element of the `list` at index -1.
- This function should [return](https://www.w3schools.com/python/ref_keyword_return.asp) a `list` containing two elements.

## 6. Accessing Sublists by Slicing

- Sequence types such as `list` already support a few [common operations](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range)
- For the last part of the exercise, think about reusing the code from the functions that you just implemented.
- These functions should [return](https://www.w3schools.com/python/ref_keyword_return.asp) a `list`.

## 7. Iterating Over List Items

- There are a few techniques to [iterate over a `list` in python](https://www.geeksforgeeks.org/iterate-over-a-list-in-python/).
- You should use the function `print` on each element of the `list` to print each of them on a separate line.
- This function should not [return](https://www.w3schools.com/python/ref_keyword_return.asp) anything so you should end it with just the statement `return`.

## 8. Creating Lists with Mixed Data Types

- There are many [built-in types](https://docs.python.org/3/library/stdtypes.html) in python.
- [`Lists` Can Contain Arbitrary Objects](https://realpython.com/python-lists-tuples/#lists-can-contain-arbitrary-objects).
- This function should [return](https://www.w3schools.com/python/ref_keyword_return.asp) a `list`.

## 9. Modifying Values in Lists

- `Lists` in python are mutable, this means that once a `list` is created, you can modify, delete or add any element as you wish.
- Python provides a wide range of [ways to modify `lists`](https://realpython.com/python-lists-tuples/#lists-are-mutable).
- This function should not [return](https://www.w3schools.com/python/ref_keyword_return.asp) anything so you should end it with the statement `return` alone.


text:
[![Build Status](https://travis-ci.org/SofHad/LogboardBundle.png?branch=master,dev)](https://travis-ci.org/SofHad/LogboardBundle)

#### Log Reporting Dashboard for Symfony2

## Installation

Add this in your `composer.json`

    "require-dev": {
        [...]
        "so/logboard-bundle": "1.4.*@dev"
    },

And run `php composer.phar update so/logboard-bundle`

#### Register the bundle in your AppKernel (`app/AppKernel.php`)

Most of the time, we need this bundle to be only activated in the `dev` environment

    [...]
    if (in_array($this->getEnvironment(), array('dev', 'test'))) {
        [...]
        $bundles[] = new So\LogboardBundle\LogboardBundle();
    }

#### Configuration file
- Create a new file logboard.yml in app/config directory and import it into config_dev.yml
- Copy/Paste the default configuration and adapt it to your environment

  See the default configuration here: https://github.com/SofHad/LogboardBundle/blob/master/Resources/config/Logboard_config_default.yml

## Screenshot

Here is a quick look at the log reporting dashboard:

![Screenshot](Resources/assets/screen_view1.png)
![Screenshot](Resources/assets/screen_view2.png)
![Screenshot](Resources/assets/screen_view3.png)

##License

This bundle is available under the [MIT license](Resources/meta/LICENSE).

repository: SofHad/LogboardBundle

repo_name: SofHad/LogboardBundle


text:
# El Javascripto y los Emuladores de la Muerte

## Installation

1.- Just clone this repo and run:

    npm install

    grunt serve

This will launch a local server on port 8000 (you can change the port by passing a --port param to the grunt serve command), and you can check the entire presentation on your computer.

## License

MIT

repository: Xabadu/Presentations

repo_name: Xabadu/Presentations


text:
---
layout: page
title: Xia Liyi's Project Portfolio Page
---

## Project: Ace CS2103/T

Ace CS2103/T is a desktop task manager application used for keeping track of tasks for CS2103/T Software Engineering. The user interacts with it using a CLI, and it has a GUI created with JavaFX.

Given below are my contributions to the project.

* **Code contributed**: [RepoSense_link]

* **Model**:
* **Storage**:
* **Architecture Design**:
* **Documentation**:
  * User Guide:

  * Developer Guide:

* **Contributions to team-based tasks**:

* **Community**:

repository: XIA-LIYI/tp

repo_name: XIA-LIYI/tp


text:
---
title: Pelvic Pain
avatar: hispanic-female-with-flower
---

Pelvic pain can be caused by a variety of things. Many women report
pelvic pain at some time in their life. There may be more than one
reason for the pain. In some women the pain is intermittent (comes and
goes). Other women may feel pain only during certain times of the
month, and some others may experience chronic pelvic pain. Your doctor
can work with you to determine possible reasons for the pain, and a
treatment plan.

Pain may only occur during intercourse. This type of pelvic pain may
have physical or psychological causes. During sex, a woman’s body goes
through several changes. During the first stages of arousal when the
vagina and vulva secrete moisture, the muscles in the vagina relax. The
clitoris gets bigger as the blood flows into the pelvis. These changes
also cause the vagina to get deeper and wider, preparing to receive the
penis. If any of these changes do not occur, intercourse can be painful.

If a woman is not aroused, dryness may cause the vulva to be irritated
or sensitive. The vulva is outside the vagina. Pain outside the vagina
can also be caused by certain soaps, vaginal sprays, cysts, or an
infection.

If pain is felt inside the vagina it may be caused by dryness. Pain in
the vagina may also be caused by vaginal sores or infection. Some women
find that a lubricant helps. Remember that only water based lubricants
are safe to use with a condom. Other kinds of lubricants can cause the
condom to break or become weakened. A frank discussion with your partner
about what arouses you may help. Perhaps you need your partner to allow
extra time for you to become fully aroused.

If a woman has vaginitas, such as a yeast infection, her vagina may also
be irritated or inflamed. This can also cause pain in the vagina. If you
have itching, burning, or a discharge, you may have vaginitis. Your
doctor can prescribe medication to be used vaginally or an oral
medication to treat vaginitis. These infections are usually treated with
antibiotics. Once treated, the pain should improve within a few days.
These infections may recur. Your doctor may recommend that your partner
be treated also.

Pain on intercourse can also be caused when the muscles of the vagina do
not relax during intercourse. Sometimes this happens due to scaring of
the vulva or vagina from childbirth, infection or sensitivity to the
condoms, spermicides or exposure to other irritants.

Sometimes this type of pain may be related to fear, past sexual abuse,
or rape. Discuss this with your healthcare provider. Treatment may be
helpful. Because sex is so closely tied to our emotions, pain on
intercourse can be affected by our state of mind. Many emotional factors
are at play. Fear of getting pregnant or of contacting an STD may cause
an inability to relax during sex, or may cause a woman to not produce
enough lubrication. Exploring the emotions tied to sex may help uncover
a source of pain that can be treated with the help of a counselor.

If a woman experiences deep pelvic pain, she may have pelvic
Inflammatory Disease, Endometriosis, Ovarian cysts or an Ectopic
Pregnancy. For a diagnosis and treatment plan, see your doctor.

Sometimes, a Urinary Tract infection, or an infection of the bladder or
kidneys can cause pain in the pelvic region. These types of infections
usually are accompanied by pain on urination, strong urge to urinate, or
pain in one or both sides. They are usually treated with antibiotics.

Ovarian cysts are fluid filled sacks. Some cysts are a normal part of
the menstrual cycle. Often the cyst will go away as the woman’s period
ends. A dull ache or heaviness in the pelvis may be due to cysts that do
not go away. If these cysts cause sharp pains, it may be due to the cyst
leaking fluid but not dissolving. Your doctor should be able to detect
cysts during your pelvic exam. If a cyst causes problems and does not go
away by itself, your doctor may advise surgery.

Fibroids are growths that occur on the inside of the uterus, on its
outer surface, or deep in the walls of the uterus. They are not
cancerous. Fibroids may cause heavier, more frequent periods with pain
or pressure in the lower back or abdomen. Some fibroids may not cause
any discomfort at all.

To determine the cause of your pelvic pain you will need to schedule a
Well Woman Exam here at the Woman’s Health Center. Your doctor will
review a detailed gynecological history, do a pelvic exam, and may order
outside tests.

Some tests that are used to diagnose problems are:

- MRI (Magnetic Resonance Imaging) This allows your doctor to see a
  picture of your internal organs, and pelvic structures.
- Sonogram allows your doctor to see images of your uterus and ovaries
  with sound waves reflected off internal organs.
- CT SCAN. This is an x-ray that shows internal organs.
- Laparoscopy. This is a minimally invasive surgical procedure used to
  look up close at the organs.

There are so many other tests that can be ordered to determine the exact
nature of the problem. Your doctor will order necessary tests of refer
you to the proper specialist.

repository: binaryphile/tampawomanshealth

branch_name: HEAD

repo_name: binaryphile/tampawomanshealth