{% extends 'base.html' %} {% import 'macros.html' as macro %} {% block styles%} {{ super() }} {% endblock %} {% block content %}
Jobs found: {{ jobs | count() }}
Find the ideal job for you
{{ one_job.department }}
{{ one_job.descriptionPlain }}
{{ one_job.team }}


Master Rigol:
Hmm, what's this? Hey Klaus, why do you get all the talented ones to teach while I get the leftovers?
Hey, don't glare at me, pal. Nothing personal...
Hmph, fine. Then prove you're not a dud.
Pick up your weapon!
Learn skills.
Ask about Skill Enchanting.
Quest


Designed for support of Employee Benefits Claims and Provider Health Care Services with onsite Pharmacy. This is a prototype which shows local and facebook user registration and login flow using Angular v5.2.1, Jason Web Token (JWT) authentivation, ASP.NET Core 2.0 WebApi and Facebook api
Signup with email Login with email Signup/login with facebook
© 2018 | AQSealy Media Project | Omaha, Nebraska | LLC


Here are some preprints of my publications:
Large Salem Sets Avoiding Nonlinear Configurations (2021)
In this paper, robust concentration inequalities are used to improve upon results previously only applied to the construction of sets avoiding linear patterns, which support measures with Fourier decay, to the construction of such sets avoiding nonlinear patterns.
Cartesian Products Avoiding Rough Patterns (2019)
In my thesis, I provide a more expository look at the work completed with Malabika Pramanik and Joshua Zahl described in the paper Large Sets Avoiding Rough Patterns, as well as new work planned for publication in a separate paper soon, on the topic of the Fourier decay of measures supported on sets avoiding configurations, and on the topic of low rank rough configurations.
Large Sets Avoiding Rough Patterns (2019)
In this paper, published in the Springer Series Harmonic Analysis and Applications' 2021 Volume, Malabika Pramanik, Joshua Zahl, and I used a novel dyadic discretization strategy combined with a simple application of the pidgeonhole principle to construct fractals avoiding a 'rough' family of patterns.
Proofs in Three Bits or Less (2018)
In this expository article, published as the front-page article in the Spring 2018 edition of the Canadian Mathematical Society's student journal Notes From the Margin, I describe the fundamentals ideas behind the PCP theorem in computational complexity theory, geared towards a general mathematical audience.
Here are some teaching resources I have used to help math students in past courses I've taught:
University of Wisconsin Analysis SEP Problem Solutions (2021-2022)
In Summer 2021 and 2022, together with Max Bacharach, I got the opportunity to prepare incoming / first year graduate students at the University of Madison, Wisconsin for the analysis qualifying exam in that department. To help students review for the exam, we produced a list of solutions to various problems for the analysis SEP. Our goal with writing these solutions was to try and isolate the general heuristics / principles which can often be applied to problems on different problems on the exam, so students could conciously think of these principles when applying them to the new questions that would occur on their upcoming qualifying exam.
Here are some notes salvaged from various talks I've given over the years:
The Lax Hormander Parametrix For the Half-Wave Equation (2023)
Heuristics Behind the FIO Parametrix For variable coefficient Half-Wave Equation via High-Frequency Asymptotic Solutions
Anticoncentration and Polynomial Decompositions (2022)
after a paper by Daniel Kane
Logarithmic Improvements To Spectral Bound Projection in the Presence of Negative Curvature (2022)
after a paper by Christopher D. Sogge and Matthew D. Blair
Algorithmic Aspects of Brascamp Lieb Inequalities (2021)
after papers by Ankit Garg, Leonid Gurvits, Rafael Oliveira, and Avi Wigderson
Salem Sets Avoiding Nonlinear Patterns (2020)
Slides for a talk relating to the paper "Large Salem Sets Avoiding Nonlinear Configurations"
Incidence Theorems in Arbitrary Characteristic (2019)
the polynomial method, flecnodes, and arithmetic genus
laplacians, riemannian manifolds, and cohomology
modular forms, sums of squares, and forbidden Eisenstein series
Radon Transforms and Exceptional Projections (2018)
singular directions, mixed norm estimates, and interpolation of besov spaces
characters, fourier inversion, and poisson summation
The Fourier-Stieltjes Transform (2016)
weak-$*$ density and physical measurement
operators, closed subspaces, and abstract harmonic analysis
Lift and Project Techniques (2016)
combinatorial optimization, vertex cover, and non-linear linear programming
On Molecular Gases and the Natural Numbers (2016)
an introduction to ergodic theory
The Brouwer Fixed Point Theorem (2016)
homology, vector Fields, and hex
The Jordan Separation Theorem (2016)
curves, intuition, and the van kampen theorem
Abstract Nonsense in Computing Science (2015)
categories, the curry howard isomorphism, and cartesian closure
A complete and continuous updated set of the lecture and research notes I have taken on various mathematical topics can be found at my github page. Note that, as a continuous work in process, the beginning of these notes tends to be more cohesive than the latter part of the notes. Here are a selection of notes I am particularly proud of:


There's more to picture,
then meets the eye.
Hey hey, my my.
Neil Young
Marble diagrams serve a method for us to visualize processes over time.
This helps programmers and engineers to understand and design reactive
processes.
The overall goal of the MarbleDesignSystem is to provide a unified way of
reading and creating stream based diagrams,
in particular one specific type of it, the marble diagrams.
This guide explains all building blocks of the design system step by step and
in detail.
In general we have some main rules that system follows:
There are several things to follow if you try to create a standard. One of them if more critical for a positive outcome than everything else, consistency. By working with a standardized, reproducible approach we managed to create a consistent way of drawing marble diagrams. A set of rules developed over many many iterations, adopted and simplified to serve as a guideline and blueprint for creating and using these diagrams.
As programming with Rx is hard we made sure to keep it intuitive. By including a lot of people into the process of the creation of this guide we collected a lot of personal feedback to improve the system. To make sure we consider a common way interpretation we created several public polls we were collected and evaluated the general understanding. This helped us to make our system intuitive to understand.
As mindset behind the system are several principles. One of them is “Easy to adopt and create”, which means we want to provide a way for everybody to read and create marble diagrams. To achieve this we create all diagrams in either googleSlides oder Powerpoint. We believe this two options enable a big group of people to edit and draw these diagrams.
Marble diagrams exist since a long time now. As there was no well thought standard out there and not all edge cases considered, people started to create their own solutions to visualize processes. These let to a variety of different ways of drawing these diagrams. Some of the better approaches were able to visualize more complex prozesses, but there is one essential thing which nobody considered yet, but which is most critical to understand processes based on Rx. The internal behavior of operators. This system is not only providing a consistent, standardized way of drawing marble diagrams, but also offers a way to visualize the internals of operators. Of course based on the systems rules it selfe.
TODO
Text is used to name things or give more information to a specific part of a diagram like observables, operators and events like subscribe or unsubscribe. It is furthermore used in notifications to give more detailed information about their content.


