| Class | Description |
|---|---|
| Onnx | |
| Onnx.AttributeProto |
A named attribute containing either singular float, integer, string
and tensor values, or repeated float, integer, string and tensor values.
|
| Onnx.AttributeProto.Builder |
A named attribute containing either singular float, integer, string
and tensor values, or repeated float, integer, string and tensor values.
|
| Onnx.GraphProto |
GraphProto defines a parameterized series of nodes to form a directed acyclic graph.
|
| Onnx.GraphProto.Builder |
GraphProto defines a parameterized series of nodes to form a directed acyclic graph.
|
| Onnx.ModelProto |
ModelProto is a top-level file/container format for bundling a ML model.
|
| Onnx.ModelProto.Builder |
ModelProto is a top-level file/container format for bundling a ML model.
|
| Onnx.NodeProto |
NodeProto stores a node that is similar to the notion of "layer"
or "operator" in many deep learning frameworks.
|
| Onnx.NodeProto.Builder |
NodeProto stores a node that is similar to the notion of "layer"
or "operator" in many deep learning frameworks.
|
| Onnx.OperatorSetIdProto |
OperatorSets are uniquely identified by a (domain, opset_version) pair.
|
| Onnx.OperatorSetIdProto.Builder |
OperatorSets are uniquely identified by a (domain, opset_version) pair.
|
| Onnx.StringStringEntryProto |
StringStringEntryProto follows the pattern for cross-proto-version maps.
|
| Onnx.StringStringEntryProto.Builder |
StringStringEntryProto follows the pattern for cross-proto-version maps.
|
| Onnx.TensorProto |
A message defined to store a tensor in its serialized format.
|
| Onnx.TensorProto.Builder |
A message defined to store a tensor in its serialized format.
|
| Onnx.TensorProto.Segment |
For very large tensors, we may want to store them in chunks, in which
case the following fields will specify the segment that is stored in
the current TensorProto.
|
| Onnx.TensorProto.Segment.Builder |
For very large tensors, we may want to store them in chunks, in which
case the following fields will specify the segment that is stored in
the current TensorProto.
|
| Onnx.TensorShapeProto |
Defines a tensor shape.
|
| Onnx.TensorShapeProto.Builder |
Defines a tensor shape.
|
| Onnx.TensorShapeProto.Dimension |
Protobuf type
onnx.TensorShapeProto.Dimension |
| Onnx.TensorShapeProto.Dimension.Builder |
Protobuf type
onnx.TensorShapeProto.Dimension |
| Onnx.TypeProto |
Define the types.
|
| Onnx.TypeProto.Builder |
Define the types.
|
| Onnx.TypeProto.Tensor |
Protobuf type
onnx.TypeProto.Tensor |
| Onnx.TypeProto.Tensor.Builder |
Protobuf type
onnx.TypeProto.Tensor |
| Onnx.ValueInfoProto |
Defines information on value, including the name, the type, and
the shape of the value.
|
| Onnx.ValueInfoProto.Builder |
Defines information on value, including the name, the type, and
the shape of the value.
|
| OnnxMl | |
| OnnxMl.AttributeProto |
A named attribute containing either singular float, integer, string
and tensor values, or repeated float, integer, string and tensor values.
|
| OnnxMl.AttributeProto.Builder |
A named attribute containing either singular float, integer, string
and tensor values, or repeated float, integer, string and tensor values.
|
| OnnxMl.GraphProto |
GraphProto defines a parameterized series of nodes to form a directed acyclic graph.
|
| OnnxMl.GraphProto.Builder |
GraphProto defines a parameterized series of nodes to form a directed acyclic graph.
|
| OnnxMl.ModelProto |
ModelProto is a top-level file/container format for bundling a ML model.
|
| OnnxMl.ModelProto.Builder |
ModelProto is a top-level file/container format for bundling a ML model.
|
| OnnxMl.NodeProto |
NodeProto stores a node that is similar to the notion of "layer"
or "operator" in many deep learning frameworks.
|
| OnnxMl.NodeProto.Builder |
NodeProto stores a node that is similar to the notion of "layer"
or "operator" in many deep learning frameworks.
|
| OnnxMl.OperatorSetIdProto |
OperatorSets are uniquely identified by a (domain, opset_version) pair.
|
| OnnxMl.OperatorSetIdProto.Builder |
OperatorSets are uniquely identified by a (domain, opset_version) pair.
|
| OnnxMl.StringStringEntryProto |
StringStringEntryProto follows the pattern for cross-proto-version maps.
|
| OnnxMl.StringStringEntryProto.Builder |
StringStringEntryProto follows the pattern for cross-proto-version maps.
|
| OnnxMl.TensorProto |
A message defined to store a tensor in its serialized format.
|
| OnnxMl.TensorProto.Builder |
A message defined to store a tensor in its serialized format.
|
| OnnxMl.TensorProto.Segment |
For very large tensors, we may want to store them in chunks, in which
case the following fields will specify the segment that is stored in
the current TensorProto.
|
| OnnxMl.TensorProto.Segment.Builder |
For very large tensors, we may want to store them in chunks, in which
case the following fields will specify the segment that is stored in
the current TensorProto.
|
| OnnxMl.TensorShapeProto |
Defines a tensor shape.
|
| OnnxMl.TensorShapeProto.Builder |
Defines a tensor shape.
|
| OnnxMl.TensorShapeProto.Dimension |
Protobuf type
onnx.TensorShapeProto.Dimension |
| OnnxMl.TensorShapeProto.Dimension.Builder |
Protobuf type
onnx.TensorShapeProto.Dimension |
| OnnxMl.TypeProto |
Define the types.
|
| OnnxMl.TypeProto.Builder |
Define the types.
|
| OnnxMl.TypeProto.Map |
map<K,V>
Protobuf type
onnx.TypeProto.Map |
| OnnxMl.TypeProto.Map.Builder |
map<K,V>
Protobuf type
onnx.TypeProto.Map |
| OnnxMl.TypeProto.Sequence |
repeated T
Protobuf type
onnx.TypeProto.Sequence |
| OnnxMl.TypeProto.Sequence.Builder |
repeated T
Protobuf type
onnx.TypeProto.Sequence |
| OnnxMl.TypeProto.Tensor |
Protobuf type
onnx.TypeProto.Tensor |
| OnnxMl.TypeProto.Tensor.Builder |
Protobuf type
onnx.TypeProto.Tensor |
| OnnxMl.ValueInfoProto |
Defines information on value, including the name, the type, and
the shape of the value.
|
| OnnxMl.ValueInfoProto.Builder |
Defines information on value, including the name, the type, and
the shape of the value.
|
| OnnxOperators | |
| OnnxOperators.OperatorProto |
An OperatorProto represents the immutable specification of the signature
and semantics of an operator.
|
| OnnxOperators.OperatorProto.Builder |
An OperatorProto represents the immutable specification of the signature
and semantics of an operator.
|
| OnnxOperators.OperatorSetProto |
An OperatorSetProto represents an immutable set of immutable operator
specifications.
|
| OnnxOperators.OperatorSetProto.Builder |
An OperatorSetProto represents an immutable set of immutable operator
specifications.
|
| Enum | Description |
|---|---|
| Onnx.AttributeProto.AttributeType |
Note: this enum is structurally identical to the OpSchema::AttrType
enum defined in schema.h.
|
| Onnx.TensorProto.DataType |
Protobuf enum
onnx.TensorProto.DataType |
| Onnx.TensorShapeProto.Dimension.ValueCase | |
| Onnx.TypeProto.ValueCase | |
| Onnx.Version |
To be compatible with both proto2 and proto3, we will use a version number
that is not defined by the default value but an explicit enum number.
|
| OnnxMl.AttributeProto.AttributeType |
Note: this enum is structurally identical to the OpSchema::AttrType
enum defined in schema.h.
|
| OnnxMl.TensorProto.DataType |
Protobuf enum
onnx.TensorProto.DataType |
| OnnxMl.TensorShapeProto.Dimension.ValueCase | |
| OnnxMl.TypeProto.ValueCase | |
| OnnxMl.Version |
To be compatible with both proto2 and proto3, we will use a version number
that is not defined by the default value but an explicit enum number.
|
| OnnxOperators.OperatorProto.OperatorStatus |
Protobuf enum
onnx.OperatorProto.OperatorStatus |
Copyright © 2020. All rights reserved.


Dimensionality reduction techniques for binary data including logistic PCA.
| Version: | 0.2 |
| Imports: | ggplot2 |
| Suggests: | rARPACK (≥ 0.10-0), testthat (≥ 0.11.0), knitr, rmarkdown |
| Published: | 2016-03-14 |
| Author: | Andrew J. Landgraf |
| Maintainer: | Andrew J. Landgraf <andland at gmail.com> |
| License: | MIT + file LICENSE |
| URL: | https://github.com/andland/logisticPCA |
| NeedsCompilation: | yes |
| Citation: | logisticPCA citation info |
| Materials: | README NEWS |
| CRAN checks: | logisticPCA results |
| Reference manual: | logisticPCA.pdf |
| Vignettes: |
An Introduction to the 'logisticPCA' R Package |
| Package source: | logisticPCA_0.2.tar.gz |
| Windows binaries: | r-devel: logisticPCA_0.2.zip, r-release: logisticPCA_0.2.zip, r-oldrel: logisticPCA_0.2.zip |
| OS X binaries: | r-release: logisticPCA_0.2.tgz, r-oldrel: logisticPCA_0.2.tgz |
| Old sources: | logisticPCA archive |
Please use the canonical form https://CRAN.R-project.org/package=logisticPCA to link to this page.


ABAP Quick Fixes - Change Append to INSERT VALUE
Using this quick fix, you can combine subsequent assignment of variables with APPEND statement at the end, to one single INSERT VALUE statement.
No selection of the whole block is required.
It's very useful in case of old ALV field-catalog preparation coding or for RANGES


Alignments of various nucleotide sequences to the reference sequences of selected genomes include:
Alignments of reference genomes to each other are also available, as part of the Ensembl Comparative Genomics ("Compara") database.


Explicit download of this package is not necessary when using auto installation instructions.
LWP::Protocol::https provides https support for LWP::UserAgent (i.e. for LWP). This module uses auto installation instructions:.
cpan -i LWP::Protocol::https
Install Perl modules using the cpan shell install command. The command automatically downloads the source from the CPAN archive, extracts it, runs the compilation, testing and installation commands mentioned above.
The first time you run cpan, you'll be prompted to enter
some information regarding download locations and methods. This
information is retained in files located in ~/.cpan
. Start the cpan shell by issuing
'cpan' as the
root
user. Any module may now be
installed from the cpan>
prompt with the command:
install <Module::Name>
For additional commands and help, issue 'help' from the cpan>
prompt.
Alternatively, for scripted or non-interactive installations, use
the following syntax as the root
user to install one or more modules:
cpan -i <Module1::Name> <Module2::Name>
Review the cpan.1
man page for
additional parameters you can pass to cpan on the command line.
Last updated on 2018-09-22 16:32:07 -0700


Fotorenamer help pagePerform the following steps to use the application:
What's the application purpose? Normally digital camera's picture names are: IMG_number.jpg Unfortunately you do not get a clue on when the picture was taken. Many camera applications change the date of the image to the date it was written on your hard disc. Therefore the application extracts picture EXIF data and writes the original creation date as a new file name.The relevant naming schema is: YYYYMMDD_HHMM_IMG_number.jpg A positive side effect of ISO-date formats is its naturally sortable by creation date.EXAMPLE Your picture IMG_1865.jpg will become20031020_1417_IMG_1865.jpg if your picture was taken on 2003-10-20 at 2:17 pm.© Idea/Author Aiki IT, Berlin Last update: 2015-12-27 |


