the coolest
about
we have the best masters in the world
There are many variations of passages of Lorem Ipsum available, but the majority have suffered alteration in some form, by injected humour, or randomised words which don't look even slightly believable. If you are going to use a passage of Lorem Ipsum, you need to be sure there isn't anything embarrassing hidden in the middle of text. Ipsum generators on the Internet tend to
There are many variations of passages of Lorem Ipsum available, but the majority have suffered alteration in some form, by injected humour, or randomised words which don't look even slightly believable. If you are going to use a passage of Lorem Ipsum, you need to be sure there isn't anything embarrassing hidden in the middle of text. Ipsum generators on the Internet tend to
every single
detail matters
services
Haircut ($10)
All the Lorem Ipsum generators on the Internet tend to repeat predefined chunks as necessary, making this the first true generator on the Internet. It uses a dictionary of over 200 Latin words, combined with a handful of model sentence structures, to generate Lorem Ipsum which looks reasonable.
Shave ($20)
All the Lorem Ipsum generators on the Internet tend to repeat predefined chunks as necessary, making this the first true generator on the Internet. It uses a dictionary of over 200 Latin words, combined with a handful of model sentence structures, to generate Lorem Ipsum which looks reasonable.
Beard style ($20)
All the Lorem Ipsum generators on the Internet tend to repeat predefined chunks as necessary, making this the first true generator on the Internet. It uses a dictionary of over 200 Latin words, combined with a handful of model sentence structures, to generate Lorem Ipsum which looks reasonable.
Special haircut ($30)
All the Lorem Ipsum generators on the Internet tend to repeat predefined chunks as necessary, making this the first true generator on the Internet. It uses a dictionary of over 200 Latin words, combined with a handful of model sentence structures, to generate Lorem Ipsum which looks reasonable.
lookbook
reservations
299 East 52nd street (bet. 1st and 2nd Ave) New York, NY 10022<PHONE_NUMBER>


Brush width
Scale
Opacity
Select index > retriever sequence for retrieval
Select object detectors
Select textbox to perform OCR (CTPN -> CRNN). Select face detector to perform (face detection -> facenet -> exact retrieval, in addition to sequence selected above)


Hooks are scripts that run when certain events occur in the repository. They can be found in the .git/hooks directory. The directory is seeded with examples all with the .sample filename extension.
Hooks
.git/hooks
.sample


In the domain of machine comprehension, making multiple passes over the given document is an effective technique to extract the relation between the given passage, question and answer.
Unlike previous approaches, which perform a fixed number of passes over the passage, Reasoning Network (ReasoNet) uses reinforcement learning (RL) to decide how many times a document should be read.
Every time the document is read, ReasoNet determines whether the document should be read again or has the termination state been reached. If termination state is reached, the answer module is triggered to generate the answer.
Since the termination state is discrete and not connected to the final output, RL approach is used.
CNN, DailyMail Dataset
SQuAD
Graph Reachability Dataset
Memory (M) - Comprises of the vector representation of the document and the question (encoded using GRU or other RNNs).
Attention - Attention vector (xt) is a function of current internal state st and external memory M. The state and memory are passed through FCs and fed to a similarity function.
Internal State (st) - Vector representation of the question state computed by a RNN using the previous internal state and the attention vector xt
Termination Gate (Tt) - Uses a logistic regression model to generate a random binary variable using the current internal state st.
Reinforcement Learning - For the RL setting, reward at time t, rt = 1 if Tt = 1 and answer is correct. Otherwise rt = 0
Workflow - Given a passage p, query q and answer a:
Extract memory using p
Extract initial hidden state using q
ReasoNet executes all possible episodes that can be enumerated by setting an upper limit on the number of passes.
These episodes generate actions and answers that are used to train the ReasoNet.
Result
CNN, DailyMail Corpus
SQuAD
Graph Reachability Dataset
ReasoNet - Standard ReasoNet as described above.
ReasoNet-Last - Use the prediction from the Tmax
ReasoNet > ReasoNet-Last > Deep LSTM Reader
ReasoNet converges faster than ReasoNet-Last indicating that the terminate gate is useful.
Notes


Press arrow up or arrow down key and watch how they are sent to other browser windows using websockets. Note that the sending browser window does not receive the message. This is by design.


vignettes/working-with-bulk-apis.Rmd
working-with-bulk-apis.Rmd
First, load the {salesforcer} and {dplyr} packages and login, if needed.
library(dplyr, warn.conflicts = FALSE)
library(salesforcer)
sf_auth()
For really large inserts, updates, deletes, upserts, and queries you can just add api_type = "Bulk 1.0"
to most functions to get the benefits of using the Bulk API instead of the SOAP or REST APIs. The change you have to make from using the REST API to the Bulk 1.0 API as simple as adding api_type="Bulk 1.0"
to your function arguments. First, let’s build a tbl_df
with two new records to be created.
n <- 4
prefix <- paste0("Bulk-", as.integer(runif(1,1,100000)), "-")
new_contacts <- tibble(FirstName = rep("Test", n),
LastName = paste0("Contact-Create-", 1:n),
My_External_Id__c=paste0(prefix, letters[1:n]))
There are some differences in the way the REST API returns response information vs. the Bulk 1.0 API. However, the changes in Salesforce are exactly the same for these two calls.
# REST
rest_created_records <- sf_create(new_contacts[1:2,],
object_name="Contact",
api_type="REST")
rest_created_records
#> # A tibble: 2 × 2
#> id success
#> <chr> <lgl>
#> 1 0033s00001BXHtxAAH TRUE
#> 2 0033s00001BXHtyAAH TRUE
# Bulk
bulk_created_records <- sf_create(new_contacts[3:4,],
object_name="Contact",
api_type="Bulk 1.0")
bulk_created_records
#> # A tibble: 2 × 4
#> Id Success Created Error
#> <chr> <lgl> <lgl> <lgl>
#> 1 0033s00001BXHu2AAH TRUE TRUE NA
#> 2 0033s00001BXHu3AAH TRUE TRUE NA
To show a more lengthy example of using the Bulk 1.0 API, below is a workflow of that creates 2 records, queries them, and deletes them. This is just an example. Typically, you’d want to use the Bulk APIs over the REST or SOAP APIs when dealing with over 10,000 records.
object <- "Contact"
created_records <- sf_create(new_contacts, object_name=object, api_type="Bulk 1.0")
created_records
#> # A tibble: 2 × 4
#> Id Success Created Error
#> <chr> <lgl> <lgl> <lgl>
#> 1 0033s00001BXHu7AAH TRUE TRUE NA
#> 2 0033s00001BXHu8AAH TRUE TRUE NA
# query bulk
my_soql <- sprintf("SELECT Id,
FirstName,
LastName
FROM Contact
WHERE Id in ('%s')",
paste0(created_records$Id , collapse="','"))
queried_records <- sf_query(my_soql, object_name=object, api_type="Bulk 1.0")
queried_records
#> # A tibble: 2 × 3
#> Id FirstName LastName
#> <chr> <chr> <chr>
#> 1 0033s00001BXHu7AAH Test Contact-Create-1
#> 2 0033s00001BXHu8AAH Test Contact-Create-2
# delete bulk
deleted_records <- sf_delete(queried_records$Id, object_name=object, api_type="Bulk 1.0")
deleted_records
#> # A tibble: 2 × 4
#> Id Success Created Error
#> <chr> <lgl> <lgl> <lgl>
#> 1 0033s00001BXHu7AAH TRUE FALSE NA
#> 2 0033s00001BXHu8AAH TRUE FALSE NA
There is one limitation to Bulk queries is that it does not support the following operations or structures of SOQL:
Salesforce has more recently introduced the Bulk 2.0 API which is supposed to be faster and have a more consistent JSON/REST based API than the Bulk 1.0 API. In some cases I have noticed that the ordering of the result records will differ from the order of the input data because the data is batched and processed asynchronously. by Salesforce instead of R. However, The Bulk 2.0 API returns every single field that was included in the call so if you have an identifying key your dataset, then it should not be a problem to join on that key with your original data to bring in the newly assigned Salesforce Id that is generated when the record was created in Salesforce. However, I have find it just seems wasteful to transfer all of the field information back after the query and have not found a significant performance improvement between the Bulk 1.0 and Bulk 2.0. Finally, note that the status field names (“Success”, “Created”, “Error”) are different from the Bulk 2.0 API.
n <- 20
prefix <- paste0("Bulk-", as.integer(runif(1,1,100000)), "-")
new_contacts <- tibble(FirstName = rep("Test", n),
LastName = paste0("Contact-Create-", 1:n),
test_number__c = 1:n,
My_External_Id__c=paste0(prefix, letters[1:n]))
created_records_v1 <- sf_create(new_contacts[1:10,],
object_name = "Contact",
api_type = "Bulk 1.0")
created_records_v1
#> # A tibble: 10 × 4
#> Id Success Created Error
#> <chr> <lgl> <lgl> <lgl>
#> 1 0033s00001BXHuCAAX TRUE TRUE NA
#> 2 0033s00001BXHuDAAX TRUE TRUE NA
#> 3 0033s00001BXHuEAAX TRUE TRUE NA
#> 4 0033s00001BXHuFAAX TRUE TRUE NA
#> 5 0033s00001BXHuGAAX TRUE TRUE NA
#> # … with 5 more rows
created_records_v2 <- sf_create(new_contacts[11:20,],
object_name = "Contact",
api_type = "Bulk 2.0")
created_records_v2
#> # A tibble: 10 × 7
#> sf__Id sf__Created sf__Error FirstName LastName My_External_Id_…
#> <chr> <lgl> <lgl> <chr> <chr> <chr>
#> 1 0033s00001BXHuMAAX TRUE NA Test Contact-C… Bulk-94075-k
#> 2 0033s00001BXHuNAAX TRUE NA Test Contact-C… Bulk-94075-l
#> 3 0033s00001BXHuOAAX TRUE NA Test Contact-C… Bulk-94075-m
#> 4 0033s00001BXHuPAAX TRUE NA Test Contact-C… Bulk-94075-n
#> 5 0033s00001BXHuQAAX TRUE NA Test Contact-C… Bulk-94075-o
#> # … with 5 more rows, and 1 more variable: test_number__c <dbl>
Below is a simple performance benchmark between the Bulk 1.0 and Bulk 2.0 APIs for a small query. In general, the Bulk 2.0 should be faster. One potential reason for the implementation in R to be faster is that the entire recordset is parsed at once from a downloaded CSV of the results when using the Bulk 1.0 API. The Bulk 2.0 retrieves the same data in large batches (typically 50,000 records at a time). I would encourage users to experiment to see what works best in their Salesforce Org.
soql <- "SELECT Id, Name FROM Contact"
bulk1_query <- function(){sf_query(soql, "Contact", api_type="Bulk 1.0")}
bulk2_query <- function(){sf_query(soql, api_type="Bulk 2.0")} # Bulk 2.0 doesn't need object name
res <- microbenchmark::microbenchmark(
bulk1_query(),
bulk2_query(),
times=8,
unit = "s"
)
res
#> Unit: seconds
#> expr min lq mean median uq max neval
#> bulk1_query() 8.189368 8.670841 10.05203 8.987773 9.573661 17.76234 8
#> bulk2_query() 7.033586 8.555408 11.25908 12.549040 13.558243 13.71369 8
suppressWarnings(suppressMessages(
ggplot2::autoplot(res) +
ggplot2::scale_y_continuous(name="Time [seconds]", n.breaks=6)
))


