%inherit file="base.html" />
It's fun to hang around with friends, especially when you are cooking a tasty meal together :) You don't want to think about money or debts and this is why we are here. Just enter what you bought for the meal and enter the addresses of your friends. We will do the rest
We love emails. This is why you can share debts with your friends, even if your friends don't have a splitpot-account. You just have to enter their email addresses. At the end of the month, we sum up all the debts and try to minimize the number of money transactions between you and your friends and everybody gets a mail, who has to give who how much money.
We love open source software (OSS), therefore, you will find all the code for creating your own Splitpot on our GitHub page: Splitpot


UI Plug-in
Choose UI plug-in features:
P
roperty page
S
how property page on first launch
A
uto-run plug-in
L
isten to events
F
riendly Name:
D
escription:
To continue, click Next
N
ext
C
ancel


1001641420
Mustafa Alhilo
Question 3:
Choose using magnitude:
Give a magnitude value(checking with cache):
Choose using time range:
Enter the number of queries to process:
Lower time:
Higher time:
Choose for searching the earthquakes occuring in CA:
Enter the number of queries to process:
Choose for searching N<100 km of a specified lat,long location:
Enter the number of queries to process:
Latitude:
Longitude:


Nissan slashes full-year forecast as first-half profit falls
YOKOHAMA, Nov 12 — Crisis-hit Japanese automaker Nissan today slashed its full-year sales and profit forecast as it struggles with weak demand in Japan, the US and Europe, as well as the arrest of former boss Carlos Ghosn.
Nissan downgraded its net profit forecast to 110 billion yen (RM4.1 billion) for the fiscal year to March 2020, compared with an earlier estimate of 170 billion yen.
Full-year sales are now estimated at 10.6 trillion yen, down from 11.3 trillion yen previously forecast.
Incoming chief financial officer Stephen Ma said: “Sales in China outpaced the market but sales in other key regions including the US, Europe and Japan underperformed in those markets. This resulted in the overall decrease of our market share.”
Net profit for the six months to September plunged 73.5 per cent to 65.4 billion yen on sales down 9.6 per cent at 5.0 trillion yen.
It was its first earnings announcement since Nissan named Makoto Uchida as new chief executive last month, elevating the insider heading the firm’s China unit as it overhauls its leadership after the Ghosn scandal.
The appointment, to take effect on December 1, came after months of turmoil for the automaker in the wake of the arrest of former chief Ghosn on allegations of financial misconduct. — AFP


Man charged with assault of woman in Ashbourne
A 29-year-old man appeared at Trim District Court today (Tuesday) charged with assault. Mark Carroll who gave an address at Killegland Walk, Ashbourne was charged with assaulting a woman yesterday (Monday).
A garda gave evidence that at 1.25pm today, she charged the accused and he made no reply after caution.
Judge Cormac Dunne remanded the accused on €100 bail to Trim District Court on the 10th December next.
Judge Dunne directed that the accused have no contact with the alleged victim, that he sign on between 9am and 9pm on Monday, Wednesday and Friday at Ashbourne Garda station and that he be contactable by phone.


ScreenFull-ES6 Demo
Simple wrapper for cross-browser usage of the JavaScript Fullscreen API, which lets you bring the page or any element into fullscreen.
Try out the Fullscreen API.
Click the image to make it fullscreen
Simple wrapper for cross-browser usage of the JavaScript Fullscreen API, which lets you bring the page or any element into fullscreen.
Click the image to make it fullscreen


Dashborads
Dashborad Inner 2
Dashborad Inner 3
Dashborad Inner 2
Dashborad Inner 3
Dashborad Inner 1
Dashborad Inner 1
Mail
Forms
Form Inner 2
Form Inner 3
Form Inner 1
Toggle navigation
Brand
Link
(current)
Link
Dropdown
Action
Another action
Something else here
Separated link
One more separated link
Submit
Link
Dropdown
Action
Another action
Something else here
Separated link
Example page header
Subtext for header
Home
Library
Data


⚬ pzza
simply pie
entree.
Select a
polygon.
Square // 12"
Circle // 16"
Mobius Strip // undefined
Select a fatty
medium.
Aged Chèvre
Red Wine Marinated Bocconcini
Authentic La Mancha Manchego
Select a textural balance and
flavor profile.
Arugula and Prosciutto
Alaskan Salmon, Spinach, Pickled Medley
Wild Morels and grass fed, humanely raised Filet Minot
addition.
Select an asortment of
earth grown
delicacies.
None
Avocado and Sesame Seeds with Honey Balsamic Vinegarette
Pickled Beet Caprese
Simple Farm Greens with Sun Dried Cherry Tomatoes
Select pairing
liquid.
None
Turmeric Shot with Lemongrass Infused Mineral Water
Lavender Honey June
Wild Ferment Basque Style Apple Wine
Select sweet
confection.
None
Golden Raspberry Sorbet
Matcha Tiramisu
Mont Blanc Chocolate Pavlova
⚬ place order ⚬
your order .
your total .
enter your name and address for delivery.
full Name
street address one
street address two
city
state
alaska
idaho
montana
oregon
washington
zip code
⚬ submit info ⚬


A collection of extendable MR aggregation and statistic methods.
View methods are used to generate various numerical or categorical data aggregations. Their behaviour is controlled via kwargs.
Methods
Will test appropriate views from a Stack for stat. sig. differences.
Tests can be performed on frequency aggregations (generated by frequency) and means (from descriptives) and will compare all unique column pair combinations.
| Parameters: | link : Quantipy Link object. name : str
kwargs : dict Keyword arguments (specific): text : str, optional, default None
metric : {‘props’, ‘means’}, default ‘props’
mimic : {‘Dim’, ‘askia’}, default ‘Dim’
level: {‘high’, ‘mid’, ‘low’} or float
|
|---|---|
| Returns: | None
Note Mimicking the askia software (mimic = 'askia') restricts the values to be one of 'high', 'low', 'mid'. Any other value passed will make the algorithm fall back to 'low'. Mimicking Dimensions (mimic = 'Dim') can use either the str or float version. |
Adds a file meta dependent aggregation to a Stack.
Checks the Link definition against the file meta and produces either a numerical or categorical summary tabulation including marginal the results.
| Parameters: | link : Quantipy Link object. name : str
kwargs : dict |
|---|---|
| Returns: | None
|
Adds num. distribution statistics of a Link defintion to the Stack.
descriptives views can apply a range of summary statistics. Measures include statistics of centrality, dispersion and mass.
| Parameters: | link : Quantipy Link object. name : str
kwargs : dict Keyword arguments (specific) text : str, optional, default None
exclude : list of int
rescale : dict
stats : str, default ‘mean’
|
|---|---|
| Returns: | None
|
Adds count-based views on a Link defintion to the Stack object.
frequency is able to compute several aggregates that are based on the count of code values in uni- or bivariate Links. This includes bases / samples sizes, raw or normalized cell frequencies and code summaries like simple and complex nets.
| Parameters: | link : Quantipy Link object. name : str
kwargs : dict Keyword arguments (specific) text : str, optional, default None
logic : list of int, list of dicts or core.tools.view.logic operation
calc : TODO calc_only : TODO |
|---|---|
| Returns: | None
Note Net codes take into account if a variable is multi-coded. The net will therefore consider qualifying cases and not the raw sum of the frequencies per category, i.e. no multiple counting of cases. |


Young
This page contains an index of all the individuals in the database with the surname of Young. Selecting the person’s name will take you to that person’s individual page.
| Given Name | Birth | Death | Partner | Parents |
|---|---|---|---|---|
| ??? | Powell | |||
| Agnes M. | about 1846 | 1884-09-18 | Thornton, Henry (or Harry) Thomas | |
| Beryl Evelyn | 1910-07-10 | 1996-09-10 | Mendel, Wilfred John | Young, John Henry Miller, Eva Clarice |
| Clarice Martha | 1917-12-07 | 1999-09-26 | Thomas, Derrick Claude | Young, John Henry Miller, Eva Clarice |
| Elsie May | 1887-11-04 | 1961-10-30 | Weiss, Leslie Edgar | |
| Enoch William & Ann or Alice | ||||
| Eric & Dorothy | ||||
| Hilda M. | Hutton, Alfred C. | |||
| James S. & Emma J. | ||||
| John Henry | 1880-10-27 | 1946-09-07 | Miller, Eva Clarice | Young, Enoch William & Ann or Alice |
| Les, Ted & Clarrie | Young, James S. & Emma J. | |||
| Miriam Jane “Dot” | 1903-07-27 | 1984-05-12 | Field, Frederick Edward Arthur | Young, James S. & Emma J. |
| Ruth & Arlie | Young, James S. & Emma J. | |||
| [Living] | Young, [Living] | |||
| [Living] | ||||
| [Living] | Young, [Living] Golby, [Living] | |||
| [Living] | Young, [Living] Golby, [Living] | |||
| [Living] | Golby, [Living] | |||
| [Living] | Campbell, Robert Richmond | Young, John Henry Miller, Eva Clarice | ||
| [Living] | Brownlee, [Living] | Young, Eric & Dorothy | ||
| [Living] | Abraham, [Living] | |||
| [Living] | Easy, [Living] |


Works ok in Firefox,Opera and Chrome. Problem in safari. Css problem in Internet explorer
Upload files here


This is a cocker spaniel.
It is one of the 12 dogs I am talk about.Along with:
This little dog was developed in scotland.West Highland Terriers are small in stature but are full of energy.
NOTE: The information for this website came from the back of the Melissa and Doug Canine Companions Collection Box. It is a great toy for kids interested in dogs.
The pictures are from google image searches and may be subject to copyright.


| DOSE: |
2 hits |
oral |
LSD |
(pill / tablet) |
It started out as a 'normal' day, went to work in the morning, Saturday, to help out my then girlfriends father. My girlfriend at the time had been telling me about how great acid could be and we'd done it a couple of times. She was always talking about orange double barrel (microdot) and how great it was.
She had gotten her hands on 4 hits and we'd decided to take them that night. It was late November and it was cool, which is good because on acid you sweat like hell, and we were looking forward to taking the acid while camping in a field nearby. It was a clear night when we set up camp around 10 pm. We'd taken the acid about an hour before and when we were finished setting up our tent we started to trip. We decided that we'd better make a fire before we were too blasted to know how. We went and gathered all kinds of wood from the nearby woods and made a fire. The sky was clear and stars were everywhere. We really started to trip at this point just laying there looking at the stars which felt like they were going to crash on our heads. The whole universe seemed open as if I was falling through space. Every once in a while I’d sit straight up scared as hell because I felt as though I would crash into a planet.
It started to get really cold so we decided to get into the tent to 'warm up' We did the usual, an hour or so of foreplay, hour of sex, laid there for another half an hour, by this time I was getting really claustrophobic and needed to go outside. When I unzipped the tent, I freaked. It was a blinding snowstorm. All the trees and the ground had about 15 inches of snow. I was lost, didn't know where the path was to get out and was really starting to get scared. I was running through the field naked and my X was following me telling me to put on some cloths but I couldn't make out what she was saying. It was like the end of the world. I felt as though the apocalypse had came and that this storm was the storm to end all storms.  We were both very cold as we didn't really prepare for a blizzard. We decided that the best place to be would be by the fire.
 Picture yourself, tripping hard, middle of a field in a snowstorm, and a 4x4 comes ripping through the woods. Thank god it was only my friend 'T', whom I’d mentioned that we were coming out here to. Needless to say I was glad to know that we weren't the only 2 left on earth and that the storm was starting to die down. There ended up being 18 inches of snow that night.