JSON
implementation for Ruby¶ ↑
Description¶ ↑
This is a implementation of the JSON
specification according to RFC 7159 www.ietf.org/rfc/rfc7159.txt . Starting from version 1.0.0 on there will be two variants available:
-
A pure ruby variant, that relies on the iconv and the stringscan extensions, which are both part of the ruby standard library.
-
The quite a bit faster native extension variant, which is in parts implemented in C or Java and comes with its own unicode conversion functions and a parser generated by the ragel state machine compiler www.complang.org/ragel/ .
Both variants of the JSON
generator generate UTF-8 character sequences by default. If an :ascii_only option with a true value is given, they escape all non-ASCII and control characters with uXXXX escape sequences, and support UTF-16 surrogate pairs in order to be able to generate the whole range of unicode code points.
All strings, that are to be encoded as JSON
strings, should be UTF-8 byte sequences on the Ruby side. To encode raw binary strings, that aren't UTF-8 encoded, please use the to_json_raw_object method of String (which produces an object, that contains a byte array) and decode the result on the receiving endpoint.
Installation¶ ↑
It's recommended to use the extension variant of JSON
, because it's faster than the pure ruby variant. If you cannot build it on your system, you can settle for the latter.
Just type into the command line as root:
# rake install
The above command will build the extensions and install them on your system.
# rake install_pure
or
# ruby install.rb
will just install the pure ruby implementation of JSON
.
If you use Rubygems you can type
# gem install json
instead, to install the newest JSON
version.
There is also a pure ruby json only variant of the gem, that can be installed with:
# gem install json_pure
Compiling the extensions yourself¶ ↑
If you want to create the parser.c
file from its parser.rl
file or draw nice graphviz images of the state machines, you need ragel from: www.complang.org/ragel/
Usage¶ ↑
To use JSON
you can
require 'json'
to load the installed variant (either the extension 'json'
or the pure variant 'json_pure'
). If you have installed the extension variant, you can pick either the extension variant or the pure variant by typing
require 'json/ext'
or
require 'json/pure'
Now you can parse a JSON
document into a ruby data structure by calling
JSON.parse(document)
If you want to generate a JSON
document from a ruby data structure call ruby JSON.generate(data)
You can also use the pretty_generate
method (which formats the output more verbosely and nicely) or fast_generate
(which doesn't do any of the security checks generate performs, e. g. nesting deepness checks).
There are also the JSON
and JSON[] methods which use parse on a String or generate a JSON
document from an array or hash:
document = JSON 'test' => 23 # => "{\"test\":23}" document = JSON['test' => 23] # => "{\"test\":23}"
and
data = JSON '{"test":23}' # => {"test"=>23} data = JSON['{"test":23}'] # => {"test"=>23}
You can choose to load a set of common additions to ruby core's objects if you
require 'json/add/core'
After requiring this you can, e. g., serialise/deserialise Ruby ranges:
JSON JSON(1..10) # => 1..10
To find out how to add JSON
support to other or your own classes, read the section “More Examples” below.
To get the best compatibility to rails' JSON
implementation, you can
require 'json/add/rails'
Both of the additions attempt to require 'json'
(like above) first, if it has not been required yet.
Serializing exceptions¶ ↑
The JSON
module doesn't extend Exception
by default. If you convert an Exception
object to JSON
, it will by default only include the exception message.
To include the full details, you must either load the json/add/core
mentioned above, or specifically load the exception addition:
require 'json/add/exception'
More Examples¶ ↑
To create a JSON
document from a ruby data structure, you can call JSON.generate
like that:
json = JSON.generate [1, 2, {"a"=>3.141}, false, true, nil, 4..10] # => "[1,2,{\"a\":3.141},false,true,null,\"4..10\"]"
To get back a ruby data structure from a JSON
document, you have to call JSON.parse
on it:
JSON.parse json # => [1, 2, {"a"=>3.141}, false, true, nil, "4..10"]
Note, that the range from the original data structure is a simple string now. The reason for this is, that JSON
doesn't support ranges or arbitrary classes. In this case the json library falls back to call Object#to_json
, which is the same as #to_s.to_json
.
It's possible to add JSON
support serialization to arbitrary classes by simply implementing a more specialized version of the #to_json method
, that should return a JSON
object (a hash converted to JSON
with #to_json
) like this (don't forget the *a
for all the arguments):
class Range def to_json(*a) { 'json_class' => self.class.name, # = 'Range' 'data' => [ first, last, exclude_end? ] }.to_json(*a) end end
The hash key json_class
is the class, that will be asked to deserialise the JSON
representation later. In this case it's Range
, but any namespace of the form A::B
or ::A::B
will do. All other keys are arbitrary and can be used to store the necessary data to configure the object to be deserialised.
If the key json_class
is found in a JSON
object, the JSON
parser checks if the given class responds to the json_create
class method. If so, it is called with the JSON
object converted to a Ruby hash. So a range can be deserialised by implementing Range.json_create
like this:
class Range def self.json_create(o) new(*o['data']) end end
Now it possible to serialise/deserialise ranges as well:
json = JSON.generate [1, 2, {"a"=>3.141}, false, true, nil, 4..10] # => "[1,2,{\"a\":3.141},false,true,null,{\"json_class\":\"Range\",\"data\":[4,10,false]}]" JSON.parse json # => [1, 2, {"a"=>3.141}, false, true, nil, 4..10] json = JSON.generate [1, 2, {"a"=>3.141}, false, true, nil, 4..10] # => "[1,2,{\"a\":3.141},false,true,null,{\"json_class\":\"Range\",\"data\":[4,10,false]}]" JSON.parse json, :create_additions => true # => [1, 2, {"a"=>3.141}, false, true, nil, 4..10]
JSON.generate
always creates the shortest possible string representation of a ruby data structure in one line. This is good for data storage or network protocols, but not so good for humans to read. Fortunately there's also JSON.pretty_generate
(or JSON.pretty_generate
) that creates a more readable output:
puts JSON.pretty_generate([1, 2, {"a"=>3.141}, false, true, nil, 4..10]) [ 1, 2, { "a": 3.141 }, false, true, null, { "json_class": "Range", "data": [ 4, 10, false ] } ]
There are also the methods Kernel#j
for generate, and Kernel#jj
for pretty_generate
output to the console, that work analogous to Core Ruby's p
and the pp
library's pp
methods.
The script tools/server.rb
contains a small example if you want to test, how receiving a JSON
object from a webrick server in your browser with the javasript prototype library www.prototypejs.org works.
Speed Comparisons¶ ↑
I have created some benchmark results (see the benchmarks/data-p4-3Ghz subdir of the package) for the JSON-parser to estimate the speed up in the C extension:
Comparing times (call_time_mean): 1 ParserBenchmarkExt#parser 900 repeats:<PHONE_NUMBER>70 ( real) -> 21.500x 0.001805307 2 ParserBenchmarkYAML#parser 1000 repeats:<PHONE_NUMBER>39 ( real) -> 8.714x 0.004454078 3 ParserBenchmarkPure#parser 1000 repeats: 26.755020642 ( real) -> 1.038x 0.037376163 4 ParserBenchmarkRails#parser 1000 repeats: 25.763381731 ( real) -> 1.000x 0.038814780 calls/sec ( time) -> speed covers secs/call
In the table above 1 is JSON::Ext::Parser
, 2 is YAML.load
with YAML compatbile JSON
document, 3 is is JSON::Pure::Parser
, and 4 is ActiveSupport::JSON.decode
. The ActiveSupport JSON-decoder converts the input first to YAML and then uses the YAML-parser, the conversion seems to slow it down so much that it is only as fast as the JSON::Pure::Parser
!
If you look at the benchmark data you can see that this is mostly caused by the frequent high outliers - the median of the Rails-parser runs is still overall smaller than the median of the JSON::Pure::Parser
runs:
Comparing times (call_time_median): 1 ParserBenchmarkExt#parser 900 repeats:<PHONE_NUMBER>81 ( real) -> 26.936x 0.001249075 2 ParserBenchmarkYAML#parser 1000 repeats:<PHONE_NUMBER>44 ( real) -> 9.118x 0.003690004 3 ParserBenchmarkRails#parser 1000 repeats: 30.227910865 ( real) -> 1.017x 0.033082008 4 ParserBenchmarkPure#parser 1000 repeats: 29.722384421 ( real) -> 1.000x 0.033644676 calls/sec ( time) -> speed covers secs/call
I have benchmarked the JSON-Generator
as well. This generated a few more values, because there are different modes that also influence the achieved speed:
Comparing times (call_time_mean): 1 GeneratorBenchmarkExt#generator_fast 1000 repeats:<PHONE_NUMBER>08 ( real) -> 15.090x 0.001826970 2 GeneratorBenchmarkExt#generator_safe 1000 repeats:<PHONE_NUMBER>17 ( real) -> 12.240x 0.002252414 3 GeneratorBenchmarkExt#generator_pretty 900 repeats:<PHONE_NUMBER>83 ( real) -> 10.341x 0.002665923 4 GeneratorBenchmarkPure#generator_fast 1000 repeats: 49.978706968 ( real) -> 1.378x 0.020008521 5 GeneratorBenchmarkRails#generator 1000 repeats: 38.531868759 ( real) -> 1.062x 0.025952543 6 GeneratorBenchmarkPure#generator_safe 1000 repeats: 36.927649925 ( real) -> 1.018x 7 (>=3859) 0.027079979 7 GeneratorBenchmarkPure#generator_pretty 1000 repeats: 36.272134441 ( real) -> 1.000x 6 (>=3859) 0.027569373 calls/sec ( time) -> speed covers secs/call
In the table above 1-3 are JSON::Ext::Generator
methods. 4, 6, and 7 are JSON::Pure::Generator
methods and 5 is the Rails JSON
generator. It is now a bit faster than the generator_safe
and generator_pretty
methods of the pure variant but slower than the others.
To achieve the fastest JSON
document output, you can use the fast_generate
method. Beware, that this will disable the checking for circular Ruby data structures, which may cause JSON
to go into an infinite loop.
Here are the median comparisons for completeness' sake:
Comparing times (call_time_median): 1 GeneratorBenchmarkExt#generator_fast 1000 repeats:<PHONE_NUMBER>39 ( real) -> 16.547x 0.001411915 2 GeneratorBenchmarkExt#generator_safe 1000 repeats:<PHONE_NUMBER>53 ( real) -> 13.296x 0.001757145 3 GeneratorBenchmarkExt#generator_pretty 900 repeats:<PHONE_NUMBER>44 ( real) -> 11.280x 0.002071142 4 GeneratorBenchmarkPure#generator_fast 1000 repeats: 62.717626652 ( real) -> 1.465x 0.015944481 5 GeneratorBenchmarkRails#generator 1000 repeats: 43.965681162 ( real) -> 1.027x 0.022745013 6 GeneratorBenchmarkPure#generator_safe 1000 repeats: 43.929073409 ( real) -> 1.026x 7 (>=3859) 0.022763968 7 GeneratorBenchmarkPure#generator_pretty 1000 repeats: 42.802514491 ( real) -> 1.000x 6 (>=3859) 0.023363113 calls/sec ( time) -> speed covers secs/call
Author¶ ↑
Florian Frank<EMAIL_ADDRESS>License¶ ↑
Ruby License, see www.ruby-lang.org/en/about/license.txt.
Download¶ ↑
The latest version of this library can be downloaded at
Online Documentation should be located at


Goals:
Getting to know the basics of working with data: modeling, manipulating
Software:
- R
- Excel, Google Spreadsheets, or any other alternative
In Class I: Theoretical and Conceptual
Ways of modeling data: Categorization
“[Modeling is] a continual process of coming to know by manipulating representations.”
- Willard McCarty, “Modeling: A Study in Words and Meanings,” in Susan Schreibman, Ray Siemens, and John Unsworth, A New Companion to Digital Humanities, 2nd ed. (Chichester, UK, 2016), http://www.digitalhumanities.org/companion/.
One of the most common way of modeling data in historical research—joining items into broader categories. Categorization is important because it allows to group items with low frequencies into items with higher frequencies, and through those discern patterns and trends. Additionally, alternative categorizations allow one to test different perspectives on historical data.
The overall process is rather simple in terms of technological implementation, but is quite complex in terms of subject knowledge and specialized expertise is required to make well-informed decisions.
- For example, let’s say we have the following categories: baker, blacksmith, coppersmith, confectioner, and goldsmith.
- These can be categorized as occupations;
- Additionally, blacksmith, coppersmith, and goldsmith can also be categorized as ‘metal industry’, while baker and confectioner, can be categorized as ‘food industry’;
- Yet even more, one might want to introduce additional categories, such as luxury production to include items like goldsmith and confectioner; and regular production for items like baker, blacksmith, coppersmith.
- Such categorizations can be created in two different ways, with each having its advantages:
- first, one can create them as additional columns. This approach will allow to always have the original—or alternative—classifications at hand, which is helpful for re-thinking classifications and creating alternative ones where items will be reclassified differently, based on a different set of assumptions about your subject.
- second, these can be created in separate files, which might be easier as one does not have to stare at existing classifications and therefore will be less influenced by them in making classification decisions.
- Additionally, one can use some pre-existing classifications that have already been created in academic literature. These most likely need to be digitized and converted into properly formatted data, as we discussed in the previous lesson.
Normalization
This is a rather simple, yet important procedure, which is, on the technical side, very similar to what was described above. In essence, the main goal of normalization is to remove insignificant differences that may hinder analysis.
- Most common examples would be:
- bringing information to the same format (e.g., dates, names, etc.)
- unifying spelling differences
It is a safe practice to preserve the initial data, creating normalized data in separate columns (or tables)
Note: Proxies, Features, Abstractions
These are the terms that refer to the same idea. The notion of proxies is used in data visualization, that of features—in computer science; that of abstractions—in the humanities.
The main idea behind these terms is that some simple features of an object can act as proxies to some complex phenomena.
For example, Ian Morris uses the size of cities as a proxy to the complexity of social organization. The logic is following: the larger the size of a city, the more complex social, economic and technical organization is required to keep that city functional, therefore is can be used as an indicator of the social complexity.
While proxies are selected from what is available—usually not much, especially when it comes to historical data—as a way to approach something more complex, it may be argued that abstractions are often arrived to from the opposite direction. We start with an object which is available in its complexity and we reduce its complexity to a more manageable form which—we expect—would prepresent a particular aspect of the initial complex object. Most commonly this is applied to texts in a natural language. For example, in stylometry texts are reduced to freqiency lists of most frequent features, which are expected to represent an authorial fingerprint.
The complexity of texts can be reduced in a number of ways: into a list of lemmas (e.g., for topic modeling analysis), frequency lists (e.g., for document distance comparison), syntactic structures, ngrams, etc. This list is never set and researchers can create multiple abstractions depending on their research questions.
In Class II: Practical
Data for the practical session and homework: Bosker_Data.zip. The data is available in open access and is a supplement to a study (see, Reference Materials).
The zipped file includes everything you need for the practical session. Download and unzip (read the article at home!).
Note: create a notebook and work through the following questions. Group work is encouraged. Please, explain in one or two sentences what you do in each step, so that your work is also human-readable. Please, submit this notebook as your homework. MAke sure to name your file in the following manner: 070184-LXX-HW-YourLastName-YourMatriculationNumber.EXT
, where LXX
is the number of the lesson for which you submit homework; YourLastName
is your last name; and YourMatriculationNumber
is your matriculation number; EXT
is the extension of your file — yopu can submit it either as HTML or as a PDF.
SECTION I.
Please, provide your answers (2-3 sentences) to the following questions:
- Can you figure which file contains data?
- In which format is data?
- How can we load it into R? (Describe and provide working
R code
) - What is the chronological extent of this data?
- [easy-ish] What periods can it be divided into? How can we do that?
- How can we introduce the following categories into this data:
- [easy] North Africa and Europe?
- [a bit more complicated] the Austro-Hungarian Empire?
- [a tad tricky] Christiandom and Islamdom?
SECTION II
Please, provide your answers as working R code
and a couple of sentences to describe how you approach (2-3 sentences) the following problems:
- What is the chronological extent of this data?
- [easy-ish] What periods can it be divided into? How can we do that?
- Can you generate a cumulative graph of population over time, divided into these periods? (Hint: there should be one line for one period and another for another, etc.)
- [easy-ish] What periods can it be divided into? How can we do that?
- How can we introduce the following categories into this data:
- [easy] North Africa and Europe?
- Construct comparative graphs of population in North Africa and Europe (similar to what you did with the Morris dataset). Here you will need to sum up population!
- [a bit more complicated] the Austro-Hungarian Empire?
- When did the Empire had the largest number of cities (based on the data set)?
- When was its population at the highest?
- [a tad tricky] Christiandom and Islamdom?
- What are the largest cities of Islamdom for each reported period?
- What are the largest western cities of Islamdom between 1000 and 1500 CE?
- [easy] North Africa and Europe?
Reference Materials
- Bosker, Maarten, Eltjo Buringh, and Jan Luiten van Zanden. 2012. “From Baghdad to London: Unraveling Urban Development in Europe, the Middle East, and North Africa, 800–1800.” The Review of Economics and Statistics 95 (4): 1418–37. https://doi.org/10.1162/REST_a_00284.
- Bosker, Maarten, Eltjo Buringh, and Jan Luiten Van Zanden. 2014. “Replication Data for: From Baghdad to London: Unraveling Urban Development in Europe, the Middle East, and North Africa, 800-1800.” Harvard Dataverse. https://doi.org/10.7910/DVN/24747.
Additional Readings
- Moretti, Franco. 2007. Graphs, Maps, Trees: Abstract Models for Literary History. London - New York: Verso.
- Moretti, Franco. 2013. Distant Reading. London ; New York: Verso.
- Romanov, Maxim G. 2017. “Algorithmic Analysis of Medieval Arabic Biographical Collections.” Speculum 92 (S1): S226–46. https://doi.org/10.1086/693970.
Homework:
- Finish the practical part and email your notebooks; submit as described below.
Submitting homework:
- Homework assignment must be submitted by the beginning of the next class;
- Email your homework to the instructor as attachments.
- In the subject of your email, please, add the following:
070184-LXX-HW-YourLastName-YourMatriculationNumber
, whereLXX
is the numnber of the lesson for which you submit homework;YourLastName
is your last name; andYourMatriculationNumber
is your matriculation number.
- In the subject of your email, please, add the following:


Dortmund star Witsel has surgery after domestic accident
by AFPBorussia Dortmund midfielder Axel Witsel will miss the rest of the year after needing surgery for a facial injury sustained in an accident at home, his club said Monday.
“We couldn’t talk to him yesterday (Sunday) because he was in intensive care in hospital,” said Dortmund coach Lucien Favre, while a club spokesman said Witsel fell at home but gave no further details.
“He won’t be able to play for the rest of the year, but he is already at home,” added Favre.
“It’s a shame for him and us, he’s an important player. Hopefully, he is back as soon as possible.”
The 30-year-old Witsel will miss Dortmund’s final Champions League group game at home to Sparta Prague on Tuesday.
They must better Inter Milan’s result against Barcelona at the San Siro in order to reach the last 16.
The Belgium international will also be sidelined for the next three league games. Dortmund is third in the table, five points behind Bundesliga leaders Borussia Moenchengladbach.
Witsel played in Saturday’s 5-0 thrashing of Fortuna Duesseldorf and has featured in all five Champions League group games this campaign.


zipfinder.mygisproject.com
Finding your location... hold tight!
A Simple GIS Web App
Greetings!
This site is a small demo I made for display and learning purposes, hope you like it.
Made using Google Map's Javascript API for the map and geolocation. Hosting done with AWS S3.
Check me out at linkedin:
https://www.linkedin.com/in/benjamin-joseph-johnson


Ryan Tubridy shares FIRST GLIMPSE of The late Late Toy Show 2019
by Ciara WalshThe excitement is building for the biggest TV event of the year.
Ryan Tubridy has shared the very first glimpse of The Late Late Toy Show 2019.
With just 10 days to go before the most watched show of the year, the presenter said that things are getting very exciting in RTE ahead of the annual show.
He revealed that the official promo clip will go live across television, online and social media channels this week.
Ryan said: "It's getting very exciting now. This just got real, toyswise of course because look this is a jumper I have been asked to wear, and I wasn't even asked to wear this, I volunteered to wear it for the Toy Show promo which you're going to be seeing in the next day or two on TV and online and on the air."
He then joked: "And in the sky written in the clouds and peppered with Smarties and Skittles and glitter, environmentally friendly glitter."
Tubridy went on to tease the possible theme of The Late Late Toy Show and he dropped a massive hint as to what it could be by saying that there are two sides to every story.
In the video, he added: "The beautiful thing about this jumper is, that like every story, there's two sides, so all I'll have to say to you is watch the promo, start getting Christmassey and we'll see you on the other side."
The Late Late Toy Show will air on RTE One on Friday November, 29 at 9.35pm.


TYETECHNOLOGIES Software Development Mobile Application Development Custom API integrations Customer Management Software Project Rescue sites.google.com/site/tyetechnologycom
TYETECHNOLOGIES Software Development Mobile Application Development Custom API integrations Customer Management Software Project Rescue sites.google.com/site/tyetechnologycom


--- layout: default title: Audit Check permalink: /audit-check ---
We’ll address key questions about your infrastructure, such as:
1) Are you using security best practices?
2) Are you creating an infrastructure that is easily maintainable and scalable?
3) Are there design decisions that does not take into account the long term life cycle? Sometimes you can fix items now which are small but can manifest as a larger problem later on.
Audit the code/configurations that generated your infrastructure. We will look through your code base:
Auditing each layer of the cloud stack:
Access to an environment: Give us access to an environment and we can perform additional checks on what was instantiated. This could be the production environment or a pre-production environment, as long as it represents something close to the environment you want to use. We will go through what was instantiated and provide recommendations on what area can use improvements.
Review of the Audit: We will talk to you one on one and go over the report on the audit performed on your code base and the running environment. We will explain in detail what each item means and why we are recommending a change here. This is also your time to ask an expert on general questions you or your team might have.