3D visualisation instructions
Use mouse to manipulate the 3D render.
To rotate: drag molecule to desired direction.
To zoom: scroll or hold shift + drag downwards to zoom in/upwards to zoom out.
To pan: hold ctrl + drag to desired direction.
To rotate: drag molecule to desired direction.
To zoom: scroll or hold shift + drag downwards to zoom in/upwards to zoom out.
To pan: hold ctrl + drag to desired direction.
1H0M
3D structure of all EsaR protein structure predictions
STRUCTURE PREDICTION
Structure prediction of EsaR was conducted using
RaptorX,
I-TASSER,
Phyre, and
Alphafold.
For I-TASSER, the EsaR homologue TraR was submitted as a template (PDB: 1H0M). After prediction, the obtained
conformations were aligned in PyMOL.
LIGAND DOCKING
SwissDock
server (Swiss Institute of Bioinformatics) was used to perform molecular docking of the cognate 3OC6HSL. We
restricted docking to a docking box enclosing the binding pocket which was identified by the cavity-detection
method provided by the DoGSiteScorer tool from the ProteinsPlus server.
The LigPlot tool was used to identify the interactions between the ligand and the EsaR predicted conformations, which were then compared to that of the ligand and protein crystal structures homologous to EsaR>. These suitable homologous structures were selected by running a BLAST search and filtering the results bound to their respective cognate ligand available from the Protein Data Bank.
The LigPlot tool was used to identify the interactions between the ligand and the EsaR predicted conformations, which were then compared to that of the ligand and protein crystal structures homologous to EsaR>. These suitable homologous structures were selected by running a BLAST search and filtering the results bound to their respective cognate ligand available from the Protein Data Bank.
MUTANT ANALYSIS
Python scripts were written to substitute the selected 4 residues with the 12 mutagenic NDT codons, generating
a total of 20,736 (124) mutants in a combinatorial process. Scripts were also written to perform
single-residue mutagenesis, substituting each of the 4 residues with the 20 amino acids and generating 80 (20
x 4) single-mutation sequences. DNA and residue mutant sequences were generated as input to downstream
prediction software.
AlphaFold codes were modified to read sequences stored in a .csv file instead of importing one sequence at a time, hence automating and accelerating the prediction. The structures of the first 50 mutants from the 20,736-mutant library were predicted to study the effect of the mutation on binding sites.
AlphaFold codes were modified to read sequences stored in a .csv file instead of importing one sequence at a time, hence automating and accelerating the prediction. The structures of the first 50 mutants from the 20,736-mutant library were predicted to study the effect of the mutation on binding sites.


Bucks-Timberwolves game delayed to repair uneven rim
by The Associated PressMINNEAPOLIS (AP) — The start of Monday night’s game between the Milwaukee Bucks and Minnesota Timberwolves was delayed because one of the rims was not level.
The game was scheduled to tip off at 8:10 p.m. Eastern. The problem with the basket was discovered during pregame warmups.
The game began after a 49-minute delay.
___
More AP NBA: https://apnews.com/NBA and https://twitter.com/AP_Sports
The Associated Press


Search imgur galleries!
Searching for images. Simply include the search term(s) at the end of the URL
https://fcc-image-otmeek.c9users.io/imagesearch/cats
For pagination, include the following query parameter with the page number
https://fcc-image-otmeek.c9users.io/imagesearch/cats?offset=2
See the latest queries
https://fcc-image-otmeek.c9users.io/api/latest/imagesearch


MyGym will help you to maintain your health and fitness you will find only at MyGym
Become a member today7:00 AM - 10:00 PM
Saturday6:00 AM - 4:00 PM
WE can assure you that ,if you join us you will surely maintain your Health and Fitness.
If you have any question regarding MyGym Membership, you can contact us immediately. Thank you.
Yoga is a light, which once lit will never dim
True power of energy comes from Aerobics
Good things come to those who sweat....
| Mon | Tue | Wed | Thu | Fri | Sat | |
|---|---|---|---|---|---|---|
| 7:00 am | Cardio 7:00 am - 9:00 am | Power Fitness 7:00 am - 9:00 am | Yoga Section 7:00 am - 9:00 am | |||
| 9:00 am | Boxing 8:00 am - 9:00 am | Areobic 8:00 am - 9:00 am | Cardio 8:00 am - 9:00 am | |||
| 11:00 am | Boxing 11:00 am - 2:00 pm | Areobic 11:30 am - 3:30 pm | Body work 11:50 am - 5:20 pm | |||
| 2:00 pm | Boxing 2:00 pm - 4:00 pm | Power lifting 3:00 pm - 6:00 pm | Cardio 6:00 pm - 9:00 pm | Crossfit 5:00 pm - 7:00 pm |
Bhiwandi ,Maharashtra , India


Volume 1: Logical Foundations
Table of Contents
Index
Roadmap
Preface
Top
Welcome
Overview
Logic
Proof Assistants
Functional Programming
Further Reading
Practicalities
Chapter Dependencies
System Requirements
Exercises
Downloading the Coq Files
Lecture Videos
Note for Instructors
Translations
Thanks
Functional Programming in Coq (
Basics
)
Top
Introduction
Data and Functions
Enumerated Types
Days of the Week
Homework Submission Guidelines
Booleans
Types
New Types from Old
Tuples
Modules
Numbers
Proof by Simplification
Proof by Rewriting
Proof by Case Analysis
More on Notation (Optional)
Fixpoints and Structural Recursion (Optional)
More Exercises
Proof by Induction (
Induction
)
Top
Proof by Induction
Proofs Within Proofs
Formal vs. Informal Proof
More Exercises
Working with Structured Data (
Lists
)
Top
Pairs of Numbers
Lists of Numbers
Reasoning About Lists
Induction on Lists
Search
List Exercises, Part 1
List Exercises, Part 2
Options
Partial Maps
Polymorphism and Higher-Order Functions (
Poly
)
Top
Polymorphism
Polymorphic Lists
Polymorphic Pairs
Polymorphic Options
Functions as Data
Higher-Order Functions
Filter
Anonymous Functions
Map
Fold
Functions That Construct Functions
Additional Exercises
More Basic Tactics (
Tactics
)
Top
The
apply
Tactic
The
apply
with
Tactic
The
injection
and
discriminate
Tactics
Using Tactics on Hypotheses
Varying the Induction Hypothesis
Unfolding Definitions
Using
destruct
on Compound Expressions
Review
Additional Exercises
Logic in Coq (
Logic
)
Top
Logical Connectives
Conjunction
Disjunction
Falsehood and Negation
Truth
Logical Equivalence
Existential Quantification
Programming with Propositions
Applying Theorems to Arguments
Coq vs. Set Theory
Functional Extensionality
Propositions and Booleans
Classical vs. Constructive Logic
Inductively Defined Propositions (
IndProp
)
Top
Inductively Defined Propositions
Using Evidence in Proofs
Inversion on Evidence
Induction on Evidence
Inductive Relations
Case Study: Regular Expressions
The
remember
Tactic
Case Study: Improving Reflection
Additional Exercises
Extended Exercise: A Verified Regular-Expression Matcher
Total and Partial Maps (
Maps
)
Top
The Coq Standard Library
Identifiers
Total Maps
Partial maps
The Curry-Howard Correspondence (
ProofObjects
)
Top
Proof Scripts
Quantifiers, Implications, Functions
Programming with Tactics
Logical Connectives as Inductive Types
Conjunction
Disjunction
Existential Quantification
True
and
False
Equality
Inversion, Again
Induction Principles (
IndPrinciples
)
Top
Basics
Polymorphism
Induction Hypotheses
More on the
induction
Tactic
Induction Principles in
Prop
Formal vs. Informal Proofs by Induction
Induction Over an Inductively Defined Set
Induction Over an Inductively Defined Proposition
Properties of Relations (
Rel
)
Top
Relations
Basic Properties
Reflexive, Transitive Closure
Simple Imperative Programs (
Imp
)
Top
Arithmetic and Boolean Expressions
Syntax
Evaluation
Optimization
Coq Automation
Tacticals
Defining New Tactic Notations
The
omega
Tactic
A Few More Handy Tactics
Evaluation as a Relation
Inference Rule Notation
Equivalence of the Definitions
Computational vs. Relational Definitions
Expressions With Variables
States
Syntax
Notations
Evaluation
Commands
Syntax
More Examples
Evaluating Commands
Evaluation as a Function (Failed Attempt)
Evaluation as a Relation
Determinism of Evaluation
Reasoning About Imp Programs
Additional Exercises
Lexing and Parsing in Coq (
ImpParser
)
Top
Internals
Lexical Analysis
Parsing
Examples
An Evaluation Function for Imp (
ImpCEvalFun
)
Top
A Broken Evaluator
A Step-Indexed Evaluator
Relational vs. Step-Indexed Evaluation
Determinism of Evaluation Again
Extracting ML from Coq (
Extraction
)
Top
Basic Extraction
Controlling Extraction of Specific Types
A Complete Example
Discussion
Going Further
More Automation (
Auto
)
Top
The
auto
Tactic
Searching For Hypotheses
The
eapply
and
eauto
variants
Postscript
Top
Looking Back
Looking Forward
Other sources
Bibliography (
Bib
)
Top
Resources cited in this volume


In this step, you are required to provide the amount and type of drinks that will be served and/or sold at your event. This information is important to help you estimate the appropriate serving quantities for your event and, if you are selling drinks, the most accurate calculation of Provincial Sales Tax (PST). The quantities you provide are subject to review and approval and may be used by police and liquor inspectors during inspections.


https://en.wikipedia.org/wiki/Recursion
A class of objects or methods exhibits recursive behavior
when it can be defined by two properties:
(1) a simple base case (or cases) - a terminating scenario
that does not use recursion to produce an answer,
(2) a recursive step - a set of rules that reduces
all other cases toward the base case.
def print_stars(n): if n > 0: # pass for the base case n=0 print("*") print_stars(n-1) print_stars(5)
# 0! = 1, 1! = 1, n! = n*(n-1)! def factorial(n): if n == 0 or n == 1: # base cases return 1 else: return n * factorial(n-1) import math print(math.factorial(10)) # Python 2.6+ print(factorial(10))
# The Fibonacci sequence # f(0) = 0, f(1) = 1, f(n) = f(n-1) + f(n-2) def fibonacci(n): if n == 0 or n == 1: # base cases return n else: return fibonacci(n-1) + fibonacci(n-2)
# binomial(n, k) = factorial(n) / (factorial(k) * factorial(n-k)) # binomial(n, 0) = binomial(n, n) = 1 def binomial(n, k): if k == 0 or k == n: return 1 else: return binomial(n-1, k-1) + binomial(n-1, k)


Import your Crusader Kings III save and view multiple fun stats!
CK3 Visualizer is fan made project. It's made using Angular, a javascript framework, and Plotly a free extensive javascript chart maker.
This project is open source and you are welcome to contribute via : Github Ck3 Visualizer
All users, event non technical can suggest charts or other ideas via this Trello board
Start here :


Psalms 56:1
Be merciful unto me, O God: for man would swallow me up; he fighting daily oppresseth me.