In retrospect the night was poorly planned. We didn't listen to the weather, weren't expecting snow, didn't have any flashlight (I don't know how she found me when I was running through the field naked) and I was scared as hell. I felt as though the earth was coming to an end and that. We were all going to freeze to death in a storm to end all storms. I've never taken acid again and the girl and I have broken up and I've been happily married to a great woman now for 1 1/2 years. That trip changed my life and I'll never take acid again.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Something short and leading about the collection below—its contents, the creator, etc. Make it short and sweet, but not too short so folks don’t simply skip over it entirely.
Position/Title
Something short and leading about the collection below—its contents, the creator, etc. Make it short and sweet, but not too short so folks don’t simply skip over it entirely.


Preparation time
less than 30 mins
Cooking time
10 to 30 mins
Serves
Serves 4
A British classic of crunchy beer-battered fish and chips, with homemade tartare sauce. Serve with lots of salt and vinegar!
First make the tartare sauce. Whisk together the egg yolks, mustard and vinegar and gradually pour in the oil in a steady stream until you have a thick, creamy mayonnaise. Season to taste and add a squeeze of lemon.
Stir in the onion, gherkins, capers, parsley and olives. The sauce should be quite piquant and chunky and have the consistency of very thick double cream.
To make the batter, mix the flours together and whisk in the ale until you have a double cream consistency. Add a pinch of salt.
Heat the oil in a deep-fat fryer to 140C (CAUTION: hot oil can be dangerous. Do not leave unattended.). Cook the chips for 8–9 minutes and set aside on kitchen paper.
Increase the heat to 190C. In batches, dip the fish fillets in the batter and drop carefully into the hot oil. Shake the basket gently so the fillets don’t stick, and cook for about 3–5 minutes. Don’t overload the basket or the oil will cool and you’ll get soggy batter. Remove and drain on kitchen paper.
Return the chips to the deep-fat fryer a further 2–3 minutes and drain on kitchen paper. Serve with the battered fish and the tartare sauce.