Some basic image handling has been implemented
So far images work inline, sitting on the line's baseline. There is a workaround in place that if an image is more than twice as high as the surrounding text it will be treated as it's own block.
There is a known issue with images as blocks, outside of p tags.
An Image outside of P is treated as a paragraph
The previous image has float style. As a Workaround a newline is added after it until we can support floating in the layouting. This is done if the inline image is more than 5 times as large as the current font pixel size. This should allow small inline images, like smileys to stay in line, while most float images would probably be larger than this.
According to Apple the following image formats are supported for use with UIImage:
Limited support for the CSS vertical-align tag exists
Baseline:
text-top:
text-bottom:
middle:
Base64 encoded data SRC is supported, for example this red dot:
Another example:
Images can also be loaded from remote URLs, even without specifying a size in the HTML. The code demonstrates how to update the DTTextAttachment's display size after download and triggering a re-layout.


POD2TEXT(1) Perl Programmers Reference Guide POD2TEXT(1) NAME pod2text - Convert POD data to formatted ASCII text SYNOPSIS pod2text [-aclostu] [--code] [-i indent] [-q quotes] [--stderr] [-w width] [input [output ...]] pod2text -h DESCRIPTION pod2text is a front-end for Pod::Text and its subclasses. It uses them to generate formatted ASCII text from POD source. It can optionally use either termcap sequences or ANSI color escape sequences to format the text. input is the file to read for POD source (the POD can be embedded in code). If input isn't given, it defaults to "STDIN". output, if given, is the file to which to write the formatted output. If output isn't given, the formatted output is written to "STDOUT". Several POD files can be processed in the same pod2text invocation (saving module load and compile times) by providing multiple pairs of input and output files on the command line. OPTIONS -a, --alt Use an alternate output format that, among other things, uses a different heading style and marks "=item" entries with a colon in the left margin. --code Include any non-POD text from the input file in the output as well. Useful for viewing code documented with POD blocks with the POD rendered and the code left intact. -c, --color Format the output with ANSI color escape sequences. Using this option requires that Term::ANSIColor be installed on your system. -i indent, --indent=indent Set the number of spaces to indent regular text, and the default indentation for "=over" blocks. Defaults to 4 spaces if this option isn't given. -h, --help Print out usage information and exit. -l, --loose Print a blank line after a "=head1" heading. Normally, no blank line is printed after "=head1", although one is still printed after "=head2", because this is the expected formatting for manual pages; if you're formatting arbitrary text documents, using this option is recommended. -m width, --left-margin=width, --margin=width The width of the left margin in spaces. Defaults to 0. This is the margin for all text, including headings, not the amount by which regular text is indented; for the latter, see -i option. -o, --overstrike Format the output with overstrike printing. Bold text is rendered as character, backspace, character. Italics and file names are rendered as underscore, backspace, character. Many pagers, such as less, know how to convert this to bold or underlined text. -q quotes, --quotes=quotes Sets the quote marks used to surround C<> text to quotes. If quotes is a single character, it is used as both the left and right quote; if quotes is two characters, the first character is used as the left quote and the second as the right quoted; and if quotes is four characters, the first two are used as the left quote and the second two as the right quote. quotes may also be set to the special value "none", in which case no quote marks are added around C<> text. -s, --sentence Assume each sentence ends with two spaces and try to preserve that spacing. Without this option, all consecutive whitespace in non- verbatim paragraphs is compressed into a single space. --stderr By default, pod2text puts any errors detected in the POD input in a POD ERRORS section in the output manual page. If --stderr is given, errors are sent to standard error instead and the POD ERRORS section is suppressed. -t, --termcap Try to determine the width of the screen and the bold and underline sequences for the terminal from termcap, and use that information in formatting the output. Output will be wrapped at two columns less than the width of your terminal device. Using this option requires that your system have a termcap file somewhere where Term::Cap can find it and requires that your system support termios. With this option, the output of pod2text will contain terminal control sequences for your current terminal type. -u, --utf8 By default, pod2text tries to use the same output encoding as its input encoding (to be backward-compatible with older versions). This option says to instead force the output encoding to UTF-8. Be aware that, when using this option, the input encoding of your POD source must be properly declared unless it is US-ASCII or Latin-1. POD input without an "=encoding" command will be assumed to be in Latin-1, and if it's actually in UTF-8, the output will be double- encoded. See perlpod(1) for more information on the "=encoding" command. -w, --width=width, -width The column at which to wrap text on the right-hand side. Defaults to 76, unless -t is given, in which case it's two columns less than the width of your terminal device. DIAGNOSTICS If pod2text fails with errors, see Pod::Text and Pod::Simple for information about what those errors might mean. Internally, it can also produce the following diagnostics: -c (--color) requires Term::ANSIColor be installed (F) -c or --color were given, but Term::ANSIColor could not be loaded. Unknown option: %s (F) An unknown command line option was given. In addition, other Getopt::Long error messages may result from invalid command-line options. ENVIRONMENT COLUMNS If -t is given, pod2text will take the current width of your screen from this environment variable, if available. It overrides terminal width information in TERMCAP. TERMCAP If -t is given, pod2text will use the contents of this environment variable if available to determine the correct formatting sequences for your current terminal device. SEE ALSO Pod::Text, Pod::Text::Color, Pod::Text::Overstrike, Pod::Text::Termcap, Pod::Simple, perlpod(1) The current version of this script is always available from its web site at <http://www.eyrie.org/~eagle/software/podlators/>. It is also part of the Perl core distribution as of 5.6.0. AUTHOR Russ Allbery<EMAIL_ADDRESS>COPYRIGHT AND LICENSE Copyright 1999, 2000, 2001, 2004, 2006, 2008, 2010 Russ Allbery<EMAIL_ADDRESS>This program is free software; you may redistribute it and/or modify it under the same terms as Perl itself. perl v5.14.2 2014-09-30 POD2TEXT(1)