{% extends "content_template.html" %} {% from "components/page-header.html" import page_header %} {% block per_page_title %} {{ _('How to pay') }} {% endblock %} {% block content_column_content %} {{ page_header('How to pay') }}
{{ _('We’ll send your organisation an invoice each quarter if you:') }}
{{ _("If your organisation has more than one service, you'll see a breakdown of each service on your invoice.") }}
{{ _('If the value of an invoice is less than £250 (before VAT), we’ll add it to the total for the next quarter to save time and effort.')}}
{{ _('You can pay by BACS, debit card, or credit card.') }}
{{ _('If your organisation’s estimated spend is more than £500 per year (before VAT), you need to send us a purchase order (PO).') }}
{{ _('Your organisation should raise a single PO for the estimated cost of all its services. You can update the PO anytime if your usage increases.') }}
{{ _('You may need to set up the Cabinet Office as a supplier before you can raise a PO.') }}
{{ _('Contact us') }} {{ _('if you need help raising a purchase order.') }}
{% endblock %}


|
QuantLib: a free/open-source library for quantitative finance
Fully annotated sources - version 1.30
|
Black-formula callable zero coupon bond engine. More...
#include <ql/experimental/callablebonds/blackcallablebondengine.hpp>
Public Member Functions | |
| BlackCallableZeroCouponBondEngine (const Handle< Quote > &fwdYieldVol, const Handle< YieldTermStructure > &discountCurve) | |
| volatility is the quoted fwd yield volatility, not price vol More... | |
| BlackCallableZeroCouponBondEngine (const Handle< CallableBondVolatilityStructure > &yieldVolStructure, const Handle< YieldTermStructure > &discountCurve) | |
| volatility is the quoted fwd yield volatility, not price vol More... | |
| Public Member Functions inherited from BlackCallableFixedRateBondEngine | |
| BlackCallableFixedRateBondEngine (const Handle< Quote > &fwdYieldVol, Handle< YieldTermStructure > discountCurve) | |
| volatility is the quoted fwd yield volatility, not price vol More... | |
| BlackCallableFixedRateBondEngine (Handle< CallableBondVolatilityStructure > yieldVolStructure, Handle< YieldTermStructure > discountCurve) | |
| volatility is the quoted fwd yield volatility, not price vol More... | |
| void | calculate () const override |
Black-formula callable zero coupon bond engine.
Callable zero coupon bond, where the embedded (European) option price is assumed to obey the Black formula. Follows "European bond option" treatment in Hull, Fourth Edition, Chapter 20.
Definition at line 74 of file blackcallablebondengine.hpp.
| BlackCallableZeroCouponBondEngine | ( | const Handle< Quote > & | fwdYieldVol, |
| const Handle< YieldTermStructure > & | discountCurve | ||
| ) |
volatility is the quoted fwd yield volatility, not price vol
Definition at line 78 of file blackcallablebondengine.hpp.
| BlackCallableZeroCouponBondEngine | ( | const Handle< CallableBondVolatilityStructure > & | yieldVolStructure, |
| const Handle< YieldTermStructure > & | discountCurve | ||
| ) |
volatility is the quoted fwd yield volatility, not price vol
Definition at line 84 of file blackcallablebondengine.hpp.


{% include "header.html" %}
Loan Application
{% include "../forms/main_form.html" %}
{% include "footer.html" %}


The AppX Manifest may refer to both string and file resources. String resource identifiers must be prefixed with "ms-resource:", the URI scheme name. File references should simply refer to the logical file.
View the manifest by opening the package.appxmanifest file.


Context size (optional):
Select a base file
Select a new file
Base Text
New Text
Side by Side Diff
Inline Diff
Colour Me


VERSE OF THE DAY
2 Corinthians 10:17-18
But, “Let the one who boasts boast in the Lord.” For it is not the one who commends himself who is approved, but the one whom the Lord commends.
Leer la Biblie
select the testaments
Mas él respondiendo, dijo: Escrito está: No con solo el pan vivirá el hombre, mas con toda palabra que sale de la boca de Dios.
2 Corinthians 10:17-18
But, “Let the one who boasts boast in the Lord.” For it is not the one who commends himself who is approved, but the one whom the Lord commends.
select the testaments


Application Logs
Live Users
Upload Statistics
Genere based Analysis
Popularity
Top viewed video
| Rank | Video Title | Description | Genere | views |
|---|---|---|---|---|
#{{i+1}} |
{{item.title}} |
{{item.description}} |
{{item.genere}} |
{{item.views}} |
Reported vidoes
Spam Reports Live
| Video Title | Spam Count | Actions |
|---|---|---|
|
{{item[0].title}} |
{{item[0].spamCount}} |
|
| {{item.title}} | {{item.spamCount}} |


Capcom announces Street Fighter V: Champion Edition, Gill joins roster next month
A "discount" if you're upgrading
by CJ AndriessenStreet Fighter V, despite its rocky launch, is still one of the biggest fighting games on the planet and at this year's North American Regional Finals of the Capcom Cup, it was announced the game would be getting even bigger with the Street Fighter V: Champion Edition. Launching in February 2020, this version of the game will include all 40 characters and 34 stages, and will feature more than 200 costumes. Fighting Chance, Pro Tour DLC, and collaboration costumes will not be included in this package.
SFV:CE will be available for PlayStation 4 and on Steam starting February 14. It will retail for $29.99, though if you own any of the current versions of Street Fighter V, you can upgrade to the new edition for $24.99. Gill, who was teased at the end of "A Shadow Falls" story mode, will be included in the package. If you don't want to wait until February, you can also pick him up starting next month for $5.99 or 100,000 in Fight Money.
Street Fighter V: Champion Edition Announced - Gill Joins Roster Next Month! [Capcom]


The Softer Side of Sears
One of the earliest examples of subliminal dickery took place on page 602 of the 1975 Sears Christmas catalog. This model clearly has his stocking stuffed.


Swift-Kuery-PostgreSQL
PostgreSQL plugin for the Swift-Kuery framework. It enables you to use Swift-Kuery to manipulate data in a PostgreSQL database.
PostgreSQL client installation
To use Swift-Kuery-PostgreSQL you must have the appropriate PostgreSQL C-language client installed.
macOS
$ brew install postgresql
Linux
$ sudo apt-get install libpq-dev
Usage
Add dependencies
Add the SwiftKueryPostgreSQL
package to the dependencies within your application’s Package.swift
file. Substitute "x.x.x"
with the latest SwiftKueryPostgreSQL
release.
.package(url: "https://github.com/Kitura-Next/Swift-Kuery-PostgreSQL.git", from: "x.x.x")
Add SwiftKueryPostgreSQL
to your target’s dependencies:
.target(name: "example", dependencies: ["SwiftKueryPostgreSQL"]),
Import package
import SwiftKueryPostgreSQL
Using Swift-Kuery-PostgreSQL
First create an instance of Swift-Kuery-PostgreSQL
by calling:
let connection = PostgreSQLConnection(host: host, port: port, options: [ConnectionOptions]?)
Where:
- host and port are the host and the port of PostgreSQL
- ConnectionOptions an optional set of:
- options - command-line options to be sent to the server
- databaseName - the database name
- userName - the user name
- password - the user password
- connectionTimeout - maximum wait for connection in seconds. Zero or not specified means wait indefinitely.
For more details refer to the PostgreSQL manual.
Alternatively, call:
let connection = PostgreSQLConnection(url: URL(string: "Postgres://\(username):\(password)@\(host):\(port)/\(databaseName)")!)
To establish a connection to the database call:
connection.connect() { result in
guard result.success else {
// Connection not established, handle error
return
}
// Connection established
}
You now have a connection that can be used to execute SQL queries created using Swift-Kuery.
Getting Started with Swift-Kuery-PostgreSQL locally
Install PostgreSQL server
Mac
brew install postgresql
Ubuntu Linux
sudo apt-get install postgresql postgresql-contrib
Make sure you have the database running. This installation should have also installed two applications we need, namely (createdb and psql) which will be used as clients to your locally running PostgreSQL.
Create a database
Let’s create a database called school
:
createdb school
Create the tables
Now, let’s create the tables we need for this example.
Use the interative psql
client to open the database we created:
$ psql school
psql (9.5.4)
Type "help" for help.
school=#
First, create the student table:
CREATE TABLE student (
studentId BIGSERIAL PRIMARY KEY,
name varchar(100) NOT NULL CHECK (name <> '')
);
Next, create the grades table:
CREATE TABLE grades (
key BIGSERIAL PRIMARY KEY,
studentId integer NOT NULL,
course varchar(40) NOT NULL,
grade integer
);
Populate the tables
First the students table:
INSERT INTO student VALUES (1, 'Tommy Watson');
INSERT INTO student VALUES (2, 'Fred Flintstone');
And then the grades table:
INSERT INTO grades (studentId, course, grade) VALUES (1, 'How to build your first computer', 99);
INSERT INTO grades (studentId, course, grade) VALUES (2, 'How to work at a rock quarry', 71);
Use Swift-Kuery
Now we are set to connect to our database from Swift and use Swift-Kuery to query the data into our Swift application.
Create simple Swift executable
First create a directory for our project and then initialize it.
$ mkdir swift-kuery-play
$ cd swift-kuery-play
$ swift package init --type executable
Creating executable package: swift-kuery-play
Creating Package.swift
Creating README.md
Creating .gitignore
Creating Sources/
Creating Sources/swift-kuery-play/main.swift
Creating Tests/
$
Now, add Swift-Kuery-PostgreSQL as a dependency for our project, this will automatically pull in Swift-Kuery.
Edit Package.swift
to contain the following, substituting "x.x.x"
with the latest Kitura
and Swift-Kuery-PostgreSQL
releases.
// swift-tools-version:4.0
import PackageDescription
let package = Package(
name: "swift-kuery-play",
dependencies: [
.package(url: "https://github.com/Kitura-Next/Kitura.git", from: "x.x.x"),
.package(url: "https://github.com/Kitura-Next/Swift-Kuery-PostgreSQL", from: "x.x.x")
],
targets: [
.target(
name: "swift-kuery-play",
dependencies: ["Kitura", "SwiftKueryPostgreSQL"]),
]
)
Now, edit your main.swift
file to contain:
import SwiftKuery
import SwiftKueryPostgreSQL
import Kitura
let router = Router()
class Grades : Table {
let tableName = "grades"
let key = Column("key")
let course = Column("course")
let grade = Column("grade")
let studentId = Column("studentId")
}
let grades = Grades()
let connection = PostgreSQLConnection(host: "localhost", port: 5432, options: [.databaseName("school")])
func grades(_ callback: @escaping (String) -> Void) -> Void {
connection.connect() { result in
guard result.success else {
guard let error = result.asError else {
return callback("Error connecting: Unknown Error")
}
return callback("Error connecting: \(error)")
}
// Build and execute your query here.
// First build query
let query = Select(grades.course, grades.grade, from: grades)
// Execute query
connection.execute(query: query) { result in
guard let resultSet = result.asResultSet else {
guard let error = result.asError else {
return callback("Error executing query: Unknown Error")
}
return callback("Error executing query: \(error)")
}
var retString = ""
resultSet.getColumnTitles() { titles, error in
guard let titles = titles else {
guard let error = error else {
return callback("Error fetching column titles: Unknown Error")
}
return callback("Error fetching column titles: \(error)")
}
for title in titles {
//The column names of the result.
retString.append("\(title.padding(toLength: 35, withPad: " ", startingAt: 0))")
}
retString.append("\n")
resultSet.forEach() { row, error in
guard let row = row else {
// A null row means we have run out of results unless we encountered an error
if let error = error {
return callback("Error fetching row: \(error)")
}
// No error so all rows are processed, make final callback passing result.
return callback(retString)
}
for value in row {
if let value = value {
let valueString = String(describing: value)
retString.append("\(valueString.padding(toLength: 35, withPad: " ", startingAt: 0))")
}
}
retString.append("\n")
}
}
}
}
}
router.get("/") {
request, response, next in
grades() {
resp in
response.send(resp)
next()
}
}
Kitura.addHTTPServer(onPort: 8080, with: router)
Kitura.run()
Now build the program and run it:
$ swift build
$ .build/debug/swift-kuery-play
Now open a web page to http://localhost:8080 and you should see:
course grade
How to build your first computer 99
How to work at a rock quarry 71
Now we can change our query line and see different results.
Change the line:
let query = Select(grades.course, grades.grade, from: grades)
to
let query = Select(grades.course, grades.grade, from: grades)
.where(grades.grade > 80)
and we should only see grades greater than 80:
course grade
How to build your first computer 99
Another possibility is to use QueryResult.asRows
that returns the result as an array of dictionaries where each dictionary represents a row of the result with the column title as the key.
Change your grades
function as follows:
func grades(_ callback: @escaping (String) -> Void) -> Void {
connection.connect() { result in
guard result.success else {
guard let error = result.asError else {
return callback("Error connecting: Unknown Error")
}
return callback("Error connecting: \(error)")
}
let query = Select(grades.course, grades.grade, from: grades)
connection.execute(query: query) { result in
result.asRows() { rows, error in
guard let rows = rows else {
guard let error = error else {
return callback("Error getting rows: Unknown Error")
}
return callback("Error getting rows: \(error)")
}
var retString = ""
for row in rows {
for (title, value) in row {
if let value = value {
retString.append("\(title): \(value) ")
}
}
retString.append("\n")
}
return callback(retString)
}
}
}
}
At http://localhost:8080 you should see:
grade: 99 course: How to build your first computer
grade: 71 course: How to work at a rock quarry
API Documentation
For more information visit our API reference.
Community
We love to talk server-side Swift, and Kitura. Join our Slack to meet the team!
License
This library is licensed under Apache 2.0. Full license text is available in LICENSE