Bhumi Pednekar Vs Taapsee Pannu: Who Wore The Sequin Top Better?
by Prajakta AjgaonkarThe Saand Ki Aankh actresses Bhumi Pednekar and Taapsee Pannu were papped in sequin tops and black pants at different events. Let’s see which diva scored more points on the style meter
Some days back, Taapsee Pannu was papped at the success bash of Saand Ki Aankh wearing a glitter top. Taapsee wore a one-shouldered rainbow sequin top with high-waist black pants.
Now talking about Bhumi Pednekar’s look, the actress was spotted during promotions of her film Pati Patni Aur Woh. The actress was dressed in a shimmery multi-coloured crop-top that she paired with high-waist black pants.
Well, both the actresses chose to add glitter to their outfits and you got to tell us who pulled off the sequin top look better?
Image Source:- viralbhayani


Namespace for the rules for fieldsets
- Source:
Methods
-
(static) allCountriesValid() → {Array}
-
Function to check all entered countries are valid
- Source:
Returns:
Array of invalidField objects for each invalid country field or an empty array if none- Type
- Array
-
(static) allNonEmpty() → {Array}
-
Function to check all fields contained in this set have a value
- Source:
Returns:
Array of invalidField objects for the fields without a value or an empty array if none- Type
- Array
-
(static) atLeastOneChecked() → {Array}
-
Function to check at least one of the child checkboxes is checked
- Source:
Returns:
Array containing one invalidField if invalid or none if not- Type
- Array
-
(static) atLeastOneCountry() → {Array}
-
Function to check at least one country has been entered in the 'Other countries' section
- Source:
Returns:
Array containing an invalidField object for the 'Other countries' section- Type
- Array
-
(static) atLeastOneNonEmpty() → {Array}
-
Function to check at least one of the children has a value that is not empty
- Source:
Returns:
Array containing one invalidField if invalid or none if not- Type
- Array
-
(static) atLeastOneTextEntry() → {Array}
-
Function to check at least one of the children has a value that is not empty
- Source:
Returns:
Array containing one invalidField if invalid or none if not- Type
- Array
-
(static) atLeastOneValid() → {Array}
-
Function to check at least one child field is valid
- Source:
Returns:
Array of invalidField objects for each invalid child or an empty array if none- Type
- Array
-
(static) checkedOtherIsValid() → {Array}
-
Function to check the 'Other countries' section is visible & its input is valid
- Source:
Returns:
Array containing invalidField objects from validating the 'Other countries' section or an empty array if none- Type
- Array
-
(static) correctAge() → {Array}
-
Function to check the entered birth data is within the accepted age range
- Source:
Returns:
Array of invalidField objects for the day, month & year fields if date is invalid or an empty array if valid- Type
- Array
-
(static) fieldOrExcuse() → {Array}
-
Function to check if either a field or its excuse section is valid
- Source:
Returns:
Array of an invalidField for the field or an empty array if either the field or the excuse is valid- Type
- Array
-
(static) firstChildValid() → {Array}
-
Function to check if the first child field is valid
- Source:
Returns:
Array containing an invalidField object for the first field if invalid or an empty array if not- Type
- Array
-
(static) max5Countries() → {Array}
-
Function to check the number of countries entered are below 5
- Source:
Returns:
Array containing an invalidField object for the 'Other countries' field if more than 5 countries or an empty array if not- Type
- Array
-
(static) radioNonEmpty() → {Array}
-
Function to check at least one of the child radios is checked
- Source:
Returns:
Array containing one invalidField if invalid or none if not- Type
- Array


Sergey was born in Moscow, Russia on August 21, 1973. Because of the religious discrimination his family faced, and the freedom that was hard to come by in Russia, his father decided to move the family to the United States. Sergey was 6 years old when he moved to the US.. He graduated from the University of Maryland in Mathematics and Computer Science and when on to grad school at Stanford University, where he met his Larry Page, his Google partner to be. At 43, Sergey has gone on to become the 12th richest person in the world.