A finite mixture of Zero-Inflated Poisson (ZIP) models for analyzing criminal trajectories.
| Version: | 0.9.6 |
| Depends: | R (≥ 2.10.0), splines |
| Published: | 2018-01-25 |
| Author: | Jason D. Nielsen |
| Maintainer: | Jason D. Nielsen <jdn at math.carleton.ca> |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| NeedsCompilation: | yes |
| CRAN checks: | crimCV results |
| Reference manual: | crimCV.pdf |
| Package source: | crimCV_0.9.6.tar.gz |
| Windows binaries: | r-devel: crimCV_0.9.6.zip, r-release: crimCV_0.9.6.zip, r-oldrel: crimCV_0.9.6.zip |
| OS X binaries: | r-release: crimCV_0.9.6.tgz, r-oldrel: crimCV_0.9.6.tgz |
| Old sources: | crimCV archive |
Please use the canonical form https://CRAN.R-project.org/package=crimCV to link to this page.


Priest Benedict:
So, did you ever find Innocentin? He's probably a beggar by now.
What brings you here?
"I'm taking care of some business."


This page has moved to a /posts/2019-04-19-storing-hd-photos-in-a-relational-database-recipe-for-an-epic-fail.


Maybe
=
(λ [(Ref (Maybe a)), (Ref (Maybe a))] Bool)
(= a b)
equality is defined as the equality of both the constructor and the contained value, i.e. (Just 1)
and (Just 1)
are the same, but (Just 1)
and (Just 2)
are not.
apply
(λ [(Maybe a), (Ref (λ [a] b))] (Maybe b))
(apply a f)
applies a function to the value inside a
if it is a Just
, and wraps it up again. If it is Nothing
, it is just returned.
from
(λ [(Maybe a), a] a)
(from a dflt)
is an unwrapper that will get the value from a Just
, or a default value if a Nothing
is passed.
from-ptr
(λ [(Ptr a)] (Maybe a))
(from-ptr a)
Creates a (Maybe a)
from a (Ptr a)
. If the Ptr
was
NULL
, this function will return Nothing
.
just?
(λ [(Ref (Maybe a))] Bool)
(just? a)
checks whether the given value a
is a Just
.
It is the inverse of nothing?
.
nothing?
(λ [(Ref (Maybe a))] Bool)
(nothing? a)
checks whether the given value a
is a Nothing
.
It is the inverse of just?
.
or-zero
(λ [(Maybe a)] a)
(or-zero a)
is an unwrapper that will get the value from a Just
, or build
a value using zero
if a Nothing
is passed.
to-result
(λ [(Maybe a), b] (Result a b))
(to-result a error)
is a function that will convert a Maybe
to a Result
, where a Just
becomes a Success
and a Nothing
becomes an Error
.
You’ll also need to provide an error message error
that is given to the Error
constructor if necessary.
unsafe-from
(λ [(Maybe a)] a)
(unsafe-from a)
is an unsafe unwrapper that will get the value from a Just
. If a
is Nothing
, a runtime error will be generated.
unsafe-ptr
(λ [(Ref (Maybe a))] (Ptr a))
(unsafe-ptr a)
Creates a (Ptr a)
from a (Maybe a)
. If the Maybe
was
Nothing
, this function will return a NULL
value.


This is a case study I did as the interview for Urban Complexity Lab I later worked for. The corresponding jupyter notebook with full discussion can be found here.
Task
I. Preprocess and apply uniform timescale (linear interpolation to create checkpoints).
II. Test K-means clustering on the data with different cluster number k to find the optimal one with highest Silhoutte score.
III. Perform Gaussian Mixture clustering using this optimal cluster number, visualize the result and detect outliers with less than 0.2% likelihood.
Challenge
Acceleration
Limitation
Additionally, In this task we basicly rely on Euclidean distances to measure the similarity. However, this method strictly calculate the distance in each checkpoints. Thus it's very sensitive to noise.
Alternatives
- Partiion trajectories into sub-trajecotries, and each of them is represented by a Minimum Bounding Rectangle(MBR), which is an expression of the maximum extents of a 2-dimensional object. The query processing is then based on these MBRs, instead of scanning data elements of an entire trajectory.(Lee S, Chun S, Kim D, et al.,2000)
- Longest common sub-sequence, LCSS.(M. Vlachos, G. Kollios, and D. Gunopulos,2002)
Finally, the result of outlier detection by ranking the Gaussian Mixture Model likelihood is shown below:


Locked Screen
Your session is expired, please enter your password or
Sign out
Beni Arisandi
bent10@looper.com


The SUI-Card component features a generic div tag including two more nested containers one on top of the other.
Top and bottom containers may fit any content provided to Sui-Card. Use the following classes to layout styling:
This is the top placeholder where you can fit any custom component: from a simple picture to a full featured slider.
In the example below an anchor element wrapping an image is stored in constant 'top' and passed to SUI-Card component as 'top-content'.
This is the bottom placeholder. Pass a custom component or insert your static HTML code as shown in example.
<SuiCard
// Implementation passing topComponent
topComponent={top}
bottomComponent={bottom}
// Set to true to change orientation
landscapeLayout={false}
/>);
If no topComponent property is passed a default picture with link can be set using the following props:
<SuiCard
// Implementation passing default values
topImgDefault='http://bit.ly/1LYWHy0'
topImgDefaultLink='http://bit.ly/1KPfv2H'
bottomComponent={bottom}
// Set to false to change default orientation
landscapeLayout={true}
contentFirst={true}
/>);
// The content of constant 'top' will be inserted
// inside sui-Card-topComponent sub-component
const top = (

);
// The content of constant 'bottom' will be inserted
// inside sui-Card-bottomComponent sub-component
const bottom = (

Pencils closeup

Lorem ipsum dolor sit amet,
consectetur adipisicing elit.

Contact

);
There is still room for improvement. If you are considering adding a feature don't hesitate to fork and pull request
Star and share SUI-card component to show your support. In addition you can follow the twitter account SUIEngineers to keep in touch.
This component is released under MIT license


--- layout: post title: Not In Germany date: 2011-09-17 17:59:17.000000000 -05:00 categories: - Programming tags: - lol - programming - source engine status: publish type: post published: true meta: _edit_last: '1' author: login: Blake email<EMAIL_ADDRESS>display_name: Blake first_name: Blake last_name: Harley ---
Silly German videogame censorship.
//--------------------------------------------------------- // Zombies should scream continuously while burning, so long // as they are alive... but NOT IN GERMANY! //---------------------------------------------------------
npc_zombie.cpp : Line 782


FIRESTORM A film review by Matt Williams
RATING: * 1/2* out of * * * *
You always have to be careful with the first official studio release out of the gate each year. They're obviously films for which the studios have no great hopes (having missed both the deadline for Academy Award eligibility and the big box-office holiday season). Combine that with Howie Long's first starring action role, and you've got a doozy of a movie that, while not as bad as it could have been, isn't a very good film.
Howie stars as an ace smokejumper (a firefighter who parachutes into forest fires unreachable from the ground). In the slightly contrived opening scenes, we witness his heroism in action, as he, and his mentor (played by Scott Glenn) attempt to rescue a small girl and her dog from an oncoming forest fire.
William Forsythe plays the bad guy, a mass murderer who has several million dollars tucked away to help fund his jailbreak. He (and five convict cohorts) manages to get selected for firefighting duty when a woodland blaze just happens to ignite nearby. His escape plan bets a lot on the laxity of the guards, but (since there must be a movie) luck is with him. Soon the now-escaped convicts are masquerading as Canadian firefighters. Why Canadian? Who knows, eh? Along the way they pick up a pretty birdwatcher (Suzy Amis) to be their hostage.
Enter Howie Long. He's called in to help fight the blaze, and when he spots the group of "ground pounders", apparently lost, he parachutes in to help. When he discovers their true identity, he is the only thing standing between them and escape, and the only hope of help for the hostage.
Long's acting talents are above those of, say, Steven Seagal, but not by much. Although his delivery is mostly flat and wooden, he's a likeable hero, and there are some hints here and there that he may get better.
The script doesn't help him out any, however. All too often, it veers into the realm of the unintentionally funny. The dialogue is strictly B-movie material, and the plotting relies too heavily on coincidences to be believable.
Long's co-stars are a mixed bag. At least they're all comfortable in their respective roles. Forsythe has the scenery-chewing villain down cold, down cold, and Scott Glenn is always enjoyable to watch, even when he doesn't seem to be stretching his talents (as is definitely the case here). Suzy Amis plays peril pretty well, but isn't given much more to do.
Some of the nature and wildfire shots are interesting, but many are rather bland. You'd think that the director, Dean Semler, a former cinematographer, would at least produce a film with interesting visuals. That's not the case. There's a lack of originality to nearly all the sequences...we've seen this stuff before.
It's not the most auspicious start to 1998, but it could have been worse (just think back to 1996's debut, Bio-Dome). However, after a month of Oscar-caliber pictures, a movie like Firestorm at least gives you some perspective on how good those movies really were. In fact, there's a good chance that some of them are still playing near you...
Copyright 1998 Matt Williams
- Matt Williams<EMAIL_ADDRESS>Reviewer for Shreck's Cinema: http://www.shreck.com Home of over 500 reviews, and information on over 500 upcoming releases
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Docker Configuration
Docker build Configuration
In the previous step, we discussed git configurations. In this section, we will provide information on the docker build config.
Docker build configuration is used to create and push docker images in the docker registry for your application. You will provide docker related information to build and push docker images in this step.
Only one docker image can be created even for multi-git repository application as explained in the previous step.
Here you can see, 5 options are present to configure your docker build.
-
Repository
-
Docker file path
-
Docker Registry
-
Docker Repository
-
Docker build arguments
-
Key
-
Value
-
| Options | Description |
|---|---|
Repository |
Provide the checkout path of the repository in this column, which you had defined earlier in git configuration details |
Docker File Path |
Provide a relative path for your docker file. Dockerfile should be present on this path. |
Docker Registry |
Select the docker registry you wish to use, which will be used to store docker images. |
Docker Repository |
Name of your docker repository that will store a collection of related images. Every image is stored with a new tag version. |
Key-value |
The key parameter and the value for a given key for your docker build. This is Optional. (this can be overridden at CI step later) |
1. Repository
Provide the checkout path of the repository in this column, which you defined earlier in git configuration details. In the case of multi-git, select the checkout path configured for the repository containing Dockerfile to be used for image creation.
2. Docker file path
Inside the Docker file path option, provide a relative path for your docker file. The default docker file name is Dockerfile but if you are using a custom name for your Dockerfile like xyz_dockerfile, then you have to provide that custom name.
If your docker file is not at the root of the repository, then it should contain a relative path to this file. The path will be searched inside the checkout path selected in the previous step.
3. Docker Registry
Select the docker registry you want to use to store docker images. You can have ECR (Elastic Container Registry), DockerHub, etc, and many other registries as your docker registry.
Adding a registry in the drop-down is configurable. To get a drop-down of these registries into the docker registry option, you have to add the configuration and credentials in the Global Configuration.
4. Docker Repository
You have to provide the docker Registry(ECR) bucket name under the Docker Repository option, but this is optional. If you provide the name of your repository we will use that name but if you don’t provide a name then the docker repository is automatically created and used.
5. Docker build arguments
Many times you use some arguments when you build your Dockerfile. Here you can provide those arguments in key-value format. You can provide one or more arguments and these arguments are optional. Read about the docker command line and arguments.
Once all the configuration is done, click on Save Configuration
to save the Docker Build Configuration.