--- title: "Softmax Gradient" date: 2017-07-27 (last update 2022-05-09) layout: post categories: tags: - article - softmax - gradient published: true comments: ---
The Softmax function is widely used in many machine learning models: maximum-entropy, as an activation function for the last layer of neural networks, … Assume, for instance, a classification task with \(\nclasses\) classes on output. To infer a probability distribution over these classes given an input vector \(\x\) of dimension \(\nfeats\), the softmax function is a common choice. The random variable \(C\) denotes the class to assign and its outcome set is a range of integers : \(c \in [1:\nclasses]\). For simplicity, the mention to this random variable is dropped and \(P(k|\x)\) is the probability of \(C=k\) given \(\x\). This distribution is parametrized by a set of parameters \(\pa\). We also omit the bias (or intercept) terms for the sake of clarity. By the way, you can assume an additional input set to 1.
First, let us define the loss function for one training example:
\[ \loss = -log( P(k=\gold|\x)), \]
where \(\gold\) is the supervision information, the right class to predict, the gold-standard. With several training examples, just take the sum of their log probabilities.
This loss function that we want to minimize has been called the log-loss or the cross-entropy loss. This loss function is simply the negative log-likelihood. Its minimization is equivalent to maximize the likelihood of the paramaters on a given training set. When considering the whole training set, there is no closed solution for this optimization problem and therefore the gradient descent is an efficient solution. In an online training scenario, the parameters are therefore updated to increase the log-likelihood for a given training example.
The parameter set \(\pa\) gathers all the vectors \(\w_k\). This is a matrix \(\W\) in which \(w_{kj}\) is the cell of row \(k\) and column \(j\), a.k.a the component \(j\) of the vector associated to the class \(k\). Let consider the gradient of the loss function w.r.t to one parameter value \(w_{kj}\):
Note that for a given \(k\) and \(\forall j\), only \(a_k\) depends on \(k\), so for the first term there are two cases:
Let us define the Kronecker delta function \(\delta_{k,k'}\) as:
Then we can compactly write: \[ \frac{\partial a_{\gold}}{\partial w_{kj}} = \delta_{k,\gold}x_j.\] Now, consider the derivative of the log-partition term.
\begin{align} \frac{\partial log(\Z)}{\partial w_{kj}}&= \frac{\partial log(\Z)}{\partial \Z}\frac{\Z}{\partial w_{kj}} = \frac{1}{\Z} \frac{\partial \Z}{\partial w_{kj}} \\ \frac{\partial \Z}{\partial w_{kj}} &= \frac{\partial\sum_{k'} exp(\a_{k'})}{\partial w_{kj}} = \frac{\partial exp(\a_{k})}{\partial w_{kj}} = exp(\a_{k})\frac{\partial \a_{k}}{\partial w_{kj}} \\ &= x_j exp(\a_{k}) \\ \frac{\partial log(\Z)}{\partial w_{kj}}&= \frac{exp(\a_{k})}{\Z}x_j = x_j P(k|\x) \end{align}Now, we merge the two terms, rearrange a bit to get : \[\frac{\partial \loss}{\partial w_{kj}} = - (\delta_{k,\gold} - P(k|\x))x_j\] Note that the term \((\delta_{k,\gold} - P(k|\x))\) can be interpreted as the prediction error made by the model \((P(k|\x)\) knowing the expected answer \((delta_{k,\gold})\). The form of the gradient is very similar to the one of the logistic regression.
The Maximum-Likelihood estimate of the parameters \(\W\) acts as a memorization of the dataset: for a given class \(k\) the weight vector of the class \(\w_k\) is a weighted sum of the training examples, weighted by the error.


public class ChartAnimator
extends java.lang.Object
| Modifier and Type | Field and Description |
|---|---|
protected float |
mPhaseX
The phase of drawn values on the x-axis.
|
protected float |
mPhaseY
The phase of drawn values on the y-axis.
|
| Constructor and Description |
|---|
ChartAnimator() |
ChartAnimator(android.animation.ValueAnimator.AnimatorUpdateListener listener) |
| Modifier and Type | Method and Description |
|---|---|
void |
animateX(int durationMillis)
Animates values along the X axis, in a linear fashion.
|
void |
animateX(int durationMillis,
Easing.EasingFunction easing)
Animates values along the X axis.
|
void |
animateXY(int durationMillisX,
int durationMillisY)
Animates values along both the X and Y axes, in a linear fashion.
|
void |
animateXY(int durationMillisX,
int durationMillisY,
Easing.EasingFunction easing)
Animates values along both the X and Y axes.
|
void |
animateXY(int durationMillisX,
int durationMillisY,
Easing.EasingFunction easingX,
Easing.EasingFunction easingY)
Animates values along both the X and Y axes.
|
void |
animateY(int durationMillis)
Animates values along the Y axis, in a linear fashion.
|
void |
animateY(int durationMillis,
Easing.EasingFunction easing)
Animates values along the Y axis.
|
float |
getPhaseX()
Gets the X axis phase of the animation.
|
float |
getPhaseY()
Gets the Y axis phase of the animation.
|
void |
setPhaseX(float phase)
Sets the X axis phase of the animation.
|
void |
setPhaseY(float phase)
Sets the Y axis phase of the animation.
|
protected float mPhaseY
protected float mPhaseX
public ChartAnimator()
public ChartAnimator(android.animation.ValueAnimator.AnimatorUpdateListener listener)
public void animateX(int durationMillis)
durationMillis
- animation durationpublic void animateX(int durationMillis, Easing.EasingFunction easing)
durationMillis
- animation durationeasing
- EasingFunctionpublic void animateXY(int durationMillisX, int durationMillisY)
durationMillisX
- animation duration along the X axisdurationMillisY
- animation duration along the Y axispublic void animateXY(int durationMillisX, int durationMillisY, Easing.EasingFunction easing)
durationMillisX
- animation duration along the X axisdurationMillisY
- animation duration along the Y axiseasing
- EasingFunction for both axespublic void animateXY(int durationMillisX, int durationMillisY, Easing.EasingFunction easingX, Easing.EasingFunction easingY)
durationMillisX
- animation duration along the X axisdurationMillisY
- animation duration along the Y axiseasingX
- EasingFunction for the X axiseasingY
- EasingFunction for the Y axispublic void animateY(int durationMillis)
durationMillis
- animation durationpublic void animateY(int durationMillis, Easing.EasingFunction easing)
durationMillis
- animation durationeasing
- EasingFunctionpublic float getPhaseY()
mPhaseY
public void setPhaseY(float phase)
phase
- float value between 0 - 1public float getPhaseX()
mPhaseX
public void setPhaseX(float phase)
phase
- float value between 0 - 1


|
flippy
a c++20 package for dynamically triangulated membrane simulations.
|
This file contains the fp::Triangulation class and several related helper classes. This is the core of flippy. More...
#include <optional>
#include <set>
#include "Nodes.hpp"
#include "vec3.hpp"
#include "utilities/utils.hpp"
#include "Triangulator.hpp"
Go to the source code of this file.
Classes | |
| struct | fp::BondFlipData< Index > |
| A helper struct; keeps track of bond flips. More... | |
| struct | fp::Neighbors< Index > |
| struct | fp::Geometry< Real, Index > |
| A helper struct. Used by the triangulation class to pass data around in one convenient package. More... | |
| class | fp::Triangulation< Real, Index, triangulation_type > |
| Implementation of Triangulation of two-dimensional surfaces in 3D. More... | |
Namespaces | |
| namespace | fp |
Macros | |
| #define | LONG_LONG_MAX<PHONE_NUMBER>854775807LL |
Redefinition of the LONG_LONG_MAX macro in case a specific compiler does not implement it. The largest number that fits in the long long type. | |
| #define | VERY_LARGE_NUMBER_ LONG_LONG_MAX |
| Literal for a very large integral number. | |
Enumerations | |
| enum | fp::TriangulationType { fp::SPHERICAL_TRIANGULATION , fp::EXPERIMENTAL_PLANAR_TRIANGULATION } |
| This enum defines named types of triangulations that are implemented in flippy. More... | |
Variables | |
| static constexpr int | fp::BOND_DONATION_CUTOFF = 4 |
| a node needs to have more than the cutoff number of bonds to be allowed to donate one | |
This file contains the fp::Triangulation class and several related helper classes. This is the core of flippy.


---
layout: post
title: The Sieff Book - My Apologies
tags:
- Black and White
- book
- General Photography
- Jeanloup Sieff
- Site News
status: publish
type: post
published: true
meta:
series_part: "7"
_edit_lock: "1263569495"
aktt_notify_twitter: "yes"
aktt_tweeted: "1"
tt_auto_tweet: "false"
_edit_last: "2"
tt_auto_tweet_text: "New blog post: [TITLE] [URL] "
---
No I am not obsessing on Seiff again but I had to post a quick apology to those of you that are still reading the post and looking for the book that I recommended. If you have not followed my articles for a while you may get the impression that I am some sort of elitist that only recommends very very expensive "stuff". My general MO is good value as in my suggestions for low cost solutions to photographic endeavors. Hey take a look at my eBook prices and my price for a sample print.
Here is the story. When I posted the follow up article to Sieff recommending a book I went to my own library and picked my favorite Sieff book. I bought this think in the early 1990's for like 30 or 40 bucks - it's right on the back dust jacket. I bought it from Borders. As a convenience I posted a search link to Amazon for that book. After I put up the article with the link I visited it myself to make sure that it worked. Sticker shock - the book was not available from Amazon itself but was available new from 3 different venders. Each of those vendors wanted like $149.00 for the new ones. There were also a few dozen used copies available that were priced from $90.00 to $149.00.
I was shocked that it was so expensive but I thought in 2010 $90 would still be fine for a book of this quality. Well it is now almost two weeks later and I was alerted by a reader that I am nuts. Why does he think I am nuts? Because since I posted the article there is only one vendor selling new copies and they are now priced at $350.00. There are also only 13 used copies available.
I have no idea if I caused a run on the books or it is a total coincidence. I did feel compelled to tell all of you that I am not in the habit of recommending $350 books. In fact I don't think I own a book that cost me even half that.
Sorry.
RB


tepam::argument_dialogbox - TEPAM argument_dialogbox, reference manual
The TEPAM argument_dialogbox is a flexible and easily usable data entry form generator that is available if Tk has been loaded. Each data entry element of a form is defined via a data entry item that can be provided to argument_dialogbox in two formats:
Using this first format, each data entry item is defined via a pair of two arguments. The first one is the item name that defines the entry widget that has to be used in the form. The second argument, called item attributes, specifies the variable which is attributed to the data entry element as well as eventual formatting and context information.
The argument_dialogbox returns ok if the entered data have been acknowledged (via the OK button) and validated by a data checker. If the entered data have been rejected (via the Cancel button) the argument_dialogbox returns cancel.
 A first entry widget in this box allows selecting a report file. It follows two frames to define respectively an itinerary start and end location. Each of these locations that are described with a comment has three entry widgets to specify respectively the city, street and the street number. Bellow the second frame there is a check button that allows specifying if eventual highways should be ignored.
Sometimes it is simpler to provide all the data entry item definitions in form of a single list to argument_dialogbox, and not as individual arguments. The second format that is supported by argument_dialogbox corresponds exactly to the first one, except that all item definitions are packed into a single list that is provided to argument_dialogbox. The previous example can therefore also be written in the following way:
set DialogResult [tepam::argument_dialogbox { -title "Itinerary selection" -file {-label "Itinerary report" -variable report_file} ... -checkbutton {-label "Don't use highways" -variable no_highway} }]
The commands argument_dialogbox as well as procedure are exported from the namespace tepam. To use these commands without the tepam:: namespace prefix, it is sufficient to import them into the main namespace:
namespace import tepam::* set DialogResult [argument_dialogbox \ -title "Itinerary selection" ...
The following subsections explain the different argument item types that are accepted by the argument_dialogbox, classified into three groups. The first data entry item definition format will be used in the remaining document, knowing that this format can always be transformed into the second format by putting all arguments into a single list that is then provided to argument_dialogbox.
The first item group allows specifying some context aspects of an argument dialog box. These items are taking a simple character string as item attribute:
tepam::argument_dialogbox \ -<argument_name> string \ ...
The following items are classified into this group:
The dialog box window title which is by default Dialog can be changed with the -title item:
tepam::argument_dialogbox \ -title "System configuration" \ ...
The argument dialog box uses by default .dialog as dialog top level window. This path can be changed with the -window item:
tepam::argument_dialogbox \ -window .dialog \ ...
By defining a parent window, the argument dialog box will be displayed beside this one. Without explicit parent window definition, the top-level window will be considered as parent window.
tepam::argument_dialogbox \ -parent .my_appl \ ...
If a context is defined the dialog box state, e.g. the entered data as well as the window size and position, is restored the next time the argument dialog box is called. The assignment of a context allows saving the dialog box state in its context to distinguish between different usages of the argument dialog box.
tepam::argument_dialogbox \ -context destination_definitions \ ...
Especially for big, complex forms it becomes important that the different data entry widgets are graphically well organized and commented to provide an immediate and clear overview to the user. A couple of items allow structuring and commenting the dialog boxes.
The items of this classification group require as item attributes a definition list, which contains itself attribute name and value pairs:
tepam::argument_dialogbox \ ... -<argument_name> { ?-<attribute_name> <attribute_value>? ?-<attribute_name> <attribute_value>? ?...? } ...
The following items are classified into this group:
The -frame item allows packing all following entry widgets into a labeled frame, until a next frame item is defined or until the last entry widget has been defined. It recognizes the following attributes inside the item attribute list:
An optional frame label can be specified with the -label statement.
Example:
tepam::argument_dialogbox \ ... -frame {-label "Destination address"} ...
To close an open frame without opening a new one, an empty list has to be provided to the -frame statement.
tepam::argument_dialogbox \ ... -frame {} ...
Entry widgets can be separated with the -sep statement which doesn't require additional definitions. The related definition list has to exist, but its content is ignored.
tepam::argument_dialogbox \ ... -sep {} ...
Comments and descriptions can be added with the -text attribute of the -comment item. Please note that each entry widget itself can also contain a -text attribute for comments and descriptions. But the -comment item allows for example adding a description between two frames.
tepam::argument_dialogbox \ ... -comment {-text "Specify bellow the destination address"} ...
This attribute allows controlling an eventual vertical scrollbar. Setting it to 0 will permanently disable the scrollbar, setting it to 1 will enable it. By default it is set to auto. The scrollbar is enabled in this mode only if the vertical data entry form size exceeds 66% of the screen height.
tepam::argument_dialogbox \ ... -yscroll auto ...
This item group allows specifying global custom checks to validate the entered data.
Custom data checks can be performed via validation commands that are defined with the -validatecommand item. Example:
tepam::argument_dialogbox \ -entry {-label "Your comment" -variable YourCom} \ -validatecommand {IllegalWordDetector $YourCom}
The validation command is executed in the context of the calling procedure, once all the basic data checks have been performed and data variables are assigned. All data is accessed via the data variables. Note that there is also an entry widget specific attribute -validatecommand that allows declaring custom checks for specific data entries.
The attribute -validatecommand can be repeated to declare multiple custom checks.
This item allows overriding the default error message for a global custom argument validation (defined by -validatecommand). Also this attribute can be repeated in case multiple checks are declared.
These items are mainly for TEPAM internal usage.
These items corrspond respectively to -validatecommand and -validatecommand_error_text. However, the data validation is not performed in the next upper stack level, but two stack levels higher.
Data entry widgets are created with the widget items. These items require as item attributes a definition list, which contains itself attribute name and value pairs:
tepam::argument_dialogbox \ ... -<argument_name> { ?-<attribute_name> <attribute_value>? ?-<attribute_name> <attribute_value>? ?...? } ...
The attribute list can contain various attributes to describe and comment an entry widget and to constrain its entered value. All entry widgets are accepting a common set of attributes that are described in the section Entry Widget Item Attributes.
TEPAM defines a rich set of entry widgets. If necessary, this set can be extended with additional application specific entry widgets (see APPLICATION SPECIFIC ENTRY WIDGETS):
The -entry item generates the simplest but most universal data entry widget. It allows entering any kind of data in form of single line strings.
tepam::argument_dialogbox \ -entry {-label Name -variable Entry}
The -text item generates a multi line text entry widget. The widget height can be selected with the -height attribute.
tepam::argument_dialogbox \ -text {-label Name -variable Text -height 5}
A group of check boxes is created with the -checkbox item. The number of check boxes and their option values are specified with a list assigned to the -choices attribute or via a variable declared with the -choicevariable attribute:
tepam::argument_dialogbox \ -checkbox {-label "Font sytle" -variable FontStyle \ -choices {bold italic underline} -default italic}
If the labels of the check boxes should differ from the option values, their labels can be defined with the -choicelabels attribute:
tepam::argument_dialogbox \ -checkbox {-label "Font sytle" -variable FontStyle \ -choices {bold italic underline} \ -choicelabels {Bold Italic Underline} \ -default italic}
In contrast to a radio box group, a check box group allows selecting simultaneously several choice options. The selection is stored for this reason inside the defined variable in form of a list, even if only one choice option has been selected.
A group of radio boxes is created with the -radiobox item. The number of radio boxes and their option values are specified with a list assigned to the -choices attribute or via a variable declared with the -choicevariable attribute.
In contrast to a check box group, a radio box group allows selecting simultaneously only one choice option. The selected option value is stored directly, and not in form of a list, inside the defined variable.
tepam::argument_dialogbox \ -radiobox {-label "Text adjustment" -variable Adjustment \ -choices {left center right} -default left}
If the labels of the radio boxes should differ from the option values, their labels can be defined with the -choicelabels attribute:
tepam::argument_dialogbox \ -radiobox {-label "Text adjustment" -variable Adjustment \ -choices {left center right} \ -choicelabels {Left Center Right} -default left}
The -checkbutton entry widget allows activating or deactivating a single choice option. The result written into the variable will either be 0 if the check button was not activated or 1 if it was activated. An eventually provided default value has also to be either 0 or 1.
tepam::argument_dialogbox \ -checkbutton {-label Capitalize -variable Capitalize -default 1}
Several types of list and combo boxes are available to handle selection lists.
The combobox is a combination of a normal entry widget together with a drop-down list box. The combobox allows selecting from this drop-down list box a single element. The list of the available elements can be provided either as a list to the -choices attribute, or via a variable that is specified with the -choicevariable attribute.
tepam::argument_dialogbox \ -combobox {-label "Text size" -variable Size -choices {8 9 10 12 15 18} -default 12}
And here is an example of using a variable to define the selection list:
set TextSizes {8 9 10 12 15 18} tepam::argument_dialogbox \ -combobox {-label "Text size" -variable Size -choicevariable TextSizes -default 12}
In contrast to the combo box, the list box is always displayed by the listbox entry widget. Only one element is selectable unless the -multiple_selection attribute is set. The list box height can be selected with the -height attribute. If the height is not explicitly defined, the list box height is automatically adapted to the argument dialog box size. The first example uses a variable to define the available choices:
set set AvailableSizes for {set k 0} {$k<16} {incr k} {lappend AvailableSizes [expr 1<<$k]} tepam::argument_dialogbox \ -listbox {-label "Distance" -variable Distance \ -choicevariable AvailableSizes -default 6 -height 5}
Here is a multi-element selection example. Please note that also the default selection can contain multiple elements:
tepam::argument_dialogbox \ -listbox {-label "Text styles" -variable Styles \ -choices {bold italic underline overstrike} \ -choicelabels {Bold Italic Underline Overstrike} \ -default {bold underline} -multiple_selection 1 \ -height 3}
A disjoint list box has to be used instead of a normal list box if the selection order is important. The disjoint list box entry widget has in fact two list boxes, one to select elements and one to display the selected elements in the chosen order.
Disjoint listboxes allow always selecting multiple elements. With the exception of the -multiple_selection attribute, disjointed list boxes are accepting the same attributes as the normal listbox, e.g. -height, -choices, -choicevariable, -default.
tepam::argument_dialogbox \ -disjointlistbox {-label "Preferred scripting languages" -variable Languages \ -comment "Please select your preferred languages in the order" \ -choices {JavaScript Lisp Lua Octave PHP Perl Python Ruby Scheme Tcl} \ -default {Tcl Perl Python}}
The file and directory selectors are building a next group of data entry widgets. A paragraph of section Entry Widget Item Attributes explains the widget specific attributes that allow specifying the targeted file types, active directory etc.
The item -file creates a group composed by an entry widget together with a button that allows opening a file browser. The data type file is automatically selected for this entry if no data type has been explicitly defined with the -type attribute.
tepam::argument_dialogbox \ -file {-label "Image file" -variable ImageF \ -filetypes {{"GIF" {*.gif}} {"JPG" {*.jpg}}} \ -initialfile "picture.gif"}
The item -existingfile creates a group composed by an entry widget together with a button that allows opening a browser to select an existing file. The data type existingfile is automatically selected for this entry if no data type has been explicitly defined with the -type attribute.
tepam::argument_dialogbox \ -existingfile {-label "Image file" -variable ImageF \ -filetypes {{"GIF" {*.gif}} {"JPG" {*.jpg}}} \ -initialfile "picture.gif"}
The item -directory creates a group composed by an entry widget together with a button that allows opening a directory browser. The data type directory is automatically selected for this entry if no data type has been explicitly defined with the -type attribute.
tepam::argument_dialogbox \ -directory {-label "Report directory" -variable ReportDir}
The item -existingdirectory creates a group composed by an entry widget together with a button that allows opening a browser to select an existing directory. The data type existingdirectory is automatically selected for this entry if no data type has been explicitly defined with the -type attribute.
tepam::argument_dialogbox \ -existingdirectory {-label "Report directory" -variable ReportDir}
Finally, there is a last group of some other special data entry widgets.
The color selector is composed by an entry widget together with a button that allows opening a color browser. The data type color is automatically selected for this entry widget type if no data type has been explicitly defined with the -type attribute.
tepam::argument_dialogbox \ -color {-label "Background color" -variable Color -default red}
The font selector is composed by an entry widget together with a button that allows opening a font browser. The data type font is automatically selected for this entry widget type if no data type has been explicitly defined with the -type attribute. The entry widget displays an example text in the format of the selected font.
The font browser allows selecting by default the font families provided by the font families Tk command as well as a reasonable set of different font sizes between 6 points and 40 points. Different sets of font families and font sizes can be specified respectively via the -font_families or -font_sizes attributes.
If no default font is provided via the -default attribute, the default font of the label widget to display the selected font will be used as default selected font. If the font family of this label widget is not part of the available families the first available family is used as default. If the font size of this label widget is not part of the available sizes the next close available size is selected as default size.
tepam::argument_dialogbox \ -font {-label "Font" -variable Font \ -font_sizes {8 10 12 16} \ -default {Arial 20 italic}}
All the entry widget items are accepting the following attributes:
Eventual descriptions and comments specified with the -text attribute are displayed above the entry widget.
tepam::argument_dialogbox \ -entry {-text "Please enter your name bellow" -variable Name}
The label attribute creates left to the entry widget a label using the provided string as label text:
tepam::argument_dialogbox \ -entry {-label Name -variable Name}
All entry widgets require a specified variable. After accepting the entered information with the OK button, the entry widget data is stored inside the defined variables.
tepam::argument_dialogbox \ -existingdirectory {-label "Report directory" -variable ReportDir}
Eventual default data for the entry widgets can be provided via the -default attribute. The default value is overridden if an argument dialog box with a defined context is called another time. The value acknowledged in a previous call will be used in this case as default value.
tepam::argument_dialogbox \ -checkbox {-label "Font sytle" -variable FontStyle \ -choices {bold italic underline} -default italic}
Data can be specified as optional or mandatory with the -optional attribute that requires either 0 (mandatory) or 1 (optional) as attribute data.
In case an entry is optional and no data has been entered, e.g. the entry contains an empty character string, the entry will be considered as undefined and the assigned variable will not be defined.
tepam::argument_dialogbox \ -entry {-label "City" -variable start_city -type string} \ -entry {-label "Street" -variable start_street -type string -optional 0} \ -entry {-label "Street number" -variable start_street_nbr -type integer -optional 1} \
If the data type is defined with the -type attribute the argument dialog box will automatically perform a data type check after acknowledging the entered values and before the dialog box is closed. If a type incompatible value is found an error message box appears and the user can correct the value.
The argument dialog box accepts all types that have been specified by the TEPAM package and that are also used by tepam::procedure (see the tepam::procedure reference manual).
Some entry widgets like the file and directory widgets, as well as the color and font widgets are specifying automatically the default data type if no type has been specified explicitly with the -type attribute.
tepam::argument_dialogbox \ -entry {-label "Street number" -variable start_street_nbr -type integer} \
Values can be constrained with the -range attribute. The valid range is defined with a list containing the minimum valid value and a maximum valid value.
The -range attribute has to be used only for numerical arguments, like integers and doubles.
tepam::argument_dialogbox \ -entry {-label Month -variable Month -type integer -range {1 12}}
Custom argument value validations can be performed via specific validation commands that are defined with the -validatecommand attribute. The provided validation command can be a complete script in which the pattern %P is placeholder for the argument value that has to be validated.
tepam::argument_dialogbox \ -entry {-label "Your comment" -variable YourCom \ -validatecommand "IllegalWordDetector %P"}
While the purpose of this custom argument validation attribute is the validation of a specific argument, there is also a global data validation attribute -validatecommand that allows performing validation that involves multiple arguments.
This attribute allows overriding the default error message for a custom argument validation (defined by -validatecommand).
Some other attributes are supported by the list and combo boxes as well as by the radio and check buttons.
Choice lists can directly be defined with the -choices attribute. This way to define choice lists is especially adapted for smaller, fixed selection lists.
tepam::argument_dialogbox \ -listbox {-label "Text styles" -variable Styles \ -choices {bold italic underline} -default underline
If the labels of the check and radio boxes should differ from the option values, they can be defined with the -choicelabels attribute:
tepam::argument_dialogbox \ -checkbox {-label "Font sytle" -variable FontStyle \ -choices {bold italic underline} \ -choicelabels {Bold Italic Underline}
Another way to define the choice lists is using the -choicevariable attribute. This way to define choice lists is especially adapted for huge and eventually variable selection lists.
set TextSizes {8 9 10 12 15 18} tepam::argument_dialogbox \ -combobox {-label "Text size" -variable Size -choicevariable TextSizes}
The list box item (-listbox) allows by default selecting only one list element. By setting the -multiple_selection attribute to 1, multiple elements can be selected.
tepam::argument_dialogbox \ -listbox {-label "Text styles" -variable Styles \ -choices {bold italic underline} -default underline \ -multiple_selection 1 -height 3}
Some additional attributes are supported by the file and directory selection widgets.
The file type attribute is used by the -file and -existingfile items to define the file endings that are searched by the file browser.
tepam::argument_dialogbox \ -file {-label "Image file" -variable ImageF \ -filetypes {{"GIF" {*.gif}} {"JPG" {*.jpg}}}}
The initial file used by the file browsers of the -file and -existingfile widgets are by default the file defined with the -default attribute, unless a file is specified with the -initialfile attribute.
tepam::argument_dialogbox \ -file {-variable ImageF -initialfile "picture.gif"}
The -activedir attribute will override the default active search directory used by the file browsers of all file and directory entry widgets. The default active search directory is defined by the directory of a specified initial file (-initialfile) if defined, and otherwise by the directory of the default file/directory, specified with the -default attribute.
tepam::argument_dialogbox \ -file "-variable ImageF -activedir $pwd"
Finally, there is a last attribute supported by some widgets:
All widgets containing a selection list (-listbox, -disjointlistbox, -font) as well as the multi line -text widget are accepting the -height attribute that defines the number of displayed rows of the selection lists.
tepam::argument_dialogbox \ -listbox {-label "Text size" -variable Size \ -choices {8 9 10 12 15 18} -default 12 -height 3}
If the no height has been explicitly specified the height of the widget will be dynamically adapted to the argument dialog box size.
An application specific entry widget can be made available to the argument dialog box by adding a dedicated procedure to the tepam namespace. This procedure has three arguments; the first one is the widget path, the second one a subcommand and the third argument has various purposes:
proc tepam::ad_form(<WidgetName>) {W Command {Par ""}} { upvar Option Option; # if required variable argument_dialogbox; # if required switch $Command { "create" <CreateCommandSequence> "set_choice" <SetChoiceCommandSequence> "set" <SetCommandv> "get" <GetCommandSequence> } }
Argument_dialogbox takes care about the -label and -text attributes for all entry widgets. For any data entry widget it creates a frame into which the data entry widget components can be placed. The path to this frame is provided via the W argument.
The entry widget procedure has to support 3 mandatory and an optional command that are selected via the argument Command:
The entry widget is called a first time with the command create to build the data entry widget.
The frames that are made available by argument_dialogbox for the entry widgets are by default only extendable in the X direction. To make them also extendable in the Y direction, for example for extendable list boxes, the command ad_form(make_expandable) $W has to be executed when an entry widget is built.
The entry widget procedure is only called with the set_choice command if the -choices or -choicevariable has been specified. The command is therefore only relevant for list and combo boxes.
The available selection list that is either specified with the -choices or -choicevariable attribute is provided via the Par argument to the entry widget procedure. This list can be used to initialize an available choice list.
If a default value is either defined via the -default attribute or via a preceding call the entry widget procedure is called with the set command. The argument Par contains in this case the value to which the entry widget has to be initialized.
The entry widget procedure command get has to return the current value of the entry widget.
Eventually specified entry widget item attributes are available via the Option array variable of the calling procedure. This variable becomes accessible inside the entry widget procedure via the upvar command.
There may be a need to store some information in a variable. The array variable argument_dialogbox has to be used for this purpose together with array indexes starting with "$W,", e.g. argument_dialogbox($W,values).
Examples of entry widget procedures are directly provided by the TEPAM package source file that specifies the standard entry widget procedures. The simplest procedure is the one for the basic entry widget:
proc tepam::ad_form(entry) {W Command {Par ""}} { switch $Command { "create" {pack [entry \$W.entry] -fill x \ -expand yes -pady 4 -side left} "set" {\$W.entry insert 0 $Par} "get" {return [\$W.entry get]} } }
It is also possible to relay on an existing entry widget procedure to derive a new, more specific one. The radiobox widget is used for example, to create a new entry widget that allows selecting either left, center or right. The original radiobox widget is called with the set_choice command immediately after the create command, to define the fixed list of selection options.
proc tepam::ad_form(rcl) {W Command {Par ""}} { set Res [ad_form(radiobox) $W $Command $Par] if {$Command=="create"} { ad_form(radiobox) $W set_choice {left center right} } return $Res }
Please consult the TEPAM package source file to find additional and more complex examples of entry widget procedures.
The argument_dialogbox is using two variables inside the namespace ::tepam:
Application specific entry widget procedures can use this array variable to store their own data, using as index the widget path provided to the procedure, e.g. argument_dialogbox($W,<sub_index>).
This array variable is only used by an argument dialog box if its context has been specified via the -context attribute. The argument dialog box position and size as well as its entered data are stored inside this variable if the data are acknowledged and the form is closed. This allows the form to restore its previous state once it is called another time.
To reuse the saved parameters not just in the actual application session but also in another one, it is sufficient to store the last_parameter array variable contents in a configuration file which is loaded the next time an application is launched.
Argument entry form, mega widget
Copyright © 2009-2013, Andreas Drollinger


A spatial localization actor
Background
Spatial localization of a sound source in 3D is extremely useful for VR and interactive applications
in general. Besides simply adding realism to virtual worlds, spatialized sound can generally provide
sonic cues to convey spatially-interpreted information in situaltions where visual cues are lacking,
insufficient, or just simply unavailable. For instance, in a VR application, a user may be navigating
through a dataset, and may need to determine the next navigational motion relative to the position of
a reference point in space. However, the user's full visual acuity and attention may be already fully
occupied in the continuous interpretation of the data. Here, a localized sound beacon can function
much like a lighthouse, guiding the user sonically toward the new navigational point.
Also, spatial cues can be used to dissociate, or disambiguate, groups of sound sources with similar
sonic character, such as when one is in the midst of a group of people talking. By spreading out each
sound source into a unique position in sonic space, the sound sources may then be perceived
individually, even if they are almost identical in character. This application is highly useful for
telecollaborative sessions involving three or more people. Here, the conversational flow may continue
freely, even if more than one person is speaking.
In either case, by exploiting the natural ability of the auditory system to perceive and separate
individual sound sources by their spatial position, completely new functionality is enabled. And, at
the very least, virtual objects can be made to emit sounds that actually seem like they are coming
from their location in virtual space.
Technical: Algorithm
The LocalizeActor's processing algorithm is implemented to optimize localization performance against
computational complexity. Primary consideration was given to the premise that vss algorithm plug-ins
should generally be able to run in real time, and not require specialized hardware to do so. Closely
following is the preference that at least two or three instances of the algorithm be able to run in
real time. This completely ruled out the HRTF types of processing, at least for current state of
development in available hardware platforms. These types of algorithms allow for localization of
sounds in full 3-D space, including from overhead and behind, using just two loudspeakers or
headphones, but at the expense of heavy amounts of processing (specifically, long convolutions), which
currently require the use of dedicated DSP cards. Therefore, a simpler type of processing was employed
using a modified cross-term cancellation method. This method makes use of the sensitivity of the
auditory system to inter-aural ampltude and delay differences, to "steer" the sound's perceived
direction and distance of emanation. It provides the ability to spread the perceived planar soundfield
emanating from a pair of speakers far beyond the section otherwise confined between the speakers, to a
full plane in front of the listener. Adding two more speakers behind the listener, the soundfield plane
extends in every azimuth direction around the listener. With eight speakers positioned, for example, at
the inside vertices of a cubic space centered around the listener, the soundfield becomes a volume so
that sounds may be differentiated overhead as well as underneath. The algorithm scales in complexity
with the number of output channels, and at all configuration points provides a dramatic improvement
over simple amplitude panning while coming in at a relatively small computational expense compared to
full-blown HRTFs.
The input signal arrives from the source generator or processor actor output, to be processed by the
localization algorithm, in this case into four output loudspeaker channels. (The four-channel case
represented here is easily reducible to the two-channel case by deleting the lower two loudspeaker
channels. It may also be extended to eight channels by repeating the portion to the right of the
panner for the lower four loudspeaker channels.) The localization is controlled by two parameters,
Distance and Direction. The Distance parameter varies from 0 to 1, where 0 corresponds to no distance
(i.e. the object is in your head, between your ears), and 1 corresponds to the object being at infinity,
or at least at the sonic equivalent of the "clipping plane". Direction varies between -1 and 1, with
0 corresponding to "straight ahead", -0.5 to "straight left", +0.5 to "straight right", and +/- 1
directly behind.
Direction figure
The input first passes through a distance modeler Hd set up to increasingly attenuate the amplitude
and dampen the high frequencies of the input with increasing amounts of Distance. This promotes the
illusion that a sound source is receding as the Distance is increasing. The signal then distributed
through a panner, in response to Direction, into 4 channels (or 2 or 8, depending on how vss is
initialized). The panner is a constant-power type so that the perceived loudness of the signal is
independent of Direction. The front and rear left-right signal pairs are then passed through recursive
cross-term cancelers to perform the stereo-to-planar spreading. The amount of spreading is controlled
by Distance in the 4 and 8 channel case, and by both Distance and Direction in the 2-channel case. The
spreading is generally controlled so as to reduce it with increasing distance, until it disappears at a
distance of 0.5. This produces a strong near-field distance cue which varies continuously from a
between-the-ears experience at zero Distance, to, at Distance = 0.5, a definite positioning of the
source along a circle circimscribing the speaker locations in space. (With eight channels, the source
appears along the surface of a circumscribing sphere.) For two channels, the circle is "squashed" and
all localization behind the listener is made to pass through the head. Processing through Hd then
becomes the dominant distance cue at Distances greater than 0.5.
Usage
To use the localization actor, load localize.so and create an actor of type LocalizeActor.
LocalizeActor handler messages
In addition to the messages understood by all handlers, the handler for the LocalizeActor
algorithm understands the following messages:
- SetInput hSound hHandler
- Set the input to come from the handler hHandler.
- SetInput hSound
- Set the input to zero (i.e., silence the input).
- SetDirection hSound x time
- Set the perceived direction of the sound source, relative to the listener, to
x. Range is normalized to [-1,1], with 0 mapping to straight ahead, -0.5
mapping to directly left, +0.5 mapping to directly right, and +/-1 mapping to
directly behind. If time is specified, modulate to the new direction over
the specified duration.
- SetDistance hSound x time
- Set the perceived distance of the sound source, relative to the listener, to
x. Range is normalized to [0,1], with 0 mapping to "no distance", i.e.,
the sound source is "in the head, between the ears", and 1 mapping to infinite
distance, i.e., the object is at the clipping plane. If time is specified,
modulate to the new distance over the specified duration.
- For tuning purposes only
- SetA hSound x time
- Tune the optimal cross-cancellation gain, setting it to x. Range is
between [-1,1], with roughly -0.6 being default. If time is specified,
modulate to the new distance over the specified duration.
- SetT hSound x time
- Tune the optimal cross-cancellation delay, setting it to x milliseconds.
Range is between [0,1] millisecond, with roughly 0.2 being default. If time
is specified, modulate to the new distance over the specified duration.


My name is Carla, I am 22, and I am currently studying 3d animation in U-tad, Madrid.
I started studying Software Engineering at UPM but I changed my mind and started in animation.
I would like to become a concept artist, although I also like shading, lighting and props modelling
Photoshop, illustrator, After effects, Premiere
Enjoy experimenting with artificial intelligences such as Dall-e, Stable Difussion or Midjourney
Maya, Zbrush
Photography
Some concepts for a couple stories I have been writing
Some free designs and logos presented to competitions


The goal is to show a collection of parking slots and let the user buy one. This must be a "Widget" because it should be an independent module that can be embedded in any Web application. I am an Angular developer, therefore I will write a reusable component for an Angular application.
The widget is composed of:
The vendor area should list the features of the vendor in a togglable manner. It should act as a filter for parking slots.
The parking slot area contains all the parking slots.
Before building the widget install all dependencies with the command:
npm install
To build the widget issue the following command from the root of the repository structure:
ng build widget
The project will be built in the dist/widget
directory.
The widget's API documentation is available by clicking the docs
badge at the beginning of this page.
The documentation can be generated with:
npm run compodoc
The generated documentation will be in the docs
folder for interoperability
with GitHub Pages and the above link.
The tool ng-packgr still does not support exporting assets with the package so translations are not yet available with this release. As soon as the relevant pull request will be released it will be possible to resume work on this feature.
Issue the command npm publish
command after testing, and building the widget to
have it published in the default npm registry. You must be logged in the default
registry for this to work.
Then run npm install parking-widget
to install in any project.
Copy the dist/widget
folder in the node_modules
folder of the destination project.
The demo project is already setup to get the package from that folder. Don't symlink it,
as it will not work that way!
You could install a local copy of an NPM registry (like Verdaccio from https://verdaccio.org/), configure it, and start it. It must act as an NPM registry proxy, too. This is still work in progress.
The test proejct it at https://github.com/marcobuschini/interview-november-2019. It the widget was installed "the easy way" described above.
This widget uses NGX Translate for internationalization. To extract
the strings to translate use the command npm run extract-i18n
. This will generate the file
projects/widget/assets/i18n/strings.pot
that can feeded into any translation tool that generates
translations in JSON format, such as OneSky. Download the translated
files ZIP archive and unpack it into the projects/widget/assets/i18n/
folder.


$version
Press the ALT key and Double Click on page to bring up the
Sahi Controller
Sahi Scripts can be recorded and played back from the Controller.
Enter start URL:
Change Resolution
Change User Agent
Logs
|
Online Documentation
Test Pages
|
Sample Application
Controller mode:
Sahi
Java
Ruby


GETPROTOENT
Section: Linux Programmer's Manual (3)
Updated: 2008-08-19
Index
Return to Main Contents
NAME
getprotoent, getprotobyname, getprotobynumber, setprotoent,
endprotoent - get protocol entry
SYNOPSIS
#include <netdb.h>
struct protoent *getprotoent(void);
struct protoent *getprotobyname(const char *name);
struct protoent *getprotobynumber(int proto);
void setprotoent(int stayopen);
void endprotoent(void);
DESCRIPTION
The
getprotoent()
function reads the next entry from the protocols database (see
protocols(5))
and returns a
protoent
structure
containing the broken-out fields from the entry.
A connection is opened to the database if necessary.
The
getprotobyname()
function returns a
protoent
structure
for the entry from the database
that matches the protocol name
name.
A connection is opened to the database if necessary.
The
getprotobynumber()
function returns a
protoent
structure
for the entry from the database
that matches the protocol number
number.
A connection is opened to the database if necessary.
The
setprotoent()
function opens a connection to the database,
and sets the next entry to the first entry.
If
stayopen
is nonzero,
then the connection to the database
will not be closed between calls to one of the
getproto*()
functions.
The
endprotoent()
function closes the connection to the database.
The
protoent
structure is defined in
<netdb.h>
as follows:
struct protoent {
char *p_name; /* official protocol name */
char **p_aliases; /* alias list */
int p_proto; /* protocol number */
}
The members of the
protoent
structure are:
- p_name
-
The official name of the protocol.
- p_aliases
-
A NULL-terminated list of alternative names for the protocol.
- p_proto
-
The protocol number.
RETURN VALUE
The
getprotoent(),
getprotobyname()
and
getprotobynumber()
functions return a pointer to a
statically allocated
protoent
structure, or a null pointer if an
error occurs or the end of the file is reached.
FILES
- /etc/protocols
-
protocol database file
CONFORMING TO
4.3BSD, POSIX.1-2001.
SEE ALSO
getnetent(3),
getprotoent_r(3),
getservent(3),
protocols(5)
Index
- NAME
-
- SYNOPSIS
-
- DESCRIPTION
-
- RETURN VALUE
-
- FILES
-
- CONFORMING TO
-
- SEE ALSO
-
This document was created by
man2html,
using the manual pages.
Time: 02:55:11 GMT, September 18, 2014


Just input details of a property and we'll calculate it's price on Airbnb and pay-back period.
Access amenities options [expert mode]


For the past few years, I worked as a Research Assistant for Skidmore College's Sociology and American Studies departments. While I enjoyed my job, I found I was most passionate about that work - solving research queries and breaking problems apart - when I leveraged those same skills in my free-time to study programming. At the beginning of this year, I decided to commit myself fully to programming and enrolled in Epicodus, a four-month long programming bootcamp.
I'm a recent transplant to Portland, OR and when I'm not programming, I like to explore the city on my bike. I also enjoy making terrariums and throwing cups and bowls on the pottery wheel.
If you would like to see a few samples of my work, feel free to explore the projects below.
PDX Adventures aggregates outdoor activities in the Portland area into a searchable, user-friendly format.
PHP, PostgreSQL, PHPUnit, Composer, Twig, Silex, Bootstrap, HTML/CSS
Have a project you need help with? Are you looking to hire a junior developer?
Feel free to contact me with any questions you might have.


Import playlists to Streamly from other services
When first using Streamly Import you may need to allow pop-ups. These are used to open your playlists outside of this site. [instructions for Chrome and Firefox]
Just open up Streamly and drag and drop or paste the URL of your playlist! Yup, it's that simple!
Paste the URL of your playlist, or the text of your Audius Playlist File:
A tab of the Streamus website should open.
Below the "Add to Streamus" button in the new tab, you should see a bunch of garbled text. Copy ALL of it, and paste it below.
Paste the contents of your Streamus Playlist File:


WILL YOU HELP US MAKE HISTORY?
We’re ending the influence of fossil fuel billionaires on our government and future.
Contributions like yours make what we do possible.
CHIP IN $5
CHIP IN $10
CHIP IN $25
CHIP IN $50
CHIP IN ANOTHER AMOUNT
These are express donate links. If you are already logged into your ActBlue
account, your donation will be processed with one click.


TimingProfile
{
"resourceType" : "StructureDefinition",
"id" : "shr-core-Timing",
"text" : {
"status" : "generated",
"div" : "

SHR Timing Profile

A timing schedule that specifies an event that may occur multiple times. Timing offers a choice of multiple OccurrenceTime (used is used to specify specific times), or recurrence patterns.

SHR Mapping Summary

shr.core.Timing maps to Timing:
OccurrenceTime maps to event
TimingCode maps to code
EventDuration.DurationRange.LowerBound maps to repeat.duration
EventDuration.DurationRange.UpperBound maps to repeat.durationMax
EventDuration.DurationRange.LowerBound.Quantity.Units.Coding.code maps to repeat.durationUnit
RecurrencePattern.RecurrenceInterval.Duration maps to repeat.period
constrain repeat.periodMax to 0..0
RecurrencePattern.RecurrenceInterval.Duration.Units.Coding.code maps to repeat.periodUnit
RecurrencePattern.DayOfWeek maps to repeat.dayOfWeek
RecurrencePattern.TimeOfDay maps to repeat.timeOfDay
RecurrencePattern.DailyLifeEvent maps to repeat.when
RecurrencePattern.LifeEventOffset maps to repeat.offset
RecurrencePattern.CountPerInterval.MinCount maps to repeat.frequency
RecurrencePattern.CountPerInterval.MaxCount maps to repeat.frequencyMax

"
},
"url" : "http://standardhealthrecord.org/fhir/StructureDefinition/shr-core-Timing",
"identifier" : [
{
"system" : "http://standardhealthrecord.org",
"value" : "shr.core.Timing"
}
],
"version" : "0.1.0",
"name" : "TimingProfile",
"title" : "SHR Timing Profile",
"status" : "draft",
"date" : "2018-08-22T00:00:00-04:00",
"publisher" : "The MITRE Corporation: Standard Health Record Collaborative",
"contact" : [
{
"telecom" : [
{
"system" : "url",
"value" : "http://standardhealthrecord.org"
}
]
}
],
"description" : "A timing schedule that specifies an event that may occur multiple times. Timing offers a choice of multiple OccurrenceTime (used is used to specify specific times), or recurrence patterns.",
"purpose" : "Need to able to track proposed timing schedules. There are several different ways to do this: one or more specified times, a simple rules like three times a day, or before/after meals.",
"fhirVersion" : "3.0.1",
"mapping" : [
{
"identity" : "v2",
"uri" : "http://hl7.org/v2",
"name" : "HL7 v2 Mapping"
},
{
"identity" : "rim",
"uri" : "http://hl7.org/v3",
"name" : "RIM Mapping"
}
],
"kind" : "complex-type",
"abstract" : false,
"type" : "Timing",
"baseDefinition" : "http://hl7.org/fhir/StructureDefinition/Timing",
"derivation" : "constraint",
"snapshot" : {
"element" : [
{
"id" : "Timing:shr-core-Timing",
"path" : "Timing",
"short" : "SHR Timing Profile",
"definition" : "A timing schedule that specifies an event that may occur multiple times. Timing offers a choice of multiple OccurrenceTime (used is used to specify specific times), or recurrence patterns.",
"comment" : "A timing schedule can be either a list of events - intervals on which the event occurs, or a single event with repeating criteria or just repeating criteria with no actual event. When both event and a repeating specification are provided, the list of events should be understood as an interpretation of the information in the repeat structure.",
"min" : 0,
"max" : "*",
"condition" : [
"ele-1"
],
"constraint" : [
{
"key" : "ele-1",
"severity" : "error",
"human" : "All FHIR elements must have a @value or children",
"expression" : "hasValue() | (children().count() > id.count())",
"xpath" : "@value|f:*|h:div",
"source" : "Element"
}
],
"mapping" : [
{
"identity" : "rim",
"map" : "n/a"
},
{
"identity" : "v2",
"map" : "N/A"
},
{
"identity" : "rim",
"map" : "QSET<TS> (GTS)"
}
]
},
{
"id" : "Timing:shr-core-Timing.id",
"path" : "Timing.id",
"representation" : [
"xmlAttr"
],
"short" : "xml:id (or equivalent in JSON)",
"definition" : "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min" : 0,
"max" : "1",
"base" : {
"path" : "Element.id",
"min" : 0,
"max" : "1"
},
"type" : [
{
"code" : "string"
}
],
"mapping" : [
{
"identity" : "rim",
"map" : "n/a"
}
]
},
{
"id" : "Timing:shr-core-Timing.extension",
"path" : "Timing.extension",
"slicing" : {
"discriminator" : [
{
"type" : "value",
"path" : "url"
}
],
"description" : "Extensions are always sliced by (at least) url",
"rules" : "open"
},
"short" : "Additional Content defined by implementations",
"definition" : "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment" : "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias" : [
"extensions",
"user content"
],
"min" : 0,
"max" : "*",
"base" : {
"path" : "Element.extension",
"min" : 0,
"max" : "*"
},
"type" : [
{
"code" : "Extension"
}
],
"mapping" : [
{
"identity" : "rim",
"map" : "n/a"
}
]
},
{
"id" : "Timing:shr-core-Timing.extension:recurrencerange",
"path" : "Timing.extension",
"sliceName" : "recurrencerange",
"slicing" : {
"discriminator" : [
{
"type" : "value",
"path" : "url"
}
],
"description" : "Extensions are always sliced by (at least) url",
"rules" : "open"
},
"definition" : "The start and end of the overall recurrence pattern in terms of dates/times or in terms of number of repeats. Could also be an event, such as when all doses are taken.",
"min" : 0,
"max" : "1",
"type" : [
{
"code" : "Extension",
"profile" : "http://standardhealthrecord.org/fhir/StructureDefinition/shr-core-RecurrenceRange-extension"
}
]
},
{
"id" : "Timing:shr-core-Timing.event",
"path" : "Timing.event",
"short" : "When the event occurs",
"definition" : "Identifies specific times when the event occurs.",
"requirements" : "In an MAR, for instance, you need to take a general specification, and turn it into a precise specification.",
"min" : 0,
"max" : "*",
"type" : [
{
"code" : "dateTime"
}
],
"isSummary" : true,
"mapping" : [
{
"identity" : "rim",
"map" : "QLIST<TS>"
}
]
},
{
"id" : "Timing:shr-core-Timing.repeat",
"path" : "Timing.repeat",
"short" : "When the event is to occur",
"definition" : "A set of rules that describe when the event is scheduled.",
"requirements" : "Many timing schedules are determined by regular repetitions.",
"min" : 0,
"max" : "1",
"type" : [
{
"code" : "Element"
}
],
"constraint" : [
{
"key" : "ele-1",
"severity" : "error",
"human" : "All FHIR elements must have a @value or children",
"expression" : "hasValue() | (children().count() > id.count())",
"xpath" : "@value|f:*|h:div",
"source" : "Element"
},
{
"key" : "tim-9",
"severity" : "error",
"human" : "If there's an offset, there must be a when (and not C, CM, CD, CV)",
"expression" : "offset.empty() or (when.exists() and ((when in ('C' | 'CM' | 'CD' | 'CV')).not()))",
"xpath" : "not(exists(f:offset)) or exists(f:when)"
},
{
"key" : "tim-5",
"severity" : "error",
"human" : "period SHALL be a non-negative value",
"expression" : "period.exists() implies period >= 0",
"xpath" : "f:period/@value >= 0 or not(f:period/@value)"
},
{
"key" : "tim-6",
"severity" : "error",
"human" : "If there's a periodMax, there must be a period",
"expression" : "periodMax.empty() or period.exists()",
"xpath" : "not(exists(f:periodMax)) or exists(f:period)"
},
{
"key" : "tim-7",
"severity" : "error",
"human" : "If there's a durationMax, there must be a duration",
"expression" : "durationMax.empty() or duration.exists()",
"xpath" : "not(exists(f:durationMax)) or exists(f:duration)"
},
{
"key" : "tim-8",
"severity" : "error",
"human" : "If there's a countMax, there must be a count",
"expression" : "countMax.empty() or count.exists()",
"xpath" : "not(exists(f:countMax)) or exists(f:count)"
},
{
"key" : "tim-1",
"severity" : "error",
"human" : "if there's a duration, there needs to be duration units",
"expression" : "duration.empty() or durationUnit.exists()",
"xpath" : "not(exists(f:duration)) or exists(f:durationUnit)"
},
{
"key" : "tim-10",
"severity" : "error",
"human" : "If there's a timeOfDay, there cannot be be a when, or vice versa",
"expression" : "timeOfDay.empty() or when.empty()",
"xpath" : "not(exists(f:timeOfDay)) or not(exists(f:when))"
},
{
"key" : "tim-2",
"severity" : "error",
"human" : "if there's a period, there needs to be period units",
"expression" : "period.empty() or periodUnit.exists()",
"xpath" : "not(exists(f:period)) or exists(f:periodUnit)"
},
{
"key" : "tim-4",
"severity" : "error",
"human" : "duration SHALL be a non-negative value",
"expression" : "duration.exists() implies duration >= 0",
"xpath" : "f:duration/@value >= 0 or not(f:duration/@value)"
}
],
"isSummary" : true,
"mapping" : [
{
"identity" : "rim",
"map" : "Implies PIVL or EIVL"
}
]
},
{
"id" : "Timing:shr-core-Timing.repeat.id",
"path" : "Timing.repeat.id",
"representation" : [
"xmlAttr"
],
"short" : "xml:id (or equivalent in JSON)",
"definition" : "unique id for the element within a resource (for internal references). This may be any string value that does not contain spaces.",
"min" : 0,
"max" : "1",
"base" : {
"path" : "Element.id",
"min" : 0,
"max" : "1"
},
"type" : [
{
"code" : "string"
}
],
"mapping" : [
{
"identity" : "rim",
"map" : "n/a"
}
]
},
{
"id" : "Timing:shr-core-Timing.repeat.extension",
"path" : "Timing.repeat.extension",
"slicing" : {
"discriminator" : [
{
"type" : "value",
"path" : "url"
}
],
"description" : "Extensions are always sliced by (at least) url",
"rules" : "open"
},
"short" : "Additional Content defined by implementations",
"definition" : "May be used to represent additional information that is not part of the basic definition of the element. In order to make the use of extensions safe and manageable, there is a strict set of governance applied to the definition and use of extensions. Though any implementer is allowed to define an extension, there is a set of requirements that SHALL be met as part of the definition of the extension.",
"comment" : "There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.",
"alias" : [
"extensions",
"user content"
],
"min" : 0,
"max" : "*",
"base" : {
"path" : "Element.extension",
"min" : 0,
"max" : "*"
},
"type" : [
{
"code" : "Extension"
}
],
"mapping" : [
{
"identity" : "rim",
"map" : "n/a"
}
]
},
{
"id" : "Timing:shr-core-Timing.repeat.bounds[x]",
"path" : "Timing.repeat.bounds[x]",
"short" : "Length/Range of lengths, or (Start and/or end) limits",
"definition" : "Either a duration for the length of the timing schedule, a range of possible length, or outer bounds for start and/or end limits of the timing schedule.",
"min" : 0,
"max" : "1",
"type" : [
{
"code" : "Duration"
},
{
"code" : "Range"
},
{
"code" : "Period"
}
],
"isSummary" : true,
"mapping" : [
{
"identity" : "rim",
"map" : "IVL(TS) used in a QSI"
}
]
},
{
"id" : "Timing:shr-core-Timing.repeat.count",
"path" : "Timing.repeat.count",
"short" : "Number of times to repeat",
"definition" : "A total count of the desired number of repetitions.",
"comment" : "If you have both bounds and count, then this should be understood as within the bounds period, until count times happens.",
"requirements" : "Repetitions may be limited by end time or total occurrences.",
"min" : 0,
"max" : "1",
"type" : [
{
"code" : "integer"
}
],
"isSummary" : true,
"mapping" : [
{
"identity" : "rim",
"map" : "PIVL.count"
}
]
},
{
"id" : "Timing:shr-core-Timing.repeat.countMax",
"path" : "Timing.repeat.countMax",
"short" : "Maximum number of times to repeat",
"definition" : "A maximum value for the count of the desired repetitions (e.g. do something 6-8 times).",
"min" : 0,
"max" : "1",
"type" : [
{
"code" : "integer"
}
],
"isSummary" : true,
"mapping" : [
{
"identity" : "rim",
"map" : "PIVL.count"
}
]
},
{
"id" : "Timing:shr-core-Timing.repeat.duration",
"path" : "Timing.repeat.duration",
"short" : "How long when it happens",
"definition" : "How long this thing happens for when it happens.",
"comment" : "For some events the duration is part of the definition of the event (e.g. IV infusions, where the duration is implicit in the specified quantity and rate). For others, it's part of the timing specification (e.g. exercise).",
"requirements" : "Some activities are not instantaneous and need to be maintained for a period of time.",
"min" : 0,
"max" : "1",
"type" : [
{
"code" : "decimal"
}
],
"isSummary" : true,
"mapping" : [
{
"identity" : "rim",
"map" : "PIVL.phase"
}
]
},
{
"id" : "Timing:shr-core-Timing.repeat.durationMax",
"path" : "Timing.repeat.durationMax",
"short" : "How long when it happens (Max)",
"definition" : "The upper limit of how long this thing happens for when it happens.",
"comment" : "For some events the duration is part of the definition of the event (e.g. IV infusions, where the duration is implicit in the specified quantity and rate). For others, it's part of the timing specification (e.g. exercise).",
"requirements" : "Some activities are not instantaneous and need to be maintained for a period of time.",
"min" : 0,
"max" : "1",
"type" : [
{
"code" : "decimal"
}
],
"isSummary" : true,
"mapping" : [
{
"identity" : "rim",
"map" : "PIVL.phase"
}
]
},
{
"id" : "Timing:shr-core-Timing.repeat.durationUnit",
"path" : "Timing.repeat.durationUnit",
"short" : "s | min | h | d | wk | mo | a - unit of time (UCUM)",
"definition" : "The units of time for the duration, in UCUM units.",
"min" : 0,
"max" : "1",
"type" : [
{
"code" : "code"
}
],
"isSummary" : true,
"binding" : {
"extension" : [
{
"url" : "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString" : "UnitsOfTime"
}
],
"strength" : "required",
"description" : "A unit of time (units from UCUM).",
"valueSetReference" : {
"reference" : "http://hl7.org/fhir/ValueSet/units-of-time"
}
},
"mapping" : [
{
"identity" : "rim",
"map" : "PIVL.phase.unit"
}
]
},
{
"id" : "Timing:shr-core-Timing.repeat.frequency",
"path" : "Timing.repeat.frequency",
"short" : "Event occurs frequency times per period",
"definition" : "The number of times to repeat the action within the specified period / period range (i.e. both period and periodMax provided).",
"min" : 0,
"max" : "1",
"type" : [
{
"code" : "integer"
}
],
"defaultValueInteger" : 1,
"isSummary" : true,
"mapping" : [
{
"identity" : "rim",
"map" : "PIVL.phase"
}
]
},
{
"id" : "Timing:shr-core-Timing.repeat.frequencyMax",
"path" : "Timing.repeat.frequencyMax",
"short" : "Event occurs up to frequencyMax times per period",
"definition" : "If present, indicates that the frequency is a range - so to repeat between [frequency] and [frequencyMax] times within the period or period range.",
"min" : 0,
"max" : "1",
"type" : [
{
"code" : "integer"
}
],
"isSummary" : true,
"mapping" : [
{
"identity" : "rim",
"map" : "PIVL.phase"
}
]
},
{
"id" : "Timing:shr-core-Timing.repeat.period",
"path" : "Timing.repeat.period",
"short" : "Event occurs frequency times per period",
"definition" : "Indicates the duration of time over which repetitions are to occur; e.g. to express "3 times per day", 3 would be the frequency and "1 day" would be the period.",
"min" : 0,
"max" : "1",
"type" : [
{
"code" : "decimal"
}
],
"isSummary" : true,
"mapping" : [
{
"identity" : "rim",
"map" : "PIVL.phase"
}
]
},
{
"id" : "Timing:shr-core-Timing.repeat.periodMax",
"path" : "Timing.repeat.periodMax",
"short" : "Upper limit of period (3-4 hours)",
"definition" : "If present, indicates that the period is a range from [period] to [periodMax], allowing expressing concepts such as "do this once every 3-5 days.",
"min" : 0,
"max" : "0",
"type" : [
{
"code" : "decimal"
}
],
"isSummary" : true,
"mapping" : [
{
"identity" : "rim",
"map" : "PIVL.phase"
}
]
},
{
"id" : "Timing:shr-core-Timing.repeat.periodUnit",
"path" : "Timing.repeat.periodUnit",
"short" : "s | min | h | d | wk | mo | a - unit of time (UCUM)",
"definition" : "The units of time for the period in UCUM units.",
"min" : 0,
"max" : "1",
"type" : [
{
"code" : "code"
}
],
"isSummary" : true,
"binding" : {
"extension" : [
{
"url" : "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString" : "UnitsOfTime"
}
],
"strength" : "required",
"description" : "A unit of time (units from UCUM).",
"valueSetReference" : {
"reference" : "http://hl7.org/fhir/ValueSet/units-of-time"
}
},
"mapping" : [
{
"identity" : "rim",
"map" : "PIVL.phase.unit"
}
]
},
{
"id" : "Timing:shr-core-Timing.repeat.dayOfWeek",
"path" : "Timing.repeat.dayOfWeek",
"short" : "mon | tue | wed | thu | fri | sat | sun",
"definition" : "If one or more days of week is provided, then the action happens only on the specified day(s).",
"comment" : "If no days are specified, the action is assumed to happen every day as otherwise specified. The elements frequency and period cannot be used as well as dayOfWeek.",
"min" : 0,
"max" : "*",
"type" : [
{
"code" : "code"
}
],
"isSummary" : true,
"binding" : {
"extension" : [
{
"url" : "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString" : "DayOfWeek"
}
],
"strength" : "required",
"valueSetReference" : {
"reference" : "http://hl7.org/fhir/ValueSet/days-of-week"
}
},
"mapping" : [
{
"identity" : "rim",
"map" : "n/a"
}
]
},
{
"id" : "Timing:shr-core-Timing.repeat.timeOfDay",
"path" : "Timing.repeat.timeOfDay",
"short" : "Time of day for action",
"definition" : "Specified time of day for action to take place.",
"comment" : "When time of day is specified, it is inferred that the action happens every day (as filtered by dayofWeek) on the specified times. The elements when, frequency and period cannot be used as well as timeOfDay.",
"min" : 0,
"max" : "*",
"type" : [
{
"code" : "time"
}
],
"isSummary" : true,
"mapping" : [
{
"identity" : "rim",
"map" : "n/a"
}
]
},
{
"id" : "Timing:shr-core-Timing.repeat.when",
"path" : "Timing.repeat.when",
"short" : "Regular life events the event is tied to",
"definition" : "Real world events that the occurrence of the event should be tied to.",
"comment" : "When more than one event is listed, the event is tied to the union of the specified events.",
"requirements" : "Timings are frequently determined by occurrences such as waking, eating and sleep.",
"min" : 0,
"max" : "*",
"type" : [
{
"code" : "code"
}
],
"isSummary" : true,
"binding" : {
"extension" : [
{
"url" : "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString" : "EventTiming"
}
],
"strength" : "required",
"description" : "Real world event relating to the schedule.",
"valueSetReference" : {
"reference" : "http://hl7.org/fhir/ValueSet/event-timing"
}
},
"mapping" : [
{
"identity" : "rim",
"map" : "EIVL.event"
}
]
},
{
"id" : "Timing:shr-core-Timing.repeat.offset",
"path" : "Timing.repeat.offset",
"short" : "Minutes from event (before or after)",
"definition" : "The number of minutes from the event. If the event code does not indicate whether the minutes is before or after the event, then the offset is assumed to be after the event.",
"min" : 0,
"max" : "1",
"type" : [
{
"code" : "unsignedInt"
}
],
"isSummary" : true,
"mapping" : [
{
"identity" : "rim",
"map" : "EIVL.offset"
}
]
},
{
"id" : "Timing:shr-core-Timing.code",
"path" : "Timing.code",
"short" : "BID | TID | QID | AM | PM | QD | QOD | Q4H | Q6H +",
"definition" : "A code for the timing schedule. Some codes such as BID are ubiquitous, but many institutions define their own additional codes. If a code is provided, the code is understood to be a complete statement of whatever is specified in the structured timing data, and either the code or the data may be used to interpret the Timing, with the exception that .repeat.bounds still applies over the code (and is not contained in the code).",
"comment" : "BID etc are defined as 'at institutionally specified times'. For example, an institution may choose that BID is "always at 7am and 6pm". If it is inappropriate for this choice to be made, the code BID should not be used. Instead, a distinct organization-specific code should be used in place of the HL7-defined BID code and/or the a structured representation should be used (in this case, specifying the two event times).",
"min" : 0,
"max" : "1",
"type" : [
{
"code" : "CodeableConcept",
"profile" : "http://standardhealthrecord.org/fhir/StructureDefinition/shr-core-CodeableConcept"
}
],
"isSummary" : true,
"binding" : {
"extension" : [
{
"url" : "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString" : "TimingAbbreviation"
}
],
"strength" : "extensible",
"description" : "Code for a known / defined timing pattern.",
"valueSetReference" : {
"reference" : "http://hl7.org/fhir/ValueSet/timing-abbreviation"
}
},
"mapping" : [
{
"identity" : "rim",
"map" : "QSC.code"
}
]
}
]
},
"differential" : {
"element" : [
{
"id" : "Timing:shr-core-Timing",
"path" : "Timing",
"short" : "SHR Timing Profile",
"definition" : "A timing schedule that specifies an event that may occur multiple times. Timing offers a choice of multiple OccurrenceTime (used is used to specify specific times), or recurrence patterns."
},
{
"id" : "Timing:shr-core-Timing.extension:recurrencerange",
"path" : "Timing.extension",
"sliceName" : "recurrencerange",
"slicing" : {
"discriminator" : [
{
"type" : "value",
"path" : "url"
}
],
"description" : "Extensions are always sliced by (at least) url",
"rules" : "open"
},
"definition" : "The start and end of the overall recurrence pattern in terms of dates/times or in terms of number of repeats. Could also be an event, such as when all doses are taken.",
"min" : 0,
"max" : "1",
"type" : [
{
"code" : "Extension",
"profile" : "http://standardhealthrecord.org/fhir/StructureDefinition/shr-core-RecurrenceRange-extension"
}
]
},
{
"id" : "Timing:shr-core-Timing.repeat",
"path" : "Timing.repeat"
},
{
"id" : "Timing:shr-core-Timing.repeat.periodMax",
"path" : "Timing.repeat.periodMax",
"min" : 0,
"max" : "0"
},
{
"id" : "Timing:shr-core-Timing.code",
"path" : "Timing.code",
"type" : [
{
"code" : "CodeableConcept",
"profile" : "http://standardhealthrecord.org/fhir/StructureDefinition/shr-core-CodeableConcept"
}
],
"binding" : {
"extension" : [
{
"url" : "http://hl7.org/fhir/StructureDefinition/elementdefinition-bindingName",
"valueString" : "TimingAbbreviation"
}
],
"strength" : "extensible",
"description" : "Code for a known / defined timing pattern.",
"valueSetReference" : {
"reference" : "http://hl7.org/fhir/ValueSet/timing-abbreviation"
}
}
}
]
}
}


welcome my Bootstrap 4 tutorials.
welcome my Bootstrap 4 tutorials. Boostrap is an open-source and free front-end library with HTML and CSS based design
Build the latest version of React
Build your Website and Front-end Application
Customize your web UI with Html5 and Css3


Sessions
Below is a list of workshops that will be offered during the inaugural DHRI at SMU. Workshops build on each other such that successive workshops use skills developed in earlier ones.
| Intro | details | repo |
| Command Line | details | repo |
| Git | details | repo |
| R | details | repo |
| Data in the Humanities | details | repo |
| Ethics | details | repo |
| Geospatial Data | details | repo |
| Project Lab | details | repo |
Intro
Introduction to the logistics and pedagogical underpinnings of DHRI. We will discuss expectations and structure. We will establish a working definiton of what is (or what is not) DH. This concept is to be established collaboratively and will evolve during your experience.
Command Line
What do we hope to accomplish in the sessions on coding? In this iteration of DHRI, we will learn Command Line, Git and Github and R. Introduction to the UNIX command line. Topics covered will include navigating the filesystem, manipulating the environment, executing useful commands, and using pipes to communicate between programs. This session will teach you how to communicate directly with your computer’s operating system using a text-based interface and is a useful first step in learning many other technical skills.
Git
Git is a tool for managing changes to a set of files. It allows users to access open source repositories, recover earlier versions of a project, and collaborate with other contributors. This session will be beneficial to anyone working with data, code, or text.
R
R is a programming language that can be used for a wide range of tasks, including collecting and analyzing data in a variety of formats.
Data in the Humanities
What is data, and what kinds of data can be useful in your research? What is data, and what kinds of data can be useful in your research? Attendees will participate in coversations about best practices for data management, file naming rules, sustainable data formats, and structuring data.
Geospatial Data
This session will introduce geospatial data and analysis. We will also discuss how to choose the best tool to visualize your datam and practice with the tool Storymaps.
Project Lab
This session will allow time to apply what we have learned throughout DHRI to your research interests.


Microwave wattage transducer
by webtoolbox
⚠Please enable JavaScript!
back to home
Input:
W
m
s
to...
W
OutPut
(update)
:


Albers was born into a Roman Catholic family of craftsmen in Bottrop, Westphalia, Germany. He worked from 1908 to 1913 as a schoolteacher in his home town; he also trained as an art teacher at Königliche Kunstschule in Berlin, Germany, from 1913 to 1915. From 1916 to 1919 he began his work as a printmaker at the Kunstgewerbschule in Essen. In 1918 he received his first public commission, Rosa mystica ora pro nobis, a stained-glass window for a church in Essen. In 1919 he went to Munich, Germany, to study at the Königliche Bayerische Akademie der Bildenden Kunst, where he was a pupil of Max Doerner and Franz Stuck.
In 1962, as a fellow at Yale, he received a grant from the Graham Foundation for the Advanced Studies of Fine Arts for an exhibit and lecture on his work. Albers also collaborated with Yale professor and architect King-lui Wu in creating decorative designs for some of Wu's projects. Among these were distinctive geometric fireplaces for the Rouse (1954) and DuPont (1959) houses, the façade of Manuscript Society, one of Yale's secret senior groups (1962), and a design for the Mt. Bethel Baptist Church (1973). Also, at this time he worked on his structural constellation pieces.


info:sid/
| info-namespace |
sid |
| namespace-title |
Namespace of Source Identifiers used in the NISO OpenURL Framework |
| registration-date |
2003-11-10 |
| namespace-authority |
| organisation-name |
NISO |
| organisation-address |
4733 Bethesda Avenue, Suite 300. Bethesda, MD 20814. USA |
| organisation-uri |
http://www.niso.org |
| contact-person |
Pat Stevens |
| contact-email |
<EMAIL_ADDRESS>|
| contact-tel |
+1<PHONE_NUMBER> |
|
| identifier-syntax |
| description |
Identifiers in the sid namespace consist of two parts. The first part is an
Internet domain name, subdomain name, or host name that is associated with the
collection. This ensures uniqueness of identifiers. The second, optional, part
of an identifier of the sid namespace is a string that may provide further
details about the nature of the collection. Examples:
info:sid/amazon.co.uk
info:sid/oclc.org
info:sid/amazon.co.uk:books
info:sid/oclc.org:inspec |
| uri |
http://www.openurl.info/registry/docs/pdf/info-sid.pdf |
|
| identifier-normalization |
| description |
A sid identifier is case-insensitive, and the canonical form is obtained by
representing all upper case letters to their lowercase equivalents. |
|
| namespace-information |
| description |
The sid namespace facilitates the identification of collections of information
assets. A collection of information assets could be an organization, a website,
a publisher, or a database. Identifiers in the sid namespace consist of two
parts. The first part is an Internet domain name, subdomain name, or host name
that is associated with the collection. This ensures uniqueness of identifiers.
The second, optional, part of an identifier of the sid namespace is a string
that may provide further details about the nature of the collection. The sid
namespace was created to accommodate needs in the NISO Z39-88-2004 Standard
"The OpenURL Framework for Context-Sensitive Services". |
| uri |
http://www.openurl.info/registry/docs/pdf/info-sid.pdf |
|
View Dublin Core metadata for this entry
|


Your web browser must have JavaScript enabled in order for this application to display correctly.
If you are an automated web crawler from a search engine, follow this
AJAX application crawl link
Loading...


As a keyword
Keyword: assume
Introduces a logical assumption into a context.
Exists as both a tactic and a statement.
As a concept
"Assumption" as a general concept also refers to a logical assumption introduced by any of:
- The
assume
keyword itself, which adds a general free-standing assumption in an action not associated with the action's visibility qualifiers or assume-guarantee reasoning between actions. - A precondition (keyword
require
) when considered from the perspective of verifying the action containing therequire
statement. - A postcondition (keyword
ensure
) when considered from the perspective of verifying an action that calls the action containing theensure
statement. - An invariant (keyword
invariant
) which also introduces an guarantee (as invariants are inductive, they both assume and guarantee).
Assumptions and guarantees together support assume-guarantee reasoning, which is a basis of modular verification in Ivy.
Assumptions occur positively in verification conditions.