Unscheduled
{{else}} {{#if appointment.ewl}}Patient is currently on the Electronic Waiting List (EWL).
{{else}} {{#compare appointment.type "VA"}}Scheduled Date
{{#if appointment.date}}{{appointment.date}}{{else}}N/A{{/if}}
Clinic
{{#if appointment.clinic}}{{appointment.clinic}}{{else}}N/A{{/if}}
Provider
{{#if appointment.provider}}{{appointment.provider}}{{else}}N/A{{/if}}
Type of Community Care
{{#if appointment.communityCareType}}{{appointment.communityCareType}}{{else}}N/A{{/if}}
Status
{{#if appointment.status}}{{appointment.status}}{{else}}N/A{{/if}}
Patient is currently being reviewed by eConsult.
{{/compare}} {{/if}} {{/if}}


You are here: Home
▸
Dive Into HTML5
▸
1. It’s not one big thingYou may well ask: “How can I start using HTML5 if older browsers don’t support it?” But the question itself is misleading.  So you can’t detect “HTML5 support,” because that doesn’t make any sense. But you can detect support for individual features, like canvas, video, or geolocation.
You may think of HTML as tags and angle brackets. That’s an important part of it, but it’s not the whole story. The HTML5 specification also defines how those angle brackets interact with JavaScript, through the Document Object Model (DOM). HTML5 doesn’t just define a Chapter 2 and Appendix A will teach you how to properly detect support for each new HTML5 feature. 2.  HTML5 builds on that success. You don’t need to throw away your existing markup. You don’t need to relearn things you already know. If your web application worked yesterday in HTML 4, it will still work today in HTML5. Period.
Now, if you want to improve your web applications, you’ve come to the right place. Here’s a concrete example: HTML5 supports all the form controls from HTML 4, but it also includes new input controls. Some of these are long-overdue additions like sliders and date pickers; others are more subtle. For example, the Read all the gory details about HTML5 forms in Chapter 9. 3. It’s easy to get started“Upgrading” to HTML5 can be as simple as changing your doctype. The doctype should already be on the first line of every HTML page. Previous versions of HTML defined a lot of doctypes, and choosing the right one could be tricky. In HTML5, there is only one doctype:
Upgrading to the HTML5 doctype won’t break your existing markup, because obsolete elements previously defined in HTML 4 will still render in HTML5. But it will allow you to use — and validate — new semantic elements like 4. It already worksWhether you want to draw on a canvas, play video, design better forms, or build web applications that work offline, you’ll find that HTML5 is already well-supported. Firefox, Safari, Chrome, Opera, and mobile browsers already support canvas (Chapter 4), video (Chapter 5), geolocation (Chapter 6), local storage (Chapter 7), and more. Google already supports microdata annotations (Chapter 10). Even Microsoft — rarely known for blazing the trail of standards support — supports most HTML5 features in Internet Explorer 9. Each chapter of this book includes the all-too-familiar browser compatibility charts. But more importantly, each chapter includes a frank discussion of your options if you need to support older browsers. HTML5 features like geolocation (Chapter 6) and video (Chapter 5) were first provided by browser plugins like Gears or Flash. Other features, like canvas (Chapter 4), can be emulated entirely in JavaScript. This book will teach you how to target the native features of modern browsers, without leaving older browsers behind. 5. It’s here to stayTim Berners-Lee invented the world wide web in the early 1990s. He later founded the W3C to act as a steward of web standards, which the organization has done for more than 15 years. Here is what the W3C had to say about the future of web standards, in July 2009: Today the Director announces that when the XHTML 2 Working Group charter expires as scheduled at the end of 2009, the charter will not be renewed. By doing so, and by increasing resources in the HTML Working Group, W3C hopes to accelerate the progress of HTML5 and clarify W3C’s position regarding the future of HTML. HTML5 is here to stay. Let’s dive in.
|


{{#contentFor "title"}}About Cyclops{{/contentFor}}
The Platform CenturyLink UX Pattern Library
Cyclops is our own collection of atomic pieces that make up the CenturyLink Platform Control Portal interface. By documenting and assembling a reference site of ui/ux patterns, we are able to speed up the development process, and address internal communication problems inherent with working on a distributed team. A common lexicon of code and UI elements benefits us in a few ways:
This Pattern Library isn’t meant to be a UI framework like Bootstrap — although we do use bootstrap as our underlying page structure. It’s tailored specifically to our needs, so if you attempt to use it as a foundation for a future project your mileage may vary. It uses the same source css and javascript libraries that are available in the Control Portal itself.
This is a living document — we will be adding and amending patterns as we see fit. If you have suggestions for additional patterns or have questions about anything you see here, here are some ways to get in touch:
The UI/UX Team


TABLE OF INTERACTIONS WITH
NON-CONTRACEPTIVE ESTROGENS
From the French ANSM drug interactions document of September 2016, p. 91
NON-CONTRACEPTIVE ESTROGENS CLASS CODE: G03C-001 |
ANTICONVULSANT ENZYMATIC INDUCERS CLASS CODE: N03A-001 |
Decrease of the effectiveness of the estrogen . |
Precaution for use Clinical monitoring and possible adjustment of the dosage of the hormonal treatment during the administration of the anticonvulsant inducer and after it is stopped. |
NON-CONTRACEPTIVE ESTROGENS CLASS CODE: G03C-001 |
BOCEPREVIR RxNorm: 1102129 ATC: J05AE12 |
Decrease of the effectiveness of the estrogen |
Precaution for use Clinical monitoring and possible adjustment of the dosage of the hormonal treatment during the administration of the boceprevir. |
NON-CONTRACEPTIVE ESTROGENS CLASS CODE: G03C-001 |
THYROID HORMONES CLASS CODE: H03AA |
Risk of clinical hypothyroidism in cases of estrogen replacement therapy. |
Precaution for use Clinical and biological monitoring; possible adjustment of the doses of the thyroid hormone for menopausal women taking estrogens. |
NON-CONTRACEPTIVE ESTROGENS CLASS CODE: G03C-001 |
OXCARBAZEPINE RxNorm: 32624 ATC: N03AF02 |
Risk of decrease of the effectiveness of the hormonal treatment, due to increase of its hepatic metabolism by the oxcarbazepine. |
Precaution for use Clinical monitoring and possible adjustment of the dosage of the hormonal treatment during the treatment with the oxcarbazepin and after it is stopped. |
NON-CONTRACEPTIVE ESTROGENS CLASS CODE: G03C-001 |
TELAPREVIR Rx Norm: 1102261 ATC: J05AE11 |
Decrease of the effectiveness of the estrogen. |
Precaution for use Clinical monitoring and possible adjustment of the dosage of the hormonal treatment during the administration of the telaprevir and after it is stopped. |


Gallery
Header
Breif overview or description. *Note: This section will not display on small mobile devices.
Item Name
Date
Item Name
Date
Item Name
Date
Item Name
Date
Item Name
Date
Item Name
Date
Notes
Add additional relevant information for review in this section. Suggestions may include shared themes, connections, concepts, and study tips.


Install
Redux DevTools Extension
Please see your developer console
Bookmarklet:
video-events-debugger
- please bookmark it.


---
layout: page
# The Achievements page.
---
{% for year in site.data.resume_info.achievement_list %}
{% capture this_year %}{{ year.value }}{% endcapture %}
{{this_year}}
{% for achievement in year.achievement_list%}
-
{{ achievement }}
{% endfor %}
{% endfor %}


Control Scheme: This is the pattern of phone to drone interaction that the system adheres to.
Device Interaction: These are the communication schemes that take place between the drone, phone, and ground station.
Drone: The Iris 3dr. The drone is controlled by the phones commands.
DroneKit Python: Python library that allows programmers to create powerful applications for UAVs
Firebase: The database used to store coordinates and work with the ground control station to control the drone.
GPS (Global Positioning System): Used by the drone and our software for tracking position and movement.
Ground Station: This is the computer that mediates the commands of the phone and the movements of the drone.
Phone: The phone is used to control the movement of the drone. For the purposes of this app we will be using an android phone
Zone: This is the area limitation (geofence) placed on the drone for safety precautions.
We used Jira to organize sprints and keep up to date on the status of our project.
Sprint 1: Consisted of getting the basics of the project working inluding: bluetooth, gyro data, and basic drone commands.
Early software issues caused us to leave some tasks in the backlog and prioritize new tasks.
Sprint 2: We reevaluated the direction of our project and focused on switching from bluetooth to firebase and making the final connections and computations to get the drone moving.
We used the Iris 3DR Drone for our testing and final demonstration.
The drone is a classic quad copter equipped with 4 propellers.
It comes with a detachable and rechargeable battery, controller as well as many other accessories.
In addition we used an android phone as our new controller and a laptop as our ground station to move the drone.
The backend was built using python and some libraries to talk between the drone and the ground control station.
Ground control connects to the Firebase database which stores all the data from the mobile app.
The data is stored in real time from the mobile app for the python code to access and interpret into commands for the drone.
The app was built for Android using android studio.
The app displays the current values of gravity for each of the three directions.
Under the hood these values are being sent to the being sent to a database that stores them for future use.
We made the app responsive by taking new readings from the sensors frequently and lightweight by saving additional computations for the ground control station to make.
The Zone, also known as the Drone Phone Zone is our built in saftey feature for the project.
In order to safely limit where the drone can go, we created a geofence that prevents the drone from leaving a square area.
For testing purposes this was limited to the flying field, however the parameters can easily be changed to reflect the location of the user.
The idea is to maximize safety so that even those with little to no flight experience could control the drone easily and safely.
We would like to get bluetooth to work in order to have a more reliable and quick connection.
In addition, edits to the directional movement to make it more efficient. (such as a consistent heading so changing direction is faster)


UNIMODEM sample controller-less modem driver (Fakemodem)
SUMMARY
This
sample demonstrates a simple controller-less modem driver. This
driver supports sending and receiving AT commands using the ReadFile/WriteFile calls or via a TAPI interface using an
application such as HyperTerminal.
BUILDING THE SAMPLE
Click
the Free Build Environment or Checked Build Environment icon under Development
Kits program group to set basic environment variables.
Change
to the directory containing the device source code, such as CD src\wdf\fakemodem.
Run build
-ceZ, or use the macro BLD. This command
invokes the Microsoft make routines to build the components. If the build succeeds, you will find the driver, fakemodem.sys, placed in a platform
specific subdirectory
src\network\modem\fakemodem\$(OBJ_PATH)\$O. If it fails you can find errors and warnings in the
buildxxx.err and buildxxx.err respectively, where xxx is either chk or fre depending on the build
environment.
INSTALLATION
To
install and test this driver, you do not need any real hardware. You can
install this driver either using Devcon.exe (ddk\tools\devcon) utility from the DDK or using toaster bus driver
sample.
To install the bus driver on Windows XP and Windows Server 2003:
- Double-click the ‘Add Hardware’
wizard in Control Panel.
- At the 'Welcome to the Add
Hardware Wizard', click ‘Next’.
- Select 'Yes, I have already
connected the hardware', then click Next.
- Select ‘Add a new hardware
device’ from the list, then click Next.
- Select ‘Install the hardware
that I manually select from a list(Advanced),' and then click next.
- Select ‘Modems’, then click
Next.
- Check the box which says
"Don't detect my modems; I will select it from a list.", then
click Next.
- Click 'Have Disk', make sure
that 'A:\' is in the "Copy manufacturer's files from:" box, and
click OK.
- Click on the desired entry, and
then click Next.
- At 'The wizard is ready to
install your hardware', click Next.
- Click Finish at 'Completing the
Add/Remove Hardware Wizard.'
To install the
driver using toaster bus:
·
Install the toaster bus driver.
Information on how to install the toaster bus driver is given in src\general\toaster\toaster.htm readme file.
·
Run the notify.exe (src\general\toaster\exe\notify) and choose Plug In a device
in the Bus menu.
·
In the plug in dialog, specify
{b85b7c50-6a01-11d2-b841-00c04fad5171}\fakemodem as
the Hardware Id and click okay.
The bus driver will enumerate a
device with the hardware id provided by the application. At this point:
On
Windows XP and later:
- "Found New Hardware Wizard"
dialog box will appear. Here select the radio button labeled "Install
from a list of specific location (Advanced)" and then hit the
"Next" button.
- In the following screen select the
radio button labeled " Search the best driver in these
locations" and then select "Include this location in the search
path" and specify the target media or the directory where the KMDF
coinstaller (wdfcoinstallerMMmmm.dll), INF and SYS files are copied and
then hit the "Next" button.
- The system will scan the directory and
pick up the matching INF and start the installation. You will get a
Hardware Installation Warning dialog stating that your driver has not
passed Windows Logo Testing. Hit "Continue Anyway" button.
- The system will copy the driver, INF
file, load the driver and start the device. If every thing goes fine, you
will get "Completing the Found New Hardware Wizard". Hit the
"Finish" button and the installation is complete.
- You should be able to see the device
in the Device manager under "Modems"
On
Windows 2000:
- "Found New Hardware Wizard"
dialog box will appear with the description of the device. Here click
"Next" button.
- In the following screen "Install
Hardware Device Driver", select the radio button labeled "Display
a list of known drivers for this device..." and then click
"Next" button.
- In the following dialog on
"Hardware Type", select "Other Devices" from the list
and click "Next".
- In the dialog on "Select a Device
Driver", click on "Have Disk".
- Specify the target media or the
directory where the KMDF coinstaller (wdfcoinstallerMMmmm.dll), INF and
SYS files are copied and then hit the "Okay" button.
- Select "OSR" in the
Manufacture section selection and click "Next".
- Click "Next" on the
"Start Device Driver Installation" dialog.
- Click Finish at 'Completing the
Add/Remove Hardware Wizard.'
Note that if you get a warning dialog with
regards to Windows Logo, or unsigned drivers, testing then click on continue.
USAGE
Once
installed, you can talk to the fakemodem driver
through HyperTerminal, or via ReadFile/WriteFile calls. The
AT command set supported by fakemodem includes:
AT returns OK
ATA returns CONNECT
ATD<number> returns CONNECT
CODE
TOUR
File
Manifest
File Description
readwrit.c Routines for receiving and sending text. This includes processing AT commands.
Driver.c Fakemodem driver initialization entry points and for handling Plug & Play events.
ioctl.c Routines to handle IOCTL messages.
mdmfake.inf INF file for installing the fakemodem driver
Top
of page
© Microsoft
Corporation 2000


Overview of issue labels¶
Here is a full list of labels that we use in the GitHub issue tracker and what they stand for.
- Bug
- An issue describing unexpected or malicious behaviour of the readthedocs.org software.
- Community Effort
- Tickets with this label are valid issues that the core team thinks are worth to fix or implement in the future. However the core team’s resources are too scarce to address these issues. Tickets marked with this label are issues that the core team will not work on, but contributions from the community are very welcome.
- Design
- Issues related to the UI of the readthedocs.org website.
- Enhancement
- Feature requests and ideas about how to make readthedocs.org better in general will have this label.
- Feature Overview
- Features that are too big to be tackled in one ticket are split up into multiple tickets. A feature overview ticket is then explaining the overarching idea. See the milestone of the feature overview ticket for all related tickets.
- Good First Bug
- This label marks tickets that are easy to get started with. The ticket should be ideal for beginners to dive into the code base.
- High Priority
- Tickets with this label should be resolved as quickly as possible.
- Mkdocs
- Tickets that are related to the Mkdocs builder.
- Needed: design decision
- Tickets that need a design decision are blocked for development until a project leader clarifies the way in which the issue should be approached.
- Needed: documentation
- If an issue involves creating or refining documentation, this label will be assigned.
- Needed: more information
- This label indicates that the issue has not enough information in order to decide on how to go forward. See the documentation about our triage process for more information.
- Needed: patch
- This label indicates that a patch is required in order to resolve the ticket. A fix should be proposed via a pull request on GitHub.
- Needed: tests
- This label indicates that a better test coverage is required to resolve the ticket. New tests should be proposed via a pull request on GitHub.
- Operations
- Tickets that require changes in the server infrastructure.
- PR: ready for review
- Pull Requests that are considered complete. A review by at least one core developer is required prior to merging it.
- PR: work in progress
- Pull Requests that are not complete yet. A final review is not possible yet, but every Pull Request is open for discussion.
- Sprintable
- Sprintable are all tickets that have the right amount of scope to be handled during a sprint. They are very focused and encapsulated.
- Status: blocked
- The ticket cannot be resolved until some other ticket has been closed. See the ticket’s log for which ticket is blocking this ticket.
- Status: duplicate
- See the ticket’s log to find the original ticket that this one is a duplicate of.
- Status: invalid
- A ticket is invalid if the reported issue cannot be reproduced.
- Status: rejected
- A ticket gets rejected if the proposed enhancement is not in line with the overall goals of readthedocs.org.
- Support
- Questions that needs answering but do not require code changes or issues that only require a one time action on the server will have this label. See the documentation about our triage process for more information.


|
Steam Audio API
2.0-beta.18
|
Parameters describing a direct sound path. More...
Data Fields | |
| IPLVector3 | direction |
| Unit vector from the listener to the source. More... | |
| IPLfloat32 | distanceAttenuation |
| Scaling factor to apply to direct sound, that arises due to the spherical attenuation of sound with distance from the source. More... | |
| IPLfloat32 | airAbsorption [3] |
| Scaling factors to apply to direct sound, for low, middle, and high frequencies, that arise due to the scattering of sound waves as they travel through the air. More... | |
| IPLfloat32 | propagationDelay |
| Time delay (in seconds) due to propagation from the source to the listener. More... | |
| IPLfloat32 | occlusionFactor |
| Scaling factor to apply to direct sound, that arises due to occlusion by scene geometry. More... | |
| IPLfloat32 | transmissionFactor [3] |
| Scaling factors to apply to direct sound, for low, middle, and high frequencies, that arise due to the transmission of sound waves through scene geometry. More... | |
| IPLfloat32 | directivityFactor |
| Scaling factor to apply to direct sound, that arises due to the directivity pattern of the source. More... | |
Parameters describing a direct sound path.
For each frequency band, the attenuation factor applied to the direct sound path is:
distanceAttenuation * airAbsorption * (occlusionFactor + (1 - occlusionFactor) * transmissionFactor)
| IPLVector3 direction |
Unit vector from the listener to the source.
| IPLfloat32 distanceAttenuation |
Scaling factor to apply to direct sound, that arises due to the spherical attenuation of sound with distance from the source.
Linear scale from 0.0 to 1.0.
| IPLfloat32 airAbsorption[3] |
Scaling factors to apply to direct sound, for low, middle, and high frequencies, that arise due to the scattering of sound waves as they travel through the air.
Linear scale from 0.0 to 1.0.
| IPLfloat32 propagationDelay |
Time delay (in seconds) due to propagation from the source to the listener.
| IPLfloat32 occlusionFactor |
Scaling factor to apply to direct sound, that arises due to occlusion by scene geometry.
Linear scale from 0.0 to 1.0.
| IPLfloat32 transmissionFactor[3] |
Scaling factors to apply to direct sound, for low, middle, and high frequencies, that arise due to the transmission of sound waves through scene geometry.
Linear scale from 0.0 to 1.0.
| IPLfloat32 directivityFactor |
Scaling factor to apply to direct sound, that arises due to the directivity pattern of the source.
Linear scale from 0.0 to 1.0.


Survey
This is a survey test for microverse
Name
Email
Number
select current role
Student
Full Time Learner
Full time Job
Definitely
Maybe
Not Sure
Wiki
Forum
Videos
Any Comments or suggestions?
Submit


{{+bindTo:partials.standard_nacl_api}}
| struct | PP_Point |
| The PP_Point structure defines the integer x and y coordinates of a point. More... | |
| struct | PP_FloatPoint |
| The PP_FloatPoint structure defines the floating-point x and y coordinates of a point. More... |
| struct PP_Point | PP_MakePoint (int32_t x, int32_t y) |
| struct PP_FloatPoint | PP_MakeFloatPoint (float x, float y) |
| PP_Point | |
| PP_FloatPoint |
This file defines the API to create a 2 dimensional point.
0,0 is the upper-left starting coordinate.


lacZ AGA codons expression codon gene Figure pep-tRNA variants mRNA variant AGG initiation translation β-Gal positions tRNA arginine pth Arg coli Escherichia pairs rate cells accumulation wild-type {border-style synthesis AAA px;} sequence #ffffff;} ribosome CGA Table expressed rates Mol. Pth activity containing different drop-off effect efficiency high levels RNA accumulated pep-tRNAs pth(rap) specific CTA downstream identical located protein CGC CGN harboring pair sequences Acids Nucleic combinations efficient indicated strain Biol. CGG carrying defective early efficiently low promoted relative (see Guarneros IPTG Methods Microbiol. cells, codon, constructs induction observed position px; results usage {font-family B). CGT Materials ORF Res. font-size growth leucine mutant secondary transformed using ′-end Bacteriol. However, affect association base binding blot cell codons, codons. does double; generated low-usage mRNAs northern peptidyl-tRNA plasmids presence ribosomal second section). stalling used variant, A). CGU CUA Cold Goldman Isaksson Spring Therefore, Thus, Total adenines associated bold border-color border-width calculated common composition conditions correlation deficient did difficult expression. extracted induced interaction limiting measured mediated propensity rRNA reading region samples shown solid; variants, variants. {font-style {font-weight –). ′-proximal Arg; Cruz-Vera EMBO Hernandez-Sanchez Miller Then, accompanying addition analyzed appropriate c.p.m. cellular changes cognate complementary contained correlated corresponding courier; cultures determined em; expression, favorable formation grown hand, highest level limited mRNA, mRNA. mixed nucleotide positions. pt;} rare reported ribosomes short showed sites spite starvation strain. strains substituted total transcription transferred triplets variant.


I2P Network
+ +
| |
| |
=---+---+-----------------=
| I2P Router |
=--+--------------------+-=
| |
=-+-----= =-+----------=
| I2CP | | I2PControl |
=-+---+-= =------------=
| |
=-+---|-------=
| Str|eaming |
=-----+-------=
|
=-+------= =-------------------=
| SAM v3 +----+ SAM APPLICATIONS |
=--------= =-------------------=
A sketch of the I2P API's, their relationship to eachother, and their relationship to the router.
I2CP is the core I2P API, it underlies many of the other I2P API's. It is also the most complex to use outside of Java, but recently several libraries have emerged that provide partial or full I2CP functionality from other languages. C, Java, and Javascript libraries are available, as is one Go library with partial support.
Java applications can also embed their own instances of I2PTunnel in order to use it to set up I2P tunnels. However, even non-java applications can take advantage of drop-in configuration of I2Ptunnel via i2ptunnel.config.d in the Java i2p router, or tunnels.conf.d in the C++ i2P router. In this way, regular clear-web applications can provide alternate configurations that automatically configure their I2P tunnels. If you ship i2ptunnel.config.d files, then any application can be turned into an I2P application without necessarily requiring any modification to the application's code.
I2PControl is a little different. Rather than setting up connections between I2P applications, it's used for configuring and retrieving information about the router programmatically.
The current recommended API for applications of all types to communicate via I2P is the SAMv3 API. It provides a convenient way to set up, communicate through, and tear down I2P connections. It is designed so that it can implement the API familiar to your programming language in a simple and straightforward way. For example, we can implement a Socket in Java or a net.Conn in Go.
SAM will by and large be the focus of this workshop.
If you need to make connections between applications automatically, then you need the SAMv3 API.
If you need to monitor or adjust the I2P router's connection, bandwidth usage, or change it's status, then you need the I2PControl API.
If you need to set up tunnels for an already-existing Web Application, then I2Ptunnel, either by embedding it in your application or by placing files into i2ptunnel.config.d.
If you need to simply check the presence of an I2P router before making connections, one way is to make a quick connection to the I2CP API. If you're writing a Java application, the I2CP API may also be a good choice. Besides that, unless you know why you need to use I2CP, you probably just need SAM.
I2Ptunnel is good at forwarding existing services to I2P, and it can concievably be used for many applications. It does provide a SOCKS proxy after all. However, setting up i2ptunnels is an involved process, with lots of settings that are intimidating to your users. Using SAM, you set up the connections and apply all the options inside the application itself, giving you the all-important oppourtunity to set up sane defaults on behalf of your users.
A good example can be found in applications that are federated with Activitypub. While I2Ptunnel is perfectly capable of making AP applications available over I2P, not many new users will correctly configure the AP-based service correctly on their first try. The process of setting up connections, deciding whether or not to "Bridge" clearnet connections or remain strictly anonymous, deciding tunnel length and the number of tunnels in your destination "Pool," and most other I2P connection-related functions.
Are you primarily:
SAM is a simple API for controlling connections on the I2P i2p router in a way which is familiar to people who write internet applications. To use it, you simply set up a SAM connection and then use it like a streaming connection or to send datagrams, either with or without a repliable address. You can use these connections just like their TCP/IP equivalents for basically every intent or purpose.
Because of the deliberate similarity to existing streaming and datagram communications, every language makes it possible to reduce this process to one or two steps at sensible layers of abstraction. Starting from the most similar, like a Socket in Java, a connection in Javascript, or a net.Conn in Go. The actual thing will vary from language to language, but when creating a library, you should probably start with a whatever's closest to a Socket.
Once you've done that, you've laid the foundation to alter the other network parts of your language. In many cases, it may be possible to forward a connection using the code you've already written, or to replace an underlying structure with your SAM-enabled version.
In a surprisingly short amount of time, you too can develop extensive tooling that makes building new I2P applications and, more importantly, adapting your existing applications to use I2P simple, reliable, and familiar.
Or you can literally just write your own i2ptunnel that you can embed in your existing application. I did that once. It works really well. I don't think we need a gazillion 'socat for I2P' out there but some would argue we didn't need a third so who am I to judge.
Sometimes, the details of setting up your SAM application require you to know whether an I2P router is present and ready to accept SAM connections or not. As of release 0.9.42 in a few weeks, this becomes a very easy problem to solve. Let's take a slightly complicated case as an example, a non-JVM, non-plugin application for Windows.
Since there's a good chance your SAM Application is in a non-Java, non-JVM language, it may be difficult or impossible to build as a plugin for the I2P router. If that's the case, then we can't assume a router is there.
Since this is a Windows machine, we can't assume that a package manager is available with a viable I2P router to install. If that's the case, we'll have to install our own.
One common way of creating a Windows installer for an application is to use Nullsoft Scriptable Install System. NSIS has the ability to do two essential things. First, it can check for the existence of the file, and second, it can start a new Windows application, and that application can be the I2P installer package.
Section "GetI2P"
SetOutPath $INSTDIR
IfFileExists "$PROGRAMFILES\i2p\i2p.exe" endGetI2P beginGetI2P
Goto endGetI2P
beginGetI2P:
MessageBox MB_YESNO "Your system does not appear to have i2p installed.$\n$\nDo you wish to install it now?"
File "i2pinstaller.exe"
ExecWait "$INSTDIR\i2pinstaller.exe"
SetOutPath "$PROGRAMFILES\i2p"
File "clients.config"
SetOutPath "C:\\ProgramData\i2p"
File "clients.config"
SetOutPath "$AppData\I2P"
File "clients.config"
endGetI2P:
SectionEnd
As you can see, after the i2pinstaller.exe is done running, a clients.config file is copied to the I2P application data directory. We can ONLY do it in this case because we already determines that I2P was not installed, and it is ONLY in this example in this way because 0.9.42 isn't out yet.
Well here's how I once did it in a Makefile:
# geti2p is an alias for i2pinstaller.exe
geti2p: i2pinstaller.exe
# This downloads the I2P installer using the url composed by the 'make url'
# target.
i2pinstaller.exe: url
wget -c `cat geti2p.url` -O i2pinstaller.exe
# This fetches an RDF listing of I2P versions from launchpad and looks for
# the most recent stable version. Using this information, it then constructs
# a URL to download the Windows I2P router installer from Launchpad.
url:
echo -n 'https://launchpad.net' | tee .geti2p.url
curl -s https://launchpad.net/i2p/trunk/+rdf | \
grep specifiedAt | \
head -n 3 | \
tail -n 1 | \
sed 's| <lp:specifiedAt rdf:resource="||g' | \
sed 's|+rdf"/>||g' | tee -a .geti2p.url
echo -n '+download/i2pinstall_' | tee -a .geti2p.url
curl -s https://launchpad.net/i2p/trunk/+rdf | \
grep specifiedAt | \
head -n 3 | \
tail -n 1 | \
sed 's| <lp:specifiedAt rdf:resource="/i2p/trunk/||g' | \
sed 's|/+rdf"/>||g' | tee -a .geti2p.url
echo '_windows.exe' | tee -a .geti2p.url
cat .geti2p.url | tr -d '\n' | tee geti2p.url
rm -f .geti2p.url
Two projects at least have been working on using the 'Jlink' tool to produce an I2P router that does not require the use of a JVM, those include i2p-zero from the Monero project and the Zero-Dependency installer from the I2P project. These may be preferable choices if you are bundling a router to use with a non-java application and are averse to requiring your users to install a JVM.
Now that we're sure an I2P router is installed, we need to make sure that a SAM API is available to your application to use. Since 0.9.42, all platforms that use SAM can also use clients.config.d. That way, you can drop a file in to an I2P router you have just installed or one that exists on the computer already, without needing to worry about over-writing or otherwise harmfully altering a potentially sensitive configuation file.
JVM applications have another, more flexible way of working with I2P. They can use I2P as a library and selectively include and configue the components they use. This is how BiglyBT works with I2P for example.
While flexible, this method requires somewhat more preparation and consideration than relying on an external I2P router.
For more information, see the embedding guide: http://i2p-projekt.i2p/en/docs/applications/embedding
To do this effectively, you need to check for the existence of an I2CP port, but you don't need to actually use I2CP for anything else.
To do this, you need to use i2pcontrol.
Simplest Useful SAM Streaming Client.
This isn't intended to be very "good" right now, but rather to illustrate the simplest ways the concepts of SAM map onto it's clearnet equivalents. It's been created as a set of examples for Def Con 27. When it's done being a basic example it might become a socket library, but probably not. sam3 is better.
package susc
import (
"encoding/base32"
"encoding/base64"
"encoding/binary"
"net"
)
// Client: A SAM Client is just a socket once it's set up.
type Client struct {
*net.TCPConn
}
// I2P uses a slightly altered base64 alphabet. You will need to customize your
// encoder to use it.
var (
i2pB64enc *base64.Encoding = base64.NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-~")
i2pB32enc *base32.Encoding = base32.NewEncoding("abcdefghijklmnopqrstuvwxyz234567")
)
// NewClient: To create a new client, create a TCP Connection to a SAM Service.
func NewClient() (*Client, error) {
//var err error
var c Client
// The default SAM address is localhost:7656
samaddr, err := net.ResolveTCPAddr("tcp", "<IP_ADDRESS>:7656")
if err != nil {
return nil, err
}
// When you create your client, establish your connection to SAM.
c.TCPConn, err = net.DialTCP("tcp", nil, samaddr)
if err != nil {
return nil, err
}
return &c, nil
}
// Base64 returns the base64 destination of the tunnel from the full destination.
// It's very helpful for SAM libraries to include a function like this even
// though it's not part of the spec
func Base64(destination string) string {
if destination != "" {
// Decode the base64 string to it's binary form
s, _ := i2pB64enc.DecodeString(destination)
// Take the length bits from the binary representation
alen := binary.BigEndian.Uint16(s[385:387])
// take the first 387 bits, + the length reported by the length bits,
// from the binary representation and re-encode it to base64.
return i2pB64enc.EncodeToString(s[:387+alen])
}
return ""
}
package susc
import (
"bufio"
"fmt"
)
// Command is a helper to send one command and return the reply as a string
func (c *Client) Command(str string, args ...interface{}) (*Reply, error) {
if _, err := fmt.Fprintf(c.TCPConn, str, args...); err != nil {
return nil, err
}
reader := bufio.NewReader(c.TCPConn)
line, _, err := reader.ReadLine()
if err != nil {
return nil, err
}
return ParseReply(string(line))
}
package susc
import (
"fmt"
"strings"
)
// Reply is a structure that represents a reply to the SAM bridge for
// convenience sake
type Reply struct {
Topic string
Type string
Pairs map[string]string
}
// ParseReply takes a string reply from the SAM bridge and turns it into a Reply
// object for later use.
func ParseReply(line string) (*Reply, error) {
line = strings.TrimSpace(line)
parts := strings.Split(line, " ")
if len(parts) < 3 {
return nil, fmt.Errorf("Malformed Reply.\n%s\n", line)
}
r := &Reply{
Topic: parts[0],
Type: parts[1],
Pairs: make(map[string]string, len(parts)-2),
}
for _, v := range parts[2:] {
kvPair := strings.SplitN(v, "=", 2)
if kvPair != nil {
if len(kvPair) != 2 {
return nil, fmt.Errorf("Malformed key-value-pair.\n%s\n", kvPair)
}
}
r.Pairs[kvPair[0]] = kvPair[len(kvPair)-1]
}
return r, nil
}
package susc
import (
"fmt"
)
// Hello does the handshake with the SAM bridge
func (c *Client) Hello() error {
reply, err := c.Command("HELLO VERSION MIN=3.0 MAX=3.2\n")
if err != nil {
return err
}
if reply.Topic != "HELLO" {
return fmt.Errorf("Unknown Reply: %+v\n", r)
}
if reply.Pairs["RESULT"] != "OK" {
return fmt.Errorf("Handshake did not succeed\nReply:%+v\n", r)
}
return nil
}
package susc
import (
"fmt"
)
// CreateStreamSession: finally creates a streaming session. You can now use
// your socket.
func (c *Client) CreateStreamSession(id int32, dest, sigtype, options string) (string, error) {
if dest == "" {
dest = "TRANSIENT"
}
r, err := c.Command(
"SESSION CREATE STYLE=STREAM ID=%d DESTINATION=%s %s %s\n",
id,
dest,
sigtype,
options,
)
if err != nil {
return "", err
}
result := r.Pairs["RESULT"]
if result != "OK" {
return "", fmt.Errorf("Reply error")
}
return r.Pairs["DESTINATION"], nil
}
package susc
import (
"fmt"
)
// StreamTCPConnect asks SAM for a TCP-Like connection to dest, has to be called on a new Client
func (c *Client) StreamTCPConnect(id int32, dest string) error {
r, err := c.Command("STREAM CONNECT ID=%d DESTINATION=%s\n", id, dest)
if err != nil {
return err
}
result := r.Pairs["RESULT"]
if result != "OK" {
return fmt.Errorf("Reply Error")
}
return nil
}
| Library Name | Language | Version | STREAM | DGRAM | RAW | Site |
|---|---|---|---|---|---|---|
| i2psam | C++, C wrap | 3.1 | yes | yes | no | github.com/i2p/i2psam |
| gosam | Go | 3.2 | yes | no | no | github.com/eyedeekay/goSam |
| sam3 | Go | 3.2 | yes | yes | yes | bitbucket.org/eyedeekay/sam3 |
| txi2p | Python | 3.1 | yes | no | no | github.com/str4d/txi2p |
| i2p.socket | Python | 3.2 | yes | yes | yes | github.com/majestrate/i2p.socket |
| i2plib | Python | 3.1 | yes | yes | yes | github.com/l-n-s/i2plib |
| i2p-rs | Rust | 3.1 | yes | yes | yes | github.com/i2p/i2p-rs |
| libsam3 | C | 3.1 | yes | yes | yes | github.com/i2p/libsam3 |
| mooni2p | Lua | 3.1 | yes | yes | yes | notabug.org/l-n-s/mooni2p |
| haskell-a-l-i | Haskell | 3.1 | yes | yes | yes | github.com/solatis/haskell-network-anonymous-i2p |
| node-i2p | Javascript | 3.0 | yes | unk | unk | github.com/redhog/node-i2p |
| Jsam | Java | 3.1 | yes | no | no | github.com/eyedeekay/Jsam |
| i2pdotnet | .Net | 3.0 | yes | unk | unk | github.com/SamuelFisher/i2pdotnet |
| i2p.rb | Ruby | 3.0 | yes | no | no | github.com/dryruby/i2p.rb |


JayStevency
29
Years Old
<EMAIL_ADDRESS>Personal
jaystevency.github.io
Personal
Jaystevency
GitHub
Interests
Leather Art
Photography
Language
Korean
Native Language
English
Intermediate Low
#Opic
(2016): IL
Server Developer
Work Experience
May 2017 - Feb 2018
Backend Developer
@JAEM
Seoul, South.Korea
Fair-Size-Backend
Fair-Size-Admin
Fair-Search-Engine
Fair-Play-Backend
Apr 2016 - Sep 2016
Backend Developer
@IMCLOUD
Seoul, South.Korea
Insurance rate & Financial forecasting System
@KCOMWEL
Education
2009 - 2015
University Kookmin Diploma
Seoul, South.Korea
Mathematics and Computer Engineering
Personal Projects
Visual-Github
SPA-ESC
E-Commerce
Professional Skills
Programming Language
Java , Javascript , Python , C/C++
Server & Framework
Spring-boot, Express, Django, Vue
Database
MySQL, MariaDB
Cloud
AWS, Azure


Collura, Thomas F,PhD., B.C.N., Wigton, Nancy L, PhD, LPC,Q.E.E.G.D., B.C.N., Zalaquett, Carlos,PhD., L.M.H.C., Chatters-Smith, S., & Bonnstetter, R. J., PhD. (2016). The value of EEG-based electromagnetic tomographic analysis in human performance and mental health. Biofeedback (Online), 44(2), 58-65. doi:http://dx.doi.org.ezaccess.libraries.psu.edu/10.5298/1081-5937-44.2.03
Flaisch, T., Häcker, F., Renner, B., & Schupp, H. T. (2011). Emotion and the processing of symbolic gestures: an event-related brain potential study. Social Cognitive & Affective Neuroscience, 6(1), 109-118. doi:10.1093/scan/nsq022
Lamm, C., & Majdandžić, J. (2015). The role of shared neural activations, mirror neurons, and morality in empathy–A critical comment. Neuroscience Research, 90, 15-24. doi:http://dx.doi.org.ezaccess.libraries.psu.edu/10.1016/j.neures.2014.10.008
Praszkier, R. (2016). Empathy, mirror neurons and SYNC. Mind & Society, 15(1), 1-25. doi:http://dx.doi.org.ezaccess.libraries.psu.edu/10.1007/s11299-014-0160-x
Valdés‐Tovar, M., Estrada‐Reyes, R., Solís‐Chagoyán, H., Argueta, J., Dorantes‐Barrón, A. M., Quero‐Chávez, D., . . . Benítez‐King, G. (2018). Circadian modulation of neuroplasticity by melatonin: A target in the treatment of depression. British Journal of Pharmacology, 175(16), 3200-3208. doi:10.1111/bph.14197
Tchekalarova, J., Stoynova, T., Ilieva, K., Mitreva, R., & Atanasova, M. (2018). Agomelatine treatment corrects symptoms of depression and anxiety by restoring the disrupted melatonin circadian rhythms of rats exposed to chronic constant light. Pharmacology, Biochemistry, and Behavior, 171, 1-9. doi:10.1016/j.pbb.2018.05.016
Langner, R., Leiberg, S., Hoffstaedter, F., & Eickhoff, S. B. (2018). Towards a human self-regulation system: Common and distinct neural signatures of emotional and behavioural control. Neuroscience & Biobehavioral Reviews, 90, 400-410. doi: 10.1016/j.neubiorev.2018.04.022
Dörfel, D., Lamke, J. P., Hummel, F., Wagner, U., Erk, S., & Walter, H. (2014). Common and differential neural networks of emotion regulation by detachment, reinterpretation, distraction, and expressive suppression: a comparative fMRI investigation. Neuroimage, 101, 298-309. doi: 10.1016/j.neuroimage.2014.06.051
Merz, E., Tottenham, N., & Noble, K. (2017). Socioeconomic Status, Amygdala Volume, and Internalizing Symptoms in Children and Adolescents. Journal of Clinical Child and Adolescent Psychology, 2, 1-12. doi: 10.1080/15374416.2017.1326122
Silvers, J.A., Goff, B., Gabard-Durnam, L.J., Gee, D.G., Fareri, D.S., Caldera, C., Tottenham, N. (2017). Vigilance, the amygdala, and anxiety in youth with a history of institutional care. Biological Psychiatry: Cognitive Neuroscience and Neuroimaging, 2(6), 493-501. doi: http://dx.doi.org/10.1016/j.bpsc.2017.03.016
Diaconescu, A. O., Litvak, V., Mathys, C., Kasper, L., Friston, K. J., & Stephan, K. E. (2017). A computational hierarchy in human cortex. ArXiv:1709.02323 [q-Bio]. Retrieved from http://arxiv.org/abs/1709.02323
Friston, K. (2010). The free-energy principle: A unified brain theory? Nature Reviews Neuroscience, 11(2), 127–138. https://doi.org/10.1038/nrn2787
Cecil, C. A., Lysenko, L. J., Jaffee, S. R., Pingault, J. B., Smith, R. G., Relton, C. L., … & Barker, E. D. (2014). Environmental risk, Oxytocin Receptor Gene (OXTR) methylation and youth callous-unemotional traits: a 13-year longitudinal study. Molecular Psychiatry, 19(10), 1071. https://doi.org/10.1038/mp.2014.95
Van Loey, N. E., Hofland, H. W. C., Vlig, M., Vandermeulen, E., Rose, T., Beelen, R. H. J., & Ulrich, M. M. W. (2018). Associations between traumatic stress symptoms, pain and bio-active components in burn wounds. Psychoneuroendocrinology. https://doi.org/10.1016/j.psyneuen.2018.05.037
Duff, J. (2004). The Usefulness of Quantitative EEG(QEEG) and Neurotherapy in the Assessment and Treatment of Post-concussion Syndrome. Clinical EEG and Neuroscience, 35(4). https://doi-org.ezaccess.libraries.psu.edu/10.1177/155005940403500410
Hunter, L. E., Branch, C. A., & Lipton, M. L. (2018). The neurobiological effects of repetitive head impacts in collision sports. Neurobiology of Disease, (May), 0–1. https://doi.org/10.1016/j.nbd.2018.06.016.
Mier, D., Lis, S., Esslinger, C., Sauer, C., Hagenhoff, M., Ulferts, J., . . . Kirsch, P. (2012). Neuronal correlates of social cognition in borderline personality disorder. Scan, 8, 531–537. doi:10.1093/scan/nss028.
Minzenberg, M. J., Fan, J., New, A. S., Tang, C. Y., & Siever, L. J. (2007). Fronto-limbic dysfunction in response to facial emotion in borderline personality disorder: An event-related fMRI study. Psychiatry Research-Neuroimaging, 155(3), 231–243. doi:10.1016/j.pseychresns.2007.03.006
Pavlakis, A. E., Noble, K., Pavlakis, S. G., Ali, N., & Frank, Y. (2015). Brain imaging and electrophysiology biomarkers: Is there a role in poverty and education outcome research? Pediatric Neurology, 52(4), 383-388. https://doi.org/10.1016/j.pediatrneurol.2014.11.005
Lee, V., & Hoaken, P. N. (2007). Cognition, emotion, and neurobiological development: Mediating the relation between maltreatment and aggression. Child Maltreatment, 12(3), 281-298. https://doi.org/10.1177/1077559507303778
Wilson, R. C., & Niv, Y. (2015). Is model fitting necessary for model-based fMRI?. PLoS Computational Biology, 11(6), e1004237. https://doi.org/10.1371/journal.pcbi.1004237
King-Casas, B., & Chiu, P. H. (2012). Understanding interpersonal function in psychiatric illness through multiplayer economic games. Biological Psychiatry, 72(2), 119-125. https://doi.org/10.1016/j.biopsych.2012.03.033
Rasmusson, A. M., Vasek, J., Lipschitz, D. S., Vojvoda, D., Mustone, M. E., Shi, Q., … & Charney, D. S. (2004). An increased capacity for adrenal DHEA release is associated with decreased avoidance and negative mood symptoms in women with PTSD. Neuropsychopharmacology, 29(8), 1546.
Szeszko, P. R., Lehrner, A., & Yehuda, R. (2018). Glucocorticoids and hippocampal structure and function in PTSD. Harvard Review of Psychiatry, 26(3), 142-157. doi: 10.1097/HRP.0000000000000188
Kim, Sang Hee, and Stephan Hamann. Neural Correlates of Positive and Negative Emotion Regulation (2007). Journal of Cognitive Neuroscience, 19(5), 776–798, https://doi.org/10.1162/jocn.2<IP_ADDRESS>6
Ochsner, Kevin N., and James J. Gross. (2008). Cognitive Emotion Regulation. Current Directions in Psychological Science, 17(2), 153–158, https://doi.org/10.1111/j.1467-8721.2008.00566.x
Doom, J. R., Doyle, C. M., & Gunnar, M. R. (2017). Social stress buffering by friends in childhood and adolescence: Effects on HPA and oxytocin activity. Social Neuroscience, 12(1), 8-21. doi: 10.1080/17470919.2016.1149095
Esposito, E. A., Jones, M. J., Doom, J. R., MacIsaac, J. L., Gunnar, M. R., & Kobor, M. S. (2016). Differential DNA methylation in peripheral blood mononuclear cells in adolescents exposed to significant early but not later childhood adversity. Development and Psychopathology, 28(4pt2), 1385-1399. https://doi.org/10.1017/S0954579416000055
Hipp, J. F., & Siegel, M. (2013). Dissociating neuronal gamma-band activity from cranial and ocular muscle activity in EEG. Frontiers in Human Neuroscience, 7, 338. doi: 10.3389/fnhum.2013.00338
McClure, E. B., Adler, A., Monk, C. S., Cameron, J., Smith, S., Nelson, E. E., … & Pine, D. S. (2007). fMRI predictors of treatment outcome in pediatric anxiety disorders. Psychopharmacology, 191(1), 97-105. doi:10.1016/j.biopsych.2005.08.012
Harrewijn, A. van der Molen, M.J.W., van Vliet, I.M., Tissier, R.L.M., Westenburg, P.M. (2018) Behavioral and EEG responses to social evaluation: A two-generation family study on social anxiety. Neuroimage: Clinical, 17(2018), 549-562. Retrieved from https://doi.org/10.1016/j.nicl.2017.11.010
Kahle, S., Utendale, W.T., Widaman, K.F., Hastings, P.D. (2018) Parasympathetic regulation and inhibitory control predict the development of externalizing problems in early childhood. Journal of Abnormal Child Psychology, 46(2), 237-249. Retrieved from https://link.springer.com/article/10.1007/s10802-017-0305-6
Foulkes, L., & Blakemore, S.J. (2018). Studying individual differences in human adolescent brain development. Nature Neuroscience, 21(3), 315–323. https://doi.org/10.1038/s41593-018-0078-4
Cavanagh, J. F., Cohen, M. X., & Allen, J. J. B. (2009). Prelude to and Resolution of an Error: EEG Phase Synchrony Reveals Cognitive Control Dynamics during Action Monitoring. Journal of Neuroscience, 29(1), 98–105. https://doi.org/10.1523/JNEUROSCI.4137-08.2009
Copyright © 2018 Rick O. Gilmore


The W3C defines the DOM as:
A platform- and language-neutral interfalce that will aloow programs and scripts to dynamically access and update the content, structure and style of documents. It is and API that can be used to navigate HTML and XML documents.


Noodles are a much-loved and used ingredient in Vietnam. Whether they are served up in soups, form the base of a salad or are wrapped up in a fresh gỏi cuốn, they are a staple enjoyed in Saigon and everywhere else in the country morning, noon and night. However, to anyone new to the country, the sheer quantity and variety can be pretty overwhelming. To help ease the passage for the budding expat or bemused tourist, here’s a list of the different noodles in Vietnam and the dishes for which they are commonly used.
Pho is the de-facto national dish of Vietnam and undoubtedly the most well-known Vietnamese dish overseas. This noodle soup is made up of three components: a broth made by simmering beef bones and herbs overnight to really bring the flavor out, fresh rice noodles and a type of meat—typically beef.
Despite Hanoi being the birthplace of pho, it is found everywhere in Vietnam and the flavors change from region to region as it does with most dishes. It also may be a common breakfast staple, yet it’s almost impossible to not find it at all hours. Try it at least once in your life.
Cao lau is the most famous noodle dish from Hoi An. This roasted pork noodle dish cannot be found in any other city, which is why it’s a must that you try it while you’re in Hoi An. The reason you can’t make an authentic cao lau elsewhere is that the broth can only be made with water drawn from the local Ba Le well. The origin story of this dish is still unknown.
This dish is made with noodles, pork, and local greens. Noodles of Cao Lau are carefully made from local new sticky rice. It is hand-cut and then cooked three times with firewood. It is invented by the Chinese but similar to Japanese wheat-based udon noodles. Water used to soak rice must be taken from wells in the undisclosed ancient Cham well, just outside the town.
The pork is stir-fried, marinated in star anise and cassia bark. It is sliced thin and cooked in the traditional Chinese method known as “Char siu”. Dry pancakes must be thick with much sesame on the surface. Toppings include peanuts, and bean sprouts making this dish hard to resist. This dish is eaten with lots of herbs and vegetables which greatly enhance its flavors. Cao Lau is surprisingly unique dish in Hoi An.
Bun rieu is a seafood vermicelli soup with a distinctive crimson color thanks to the use of tomato paste and annatto oil. Crab meat is the star of this noodle dish, but depending on the region, you can find various takes such as the use of beef, pork or even snail. The dish is light, and well balanced.
The interplay between crab and tomato makes bún riêu a truly standout dish. A hearty soup bursting with acidity, the components of this meal include slippery bún, fresh crab meat, blocks of tofu and stewed tomatoes. Cooking an authentic bowl of bún riêu is a labour-intensive process. After the crab meat is separated from the body, the shell is then pulverized using a mortar and pestle and then strained through to form the base of the broth. Floating around the bowl are pillowy clusters of minced crab combined with ground pork and egg that melt in your mouth.
This is the standard street food item in the south. The Vietnamese version of the kuy teav in Cambodia and guay tiew in Thailand, hủ tiếu is a bowl of noodles served either wet (nước) or dry (khô). Typically, an opaque broth made from pork bones is eaten with hủ tiếu noodles. The definitive rendition of hủ tiếu is Hủ Tiếu Nam Vang. The recipe calls for pork on the bone, boiled liver, a quail egg and some shrimp. If you’re squeamish, ask them to hold off on the congealed pork blood chunks, which make their way into a bowl every now and then. The peppery broth speckled with chopped green onions also has a noticeable sweetness to it, coming from the addition of rock sugar.
If your travel bucket list includes trying worldly cuisine, there should be room in it for bun dau mam tom – Vietnamese fermented shrimp paste noodle. Sure, pho, bun cha, banh mi, banh xeo may be among the most popular in Vietnam, but if you would like to try something a little more unique, then bun dau mam tom should be in that list. We know it sounds a little unappetizing when we say fermented shrimp paste noodle, but hopefully this article will be able to convince you as to why you should try it at least once.
Bun dau mam tom has no soup, and the components are served separately—vermicelli noodles, tofu, pork and the star of the dish, the smelly mam tom sauce. Mam tom sauce is essentially fermented shrimp paste and you can think of it like the vegemite of Vietnam—you’ll either love it or hate it. Squeeze in some lime wedges into the sauce, and then use it to flavor the slabs of tofu and pork you eat with the noodles.


|
Mackey
V3.1
A C++ library for computing RO(G) graded homology
|
Contains the computations for RO(G) Chains and Homology as Mackey and Green functors.
More...
Go to the source code of this file.
Namespaces | |
| mackey | |
| The namespace for everything that is group-independent. | |
Functions | |
| template<typename T , typename deg_t = std::vector<int>> | |
| int | dimension (const deg_t &sphere) |
| Compute the dimension of a representation sphere. More... | |
| template<typename T , typename deg_t = std::vector<int>> | |
| deg_t | Reindex (deg_t degree) |
| Given degree (k,sphere) returns degree (k',sphere) where k' is a reindexing of k s.t. 0<=k'<=dimension(sphere) More... | |
| template<typename T , typename deg_t = std::vector<int>> | |
| deg_t | invReindex (deg_t degree) |
| Inverse of Reindex. More... | |
| template<typename T , typename deg_t = std::vector<int>> | |
| auto | getChains (const deg_t &sphere, int i=-1) |
| Returns the standard Chains of the given sphere. Optionally stop at index i (i=-1 means nonstop i.e. i=dimension(sphere) ) More... | |
| template<typename group_t , typename deg_t > | |
| auto | ROChains (const deg_t &sphere, int i=-1) |
| Returns the Chains of given sphere. Optionally stop at index i (i=-1 means nonstop i.e. i=dimension(sphere) ) More... | |
| template<typename group_t > | |
| auto | HomologyLevels (const Levels< Junction< typename group_t::rank_t, typename group_t::diff_t >, group_t > &J) |
| The Mackey functor Homology of a Junction of Mackey functors. More... | |
| template<typename group_t , typename deg_t = std::vector<int>> | |
| auto | ROHomology (int level, const deg_t °ree) |
| Computes the homology for the given level and degree. More... | |
| template<typename group_t , typename deg_t = std::vector<int>> | |
| auto | ROHomology (const deg_t &sphere) |
| Computes the Mackey functor homology of the given sphere. More... | |
| template<typename group_t , typename deg_t > | |
| auto | ROGreen (int level, const deg_t &first, const deg_t &second, int selectFirst=0, int selectSecond=0) |
| Computes the product of two generators in the RO(G) homology given their level, degrees and selections (if noncyclic). Selections are 0,0 by default. More... | |
| template<typename group_t , typename deg_t > | |
| Massey< group_t > | ROMassey (int level, const deg_t &first, const deg_t &second, const deg_t &third, bool do_indeter, int selectFirst=0, int selectSecond=0, int selectThird=0) |
| Computes the Massey product of three generators in the RO(G) homology given their level, degrees and selections (if noncyclic). Selections are 0,0,0 by default. Also optionally compute the indeterminacy. More... | |
Contains the computations for RO(G) Chains and Homology as Mackey and Green functors.


Gecode::Int::IntVarImp Class Reference
[Other available functionality]
Inherits Gecode::Int::IntVarImpBase.
Detailed Description
Integer variable implementation.
Definition at line 40 of file var.icc.
Value access | |
| int | min (void) const |
| Return minimum of domain. | |
| int | max (void) const |
| Return maximum of domain. | |
| int | val (void) const |
| Return assigned value (only if assigned). | |
| int | med (void) const |
| Return median of domain. | |
| unsigned int | size (void) const |
| Return size (cardinality) of domain. | |
| unsigned int | width (void) const |
| Return width of domain (distance between maximum and minimum). | |
| unsigned int | regret_min (void) const |
| Return regret of domain minimum (distance to next larger value). | |
| unsigned int | regret_max (void) const |
| Return regret of domain maximum (distance to next smaller value). | |
Domain tests | |
| bool | range (void) const |
| Test whether domain is a range. | |
| bool | assigned (void) const |
| Test whether variable is assigned. | |
| bool | in (int n) const |
| Test whether n is contained in domain. | |
| bool | in (double n) const |
| Test whether n is contained in domain. | |
Domain update by value | |
| ModEvent | lq (Space *home, int n) |
| Restrict domain values to be less or equal than n. | |
| ModEvent | lq (Space *home, double n) |
| Restrict domain values to be less or equal than n. | |
| ModEvent | gq (Space *home, int n) |
| Restrict domain values to be greater or equal than n. | |
| ModEvent | gq (Space *home, double n) |
| Restrict domain values to be greater or equal than n. | |
| ModEvent | nq (Space *home, int n) |
| Restrict domain values to be different from n. | |
| ModEvent | nq (Space *home, double n) |
| Restrict domain values to be different from n. | |
| ModEvent | eq (Space *home, int n) |
| Restrict domain values to be equal to n. | |
| ModEvent | eq (Space *home, double n) |
| Restrict domain values to be equal to n. | |
Domain update by range iterator | |
| template<class I> | |
| ModEvent | narrow (Space *home, I &i) |
| Replace domain by range sequence described by i. | |
| template<class I> | |
| ModEvent | inter (Space *home, I &i) |
| Intersect domain with range sequence described by i. | |
| template<class I> | |
| ModEvent | minus (Space *home, I &i) |
| Remove from domain the range sequence described by i. | |
Boolean update operations | |
| void | t_zero_none (Space *home) |
| Assign unassigned variable to zero. | |
| void | t_one_none (Space *home) |
| Assign unassigned variable to one. | |
Dependencies | |
| void | subscribe (Space *home, Propagator *p, PropCond pc, bool process=true) |
| Subscribe propagator p with propagation condition pc to variable. | |
Cloning | |
| IntVarImp * | copy (Space *home, bool share) |
| Return copy of this variable. | |
| IntVarImp * | copy_bool (Space *home, bool share) |
| Return copy of this variable (Boolean). | |
Range list access for iteration | |
| const RangeList * | ranges_fwd (void) const |
| Return range list for forward iteration. | |
| const RangeList * | ranges_bwd (void) const |
| Return range list for backward iteration. | |
Public Member Functions | |
| IntVarImp (Space *home, int min, int max) | |
| Initialize with range domain. | |
| IntVarImp (Space *home, const IntSet &d) | |
| Initialize with domain specified by d. | |
Protected Member Functions | |
| RangeList * | fst (void) const |
| Return first element of rangelist. | |
| void | fst (RangeList *f) |
| Set first element of rangelist. | |
| RangeList * | lst (void) const |
| Return last element of rangelist. | |
| void | lst (RangeList *l) |
| Set last element of rangelist. | |
| IntVarImp (Space *home, bool share, IntVarImp &x, bool is_bool) | |
| Constructor for cloning x (is_bool whether this is a Boolean variable). | |
Protected Attributes | |
| RangeList | dom |
| Domain information. | |
| RangeList * | _lst |
| Link the last element. | |
| unsigned int | holes |
| Size of holes in the domain. | |
Classes | |
| class | RangeList |
| Lists of ranges (intervals). More... |
Constructor & Destructor Documentation
|
|
Constructor for cloning x (is_bool whether this is a Boolean variable).
|
|
|
Initialize with range domain.
|
|
|
Initialize with domain specified by d.
|
Member Function Documentation
|
|
Return first element of rangelist.
|
|
|
Set first element of rangelist.
|
|
|
Return last element of rangelist.
|
|
|
Set last element of rangelist.
|
|
|
Return minimum of domain.
|
|
|
Return maximum of domain.
|
|
|
Return assigned value (only if assigned).
|
|
|
Return median of domain.
|
|
|
Return size (cardinality) of domain.
|
|
|
Return width of domain (distance between maximum and minimum).
|
|
|
Return regret of domain minimum (distance to next larger value).
|
|
|
Return regret of domain maximum (distance to next smaller value).
|
|
|
Test whether domain is a range.
|
|
|
Test whether variable is assigned.
|
|
|
Test whether n is contained in domain.
|
|
|
Test whether n is contained in domain.
|
|
|
Return range list for forward iteration.
|
|
|
Return range list for backward iteration.
|
|
|
Restrict domain values to be less or equal than n.
|
|
|
Restrict domain values to be less or equal than n.
|
|
|
Restrict domain values to be greater or equal than n.
|
|
|
Restrict domain values to be greater or equal than n.
|
|
|
Restrict domain values to be different from n.
|
|
|
Restrict domain values to be different from n.
|
|
|
Restrict domain values to be equal to n.
|
|
|
Restrict domain values to be equal to n.
|
|
|
Replace domain by range sequence described by i.
|
|
|
Intersect domain with range sequence described by i.
|
|
|
Remove from domain the range sequence described by i.
|
|
|
Assign unassigned variable to zero.
|
|
|
Assign unassigned variable to one.
|
|
|
Subscribe propagator p with propagation condition pc to variable. In case process is false, the propagator is just subscribed but not processed for execution (this must be used when creating subscriptions during propagation). |
|
|
Return copy of this variable.
|
|
|
Return copy of this variable (Boolean).
|
Member Data Documentation
|
|
Domain information. Provides fast access to minimum and maximum of the entire domain and links to the first element of a RangeList defining the domain. |
|
|
Link the last element.
|
|
|
Size of holes in the domain.
|
The documentation for this class was generated from the following files:
- gecode/int/var.icc (Revision: 3686)
- gecode/int/var/imp.cc (Revision: 3568)
- gecode/int/var/imp.icc (Revision: 3568)


Spring 2017.
Introduction to Machine Learning, Class Assignment, Spring 2016.
Algorithms, Class Project, Spring 2016. Partners: Derrick Mar, Nader Azari, Andrew Wong.
Probability and Random Processes, Class Project, Fall 2015. Partner: Alex Lin.
Linear Feedback Control Systems, Class Project, Fall 2015. Group members: Edward Lai, Hillary Chen (report).
Linear Feedback Control Systems, Class Project, Fall 2015. Group members: Edward Lai, Hillary Chen (report).
Digital Signal Processing, Class Project, Spring 2015. Partner: Jason Cramer.
Virtual Poster, Society for Neuroscience, 50th Annual Meeting, November 2021.
Poster, Stanford Undergraduate Psychology Conference, May 2016.
Poster, SURF Symposium, Summer 2015.
Presentation, REU Symposium, Summer 2014.
December 2021-Present.
Women in Science and Engineering, University of Southern California. August 2021-Present.
Pioneers in Engineering, UC Berkeley. February 2016-Present.
East Bay YMCA, Oakland, CA. April 2017.


Using Unicorns Icon Set is easy. Icons are called by their name:

You can change the color with a Hex value:


|
Fighters
|
Public Member Functions | |
| getActor () | |
| getActionName () | |
Protected Member Functions | |
| __construct (Fighter $pFighter) | |
| setActionName (string $pName) | |
Protected Attributes | |
| $actionName | |
| $actor | |
Definition at line 9 of file Action.php.
|
protected |
| $Fighter |
Reimplemented in ActionDeath, and ActionMiss.
Definition at line 24 of file Action.php.
| getActionName | ( | ) |
Definition at line 41 of file Action.php.
| getActor | ( | ) |
|
protected |
| $string |
Definition at line 48 of file Action.php.
|
protected |
Definition at line 14 of file Action.php.
|
protected |
Definition at line 19 of file Action.php.


Dear Open Energy monitor partners:
I am trying to develop a touch screen Raspberry Pi with open energy monitor inside.
I am having may problems because of the compatibility between these software.
I have tried to install Adafruit software over emoncms SD ready to go and also install emoncms over Adafruit SD ready to go. The result is the same: Black screen.
I don't know the incompatibilities between these software, at the beginning they seem to be compatible, but i can solve it properly. Any idea? someone had to solve it before?
Adafruit software: https://learn.adafruit.com/adafruit-pitft-3-dot-5-touch-screen-for-raspberry-pi/easy-install
Emoncms software: https://learn.adafruit.com/adafruit-pitft-3-dot-5-touch-screen-for-raspberry-pi/easy-install
I want to use both software in the same raspberry pi.
Thanks in advance.
Re: Joining Emoncms and Adafruit PiTFT 3.5"
Dear Open energy monitors:
I am making huge advances in my project, actually it is nearly done.
I have discover very interesting method and tricks to achieve an open energy monitor running into a PiTFT 3.5
1. SD image.
I took as a Starting SD image the Adafruit 3.5 PITFT Ready to go SD with the kernel and packages to run these screens:
https://learn.adafruit.com/adafruit-pitft-3-dot-5-touch-screen-for-raspb...
I prefer this image because i am using Raspberry 2 and 2014 debian is a bit outdated (emoncms ready to go was made in August 2014)
2. Resizing partitions.
The most important thing is resize the 2 partitions because Linux partition (partition 2) is nearly completed with Adafruit and Raspbian data, so you must increase the size using the following method:
http://raspberrypi.stackexchange.com/questions/499/how-can-i-resize-my-r...
I have a 8 Gb SD and I am using 5 Gb for the partition 2 and 3 Gb (system data) for partition 3 (open energy monitor data).
3. Following Open energy monitor installation in this web page:
https://github.com/emoncms/emoncms/blob/low-write/docs/install.md
however you must be careful in this step:
sudo nano /boot/cmdline.txt
replace the line:
dwc_otg.lpm_enable=0 console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait
you have to reboot the raspberry because after this step you must reconfigure the screen again, it turns black BUT DON'T PANIC you must only do this:
# login
pi
raspberry
#configure pitft
sudo adafruit-pitft-helper -t 35r
yes
sudo reboot
After reboot, the screen will appear again normally.
I recommend you do this steps with a HDMI screen connected because in other way you must do it "blind". I usually do it "blind" but I have repeated around 10 times :-) now
This step is fully explained here:
https://learn.adafruit.com/adafruit-pitft-3-dot-5-touch-screen-for-raspb...
4. Danger, some Emoncms steps with tiny mistakes:
There are 2 "sudo" mistakes installing debian packages
mkdir /home/pi/data/mysql must be changed by:
sudo mkdir /home/pi/data/mysql
$ git clone -b low-write https://github.com/emoncms/emoncms.git must be changed by:
$ sudo git clone -b low-write https://github.com/emoncms/emoncms.git
For now that's all, I am configuring emoncms and making more advances in order to have a "perfect" SD image with Pitft 3.5 and Emoncms.
See you!
[Two further copies of this post have been deleted. Please observe the notice on the right "NEW USERS, PLEASE READ - Posts held for moderation" - Moderator (RW)]
Re: Joining Emoncms and Adafruit PiTFT 3.5"
This is very interesting! Which version of EmonCMS are you installing?


<juicy-html>
(precisely: <template is="juicy-html">
) is a custom element that lets you load HTML partials from JS objects and external files into your DOM. It acts more or less, as `include` statement known in many other languages. It also provides data binding, that works for native JS/HTML as well as for Polymer's dom-bind
. See README.md for more information.


PHP Hypertext Preprocessor (PHP) is an open source server-side scripting language designed for web develoment.
When PHP interpreter parses a file,
it looks for opening and closing tags
<?php
// declare and initialize variable txt to store a value
$txt = "Hello world!";
// display the stored value in variable txt
echo $txt;
?>
Everything outside of a pair of opening and closing tags is ignored by the PHP parser which allows PHP files to have mixed content (hybrid).
<html>
<body>
<?php
$txt = "Hello world!";
?>
<h1>
<?php echo $txt; ?>
</h1>
</body>
</html>
| <? | PHP also allows for short open tag <? which is discouraged since it is only available if enabled and conflicts with other XML tags. |
| <?= |
|
What distinguishes PHP from something like client-side JavaScript is that the code is executed on the server, generating HTML which is then sent to the client. The client would receive the results of running that script, but would not know what the underlying code was.
Always validate the generated HTML!
identifiers, single and double quotes, curly braces, constants
integer, float, string, Boolean, NULL, Array, Object, Resource
arrays, strings, Objects, Classes
| Casino Craps | Modified version |
|---|---|
| Rock Paper Scissors | Modified — both players random selections, no user input |
| Rock Paper Scissors Lizard Spock | Modified — both players random selections, no user input |
| Tic Tac Toe | Modified version |
Use w3school's PHP Tryit Editor to start thinking how to rewrite the code in PHP. Complete Worksheet 6 to study the PHP language.


Linha do Tempo/Timeline Capoeira Tai Chi Fé/Faith Sucesso/Success Alimentação/Feeding Fotos/photos Música/music
Escritos para mudar o mundo: A dança das salas
My name is Hylson Vescovi Netto. I was born in Vitória/ES.
During March 2004 to Septembro 2005 I live in Ilhéus city, in Bahia State.
In October 2005 I arrived in Rio do Sul city, in Santa Catarina state.
I get married in 2009 with Léia.
In October 2010, we moved to Blumenau city.
In January 2013 we moved to Florianópolis city.
were I started the doctoral at UFSC.
We returned to Blumenau in May 2004 because Léia started to work at IFC.
Since October 2015 I live in Florianópolis during the week, and in Blumenau on weekends.
In December 15 2016, I finished my activites in LaPeSD, at UFSC, and returned to live fulltime in Blumenau.
My e-mail is hvescovi, at gmail.com.


Why are we here?
It's all about the users!
We have two types of users that we need to account for when we implement websites:
- End-users
- CMS-users (content authors/editors)
When we build websites, we account for both kinds of user — but usually the back-end (Tridion) developers focus on the CMS user, while the front-end developers focus primarily on the end-user.
The Problem is the Balance
If front-end developers focus exclusively on the end-user experience, without considering the content-author experience, this can create a lot of strain on the Tridion developer and the Tridion user.
If a Front-end developer codes, without thinking about thinking about how content will be managed, this leads to problems:
- Inconsistent markup for the same content -> too many Component Templates
- Too many divs -> developer gets lost in code, contracts '
div
itis', perpetuates drinking problem
- Too many divs -> site isn't SEO friendly or accessible
- Assuming a container always has content -> blank spaces and weird gaps
- Hard-coded classes for layout -> no flexibility in adding removing items
- Hard-coded background images and colors -> no flexibility in changing content areas
- Every jQuery plugin ever -> content author can't change features in a plugin
The solution is in the code content
- Tell the FE dev about the content models (schemas)
- Collect authoring rules before writing code
- Accept FE code that's flexible, not fixed
We're here today to talk about #3. You're on your own for those first two.


Frontend building is delegated to NPM and so leverages the NodeJS ecosystem.


| Class and Description |
|---|
| org.apache.beam.sdk.transforms.Combine.SimpleCombineFn |
| Field and Description |
|---|
| org.apache.beam.sdk.util.AppEngineEnvironment.IS_APP_ENGINE |
| Constructor and Description |
|---|
| org.apache.beam.sdk.io.gcp.bigquery.BigQueryIO.Write.Bound()
Should be private. Instead, use one of the factory methods in
BigQueryIO.Write , such as BigQueryIO.Write.to(String) , to create an
instance of this class. |
| org.apache.beam.sdk.Pipeline(PipelineRunner<?>) |
| org.apache.beam.sdk.util.RetryHttpRequestInitializer(HttpRequestInitializer) |
| org.apache.beam.sdk.util.RetryHttpRequestInitializer(HttpRequestInitializer, Collection<Integer>) |
| org.apache.beam.sdk.util.RetryHttpRequestInitializer(HttpRequestInitializer, Collection<Integer>, HttpResponseInterceptor) |
| Enum Constant and Description |
|---|
| org.apache.beam.runners.dataflow.options.DataflowPipelineWorkerPoolOptions.AutoscalingAlgorithmType.BASIC |
Copyright © 2016 The Apache Software Foundation. All rights reserved.


|
|
| json_builder (actor_system &sys) |
| |
|
| json_builder (execution_unit *ctx) |
| |
|
| json_builder (const json_builder &)=delete |
| |
|
json_builder & | operator= (const json_builder &)=delete |
| |
|
bool | skip_empty_fields () const noexcept |
| | Returns whether the writer omits empty fields entirely (true) or renders empty fields as $field: null (false).
|
| |
|
void | skip_empty_fields (bool value) noexcept |
| | Configures whether the writer omits empty fields.
|
| |
|
bool | skip_object_type_annotation () const noexcept |
| | Returns whether the writer omits '@type' annotations for JSON objects.
|
| |
|
void | skip_object_type_annotation (bool value) noexcept |
| | Configures whether the writer omits '@type' annotations for JSON objects.
|
| |
| std::string_view | field_type_suffix () const noexcept |
| | Returns the suffix for generating type annotation fields for variant fields.
|
| |
|
void | field_type_suffix (std::string_view suffix) noexcept |
| | Configures whether the writer omits empty fields.
|
| |
|
void | reset () |
| | Restores the writer to its initial state.
|
| |
| json_value | seal () |
| | Seals the JSON value, i.e., rendering it immutable, and returns it.
|
| |
| bool | begin_object (type_id_t type, std::string_view name) override |
| | Begins processing of an object.
|
| |
| bool | end_object () override |
| | Ends processing of an object.
|
| |
| bool | begin_field (std::string_view) override |
| |
| bool | begin_field (std::string_view name, bool is_present) override |
| |
| bool | begin_field (std::string_view name, span< const type_id_t > types, size_t index) override |
| |
| bool | begin_field (std::string_view name, bool is_present, span< const type_id_t > types, size_t index) override |
| |
| bool | end_field () override |
| |
| bool | begin_tuple (size_t size) override |
| | Begins processing of a tuple.
|
| |
| bool | end_tuple () override |
| | Ends processing of a tuple.
|
| |
| bool | begin_key_value_pair () override |
| | Begins processing of a tuple with two elements, whereas the first element represents the key in an associative array.
|
| |
| bool | end_key_value_pair () override |
| | Ends processing of a key-value pair after both values were written.
|
| |
| bool | begin_sequence (size_t size) override |
| | Begins processing of a sequence. Saves the size to the underlying storage.
|
| |
| bool | end_sequence () override |
| | Ends processing of a sequence.
|
| |
| bool | begin_associative_array (size_t size) override |
| | Begins processing of an associative array (map).
|
| |
| bool | end_associative_array () override |
| | Ends processing of an associative array (map).
|
| |
| bool | value (std::byte x) override |
| | Adds x to the output.
|
| |
| bool | value (bool x) override |
| | Adds x to the output.
|
| |
| bool | value (int8_t x) override |
| | Adds x to the output.
|
| |
| bool | value (uint8_t x) override |
| | Adds x to the output.
|
| |
| bool | value (int16_t x) override |
| | Adds x to the output.
|
| |
| bool | value (uint16_t x) override |
| | Adds x to the output.
|
| |
| bool | value (int32_t x) override |
| | Adds x to the output.
|
| |
| bool | value (uint32_t x) override |
| | Adds x to the output.
|
| |
| bool | value (int64_t x) override |
| | Adds x to the output.
|
| |
| bool | value (uint64_t x) override |
| | Adds x to the output.
|
| |
| bool | value (float x) override |
| | Adds x to the output.
|
| |
| bool | value (double x) override |
| | Adds x to the output.
|
| |
| bool | value (long double x) override |
| | Adds x to the output.
|
| |
| bool | value (std::string_view x) override |
| | Adds x to the output.
|
| |
| bool | value (const std::u16string &x) override |
| | Adds x to the output.
|
| |
| bool | value (const std::u32string &x) override |
| | Adds x to the output.
|
| |
| bool | value (span< const std::byte > x) override |
| | Adds x as raw byte block to the output.
|
| |
|
| serializer (actor_system &sys) noexcept |
| |
|
| serializer (execution_unit *ctx=nullptr) noexcept |
| |
|
auto | context () const noexcept |
| |
|
bool | has_human_readable_format () const noexcept |
| |
| virtual bool | begin_object (type_id_t type, std::string_view name)=0 |
| | Begins processing of an object.
|
| |
| virtual bool | end_object ()=0 |
| | Ends processing of an object.
|
| |
|
virtual bool | begin_field (std::string_view)=0 |
| |
|
virtual bool | begin_field (std::string_view name, bool is_present)=0 |
| |
|
virtual bool | begin_field (std::string_view name, span< const type_id_t > types, size_t index)=0 |
| |
|
virtual bool | begin_field (std::string_view name, bool is_present, span< const type_id_t > types, size_t index)=0 |
| |
|
virtual bool | end_field ()=0 |
| |
| virtual bool | begin_tuple (size_t size)=0 |
| | Begins processing of a tuple.
|
| |
| virtual bool | end_tuple ()=0 |
| | Ends processing of a tuple.
|
| |
| virtual bool | begin_key_value_pair () |
| | Begins processing of a tuple with two elements, whereas the first element represents the key in an associative array.
|
| |
| virtual bool | end_key_value_pair () |
| | Ends processing of a key-value pair after both values were written.
|
| |
| virtual bool | begin_sequence (size_t size)=0 |
| | Begins processing of a sequence. Saves the size to the underlying storage.
|
| |
| virtual bool | end_sequence ()=0 |
| | Ends processing of a sequence.
|
| |
| virtual bool | begin_associative_array (size_t size) |
| | Begins processing of an associative array (map).
|
| |
| virtual bool | end_associative_array () |
| | Ends processing of an associative array (map).
|
| |
| virtual bool | value (std::byte x)=0 |
| | Adds x to the output.
|
| |
| virtual bool | value (bool x)=0 |
| | Adds x to the output.
|
| |
| virtual bool | value (int8_t x)=0 |
| | Adds x to the output.
|
| |
| virtual bool | value (uint8_t x)=0 |
| | Adds x to the output.
|
| |
| virtual bool | value (int16_t x)=0 |
| | Adds x to the output.
|
| |
| virtual bool | value (uint16_t x)=0 |
| | Adds x to the output.
|
| |
| virtual bool | value (int32_t x)=0 |
| | Adds x to the output.
|
| |
| virtual bool | value (uint32_t x)=0 |
| | Adds x to the output.
|
| |
| virtual bool | value (int64_t x)=0 |
| | Adds x to the output.
|
| |
| virtual bool | value (uint64_t x)=0 |
| | Adds x to the output.
|
| |
| template<class T > |
| std::enable_if_t< std::is_integral< T >::value, bool > | value (T x) |
| | Adds x to the output.
|
| |
| virtual bool | value (float x)=0 |
| | Adds x to the output.
|
| |
| virtual bool | value (double x)=0 |
| | Adds x to the output.
|
| |
| virtual bool | value (long double x)=0 |
| | Adds x to the output.
|
| |
| virtual bool | value (std::string_view x)=0 |
| | Adds x to the output.
|
| |
| virtual bool | value (const std::u16string &x)=0 |
| | Adds x to the output.
|
| |
| virtual bool | value (const std::u32string &x)=0 |
| | Adds x to the output.
|
| |
| virtual bool | value (span< const std::byte > x)=0 |
| | Adds x as raw byte block to the output.
|
| |
| virtual bool | list (const std::vector< bool > &xs) |
| | Adds each boolean in xs to the output.
|
| |
Serializes an inspectable object to a json_value.