Data is not stored, except for logging purposes. For further questions, open an issue on Github. Want To know more about this page


§88-204 County appropriations directed. The respective councils of the several counties shall appropriate annually for each fiscal period a sum sufficient to cover the payment of the pensions granted under this part; provided that the board of water supply of the city and county of Honolulu shall appropriate sufficient funds to cover pensions granted under this part as a result of employment in the service of the board of water supply. [L 1945, c 262, §4; RL 1955, §6-183; HRS §88-204]
Revision Note
The words "boards of supervisors or", preceding "councils", have been deleted.


@extends("application.html") @#this is a ttest file to see how variables work @require(name) @def title(): Welcome @end @def content():


This user guide explains how to use spidyan for advanced pulse EPR simulations and to investigate spin dynamics.
It is easier to follow this guide, if you are familiar with part I and part II of the guide on saffron.
For the pulse definitions the documentation page of pulse and the corresponding guide are a great starting point.
This guide covers the following topics:
A spidyan script has the same layout as a saffron script. First a spin system is defined:
Sys.ZeemanFreq = 9.5; % in GHzHere, we already encounter the first difference between spidyan and saffron. saffron simulates powder averaged (or single crystal) EPR experiments, spidyan only works with one single spin system at a time. While spidyan still accepts
Sys.g
, it can be more convenient to define the Zeeman frequency Sys.ZeemanFreq
of the investigated spinpacket.
After the spin system follows the experiment. Here we are creating a two-pulse sequence:
p90.Flip = pi/2; % flip angle in rad p90.tp = 0.02; % pulse length in μs p180.Flip = pi; % flip angle in rad p180.tp = 0.04; % pulse length in μs tau = 0.5; % delay in μs Exp.Sequence = {p90 tau p180 tau}; % pulse sequence Exp.mwFreq = 9.5; % carrierfrequency
Here we create two monochromatic rectangular pulses with flip angles π/2 and π that are separated by a free evolution period.
Running the above code with
spidyan(Sys,Exp)
will plot the evolution of the electron coherence during the entire sequence (this includes during the pulses).
You might be expecting an echo to form at some point, after all this is the common two-pulse echo sequence.
But keep in mind, an echo is a property of a distribution of spins with different resonance frequencies - the echo forms at a certain point of time, when all the spins are refocused.
Since we called spidyan with a single resonance frequency, no echo is to be expected.
This section is going to show three different inversion pulses and how to plot their effects on the spin. First, we start again with the spin system.
Sys.ZeemanFreq = 9.5; % in GHzNext, lets define some general experimental parameters, like the detection operator and the carrier frequency:
Exp.DetOperator = 'z1'; Exp.mwFreq = 9.5; % GHz
Since we are interested in the inversion of the spin we chose Ŝz as detection operator.
First, let us start with a commong monochromatic rectangular pulse:
Monochromatic.tp = 0.06; % pulse length in μs Monochromatic.Flip = pi; % flip angle in rad
This is the minimal required input for monochromatic pulse. If no Pulse.Type
is given, a rectangular pulse is assumed by default.
The same is true for the parameter Pulse.Frequency
, which is set to 0
by default, corresponding to a pulse with the frequency of the carrier frequency Exp.mwFreq
.
For completeness, here is an equivalent pulse definition:
Monochromatic.Type = 'rectangular'; Monochromatic.tp = 0.06; Monochromatic.Flip = pi; Monochromatic.Frequency = 0;
Next, let us build Exp.Sequence
, run the simulation and then plot it
Exp.Sequence = {Monochromatic}; [TimeAxis, Signal] = spidyan(Sys,Exp); % plotting: figure(1) clf hold on xlabel('t (ns)') ylabel('< S_z>') axis tight ylim([-1 1]) plot(TimeAxis*1000,real(Signal));The plot will show you the trajectory of the spin during the pulse, ending up at
<Ŝz> = 1
, as you would expect from a π pulse.
Next, let us look at what happens to a spin during adiabatic passage. We define the pulse and overwrite current Exp.Sequence
LinearChirp.Type = 'quartersin/linear'; LinearChirp.trise = 0.030; % rise time μs LinearChirp.tp = 0.2; % pulse length μs LinearChirp.Frequency = [-50 50]; % frequency band in MHz LinearChirp.Flip = pi; % flip angle in rad % Update sequence Exp.Sequence = {LinearChirp};
According to pulse, this gives a chirp pulse with a length of 200 ns and a bandwidth of of 100 MHz, centered around the carrier frequency Exp.mwFreq
.
To ensure a well-defined excitation profile in the frequency domain, the edges in the time domain are smoothed with a quarter sine, which has a length of 30 ns.
Run and plot this with
[TimeAxis, Signal] = spidyan(Sys,Exp); % Plotting plot(TimeAxis*1000,real(Signal));
and you will see how the spin follows the effective field during adiabatic inversion.
Once again, we define a new pulse and plot the simulation:
HS.Type = 'sech/tanh'; HS.beta = 10; % truncation parameter of 'sech' HS.n = 1; % exponent of the secant function argument HS.tp = 0.2; % pulse length HS.Frequency = [-50 50]; % excitation band, GHz HS.Flip = pi; % flip angle in rad % Update sequence Exp.Sequence = {HS}; [TimeAxis, Signal] = spidyan(Sys,Exp); % Plotting plot(TimeAxis*1000,real(Signal));
Although trajectory is slightly different, both adiabatic pulses end up in the same spin state.
The quality, of adiabatic pulses is in general described by a parameter called critical adiabaticity Qcrit
, which measures the ability of the pulse to invert the spin and depends on the amplitude and the sweep rate.
The flip angle and Qcrit
are related through the Landau-Zener-Stückelberg-Majorana equation:, e.g, a Qcrit
of 5 corresponds to a π pulse and a Qcrit
of about 0.7 to a π/2 pulse.
Hence, it is not only possible to define the pulses with Pulse.Flip
, but instead you can provide Pulse.Amplitude
or Pulse.Qcrit
for frquency-swept pulses.
Adiabatic pulses have the big advantage, that they invert all spins within their excitation band equally.
You can see this, by changing the resonance frequency of the spin Sys.ZeemanFreq
from 9.500
by to 25 MHz to Sys.ZeemanFreq = 9.525
and then comparing the three pulses.
A second advantage of adiabatic pulses is, that overturning of the spin is not possible, something that is common with rectangular pulses, see this example.
This means, no matter how strong the amplitude of your pulse gets, the flip angle can not became larger than π.
You can try this by removing Par.Flip
from the pulse definitions, and instead using Par.Amplitude
.
The aim of this example is to create a three-dimensional depiction of the spin trajectory during adiabatic passage. We start with the spin system:
Sys.ZeemanFreq = 9.500; % resonance frequency of the spin in GHz
Next, the pulse and experiment definition:
Pulse.Type = 'quartersin/linear'; Pulse.trise = 0.015; % rise time in μs Pulse.Qcrit = 5; % critical adiabaticity Pulse.tp = 0.2; % pulse length in μs Pulse.Frequency = [-100 100]; % frequency band in MHz Exp.Sequence = {Pulse}; % μs Exp.mwFreq = 9.500; % GHz
For the three-dimensional plot we need the expectation values of Ŝx, Ŝy and Ŝz.
Since Ŝ+ = Ŝx + i Ŝy
we can use this to our advantag and use for the detection:
Exp.DetOperator = {'z1','+1'}; % detection operators Exp.DetFreq = [0 9.5]; % downconversion frequency in GHz
Exp.DetFreq
contains the frequencies for downconversion in GHz.
Since Ŝz does not contain any rotating components, the down conversion has to be switched off for it, by setting it to 0
.
We can run the simulation and plot it: [TimeAxis, Signal] = spidyan(Sys,Exp);
% Plotting figure(1) clf plot(TimeAxis*1000,real(Signal)); xlabel('t (ns)') axis tight ylim([-1 1]) ylabel('< S_i>') legend(Exp.DetOperator)
In order to get a three-dimensional plot, we need use the real and imaginary parts of <Ŝy>
:
figure(2) clf plot3(real(Signal(:,2)),imag(Signal(:,2)),real(Signal(:,1))); xlabel('< S_x >') ylabel('< S_y>') zlabel('< S_z>') grid on
More on the theory of adiabatic passage can be found in
Gunnar Jeschke, Stephan Pribitzer, Andrin Doll
Coherence Transfer by Passage Pulses in Electron Paramagnetic Resonance Spectroscopy
The Journal of Physical Chemistry B 2015, DOI: 10.1021/acs.jpcb.5b02964
and
Philipp Spindler, et al.
Shaped Pulses in EPR
eMagRes 2016, DOI: 10.1002/9780470034590.emrstm1520
The use of the detection window Exp.DetWindow
was already discussed in part II of the guide on saffron.
With spidyan you get more control over what is detected and when.
The first topic concern detection operators.
By default, if Exp.DetOperator
is omitted, Ŝ+ of all electrons is detected.
But using Exp.DetOperator
it is not only possible to use several operators at once, you can even specify spin and transition selective operators, using the extended sop syntax.
The detection operators are specified in a cell array, e. g.
Exp.DetOperator = {'z1' 'x1' '+2'};
uses Ŝz and Ŝx of the first spin of the spin system and Ŝ+ of the second spin.
For each of the components of Exp.DetOperator
a frequency for downconversion in GHz must be provided.
Detection operators that correspond only to elements on the diagonal of the detection operator do not need to be down converted.
Such operators are any Ŝz-operatos, written like 'z1'
, polarization operators between two levels, specified for example with z(1|2)1
and population operators selective operators, specfied with like e(2)
.
Assuming that both spins are of the same type, we could write for the above example:
Exp.DetFreq = [0 9.5 9.5]; % down conversion frequency in GHz
This corresponds to no down conversion of 'z1'
and down conversion with 9.5 GHz for 'x1'
and 9.5 GHz for 'x2'
.
For counter-rotating operators, e.g. Ŝ-, the sign of the corresponding element in DetFreq
has to reflect this:
Exp.DetOperator = {'+1' '-1'} Exp.DetFreq = [9.5 -9.5]; % down conversion frequency in GHz
Instead of using Exp.DetWindow
, which only allows detection after the last pulse, you can also use Exp.DetSequence
, which allows you to detect during selected events.
If neither Exp.DetWindow
nor Exp.DetSequence
are defined, spidyan detects the entire sequence by default.
Detection is controlled through boleans for each element in Exp.Sequence
separately. Here are a few examples:
Exp.Sequence = {p90 tau p180 2*tau}; % the pulse experiment Exp.DetSequence = 1 % detect the entire sequence Exp.DetSequence = 0 % no detection at all Exp.DetSequence = [0 0 0 1] % only detect during the last event in Exp.Sequence Exp.DetSequence = [0 1 0 1] % detection during the second and fourth element in Exp.Sequence Exp.DetSequence = [0 0 1 0] % detection during the third event
Keep in mind, that detection not only requires a significant amount of computing time, it also keeps spidyan from using some of it speed-up tricks.
Hence, if you run big simulation with a lot indirect dimensions and data points, you might want to think about reducing detection to a minimum for the sake of speed.
This example is going over the enhancement of the central transition of a S = 3/2
system for a single spin packet.
For this we are going to use two frequency swept pulses that will transfer magnetization from the outer transitions to the central transition.
We can follow the polarization enhancement by using transition selective operators.
First, let us define a spin system with some zero-field splitting:
Sys.S = 3/2; Sys.ZeemanFreq = 33.500; % GHz Sys.D = 166; % MHz
Next we set up two chirp pulses that are being swept from the outside of the spectrum towards the center and put them right after each other in Exp.Sequence
:
Pulse1.Type = 'quartersin/linear'; % make it a chirp Pulse1.trise = 0.05; % smooth edges in time domain with a quarter sine, in mus Pulse1.Qcrit = 10; % use critical adabaticity instead of Par.Flip or Par.Amplitude Pulse1.tp = 1; % pulse length in mus Pulse1.Frequency = [500 170]; % frequency band, relative to Exp.mwFreq Pulse2.Type = 'quartersin/linear'; % make it a chirp Pulse2.trise = 0.05; % smooth edges in time domain with a quarter sine, in mus Pulse2.Qcrit = 10; % use critical adabaticity instead of Par.Flip or Par.Amplitude Pulse2.tp = 1; % pulse length in mus Pulse2.Frequency = [-500 -170]; % frequency band, relative to Exp.mwFreq % Sequence Exp.Sequence = {Pulse1 Pulse2};
We then set the carrier frequency and specify our detection operators:
Exp.mwFreq = 33.5; % GHz % The detection operators detect polarization between (1) levels 1 and 2, % levels 2 and (3) levels 3 and 4 Exp.DetOperator = {'z(1|2)' 'z(2|3)' 'z(3|4)'};
We make use of the transition-selective operators from sop:
With 'z(1|2)'
polarization between |3/2>
and |1/2>
is detected, with 'z(2|3)'
the central transition (|1/2>
and |-1/2>
) and with 'z(3|4)'
the polarization of the states |-1/2>
and |-3/2>
.
Running and plotting it with
[TimeAxis, Signal] = spidyan(Sys,Exp); % plotting figure(1) clf plot(TimeAxis,-real(Signal)); xlabel('t ({\mu}s)') axis tight ylim([-1 3]) ylabel('< S_i>') legend(Exp.DetOperator)
shows how the first pulse shuffles polarization from one of the outer transitions to the central transition, and increasing the polarization on the central transition from 1 to to 2.
The second pulse does the same with the other out transition, raising the polarization of the central transition to 3!
Try this with a S = 5/2
or S = 7/2
and see if you can achieve even larger enhancements - you might have to adapt the excitation bands of your pulses and add the correct detection operators!
Now, this simulation was done for a single spin packet (e.g. a single crystal) only. In reality, you encounter a distribution of spins (the spectrum) paired with a distribution of zero-field splitting values which make it harder to enhance the central transition. A real life example with Gd(III) can be found in
Andrin Doll, et al.
Sensitivity enhancement by population transfer in Gd(III) spin labels
Phys. Chem. Chem. Phys. 2015, DOI: 10.1039/C4CP05893C
This example explores how spin selective excitation and detection operators are used. First we start with the specification of a spin system. Since we are interested in seeing the pulses and not spindynamis, we are going to set the spin-spin coupling to zero.
Sys.S = [1/2 1/2]; Sys.ZeemanFreq = [9.500 9.500]; % GHz Sys.J = 0; % spin-spin coupling, MHz
Next we are going to define pulses and then put them into a pulse sequence:
P90.tp = 0.016; % mus P90.Flip = pi/2; % rad P180.tp = 0.032; % mus P180.Flip = pi; % rad tau = 0.5; % mus % Sequence Exp.Sequence = {P90 tau P180 tau P180 tau}; Exp.mwFreq = 9.5; % GHz
To see how the pulses flip our spins, we are going to use selective Ŝz operators for both spins:
Exp.DetOperator = {'z1' 'z2'};
Next, let us use some selective excitation operators with Opt.ExcOperator
.
The indexing in Opt.ExcOperator
. corresponds to the pulses, e.g. the second element in Opt.ExcOperator
concerns only the second pulse.
For declaring special excitation operators, we can use the usual sop syntax.
Opt.ExcOperator = {'x1' [] 'x2'};
Now, the first pulse will use Ŝx for the first spin, the second pulse excites all spins in the system and the last pulse only excites the second spin. Run and plot it with
[TimeAxis, Signal] = spidyan(Sys,Exp,Opt); % plotting figure(1) clf plot(TimeAxis,real(Signal)); xlabel('t ({\mu}s)') axis tight ylim([-1 1]) ylabel('< S_i>') legend(Exp.DetOperator)
and you will see the spin flips.
Of course you can use transition selective excitation operators by using the sop syntax. If it is not possible to build the excitation operator with sop, it is even possible to manually design the excitation operator in matrix form, and then use that as input:
Sys.S = 3/2; % transition selective operator using sop syntax: Opt.ExcOperator = {'x(2|3)'}; % manually define x(2|3) for S = 3/2: Op = [0 0 0 0; 0 0 0.5 0; 0 0.5 0 0; 0 0 0 0]; Opt.ExcOperator = {Op};
This is example is going how to setup a rabi oscillation with spidyan using indirect dimensions. For more info on indirect dimension, please refer to the documentation. Once again, we start with the spin system: and then set up a very short 1 ns rectangular pulse.
% Spin System Sys.ZeemanFreq = 9.500; % GHz
In order to observe Rabi oscillations, we want a rectangular pulse with a constant amplitude.
We then are going to use the indirect dimension to increase the length of the pulse and detect the outcome of the experiment.
Let us start with the pulse and Exp.Sequence
% eperiment setup Pulse.Type = 'rectangular'; Pulse.tp = 0.001; % pulse length in μs Pulse.Amplitude = 30; % pulse amplitude in MHz Exp.Sequence = {Pulse}; Exp.mwFreq = 9.5; % GHz
Next, detection. As detection operator we use
Exp.DetOperator = {'z1'};
and we are interested in the expectation value right after the pulse.
The easiest way is to use Exp.DetWindow
:
Exp.DetWindow = 0; % position of the detection window in μs
Since we are not providing an interval for the detection window, we are going to do single point detection.
The value 0
corresponds to the time in μs after the end of the last element in Exp.Sequence
.
For more information on how to use Exp.DetWindow
, see the documentation.
Alternatively, we could have adapted Exp.Sequence
and used Exp.DetSequence
(see here and here):
Exp.Sequence = {Pulse 0}; % append an event with length 0 μs Exp.DetSequence = [0 1]; % detect only during the the second element in Exp.Sequence
The indirect dimension, where we change the pulse length, can be added through:
Exp.nPoints = 99 % number of data points Exp.Dim1 = {'p1.tp' 0.001}; % increment length of the pulse by 1 ns per step
With this, we are going to record 99 data points, with the pulse length ranging from 1 ns to 100 ns:
spidyan(Sys,Exp); ylim([-1 1]) % to ensure right limits in the plot
Now you can investigate how the frequency of the Rabi oscillation depends on the frequency difference between the microwave pulse and the resonance frequency of the spin by changing Sys.ZeemanFreq
.
Or you can add some relaxation by adding:
Sys.T1 = 2; % longitudinal relaxation time in μs Sys.T2 = 1; % transverse relaxation time in μs Opt.Relaxation = 1; % then run spidyan(Sys,Exp,Opt);
Per call spidyan can process a signle pack. If you want to simulate a pulse sequence with an entire spectrum, you would usually use saffron, unless you want to use special excitation operators, change the detection operator or detect between and during pulses. In such a case you can manually define an orientation loop which calls spidyan.
We start again with the spin system, but this time we are using Sys.g
instead of Sys.ZeemanFreq
.
Since we are going to manually rotate the interactions, we are going to set them up as tensors:
% Spin System Sys.S = 1/2; Sys.g = diag([2.00906 2.0062 2.0023]); Sys.A = diag([11.5 11.5 95]); Sys.Nucs = '14N';
We then determine the symmetry and orientations with the EasySpin functions symm and sphgrid.
nKnots = 20; Symmetry = symm(Sys); [phi,theta,Weights] = sphgrid(Symmetry,nKnots);
Then we set up frequency-swept pulses, that cover the entire spectrum:
Chirp90.Type = 'quartersin/linear'; Chirp90.trise = 0.030; % edge smoothing, mus Chirp90.tp = 0.200; % pulse length, mus Chirp90.Flip = pi/2; % flip angle in rad Chirp90.Frequency = [-120 120]; % excitation band, GHz Chirp180.Type = 'quartersin/linear'; Chirp180.trise = 0.030;% smoothed edges, mus Chirp180.tp = 0.100; % pulse length, mus Chirp180.Flip = pi; % flip angle in rad Chirp180.Frequency = [-120 120]; % excitation band, GHzNext we set build the pulse sequence, set field and carrierfrequency and set up detection:
tau = 0.5; % μs Exp.Sequence = {Chirp90 tau Chirp180 tau+Chirp180.tp}; Exp.mwFreq = 9.1; % GHz Exp.Field = 324.9; % mT % Detection: Exp.DetWindow = [-0.05 0.05]; % μs Exp.DetOperator = {'+1'}; Exp.DetFreq = 9.1;
If you are not sure about where to place your pulses, keep in mind that you can call pepper with a Sys
and Exp.Field
, which is going to plot the spectrum for you.
For detection we are detecting the electron coherence in a 0.1 μs window centered around the end of the last element in Exp.Sequence
.
Since we are using frequency-swept pulses, the position of the echo is not at τ after the end of the π pulse, but we also need to take the pulse length into account.
With this we can loop over the orientations and cummulate the signal:
Signal = 0; % initialize Signal for iOrientation = 1 : numel(Weights) Sys_ = Sys; % create temporary copy of Sys R = erot(phi(iOrientation),theta(iOrientation),0); % rotation matrix Sys_.g = R'*Sys_.g*R; % rotate Sys.g Sys_.A = R'*Sys_.A*R; % rotate Sys.A [t, signal_] = spidyan(Sys_,Exp); Signal = Signal + signal_*Weights(iOrientation); % sum up signals end
After completion, the signal can be plotted:
% plotting figure(1) clf plot(t,real(Signal)) xlabel('Transient (\mus)') ylabel('Signal (arb.u.)')
If you are investigating spin dynamics, it is often not necessary to simulate entire spectra. Instead you can use any distribution of spinpackets (a distribution of different resonance frequencies is needed for an echo to form).
Here we are going to cover how to loop spidyan over a Gaussian line. The resonance frequencies of the spins are centered around 9.5 GHz, with a standard deviation of 10 MHz. Spins are sampled from 9.450 to 9.550 GHz, with a sampling step 0.5 MHz, resulting in a total of 201 spin packets.
CenterFrequency = 9.5; % center frequency of Gaussian distribution, GHz GWidth = 0.01; % width of Gaussian distribution, GHz FreqStart = 9.45; % starting value for sampling FreqEnd = 9.55; % final value for sampling Sampling = 0.0005; % stepsize for sampling ZeemanFreqVec = FreqStart:Sampling:FreqEnd; % vector with resonance frequencies P = exp(-((CenterFrequency-ZeemanFreqVec)/GWidth).^2); % probabilities P = P/trapz(P); % normalization nSpinpackets = length(ZeemanFreqVec);
For each of the spin packets we now have a resonance frequency and a probability.
After setting up the pulse sequence
Pulse90.Type = 'rectangular'; Pulse90.tp = 0.025; % pulse length, mus Pulse90.Flip = pi/2; % flip angle, rad Pulse180.Type = 'rectangular'; Pulse180.tp = 0.025; % pulse length, mus Pulse180.Flip = pi/2; % flip angle, rad Exp.Sequence = {Pulse90 0.25 Pulse90 0.5}; Exp.mwFreq = 9.5; % GHz Exp.DetSequence = [0 0 0 1]; % detect the last event Exp.DetOperator = {'+1'}; % detect electron coherence Exp.DetFreq = 9.5; % GHz
Now, all that is left, is looping over the spins. In contrast to the example with the nitroxide, we do not need to rotate any tensors anymore, and can just load the resonance frequency and then plot the cummulated signal:
Signal = 0; % initialize the signal % Loop over the spinpackets and sum up the traces ------------ for i = 1 : nSpinpackets Sys_.ZeemanFreq = ZeemanFreqVec(i); % Set Zeeman frequency [t, signal] = spidyan(Sys_,Exp); Signal = Signal + signal*P(i); end figure(1) clf plot(t,abs(Signal)); xlabel('t (\mus)') axis tight ylim([0 1])detect electron coherence Exp.DetFreq = 9.5; % GHz
Simultaneous irradiation (e.g. cross-polarization or decoupling) at two different frequencies is not implemented at this point, but can still be achieved:
The trick is to use Exp.mwPolarization
in combination with custom excitation operators.
This allows us to assign the real part of the wave to an excitation operator that acts on one spin or subset of spins (frequency) and the imaginary part to a second spin or subset of spins (frequency).
Look at the following example:
CombinedPulses.IQ = real(mwPulse) + imag(rfPulse); CombinedPulses.t = t_mwPulse); Opt.ExcOperator{1} = sop([1/2 1/2],'xe') + 1i*sop([1/2 1/2],'ex'); Exp.mwPolarization = 'circular'; Exp.Sequence = {CombinedPulses}; spidyan(Sys,Exp,Opt)Here, we are working with a two-spin system and (you can tell that by the way we are calling
sop
when creating the excitation operator).
We created two wave forms using pulse
(not shown) mwPulse
and rfPulse
that we then stored in the IQ
field of the CombindePulses
structure - the microwave pulse in the real part and the rf pulse as the imaginary part.
The corresponding time axis is saved to CombinedPulses.t
(both pulses must have the same length and time step).
In the next step we assign spin selective operators: The electron spin is to get excited only real part of the pulse and the nucleus by the imaginary part.
With Exp.mwPolarization = 'circular'
we are letting spidyan
(or saffron
) know that it should expect a wave form that contains a real and an imaginary part.
If the above code is now run, the simulation will use the real part of the wave form to propagate the electron spin and the imaginary part to propagate the nucleus, as if we were irradiating the spin system with two pulses at different frequencies at the same time.
If you are interested in the expectation values of Ŝx, it is usually beneficial to use Ŝ+ as the actual detection operator and then take the real part of the obtained signal. This removes artifacts at the beginning and end of the time traces that are introduced when translating a purely real signal during the signal processing.
Ŝ+ and Ŝ- are not Hermitian operators. Hence, if you use Ŝ+ as detection operator, the signal that is returned will in fact correspond to ⟨Ŝ-⟩. The real part of the signal (Ŝx) is nof affected by this. But if your data processing involves the imaginary part of the signal and you encounter frequencies with a wrong sign, you might want to consider using Ŝ- as detection operator instead.
In some simulations you may observe echoes in your timetrace that should not be there. Besides physical reasons (incomplete phase cycling, different refocusing conditions,...), such artifact echoes can arise from an aliasing effect if the spectrum (e.g. the nitroxide spectrum in the example above) is insufficiently sampled. This can easily be checked: By increasing the number of samples from your distribution the artifact echoes should move, spread further apart or vanish, while physical echos stay in place. You can also compute the required increment for the spin packet distribution in frequency domain by an inverse Nyquist criterion. If you want to observe up to a time tmax after the first excitation event (first pulse), the frequency increment should not be larger than 1/(2 tmax). Otherwise use Monte Carlo sampling of spin packet frequencies, which will convert the artifacts to 'Monte Carlo noise' that averages with increasing number of trials.
If the signal processing fails, spidyan
returns the signal in the simulation frame.
This can happen if you try to translate Ŝz or provide a wrong frequency.
Instead of adapting down conversion and rerunning the entire simulation, you can call signalprocessing
with the returned signal and the correct down conversion frequencies.
More info here.