Triangle by three points.
More...
#include <triangle_2d.h>
Triangle by three points.
Definition at line 18 of file triangle_2d.h.
| gbmath::triangle_2d::triangle_2d |
( |
) | |
|
|
inline |
| gbmath::triangle_2d::triangle_2d |
( |
const triangle_2d & |
t) | |
|
|
inline |
| gbmath::triangle_2d::triangle_2d |
( |
const vec2 |
_p1, |
|
|
const vec2 |
_p2, |
|
|
const vec2 |
_p3 |
|
) |
| |
|
inline |
| vec2 gbmath::triangle_2d::middle_point |
( |
) | |
const |
|
inline |
Compute and return the middle point of the triangle.
Definition at line 52 of file triangle_2d.h.
| triangle_2d& gbmath::triangle_2d::offset |
( |
float |
x, |
|
|
float |
y |
|
) |
| |
|
inline |
| gbmath::triangle_2d::operator const float * |
( |
) | |
const |
|
inline |
| gbmath::triangle_2d::operator float * |
( |
) | |
|
|
inline |
| gbmath::triangle_2d::operator std::string |
( |
) | |
const |
|
inline |
| void gbmath::triangle_2d::operator= |
( |
const std::string & |
str) | |
|
| throw | ( | std::invalid_argument |
| ) | | |
|
inline |
| void gbmath::triangle_2d::set |
( |
const vec2 |
_p1, |
|
|
const vec2 |
_p2, |
|
|
const vec2 |
_p3 |
|
) |
| |
|
inline |
| std::ostream& operator<< |
( |
std::ostream & |
stream, |
|
|
const triangle_2d & |
t |
|
) |
| |
|
friend |
| vec2 gbmath::triangle_2d::p1 |
the first point (vertex) triangular
Definition at line 22 of file triangle_2d.h.
| vec2 gbmath::triangle_2d::p2 |
the second point (vertex) triangular
Definition at line 23 of file triangle_2d.h.
| vec2 gbmath::triangle_2d::p3 |
the second point (vertex) triangular
Definition at line 24 of file triangle_2d.h.
The documentation for this class was generated from the following file:


Your order is placedDummy text of the printing and typesetting industry.
New Message receivedYou have 87 unread messages
Your item is shippedIt is a long established fact that a reader will
Des 16, 2019
Hello – Trip home from Colombo has been arranged, then Jenna will come get me from Stockholm. :)
April 23, 2019
Hello – Alright thanks. I'll have to re-book that somehow, i'll get back to you.
Jun 02, 2019
Re: New mail settings – Will you answer him asap?
Des 24, 2019
Hello – Eff that place, you might as well stay here with us instead! 2019 at 5:55 pm
This Week's Top Stories – Our top pick for you on Medium this week The Man Who Destroyed America’s Ego
April 25, 2019
Montly High-Res Photos – To create this month's pack, we hosted a party with local musician Jared Mahone here in Columbus, Ohio.
Feb 29, 2019
April 19, 2019
Mochila Beta: Subscription Confirmed – You've been confirmed! Welcome to the submitted to us...
April 11, 2019
Sveriges Hetaste sommarjobb – Hej Nicklas Sandell! Vi vill bjuda in dig till "First tour 2014", ett rekryteringsevent som erbjuder jobb på 16 semesterorter iSverige.
Jan 18, 2019
Weekend on Revibe – Today's Friday and we thought maybe you want some music inspiration for the weekend. Here are some trending tracks and playlists we think you should give a listen!
April 2, 2019
Regarding our meeting – That's great, see you on Thursday!
Jun, 2019
Task assigned: Clone ARP's website – You have been assigned a task by Alex@Work on the board Web.
Feb 13, 2019
Let's go fishing! – Hey, You wanna join me and Fred at the lake tomorrow? It'll be awesome.
Hey man – Nah man sorry i don't. Should i get it?
Home again! – That's just perfect! See you tomorrow.
1 new items in your Stackexchange inbox – The following items were added to your Stack Exchange global inbox since you last checked it.
Jun 13, 2019
You can now use your storage in Google Drive – Hey Nicklas Sandell! Thank you for purchasing extra storage space in Google Drive.
Feb 26, 2019
Train/Bus – Yes ok, great! I'm not stuck in Stockholm anymore, we're making progress.


Introduction to the extcsv package, which provides a comfortable usage of csv-like files
From many sources you can get csv-like datasets: all kinds of measurement systems, webservices, spreadsheets or a scope ...
You can do it the fast way and use a spreadsheet software. But the problem is: What do you do, if the format slightly changes?
Macros tend to break down. And even if the macro language is your best friend, the fancy preformatting facilities will catch you. Not to mention the problem of number notation depending of the language of your intallation. Then a full featured scripting language comes in handy.
The extcsv library provides methods for easy navigation through the datasets by selectBy. This method accepts multiple keys (which are treated as columns names) and values or comparison operators for values. Additionally regular expressions can be used as selection criteria.
Additionally datasets can be accessed by the [] operator know from Ruby arrays.
Splitting: ExtCsv objects can be splitted by the different values of one or more columns (split)
Iteration: With the Enumerable module included, all its searching/traversal methods can be used. The specific each_by and each_obj methods make it possible to iterate over the differrent values of a column or over subobjects, where these different values are constant.
Comparison: Through the Comparable module ExtCsv objects can be compared or sortet.
Combination: Objects from files with the same structure can easily be concatenated with concat. For differential structured object, the combine method can do simple merging.
For more inforamtion, please have a look at the rdoc documention and the test files.
Plotting is still under developement. It will be done with gnuplot.
For the basic stuff, Ruby is the only requirement. For plotting (which will be included soon), gnuplot and it’s gem have to be installed.
Gnuplot was choosen, because it is available for many platforms and operating systems. For windows systems, a simple MSExcel-export will be implemented.
You have suggestions, feature requests, ideas, diffs, criticsm? GREAT!
Drop me a line {stark.dreamdetective(-,-)gmail.com} and I will answer as soon as possible.