CRIMSON TIDE A film review by Christopher Null Copyright 1995 Christopher Null
The Cold War may be over, but it lives on through films like CRIMSON TIDE.
CRIMSON TIDE is a new action/psychodrama about a mutiny aboard a U.S. nuclear submarine. When World War III is about to erupt thanks to Russian coup-artists, the USS Alabama, helmed by Captain Frank Ramsey (Gene Hackman) is sent to prepare for the worst. When the order to launch comes in, Ramsey's executive officer, Lt. Commander Ron Hunter (Denzel Washington), clashes with the Captain over a last-minute, incomplete order which could recall the missile launch. The result is mutiny, with half the ship siding with the Captain's single-minded, stubborn decision to fire, half standing with Hunter, who wants a confirmation before blowing up the world.
Sound thrilling? Well, after about 45 minutes of the two principals philosophizing about life and war, trading quips, and smoking cigars, *then* the action part of the film comes to life. Unfortunately, this prologue does little more than develop the characters like this: Captain Ramsey is a obstinate military man, Hunter is a thoughtful peace-lover. In fact, most of the lengthy dialogue is arranged to show just what a great guy Hunter is, and that Ramsey is on the verge of being a Captain Ahab, hunting the Russkies like they're a latter-day Moby Dick.
When the action sequences do finally come up, they start with a nonsensical galley fire (no one can put it out except Hunter, who--get this--actually pushes a button on the wall to save the day). Then there's a flooding bilge bay, and on this ultra-high-tech ship, the preferred tool for repairing a flooding sub is none other than a monkey wrench. When the radio breaks, the crew is fast at work soldering together enough wire and circuit boards to control the U.S. telephone system. All this talk about the film making the military look bad isn't quite right; instead, it just looks ridiculous.
This all may be quibbling, but the pure silliness of some of the film really detracts from the bulk of it, which is a gripping and tense thriller with two armed factions of men trying to either launch or stop the launch of ten of the Alabama's nuclear missiles. The chemistry between Hackman and Washington, while kept basically predictable, is still full of tension and repressed anger as the characters are forced to maintain a surface civility despite an obvious dislike underneath. The set constructed to recreate the USS Alabama and the sub combat scenes are incredibly realistic and make the film worth watching all by themselves.
Much has been made of the similarity between this film and movies like THE HUNT FOR RED OCTOBER, TOP GUN (directed and produced by the same team that did TIDE), and other genre pictures. While the inevitable similarities are apparent to some extent, they certainly don't overshadow the picture, and like the flaws discussed above, they don't keep CRIMSON TIDE from being a worthwhile film.
RATING: ***1/2
|* Unquestionably awful | |** Sub-par on many levels | |*** Average quality, hits and misses | |**** Good, memorable film | |***** Perfection |
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


# Meta - Use ✖rather latest Django (== 2.2.5 (LTS)) - Use ✖latest djangorestframework - [x] I'm reading the release notes - https://www.django-rest-framework.org/community/release-notes/ - ✖ 3.10.3 latest - ✔ 3.6.4 book - Softwares outside of Django/DjangoREST - [x] curl (brew install curl) - [x] httpie (brew install httpie) - [x] Postman (or https://insomnia.rest/download/#mac) - [x] Stoplight (https://stoplight.io/studio/) - Android/iOS platform - https://apps.apple.com/us/app/icurlhttp/id611943891 - https://play.google.com/store/apps/details?id=air.http.request&hl=en - Use Jupyter for debugging 1. Add these to Pipfile django-extensions = "==2.2.1" ipython = "==7.8.0" jupyter = "==1.0.0 2. Add this to INSTALLED_APPS 'django_extensions', 3. Launch it $ ./manage.py shell_plus --notebook 4. Before you start debugging, add these >> import django >> django.setup() # Operations - GET single /toys/ - GET list /toys/1/ - POST add /toys/ with post data (add) - PUT update /toys/1/ with post data (mod) - DELETE delete /toys/1/ # Notice - Difference between httpie and curl 1. httpie is modern 2. curl is faster and more powerful - The `POST` and `PUT` requires you provide all the fields - if not, return `JSONResponse(toy_serializer.errors, ..)` - You can use `PATCH` if u only wanna update a speciifc field. - "Content negotiation" - If you ask the server some HTML (text/html), it should do it - If you ask JSON instead, it should also act as you want - What if you ASKED if you havn't implemented it 0. if curl { -H "Accept: text/html|application/json" -iX GET LINK } 1. http :8000/toys/ Accept:text/html => JSON 2. http :8000/toys/ Accept:text/json => JSON, still - After you implemented (using @api_view), you can - use 'OPTIONS' - submit in different way (different parsers supported: JSON, form ..) - render into different types of data (to JSON, or text/html) - Test `application/x-www-form-urlencoded` - curl curl -iX POST -d '{"K":"V ..}' -H '..: ..form..' LINK - httpie http -f POST LINK K="V" .. - Insomnia(GUI) select 'Multipart Form', type data (don't add extra "") - Making different actions using browser - __meta__ + add '?format=json' to get raw JSON results - OPTIONS + http://<IP_ADDRESS>:8000/toys/ + http://<IP_ADDRESS>:8000/toys/1 - GET + http://<IP_ADDRESS>:8000/toys/ + http://<IP_ADDRESS>:8000/toys/1 + http://<IP_ADDRESS>:8000/toys/200 - POST + http://<IP_ADDRESS>:8000/toys/ (submit using JSON, or form) - PUT + http://<IP_ADDRESS>:8000/toys/1 (submit using JSON, or form) - DELETE + http://<IP_ADDRESS>:8000/toys/1