ABOUT
Technology ("science of craft", from Greek τέχνη, techne, "art, skill, cunning of hand"; and -λογία, - logia[2]) is the sum of techniques, skills, methods, and processes used in the production of goods or services or in the accomplishment of objectives, such as scientific investigation. Technology can be the knowledge of techniques, processes, and the like, or it can be embedded in machines to allow.
COMPANY PROFILE
VIDEO
OUR BRAND
PRODUCTS
We provide production systems – designed to save both time and space. Eton Systems eliminates manual transportation and adds more value to your products. Real-time traceability of individual units for complete sequencing control throughout your production line.
ROTONDI GROUP SRL is a company based in the outskirts of Milan. We produce hi-tech pressing equipment for mens and ladies jackets, trousers, jeans, shirts and knitwear. Two advanced production plants of almost 10,000 square meters (100,000 square feet) give an integrated manufacturing cycle from design to completion using the latest automatic cutters and robots.
ROTONDI GROUP SRL is a company based in the outskirts of Milan. We produce hi-tech pressing equipment for mens and ladies jackets, trousers, jeans, shirts and knitwear. Two advanced production plants of almost 10,000 square meters (100,000 square feet) give an integrated manufacturing cycle from design to completion using the latest automatic cutters and robots.
Enmos, who has a grasp of the fabric dyeing processes,
collects all the experience and process knowledge from
the past years, on the Simplex control computers and
Focus Centeral Monitoring software.
Simplex dyeing machines with state-of-the-art
technology in different models and capacities, fully
control and operate machines in different capacities,
brands, models and technologies with specially
designed commands for fabric dyeing machines.
SERVICES
Sale of new product
Technology ("science of craft", from art, skill, cunning of hand"; and - λογία, -logia[2]) is the sum of techniques, skills, methods, and processes used in the
Repairing of machine
Technology ("science of craft", is the sum of techniques, skills, methods, and processes used in the production of goods or services or in the accomplishment of objectives, such as
Sale of spare parts
Technology ("science of craft", from art, skill, cunning of hand"; and - λογία, -logia[2]) is the sum of techniques, skills, methods, and processes used in the production of goods or services or in the
Technical support
Technology ("science of craft", from art, skill, cunning of hand"; and - λογία, -logia[2]) is the sum of techniques, skills, methods, and processes used in the production of goods or services or in the


Login to Account
Sign Up
Welcome User
Welcome to Firebase web login Example. You're currently logged in.
Logout


--- layout: default title: User Activity permalink: /users-activity ---
Using license shows how many GitHub Enterprise licenses were used at a given date.
Pushing commits corresponds to how many different people pushed commits to the appliance in the last month, week, or day.
The gap to using license indicates the number of people who didn’t log in or push code (for example, people who only read or comment code).


Mappings for the Profile.
| UKCoreMedicationRequest |
| MedicationRequest | Entity. Role, or Act, CombinedMedicationRequest |
| text | Act.text? |
| contained | N/A |
| extension | N/A |
| modifierExtension | N/A |
| identifier | .id |
| id | n/a |
| extension | n/a |
| use | Role.code or implied by context |
| type | Role.code or implied by context |
| system | II.root or Role.id.root |
| value | II.extension or II.root if system indicates OID or GUID (Or Role.id.extension or root) |
| period | Role.effectiveTime or implied by context |
| assigner | II.assigningAuthorityName but note that this is an improper use by the definition of the field. Also Role.scoper |
| status | .statusCode |
| statusReason | .inboundRelationship[typeCode=SUBJ].source[classCode=CACT, moodCode=EVN].reasonCOde |
| intent | .moodCode (nuances beyond PRP/PLAN/RQO would need to be elsewhere) |
| category | .inboundRelationship[typeCode=COMP].source[classCode=OBS, moodCode=EVN, code="type of medication usage"].value |
| priority | .priorityCode |
| doNotPerform | SubstanceAdministration.actionNegationInd |
| reported[x] | .participation[typeCode=INF].role |
| medication[x] | consumable.administrableMedication |
| subject | .participation[typeCode=AUT].role |
| id | n/a |
| extension | n/a |
| reference | N/A |
| type | N/A |
| identifier | .identifier |
| id | n/a |
| extension | n/a |
| use | Role.code or implied by context |
| type | Role.code or implied by context |
| system | II.root or Role.id.root |
| value | II.extension or II.root if system indicates OID or GUID (Or Role.id.extension or root) |
| period | Role.effectiveTime or implied by context |
| assigner | II.assigningAuthorityName but note that this is an improper use by the definition of the field. Also Role.scoper |
| display | N/A |
| encounter | .inboundRelationship[typeCode=COMP].source[classCode=ENC, moodCode=EVN, code="type of encounter or episode"] |
| id | n/a |
| extension | n/a |
| reference | N/A |
| type | N/A |
| identifier | .identifier |
| id | n/a |
| extension | n/a |
| use | Role.code or implied by context |
| type | Role.code or implied by context |
| system | II.root or Role.id.root |
| value | II.extension or II.root if system indicates OID or GUID (Or Role.id.extension or root) |
| period | Role.effectiveTime or implied by context |
| assigner | II.assigningAuthorityName but note that this is an improper use by the definition of the field. Also Role.scoper |
| display | N/A |
| supportingInformation | .outboundRelationship[typeCode=PERT].target[A_SupportingClinicalStatement CMET minimal with many different choices of classCodes(ORG, ENC, PROC, SPLY, SBADM, OBS) and each of the act class codes draws from one or more of the following moodCodes (EVN, DEF, INT PRMS, RQO, PRP, APT, ARQ, GOL)] |
| id | n/a |
| extension | n/a |
| reference | N/A |
| type | N/A |
| identifier | .identifier |
| id | n/a |
| extension | n/a |
| use | Role.code or implied by context |
| type | Role.code or implied by context |
| system | II.root or Role.id.root |
| value | II.extension or II.root if system indicates OID or GUID (Or Role.id.extension or root) |
| period | Role.effectiveTime or implied by context |
| assigner | II.assigningAuthorityName but note that this is an improper use by the definition of the field. Also Role.scoper |
| display | N/A |
| authoredOn | author.time |
| requester | .participation[typeCode=AUT].role |
| id | n/a |
| extension | n/a |
| reference | N/A |
| type | N/A |
| identifier | .identifier |
| id | n/a |
| extension | n/a |
| use | Role.code or implied by context |
| type | Role.code or implied by context |
| system | II.root or Role.id.root |
| value | II.extension or II.root if system indicates OID or GUID (Or Role.id.extension or root) |
| period | Role.effectiveTime or implied by context |
| assigner | II.assigningAuthorityName but note that this is an improper use by the definition of the field. Also Role.scoper |
| display | N/A |
| performer | .participation[typeCode=PRF].role[scoper.determinerCode=INSTANCE] |
| id | n/a |
| extension | n/a |
| reference | N/A |
| type | N/A |
| identifier | .identifier |
| id | n/a |
| extension | n/a |
| use | Role.code or implied by context |
| type | Role.code or implied by context |
| system | II.root or Role.id.root |
| value | II.extension or II.root if system indicates OID or GUID (Or Role.id.extension or root) |
| period | Role.effectiveTime or implied by context |
| assigner | II.assigningAuthorityName but note that this is an improper use by the definition of the field. Also Role.scoper |
| display | N/A |
| performerType | .participation[typeCode=PRF].role[scoper.determinerCode=KIND].code |
| recorder | .participation[typeCode=TRANS].role[classCode=ASSIGNED].code (HealthcareProviderType) |
| id | n/a |
| extension | n/a |
| reference | N/A |
| type | N/A |
| identifier | .identifier |
| id | n/a |
| extension | n/a |
| use | Role.code or implied by context |
| type | Role.code or implied by context |
| system | II.root or Role.id.root |
| value | II.extension or II.root if system indicates OID or GUID (Or Role.id.extension or root) |
| period | Role.effectiveTime or implied by context |
| assigner | II.assigningAuthorityName but note that this is an improper use by the definition of the field. Also Role.scoper |
| display | N/A |
| reasonCode | reason.observation.reasonCode |
| reasonReference | reason.observation[code=ASSERTION].value |
| id | n/a |
| extension | n/a |
| reference | N/A |
| type | N/A |
| identifier | .identifier |
| id | n/a |
| extension | n/a |
| use | Role.code or implied by context |
| type | Role.code or implied by context |
| system | II.root or Role.id.root |
| value | II.extension or II.root if system indicates OID or GUID (Or Role.id.extension or root) |
| period | Role.effectiveTime or implied by context |
| assigner | II.assigningAuthorityName but note that this is an improper use by the definition of the field. Also Role.scoper |
| display | N/A |
| instantiatesCanonical | .outboundRelationship[typeCode=DEFN].target |
| instantiatesUri | .outboundRelationship[typeCode=DEFN].target |
| basedOn | .outboundRelationship[typeCode=FLFS].target[classCode=SBADM or PROC or PCPR or OBS, moodCode=RQO orPLAN or PRP] |
| id | n/a |
| extension | n/a |
| reference | N/A |
| type | N/A |
| identifier | .identifier |
| id | n/a |
| extension | n/a |
| use | Role.code or implied by context |
| type | Role.code or implied by context |
| system | II.root or Role.id.root |
| value | II.extension or II.root if system indicates OID or GUID (Or Role.id.extension or root) |
| period | Role.effectiveTime or implied by context |
| assigner | II.assigningAuthorityName but note that this is an improper use by the definition of the field. Also Role.scoper |
| display | N/A |
| groupIdentifier | .outboundRelationship(typeCode=COMP].target[classCode=SBADM, moodCode=INT].id |
| id | n/a |
| extension | n/a |
| use | Role.code or implied by context |
| type | Role.code or implied by context |
| system | II.root or Role.id.root |
| value | II.extension or II.root if system indicates OID or GUID (Or Role.id.extension or root) |
| period | Role.effectiveTime or implied by context |
| assigner | II.assigningAuthorityName but note that this is an improper use by the definition of the field. Also Role.scoper |
| courseOfTherapyType | Act.code where classCode = LIST and moodCode = EVN |
| insurance | .outboundRelationship[typeCode=COVBY].target |
| id | n/a |
| extension | n/a |
| reference | N/A |
| type | N/A |
| identifier | .identifier |
| id | n/a |
| extension | n/a |
| use | Role.code or implied by context |
| type | Role.code or implied by context |
| system | II.root or Role.id.root |
| value | II.extension or II.root if system indicates OID or GUID (Or Role.id.extension or root) |
| period | Role.effectiveTime or implied by context |
| assigner | II.assigningAuthorityName but note that this is an improper use by the definition of the field. Also Role.scoper |
| display | N/A |
| note | .inboundRelationship[typeCode=SUBJ]/source[classCode=OBS,moodCode=EVN,code="annotation"].value |
| id | n/a |
| extension | n/a |
| author[x] | Act.participant[typeCode=AUT].role |
| time | Act.effectiveTime |
| text | Act.text |
| dosageInstruction | see dosageInstruction mapping |
| id | n/a |
| extension | n/a |
| modifierExtension | N/A |
| sequence | .text |
| text | .text |
| additionalInstruction | .text |
| patientInstruction | .text |
| timing | .effectiveTime |
| asNeeded[x] | .outboundRelationship[typeCode=PRCN].target[classCode=OBS, moodCode=EVN, code="as needed"].value=boolean or codable concept |
| site | .approachSiteCode |
| route | .routeCode |
| id | n/a |
| extension | n/a |
| coding | union(., ./translation) |
| coding (snomedCT) | union(., ./translation) |
| id | n/a |
| extension | n/a |
| system | ./codeSystem |
| version | ./codeSystemVersion |
| code | ./code |
| display | CV.displayName |
| userSelected | CD.codingRationale |
| text | ./originalText[mediaType/code="text/plain"]/data |
| method | .doseQuantity |
| doseAndRate | |
| id | n/a |
| extension | n/a |
| dose[x] | .doseQuantity |
| rate[x] | .rateQuantity |
| maxDosePerPeriod | .maxDoseQuantity |
| maxDosePerAdministration | not supported |
| maxDosePerLifetime | not supported |
| dispenseRequest | component.supplyEvent |
| id | n/a |
| extension | n/a |
| modifierExtension | N/A |
| initialFill | SubstanceAdministration -> ActRelationship[sequenceNumber = '1'] -> Supply |
| id | n/a |
| extension | n/a |
| modifierExtension | N/A |
| quantity | Supply.quantity[moodCode=RQO] |
| duration | Supply.effectivetime[moodCode=RQO] |
| dispenseInterval | Supply.effectivetime[moodCode=RQO] |
| validityPeriod | effectiveTime |
| numberOfRepeatsAllowed | repeatNumber |
| quantity | quantity |
| expectedSupplyDuration | expectedUseTime |
| performer | .outboundRelationship[typeCode=COMP].target[classCode=SPLY, moodCode=RQO] .participation[typeCode=PRF].role[scoper.determinerCode=INSTANCE] |
| id | n/a |
| extension | n/a |
| reference | N/A |
| type | N/A |
| identifier | .identifier |
| id | n/a |
| extension | n/a |
| use | Role.code or implied by context |
| type | Role.code or implied by context |
| system | II.root or Role.id.root |
| value | II.extension or II.root if system indicates OID or GUID (Or Role.id.extension or root) |
| period | Role.effectiveTime or implied by context |
| assigner | II.assigningAuthorityName but note that this is an improper use by the definition of the field. Also Role.scoper |
| display | N/A |
| substitution | subjectOf.substitutionPersmission |
| id | n/a |
| extension | n/a |
| modifierExtension | N/A |
| allowed[x] | code |
| reason | reasonCode |
| priorPrescription | .outboundRelationship[typeCode=?RPLC or ?SUCC]/target[classCode=SBADM,moodCode=RQO] |
| id | n/a |
| extension | n/a |
| reference | N/A |
| type | N/A |
| identifier | .identifier |
| id | n/a |
| extension | n/a |
| use | Role.code or implied by context |
| type | Role.code or implied by context |
| system | II.root or Role.id.root |
| value | II.extension or II.root if system indicates OID or GUID (Or Role.id.extension or root) |
| period | Role.effectiveTime or implied by context |
| assigner | II.assigningAuthorityName but note that this is an improper use by the definition of the field. Also Role.scoper |
| display | N/A |
| detectedIssue | .inboundRelationship[typeCode=SUBJ]/source[classCode=ALRT,moodCode=EVN].value |
| id | n/a |
| extension | n/a |
| reference | N/A |
| type | N/A |
| identifier | .identifier |
| id | n/a |
| extension | n/a |
| use | Role.code or implied by context |
| type | Role.code or implied by context |
| system | II.root or Role.id.root |
| value | II.extension or II.root if system indicates OID or GUID (Or Role.id.extension or root) |
| period | Role.effectiveTime or implied by context |
| assigner | II.assigningAuthorityName but note that this is an improper use by the definition of the field. Also Role.scoper |
| display | N/A |
| eventHistory | .inboundRelationship(typeCode=SUBJ].source[classCode=CACT, moodCode=EVN] |
| id | n/a |
| extension | n/a |
| reference | N/A |
| type | N/A |
| identifier | .identifier |
| id | n/a |
| extension | n/a |
| use | Role.code or implied by context |
| type | Role.code or implied by context |
| system | II.root or Role.id.root |
| value | II.extension or II.root if system indicates OID or GUID (Or Role.id.extension or root) |
| period | Role.effectiveTime or implied by context |
| assigner | II.assigningAuthorityName but note that this is an improper use by the definition of the field. Also Role.scoper |
| display | N/A |


--- layout: default --- Start a project with real datasets from the Department of Energy Search Datasets: {% comment %} Use "raw" Markdown tag to skip expansion of braces inside Handlebars template. {% endcomment %} {% raw %} {% endraw %}


fun getHighlightTexture(type: HighlightType): TextureComponent
Loads the texture for the given HighlightType.
type - HighlightType
type
Return A TextureComponent with the texture for the HighlightType. Returns null if no texture was found for the type.


Documentation
Contents
Prerequisites
This documentation was built with beginners in mind, but has the necessary information for more seasoned producers.
To install and use Ed you will be using your terminal. If you need a refresher, I highly recommend “The Command Line Crash Course.” Working knowledge of HTML and CSS is also taken for granted. If you’re new to HTML and CSS, you may want to check out the relevant courses on codecademy.com.
Jekyll does not run very well on Windows machines for now. If you are using Windows, this theme won’t work for you, but we hope that you simply deploy our principles, and parts of our stylesheet, on a system like Hugo, which does work on Windows.
Installing Ed: Easy
The easy way to do this is not necessarily the more robust, and may simply not work on your system. The easy way could also be called the ‘lucky’ way. It will work if your system is ready for Ed. Two major caveats to keep in mind if you go the easy route: a) You may run into problems later when some Ed components need updating; and, b) You may run into conflicts if you run several Ruby environments for different projects. That said, if you just want to quickly try Ed, and you don’t run into problems installing, this is perhaps the best approach.
If you’re using a Mac, make sure you have the appropriate version of XCode command line tools for your OSX. Using the terminal’s cd
command, switch to the directory where you want to install your project. Once inside the folder, you are ready to download and start using Ed. Enter each of these lines into your terminal (remember to ignore the $
):
$ git clone https://github.com/minicomp/ed.git
$ cd ed
$ gem install bundler
$ bundle install
That’s it. To see if Ed is working properly we will take advantage of Jekyll’s built in server. You can build the first version of your site and run the jekyll server at the same time by entering:
$ jekyll serve
If at any point during this process you had an error you could not resolve, move on to the next section. If the site was rendered fine, copy the url from your terminal log and paste it into your browser of choice (I recommend Firefox). This url usually looks something like this http://<IP_ADDRESS>:4000/ed
. At this point you should be looking at your very own working version of Ed:
![Your very own Ed]({{ site.baseurl }}/assets/screenshot-home.png)
Installing Ed: Robust
The first step to install Ed is to download the source files from GitHub. To do so you must have git installed on your computer. You probably have git already, but if you don’t, the easiest way is probably to install Github Desktop (even though we will be using git and github from the terminal in this tutorial). Mac users may want to ensure they have Xcode and its command line tools installed as well. To check if git is running on your system enter the following line on your terminal (remember to ignore the $):
$ git --version
If you don’t get an error, you’re good to go. Using the cd
command on your terminal, navigate to the folder where you keep your web projects. Once you’re in the folder where you want Ed to live, download it from github using the following line (remember you can copy and paste):
$ git clone https://github.com/minicomp/ed.git
At this point you should navigate inside your Ed project folder and stay there until further notice:
$ cd ed
Jekyll is a Ruby gem (Ruby’s name for software packages). The best way to ensure you have the right environment is to use Ruby Version Manager, or rvm, and the latest stable version of Ruby. To install rvm and a recent version of Ruby at the same time, follow the instructions on rvm’s site. Remember to add --ruby=2.3.0
at the end of the curl
command to install ruby at the same time.
After the process runs succesfully, read the last few lines generated by the terminal. You will see final instructions for making rvm run. Once you finish the process, check to see if rvm is running by entering:
$ rvm --version
If you don’t get an error, you’re ready for the next step. If you do get an error, and don’t feel comfortable troubleshooting on the terminal, this is a good opportunity to reach out to a friend who can help. You can leave me a note on the issues page, for example. I’ll try to get to it as soon as my other commitments permit. If you’re comfortable troubleshooting on your own, I recommend Jekyll’s own troubleshooting documentation. Another great strategy for troubleshooting on the terminal is to copy and paste the errors you receive (sans personal information) into your favorite search engine.
The next step is to create a gemset for your jekyll projects. A gemset is a set of gems. If you don’t create and use a gemset, every gem you install will be applied system-wide. This is not necessarily a bad thing, but if you will have several projects with several setups, this strategy will serve you well in the long run. To create a gemset:
$ rvm gemset create ed
To use the gemset you just created:
$ rvm gemset use ed
N.B. Everytime you open a new tab or window on your terminal you need to declare your gemset using rvm gemset use ed
, or else it will revert to (default)
.
Now that rvm and Ruby are set up, we’re ready to install our first gem: Bundler. Bundler is a gem that allows you to install many gems at the same time using Gemfiles, which is a simple list of specific gems that lives in your project folder. Once you install it, you will be ready to run the Gemfile I provided in the source files. To install Bundler:
$ gem install bundler
You’re very close. Now that Bundler is installed, the final step is to install the right version of Jekyll. To do so run the Gemfile this way (remember you must be inside the ed
folder for this to work):
$ bundle install
If you don’t get any errors, Ed should work at this point. To see if Ed is working properly we will take advantage of Jekyll’s built in server. You can build the first version of your site and run the jekyll server at the same time by entering:
$ jekyll serve
If you are running multiple Ruby environments using bundler, you will need to add bundle exec
to the command:
$ bundle exec jekyll serve
Copy the url from your terminal log and paste it into your browser of choice (I recommend Firefox). This url usually looks something like this http://<IP_ADDRESS>:4000/ed
. At this point you should be looking at your very own working version of Ed:
![Your very own Ed]({{ site.baseurl }}/assets/screenshot-home.png)
Installing Ed: Replacing an existing Jekyll theme
Ed, like Jekyll, is also a gem. Jekyll gives you the option to switch themes, as long as those themes are gems as well. If you have existing content and would like to use Ed, you need to add the following line to your _config.yml file, usually at the bottom:
theme: "ed."
You also need to add the gem to your Gemfile file:
gem "ed."
Make sure to replace the version number with the one you need. I will do my best to document what changes come with each new gem. If your current theme does not have a Gemfile, you would need to create one and add the line above. The Gemfile is a plain text file like all other files in Jekyll, and should not have a file extension.
After these files have been modified, you need to update your Bundle in the terminal:
$ bundle update
When using the gem on top of a previous theme, you will not have all the files of a full Ed install immediately available to you. More importantly, you may not have a _texts folder. You need to create one or copy them from a full installation of Ed. You might also want to add the search and index file. The gem comes bundled with all these files once you install it on your system, but they won’t be in the same folder as your project. To locate them you can refer to the Jekyll documentation for gem-based themes. With some previous themes you might need to erase lingering files that interfere with the functioning of Ed. This can be an advanced operation I can’t do justice to here. At that point you might need to familiarize yourself with the architecture of Jekyll, or pay close attention to errors when you try to serve the site, and reverse-engineer from there.
Going forward, updating to a new version of Ed is as simple as changing the release version and running the bundle update. I will try to keep changes in the actual markup to a minimum, but will let users know if any changes require a global find and replace in your editions.
Jekyll
Ed is a Jekyll theme. That means you will need some familiarity with Jekyll to take advantage of its full potential. While running a Jekyll site is a bit more involved than Wordpress and other similar tools, the payoff in the long term is worth the effort to learn it. If you are new to Jekyll, I recommend you take a look at “How (and Why) to Generate a Static Website Using Jekyll” at ProfHacker, Amanda Visconti’s excellent Building a static website with Jekyll and GitHub Pages on The Programming Historian and Jekyll’s own documentation to start getting a sense of how it works.
Once you have gone through these tutorials, you can get started using Ed by replacing the sample texts included in in the _texts
folder in Ed with your own edited texts. Remember to always and only edit files in Ed using a plain text editor, and not a word processor. I’m composing this file using a plain text editor called Sublime Text.
An easy way to make new texts is to copy an existing text, replace the content and rename the file. Remember to always use the jekyll convention for naming files: your-title.md
. You should also make sure that all your texts have the YAML front matter (the information at the top of the file). YAML stands for “YAML Ain’t Markup Language”—no disrespect to XML—and it’s the main way that Jekyll handles named data. Here’s an example of YAML front matter:
---
layout: poem
title: "Cahier d'un retour au pays natal"
author: Aimé Césaire
---
Besides replacing content and creating new texts, you will probably want to edit the _config.yml
file to replace the boilerplate information we provided with your own personalized information in the relevant categories. Avoid replacing the information in categories that are not clear to you. Make sure to use proper YAML formatting when writing in the _config.yml
file. Here’s a good reference source in case you have doubts.
Markdown and kramdown
Ed is designed for scholars and amateur editors who want to produce either a clean reading edition or a scholarly annotated edition of a text. The main language we use to write in the Jekyll environment is called Markdown. To learn more about the Markdown family, see Dennis Tenen and Grant Wythoff’s “Sustainable Authorship in Plain Text using Pandoc and Markdown.”
Our version of Jekyll uses a special Markdown processor called kramdown. The processor can be said to use it’s own ‘flavor’ of Markdown, and sometimes the Markdown syntax will be different than other flavors of Markdown. Kramdown is convenient for scholars because of the way it handles footnotes. You can become familiar with the kramdown syntax in the kramdown documentation. Another way to become familiar is to examine the sample text source files we provided.
Genres
Ed offers three different layouts: poem, narrative and drama. The genre is indicated in the YAML front matter on your texts. The templates that govern how these genres are displayed can be found in the _layouts
folder. Using these layouts will allow you to tweak the stylesheets according to your different needs. Out of the box, Ed contains some special instructions for poetry in its stylesheets that allow you to deal with some of the peculiarities of poetry layouts.
To indicate lines in poetry we use the line syntax from Markdown:
- Hold fast to dreams
- For if dreams die
- Life is a broken-winged bird
- That cannot fly.
- Hold fast to dreams
- For when dreams go
- Life is a barren field
- Frozen with snow.
To indent specific lines we take advantage of a feature in kramdown that allows us to indicate classes for a line. This approach still allows the line to be readable while editing.
- {:.indent-3} But O heart! heart! heart!
- {:.indent-4} O the bleeding drops of red,
- {:.indent-5} Where on the deck my Captain lies,
- {:.indent-6} Fallen cold and dead.
The -
at the beginning of each line indicates that these are lines. The {:.indent-3}
is what we need to in order to indicate the indent value for that line. Values can range from 1-10. You can expand the range or adjust the values in the Ed stylesheet (_ed.scss
) in the _sass
folder.
The example from Raisin in the Sun shows us that we don’t need much special markup for theater as long as we use CAPITAL LETTERS for speakers. Italics for directions are easy enough. Just use *
around the words you want to italicize.
Narrative of the Life of Frederick Douglass shows us an example of narrative that includes footnotes and quoted poetry. See the sections below for how to accomplish these different effects.
Footnotes
Footnotes are the bread and butter of scholarship. Kramdown makes footnotes a fairly simple affair:
- O Captain! my Captain! rise up and hear the bells;
- Rise up—for you the flag is flung—for you the bugle[^fn2] trills,
...
[^fn2]: The bugle is a small trumpet implicated in the military industrial complex.
These footnotes can be placed anywhere, but they will always be generated at the bottom of the document. To have a multi-paragraph footnote you need to start the footnote text on the next line after the footnote anchor and indent it:
[^fn3]:
Ugh pinterest fixie cronut pitchfork beard. Literally deep
cold-pressed distillery pabst austin.
Typewriter 90's roof party poutine, kickstarter raw
denim pabst readymade biodiesel umami chicharrones XOXO.
The footnotes system provided by kramdown does have one limitation: It generates the numeration for you automatically, and it only allows you to have one set of footnotes for a text. In some cases we have to separate the author’s footnotes from our own, in others we want to represent the author’s own footnote style. In these cases we have to use HTML. Here’s the example from Narrative of the Life:
... At this time, Anna,\* my intended wife, came on;
...
* She was free. [↩](#ref2)
Notice the double HTML Entity (hex), ↩
, used at the end of the footnote to return us to the top. The first hex is the ↩ symbol proper. The second assigns the proper variant glyph. This is a necessary hack while we wait for Apple devices to stop turning everything into unseemly emojis.
Blockquotes
Narrative of the Life also includes several blockquotes. You can also find another example of blockquote use in the footnote of “O Captain! My Captain!” Simple blockquotes are simple enough in kramdown:
> This is to certify that I, the undersigned, have given the bearer, my servant, full liberty to go to Baltimore, and spend the Easter holidays.
>
> Written with mine own hand, &c., 1835.
> WILLIAM HAMILTON,
To use a line break in block elements add two spaces after the end of the line where you want the break. You can’t see them after &c., 1835.
but they are there.
Things get a bit complicated when we want to use poetry inside the block or when the block is included in another block element, like a footnote. Here’s the last two stanzas from “A Parody” in Narrative of the Life, which shows an example of a blockquote of poetry:
...
> - Two others oped their iron jaws,
> - And waved their children-stealing paws;
> - There sat their children in gewgaws;
> - By stinting negroes' backs and maws,
> - They kept up heavenly union.
> ^
> - All good from Jack another takes,
> - And entertains their flirts and rakes,
> - Who dress as sleek as glossy snakes,
> - And cram their mouths with sweetened cakes;
> - And this goes down for union.
{:.poetry}
The {:.poetry}
tag at the end tells the processor to think of the lines above it as poetry. The {:.poetry}
tag is an example of kramdown class assignments for block-elements. Because this segment of poetry exists in the ‘narrative’ layout, and because it is part of a blockquote, we need to signal to the processor to process poetry this way, so that the right class is invoked in the stylesheet. Notice also the ^
separating the stanzas. This bit of kramdown syntax helps us separate the stanzas while staying within the blockquote. The good news is this is the most complex kramdown syntax layout you will encounter in Ed.
Pages
Your editions are treated as collections in Ed. Other web pages in your site exist outside the _texts
folder. The homepage, for example, is constructed from the index.html
file found on the root folder of your Ed project.
You will notice that the homepage in particular has a .html
file ending instead of a .md
ending. All template files in Jekyll are HTML, and the index behaves as a template file. Although these files are mostly written in HTML, notice that they still contain YAML front matter and liquid tags. To edit the homepage replace the content on the file shipped with Ed, making sure that your changes to index.html
are written in valid HTML. The same goes for the template files in the _layouts
folder.
Ed also comes with a search page, search.html
. This page implements elastic lunr, “a lightweight full-text search engine in Javascript for browser search and offline search.” This simple search page can be useful if you have large collections of texts. If you don’t, and don’t feel the need, go ahead and delete it along with the assets/js
folder.
Besides the homepage and the search page, Ed ships with an About page, about.md
and a documentation page, documentation.md
, i.e. this page. As you can see, these are regular .md
files. You can replace the contents of each file using normal kramdown syntax. This also applies to any new page you create, which you should remember to save with an .md
extension. When editing the bibliography.md
file, be careful not to replace the liquid tag that generates your bibliography, unless you don’t want to have a bibliography at all.
Tables of Content
You will find three kinds of Tables of Content in Ed. The first example is in the list of Sample Texts in the Homepage. This list is generated using the Liquid Templating language. This is one of the major components of Jekyll, and I recommend you deepen your knowledge of it if you want to modify the logic that automates much of Ed. Here is the code that generates the Sample Texts list on the homepage:

Sample texts

{% for item in site.texts %}

{{ item.title }}

{% endfor %}

As you can see, the liquid tags {%raw%}{% %}{%endraw%}
and {%raw%}{{ }}{%endraw%}
are embedded into the HTML. Those with {%raw%}{% %}{%endraw%}
often use programmatic logic, as is the case here. If you are not already familiar with programming languages, you may need to start elsewhere. I recommend learning Ruby, since this is the language used to build jekyll and jekyll-scholar in the first place (it’s also the first programming language I used, so I’m biased). The {%raw%}{{ }}{%endraw%}
simply pulls data from your project. In the example above it pulls the title from each ‘post’, i.e. each edited text. As you may have noticed already, we are basically adapting the blogging features of Jekyll to our own ends, what Cuban designer and theorist Ernesto Oroza would call “technological dissobedience.”
The second kind of table of content is exemplified in this documentation. If you open the source file for the documentation, you will notice at the top this snippet:
## Contents
{:.no_toc}
* ToC
{:toc}
This is the kramdown way. The first tag, {:.no_toc}
tells the processor not to add ## Contents
to the ToC. The second part creates an empty list and then tells the processor to replace it with a table of contents based on headers in the document. You can use this syntax in any page on the site that uses headers.
The third way is slightly more involved, but very useful for long texts. If we add the table of contents to the YAML front matter of a page, Ed will activate the optional table of content sidebar (_includes/sidebar-toc.html
) and move the table of contents to a special sidebar for that page. Narrative of the Life uses this method for its table of content. If you would like to replicate this functionality in your own long texts, make sure to use the same syntax:
toc:
- Title Page
- Preface
- Letter From Wendell Phillips
- Chapter I
- Chapter II
The internal links pointing to the right sections in your document are generated from the title names automatically. In order for the links to work the names on section headings must contain the same words as the section headers. The punctuation and capitalization is irrelevant. If you can figure out how Ed accomplishes this trick, you have graduated from the Ed school of minimal editions.
Bibliographies
If you want to include a small bibliography, and you feel it would be easier to write it out directly, Ed can help you render it with hanging indentation. To achieve this effect make sure to use the .bibliography
class in an ordered list. For example:
1. Douglass, Frederick et al. Narrative of the Life of Frederick Douglass: An American Slave. Charlottesville, Va.: University of Virginia Library, 1996. Open WorldCat. Web. 17 Apr. 2016.
2. Hansberry, Lorraine, and Robert Nemiroff. A Raisin in the Sun. Rep Rei edition. New York: Vintage, 2004. Print.
{.bibliography}
Which should display like this:
- Douglass, Frederick et al. Narrative of the Life of Frederick Douglass: An American Slave. Charlottesville, Va.: University of Virginia Library, 1996. Open WorldCat. Web. 17 Apr. 2016.
- Hansberry, Lorraine, and Robert Nemiroff. A Raisin in the Sun. Rep Rei edition. New York: Vintage, 2004. Print.
To help us style and generate bibliographies and citations automatically, Ed can use the jekyll-scholar gem by Sylvester Keil. To learn more about the gem beyond the basic instructions below, make sure to read the documentation on the jekyll-scholar GitHub page. Keep in mind, though, that installing jekyll-scholar and working with it may be a bit difficult for beginners.
If you can get over the hurdles, jekyll-scholar can save you enormous amounts of time in the long term for your citation and bibliographic work. To begin, you must move the contents of the jekyll-scholar starter kit
in your optional
folder into the root folder. This will effectively replace the original _config.yml
and Gemfile
files, and add a _bibliography
folder, and the bibliography.md
and Rakefile
files. To enable jekyll-scholar you must re-run bundle install
again.
If everything goes smoothly, you should be able to start using jekyll-scholar at this point. The first thing you may want to do is provide Jekyll with your own bibliographic information in the form of a .bib
file to replace the content of the references.bib
file we’ve provided in the _bibliography
folder.
To make it easy to create your own version of this file and to keep track of your bibliography for your project, in general I recommend you use Zotero. To export from Zotero in this format select the references you need from within your Zotero library, right click and select export in...
and choose the BibLaTeX format. Rename your file to references.bib
and move it into the _bibliography
folder. You are, of course, free to create your references.bib
file using any method you prefer as long as it is a BibTeX file.
Because as textual editors we are more likely than not to use citations in footnotes or pages that contain footnotes, and because footnotes will be necessarily generated at the bottom of the page, Ed also needs a separate page for your Bibliography or works cited. This is the role of the bibliography.md
file. Feel free to edit the sample text, but make sure to leave the following line intact:
{% bibliography %}
To link your citations to the bibliography page, instead of writing them by hand, you can use the cite function in jekyll-scholar:
{% cite cesaire_discourse_2001 %}
Here’s the breakdown:
cite
is the jekyllscholar command.cesaire_discourse_2001
is the unique ID for Césaire’s Discourse on Colonialism entry included in the reference.bib file.
Note that our jekyll-scholar starter kit comes ready for MLA style. To use Chicago style or more advanced citation features, refer to the documentation on jekyll-scholar to make the appropriate changes.
Publishing your site on Github Pages with jekyll-scholar
If you install jekyll-scholar, or most other plugins in Jekyll, you will need a workaround to publish your site on Github Pages, which only runs in ‘safe mode.’ I’ve provided a slightly modified version of a Rakefile
originally created by Robert Rawlins that will help you accomplish this task. Once you are ready to publish, switch to your gh-pages
branch and run the following command:
$ rake ed:publish
Tips and Tricks
- The folding sidebar menu is generated from the
sidebar.html
file in the_includes
folder. The top menu items are generated automatically from your pages. The bottom menu items are manually written in HTML. This structure can allow you to add external links. If you don’t have that many pages, you may choose to do all the links by hand. - For more hand-crafted layouts—such as [the title page in The Narrative of the Life]({{ site.baseurl }}/texts/narrative/index.html#title-page)—you may choose to work directly with HTML. One of the great advantages of working with the kramdown processor is that we have a lot of flexibility to mix HTML with the kramdown syntax. Note though, that even in the case of the title page, you can achieve these effects using kramdown syntax.
- Make sure to add horizontal rules,
---
, to separate sections in your texts. This creates a more pleasant layout. - You can clean unnecessary folders and files from the original Ed package before publishing your site. This will help you reduce overhead. For example, you can erase this page, the sample texts and the
syntax.css
file (used for styling code). - Consider providing tips for your readers on how to make their font bigger or smaller by taking advantage of Command + + and Command + -. Or returning to the top of the page using Command + Up Arrow. Part of the philosophy behind Ed is to avoid duplicating features that are already easily available in most web ecosystems.
- If you want to allow annotations on your site, consider providing a
via.hypothes.is
link. Our sample site can be annotated, for example, using the following link:https://via.hypothes.is/http://minicomp.github.io/ed/
, which readers can access on the sidebar. Once you’ve indicated your own URL in the config file, the link will update automatically. Make sure to visit hypothes.is to learn more. - Ed includes metadata in the headers that makes it easier for users of Zotero, and other systems to grab bibliographic information for the site and individual texts. Our metadata functionality may not be enough to generate a full proper citation. Consider providing visible citation information in your about page or homepage.
- Make sure to deepen your knowledge of the building blocks of Ed: Jekyll, YAML and Liquid. A great list of resources can be found in the blog “Jekyll for Web Designers”.
- Our base themes Poole/Lanyon allow for easily customization of the interface. You can, for example, switch the position of the sidebar, change the theme colors and overlay options. To learn more check out the Lanyon documentation, and make sure to try the green,
.theme-base-0b
, it’s really nice. - You can change the look and feel of the site as a whole by changing the
color-scheme
in the_config.yml
file. If you want to have more granularity, short of editing thecss
, you can change the variable values in theassets/css/style.scss
file. - In the
optional
folder you will find a samplexslt
to help you get started converting TEI to Ed. You will also find css for adding pop-up “balloons” or tooltips to your texts.
Publishing: A UNIX server
Publishing and Ed edition can be done in one of two ways. One way is to host it on a server you rent, own or have access to. Most mortals pay a hosting provider to host their sites. I recommend Reclaim Hosting, which is run by scholars for scholars. If you are affiliated with a university, chances are that your institution provides you with a UNIX account and a bit of server space. Since Jekyll generates a full static site for you, that means you can park it there too. To do so you need to build the site first. If you have been keeping your eye on your project by using jekyll serve
, chances are you have a current built site in your project folder labelled _site
.
If you don’t already, you can build one easily by using the following Jekyll command:
$ jekyll build
Or, again, if you have multiple environments:
$ bundle exec jekyll serve
Using an FTP client like Filezilla, or SSH on your terminal, you need to push the contents of the _site
folder to the folder on your server where you would like your project to exist. Depending on your host provider, you may be able to receive help from the sys admins with this step.
Please refer to the note below on base urls to make sure your new links work on your new site.
Publishing: GitHub pages
The second option is to publish your site for free on GitHub Pages. Whether you decide to publish on GitHub pages or not, we recommend that you still use git and GitHub to version your edition and make the data available via another channel other than your webpage. This is one of the great advantages of using our system, increasing the chances of survival of your work and opening new audiences for it.
If you do decide to use the GitHub pages option, please make sure to read the note below on base urls.
To publish on GitHub pages, you must have a copy of the repository in GitHub. That means you also need an account there. Once you’ve created the repository that you will use, you must link your local repository to the one on GitHub. Notice that because you cloned the original source files from my repository, it will be linked to my repository (to which you don’t have writing privileges) until you do this step. Instructions for changing the remote URL can be found here.
The usual way of doing it is to create a different git branch called gh-pages
within your local repository for your site. This is a branch is published by GitHub by default. GitHub also gives you the option to select any branch you want to publish, including the master branch.
In the following I use the gh-pages branch. To create and use that branch use the following command:
$ git checkout -b gh-pages
Once you are using that branch, you are ready to publish your site. To do so use simply push the gh-pages branch to github:
$ git push origin gh-pages
You can now access your site using an address that looks like http://your-username.github.io/your-project-name
. The sample page for Ed, for example, is hosted at minicomp.github.io/ed.
A note on your base url
When you publish on a subfolder—automatic on GitHub pages—many of your links will break unless you indicate the name of your sub-folder in the baseurl
value in your _config.html
file. In addition, you need to make sure that your site-wide links (your links to your CSS files, for example) are preceded by the {{ site.baseurl }}
tag. The base Ed install already uses this system, so you can simply replace the value /ed
in your baseurl
to /your-project-slug
.
If on the other hand you are running your site on a root folder, simply erase /ed
, but do make sure to leave the single quotes:
baseurl: ''
That should do it. If you have suggestions on how to improve Ed, make sure to leave us a line on our issues page, or send us a pull request.
Happy editing!
Alex Gil
April 2016


Animated Model of Inner Planets (at no particular time)
Currently only based on each planet's semi-major axis, eccentricity, and argument of the perihelion. Inclination and longitude of the ascending node to be incorporated shortly.
Currently only based on each planet's semi-major axis, eccentricity, and argument of the perihelion. Inclination and longitude of the ascending node to be incorporated shortly.


Modules | |
| GLM_GTX_associated_min_max | |
| Min and max functions that return associated values not the compared onces. <glm/gtx/associated_min_max.hpp> need to be included to use these functionalities. | |
| GLM_GTX_bit | |
| Allow to perform bit operations on integer values. | |
| GLM_GTX_closest_point | |
| Find the point on a straight line which is the closet of a point. | |
| GLM_GTX_color_space | |
| Related to RGB to HSV conversions and operations. | |
| GLM_GTX_color_space_YCoCg | |
| RGB to YCoCg conversions and operations. | |
| GLM_GTX_compatibility | |
| Provide functions to increase the compatibility with Cg and HLSL languages. | |
| GLM_GTX_component_wise | |
| Operations between components of a type. | |
| GLM_GTX_euler_angles | |
| Build matrices from Euler angles. | |
| GLM_GTX_extend | |
| Extend a position from a source to a position at a defined length. | |
| GLM_GTX_extented_min_max | |
| GLM_GTX_fast_exponential | |
| Fast but less accurate implementations of exponential based functions. | |
| GLM_GTX_fast_square_root | |
Fast but less accurate implementations of square root based functions.
| |
| GLM_GTX_fast_trigonometry | |
| Fast but less accurate implementations of trigonometric functions. | |
| GLM_GTX_gradient_paint | |
| Functions that return the color of procedural gradient for specific coordinates. <glm/gtx/gradient_paint.hpp> need to be included to use these functionalities. | |
| GLM_GTX_handed_coordinate_space | |
| To know if a set of three basis vectors defines a right or left-handed coordinate system. | |
| GLM_GTX_inertia | |
| Create inertia matrices. | |
| GLM_GTX_integer | |
| Add support for integer for core functions. | |
| GLM_GTX_intersect | |
| Add intersection functions. | |
| GLM_GTX_io | |
| std::[w]ostream support for glm types | |
| GLM_GTX_log_base | |
| Logarithm for any base. base can be a vector or a scalar. | |
| GLM_GTX_matrix_cross_product | |
| Build cross product matrices. | |
| GLM_GTX_matrix_interpolation | |
| Allows to directly interpolate two exiciting matrices. | |
| GLM_GTX_matrix_major_storage | |
| Build matrices with specific matrix order, row or column. | |
| GLM_GTX_matrix_operation | |
| Build diagonal matrices from vectors. | |
| GLM_GTX_matrix_query | |
| Query to evaluate matrix properties. | |
| GLM_GTX_matrix_transform_2d | |
| Defines functions that generate common 2d transformation matrices. | |
| GLM_GTX_mixed_producte | |
| Mixed product of 3 vectors. | |
| GLM_GTX_multiple | |
| Find the closest number of a number multiple of other number. | |
| GLM_GTX_norm | |
| Various ways to compute vector norms. | |
| GLM_GTX_normal | |
| Compute the normal of a triangle. | |
| GLM_GTX_normalize_dot | |
| Dot product of vectors that need to be normalize with a single square root. | |
| GLM_GTX_number_precision | |
| Defined size types. | |
| GLM_GTX_optimum_pow | |
| Integer exponentiation of power functions. | |
| GLM_GTX_orthonormalize | |
| Orthonormalize matrices. | |
| GLM_GTX_perpendicular | |
| Perpendicular of a vector from other one. | |
| GLM_GTX_polar_coordinates | |
| Conversion from Euclidean space to polar space and revert. | |
| GLM_GTX_projection | |
| Projection of a vector to other one. | |
| GLM_GTX_quaternion | |
| Extented quaternion types and functions. | |
| GLM_GTX_raw_data | |
| Projection of a vector to other one. | |
| GLM_GTX_rotate_vector | |
| Function to directly rotate a vector. | |
| GLM_GTX_simd_mat4 | |
| SIMD implementation of mat4 type. | |
| GLM_GTX_simd_quat | |
| SIMD implementation of quat type. | |
| GLM_GTX_spline | |
| Spline functions. | |
| GLM_GTX_std_based_type | |
| Adds vector types based on STL value types. <glm/gtx/std_based_type.hpp> need to be included to use these functionalities. | |
| GLM_GTX_string_cast | |
| Setup strings for GLM type values. | |
| GLM_GTX_transform | |
| Add transformation matrices. | |
| GLM_GTX_transform2 | |
| Add extra transformation matrices. | |
| GLM_GTX_vec1 | |
| Add vec1, ivec1, uvec1 and bvec1 types. <glm/gtx/vec1.hpp> need to be included to use these functionalities. | |
| GLM_GTX_vector_angle | |
| Compute angle between vectors. | |
| GLM_GTX_vector_query | |
| Query informations of vector types. | |
| GLM_GTX_wrap | |
| Wrapping mode of texture coordinates. |
Experimental extensions are useful functions and types, but the development of their API and functionality is not necessarily stable. They can change substantially between versions. Backwards compatibility is not much of an issue for them.
Even if it's highly unrecommended, it's possible to include all the extensions at once by including <glm/ext.hpp>. Otherwise, each extension needs to be included a specific file.


Products
X-Press
Volka
X-Pro
Micra
Sarita Super 3
Sarita Super 6
Mega
Become a Distributor
Careers
Team
Contact
Loading...


Although all of the data has been retrieved and displayed to the user there is just something nicer about graphing it.
To do this a new task is going to be created who's action will load a page
Steps to complete:
- Copy the contents of tab 'joinTiming.xml' located to the right into the file 'joinTiming.xml'.
- Save the file, but do not close it
- Reload the 'About table joins' tutorial navigate to the last page. An action panel with one button should now be displayed on the right hand side. You can run both action to test your work.