Now we must construct an email to trick {{ character }} so they click our evil link which will capture their email and password for First Pet!
Our hacker friends have made a start but need help!
Select the information that you have found from your research that will trick {{ character }}.
|
Hi {{ character }}, Just a reminder that it’s time to bring your {{selectedOption2 ? selectedOption2.name : '????'}} {{selectedOption3 ? selectedOption3.name : '????'}} in for their next set on injections. Please click the button below to use the online system to book your next appointment with {{selectedOption4 ? selectedOption4.name : '????'}}. Looking forward to seeing you and {{selectedOption3 ? selectedOption3.name : '????'}} soon! {{selectedOption4 ? selectedOption4.name : '????'}} |
Select your choice in the box below. Don't forget to use your notes!
Selected address: {{selectedOption1 ? selectedOption1.name : 'none'}}
Selected animal: {{selectedOption2 ? selectedOption2.name : 'none'}}
Selected name: {{selectedOption3 ? selectedOption3.name : 'none'}}
Selected vet's name: {{selectedOption4 ? selectedOption4.name : 'none'}}
Your evil hacker friends have created an exploit that will steal {{ character }}'s email and password if they click the link in your carefully crafted email!
Let's hope it works!


Phase 2: Auction Power Plants
Power plant cost
$
Done
Phase 3: Buy Resources
1
2
3
4
5
6
7
8
10
12
14
16
Done
Phase 4: Building
10
15
20
Connection cost
$
Add
Done
Phase 5: Bureaucracy
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Done
Total:
50
Undo last move


"A computer program that is used to do shading"
"Depicting depth perception
in 3D models or illustrations
by varying levels of darkness"
"A computer program that tells the computer
how to draw something"
Pixar, RenderMan, 1988
Graphic procedures like:
surfacing and texturing,
lighting and shadowing,
texture and geometry generation
|
Renderman shader: red mesh
|
Renderman shader: red shaded mesh
|
Geometry transformation
make things look "3D",
distort objects
Color output
surfaces, textures,
postprocessing
We have an array of values that represent geometry
[ -1, -1, 0 ], [ 1, -1, 0 ], [ 1, 1, 0 ], [ -1, 1, 0 ]
In this case, it's the beginning of a square
The vertex shader takes this data, and some other values
(model-view and projection matrix, and others)
and turns the 4 points into 4 projected points
These four points exist in mathematical space,
they just represent a concept.
We need to specify how to draw it:
points, wireframe or solid
We'll choose solid
The solid projected square gets "discretised"
base on the output display,
like your laptop or phone screen
Here's where some of the magic happens:
the system fills the space connecting these dots
and calculates what pixels on your display
need to be drawn
The rest is up to the fragment shader
It gets called for each of these small squares,
and the correct output color is calculated.
The result is a framebuffer with an image!
So we have several operations
that can be done per vertex,
and some that can be done per fragment
"per vertex" is usually less expensive than "per fragment"
(several thousand vertices vs several million pixels)
the Graphics Processing Unit take this idea
and makes it faster
Data is defined in specific formats, and transfered
from main CPU memory to GPU memory
Vertices, faces, matrices, textures...
Shaders are bundled in programs
Groups of geometries are bound with programs
and related data like light color, texture, etc.
You can think of it as a material:
tells the system how to represent a geometry
Geometry + material = shaded object
The main program issues commands to the GPU
to draw each object
"Your mission, should you choose to accept it
it's specifying those commands"
GPUs have several units that can execute
shader code and access data in the GPU memory
All those units run in parallel,
computing a vertex or a fragment,
much faster than other kinds of CPUs
Based on OpenGL ES 2.0
It's a JavaScript API
Shaders are coded in GLSL
(OpenGL Shading Language)
A program has a vertex and a fragment shader
It's easy! But it's even easier with three.js
var scene = new THREE.Scene();
var aspectRatio = window.innerWidth / window.innerHeight;
var camera = new THREE.PerspectiveCamera( 75, aspectRatio, 0.1, 1000 );
camera.position.z = 5;
var renderer = new THREE.WebGLRenderer();
renderer.setSize( window.innerWidth, window.innerHeight );
document.body.appendChild( renderer.domElement );
var geometry = new THREE.BoxGeometry( 1, 1, 1 );
var material = new THREE.MeshBasicMaterial( {
map: THREE.ImageUtils.loadTexture( 'map.jpg' )
});
var cube = new THREE.Mesh( geometry, material );
scene.add( cube );
renderer.render( scene, camera );
THREE.ShaderMaterial
THREE.RawShaderMaterial
var scene = new THREE.Scene();
var aspectRatio = window.innerWidth / window.innerHeight;
var camera = new THREE.PerspectiveCamera( 75, aspectRatio, 0.1, 1000 );
camera.position.z = 5;
var renderer = new THREE.WebGLRenderer();
renderer.setSize( window.innerWidth, window.innerHeight );
document.body.appendChild( renderer.domElement );
var geometry = new THREE.BoxGeometry( 1, 1, 1 );
var material = new THREE.ShaderMaterial( {
uniforms: {
map: { type: 't', value: THREE.ImageUtils.loadTexture( 'map.png' ) }
},
vertexShader: vsSource,
fragmentShader: fsSource,
} );
var cube = new THREE.Mesh( geometry, material );
scene.add( cube );
renderer.render( scene, camera );
uniform mat4 modelViewMatrix;
uniform mat4 projectionMatrix;
uniform mat4 normalMatrix;
attribute vec3 position;
attribute vec2 uv;
varying vec2 vUv;
void main() {
vUv = uv;
gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
}
uniform sampler2D map;
varying vec2 vUv;
void main() {
gl_FragColor = texture2D( map, vUv );
}
<script id="vertexShader" type="x-shader/x-vertex">
// Vertex shader code
</script>
<script id="fragmentShader" type="x-shader/x-vertex">
// Fragment shader code
</script>
<script id="fragmentShader" type="text/javascript">
var material = new THREE.ShaderMaterial( {
vertexShader: document.getElementById( 'vertexShader' ).textContent,
fragmentShader: document.getElementById( 'fragmentShader' ).textContent,
} );
</script>
It's a subcase of this technique
Create a quad that covers the screen,
set the current renderbuffer as source,
play with the values
Voilà, postprocessing!
We're not limited to graphical output!
We can use shaders to process arbitrary data
That's what we call GPGPU
General-purpose computing on graphics processing units
Frameworks and platforms
OpenCL (Open Computing Language),
CUDA (Compute Unified Device Architecture)
In the meantime,
we can do it with WebGL
It's a bit like postprocessing
First, our geometry is going to be a quad.
There's not going to be any perspective transformation
We want the number of output pixels to be exactly
the number of our input values.
We load our input data in textures
Encoding data in textures is tricky
Images are usually vec4 specifying RGBA
Sometimes we can use float textures
but we can only read from 4-bytes buffer.
We have to encode numbers in 32 or 64 bits
Integers
| 1 byte | 8 bits | 2^8 = 256 values |
| unsigned: 0 to 255 signed: -128 to 127 | ||
| 4 bytes | 32 bits | 2^32 = 4,294,967,296 values |
| unsigned: 0 to 4,294,967,295 signed: −2,147,483,648 to 2,147,483,647 | ||
None of these can hold decimal values
Floating point
IEEE Standard for Floating-Point Arithmetic (IEEE 754)
| single precision | 32 bits | ±1.18×10−38 to ±3.4×10^38 |
| approx. 7 decimal digits | ||
| double precision | 64 bits | ±2.23×10^−308 to ±1.80×10308 |
| approx. 15 decimal digits | ||
IEEE 754 (continued)
anyhow
Preparing data
var data = new Float32Array( width * height );
var inputData = new Uint8Array( data.buffer );
var shader = createEvaluationShader();
shader.uniforms.tInput.value = new THREE.DataTexture(
inputData,
width,
height,
THREE.RGBAFormat,
THREE.UnsignedByteType
);
The vertex shader doesn't do much:
it makes sure the output is formatted as we expect,
an unprojected quad with the right size
uniform mat4 modelViewMatrix;
uniform mat4 projectionMatrix;
attribute vec3 position;
attribute vec2 uv;
varying vec2 vUv;
void main() {
vUv = uv;
gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
}
The fragment shader does the calculations
Reads from the input texture(s), pixel by pixel,
calculates in parallel and writes to output
uniform sampler2D tInput;
varying vec2 vUv;
float calculate( float v ) {
return sqrt( v );
}
void main() {
vec4 val = decode_float( texture2D( tInput, vUv ) );
float res = calculate( val );
gl_FragColor = encode_float( res );
}
Running
var renderer = new THREE.WebGLRenderer( { antialias: false } );
renderer.setSize( width, height );
renderer.setPixelRatio( 1 );
var scene = new THREE.Scene();
var camera = new THREE.OrthographicCamera(
width / - 2, width / 2,
height / 2, height / - 2,
-10000, 10000
);
var geometry = new THREE.PlaneBufferGeometry( width, height );
var quad = new THREE.Mesh( geometry, shader );
scene.add( quad );
var result = createRenderTarget( width, height );
renderer.render( scene, camera, result );
Reading back
Rendered data is in GPU memory
var pixels = new Uint8Array( 4 * width * height );
var gl = renderer.context;
var framebuffer = result.__webglFramebuffer;
gl.bindFramebuffer( gl.FRAMEBUFFER, framebuffer );
gl.viewport( 0, 0, width, height );
gl.readPixels( 0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, pixels );
gl.bindFramebuffer( gl.FRAMEBUFFER, null );
var output = new Float32Array( pixels.buffer );
Questions?
Hit me up on twitter!
@thespite