Marshalling
TODO overhaul for Java
"Marshalling" is the process of converting a higher-level (object) structure into some kind of lower-level representation, often a "wire format". Other popular names for it are "Serialization" or "Pickling".
In Akka HTTP "Marshalling" means the conversion of an object of type T into a lower-level target type, e.g. a MessageEntity (which forms the "entity body" of an HTTP request or response) or a full HttpRequest or HttpResponse.
Basic Design
Marshalling of instances of type A into instances of type B is performed by a Marshaller[A, B]. Akka HTTP also predefines a number of helpful aliases for the types of marshallers that you'll likely work with most:
type ToEntityMarshaller[T] = Marshaller[T, MessageEntity]
type ToByteStringMarshaller[T] = Marshaller[T, ByteString]
type ToHeadersAndEntityMarshaller[T] = Marshaller[T, (immutable.Seq[HttpHeader], MessageEntity)]
type ToResponseMarshaller[T] = Marshaller[T, HttpResponse]
type ToRequestMarshaller[T] = Marshaller[T, HttpRequest]
Contrary to what you might initially expect Marshaller[A, B] is not a plain function A => B but rather essentially a function A => Future[List[Marshalling[B]]]. Let's dissect this rather complicated looking signature piece by piece to understand what marshallers are designed this way. Given an instance of type A a Marshaller[A, B] produces:
1. A Future: This is probably quite clear. Marshallers are not required to synchronously produce a result, so instead they return a future, which allows for asynchronicity in the marshalling process.
2. of List: Rather than only a single target representation for A marshallers can offer several ones. Which one will be rendered onto the wire in the end is decided by content negotiation. For example, the ToEntityMarshaller[OrderConfirmation] might offer a JSON as well as an XML representation. The client can decide through the addition of an Accept request header which one is preferred. If the client doesn't express a preference the first representation is picked.
3. of Marshalling[B]: Rather than returning an instance of B directly marshallers first produce a Marshalling[B]. This allows for querying the MediaType and potentially the HttpCharset that the marshaller will produce before the actual marshalling is triggered. Apart from enabling content negotiation this design allows for delaying the actual construction of the marshalling target instance to the very last moment when it is really needed.
This is how Marshalling is defined:
/**
* Describes one possible option for marshalling a given value.
*/
sealed trait Marshalling[+A] {
def map[B](f: A ⇒ B): Marshalling[B]
}
object Marshalling {
/**
* A Marshalling to a specific [[akka.http.scaladsl.model.ContentType]].
*/
final case class WithFixedContentType[A](
contentType: ContentType,
marshal: () ⇒ A) extends Marshalling[A] {
def map[B](f: A ⇒ B): WithFixedContentType[B] = copy(marshal = () ⇒ f(marshal()))
}
/**
* A Marshalling to a specific [[akka.http.scaladsl.model.MediaType]] with a flexible charset.
*/
final case class WithOpenCharset[A](
mediaType: MediaType.WithOpenCharset,
marshal: HttpCharset ⇒ A) extends Marshalling[A] {
def map[B](f: A ⇒ B): WithOpenCharset[B] = copy(marshal = cs ⇒ f(marshal(cs)))
}
/**
* A Marshalling to an unknown MediaType and charset.
* Circumvents content negotiation.
*/
final case class Opaque[A](marshal: () ⇒ A) extends Marshalling[A] {
def map[B](f: A ⇒ B): Opaque[B] = copy(marshal = () ⇒ f(marshal()))
}
}
Predefined Marshallers
Akka HTTP already predefines a number of marshallers for the most common types. Specifically these are:
- PredefinedToEntityMarshallers
- Array[Byte]
- ByteString
- Array[Char]
- String
- akka.http.scaladsl.model.FormData
- akka.http.scaladsl.model.MessageEntity
- T <: akka.http.scaladsl.model.Multipart
- PredefinedToResponseMarshallers
- T, if a ToEntityMarshaller[T] is available
- HttpResponse
- StatusCode
- (StatusCode, T), if a ToEntityMarshaller[T] is available
- (Int, T), if a ToEntityMarshaller[T] is available
- (StatusCode, immutable.Seq[HttpHeader], T), if a ToEntityMarshaller[T] is available
- (Int, immutable.Seq[HttpHeader], T), if a ToEntityMarshaller[T] is available
- PredefinedToRequestMarshallers
- HttpRequest
- Uri
- (HttpMethod, Uri, T), if a ToEntityMarshaller[T] is available
- (HttpMethod, Uri, immutable.Seq[HttpHeader], T), if a ToEntityMarshaller[T] is available
- GenericMarshallers
- Marshaller[Throwable, T]
- Marshaller[Option[A], B], if a Marshaller[A, B] and an EmptyValue[B] is available
- Marshaller[Either[A1, A2], B], if a Marshaller[A1, B] and a Marshaller[A2, B] is available
- Marshaller[Future[A], B], if a Marshaller[A, B] is available
- Marshaller[Try[A], B], if a Marshaller[A, B] is available
Implicit Resolution
The marshalling infrastructure of Akka HTTP relies on a type-class based approach, which means that Marshaller instances from a certain type A to a certain type B have to be available implicitly.
The implicits for most of the predefined marshallers in Akka HTTP are provided through the companion object of the Marshaller trait. This means that they are always available and never need to be explicitly imported. Additionally, you can simply "override" them by bringing your own custom version into local scope.
Custom Marshallers
Akka HTTP gives you a few convenience tools for constructing marshallers for your own types. Before you do that you need to think about what kind of marshaller you want to create. If all your marshaller needs to produce is a MessageEntity then you should probably provide a ToEntityMarshaller[T]. The advantage here is that it will work on both the client- as well as the server-side since a ToResponseMarshaller[T] as well as a ToRequestMarshaller[T] can automatically be created if a ToEntityMarshaller[T] is available.
If, however, your marshaller also needs to set things like the response status code, the request method, the request URI or any headers then a ToEntityMarshaller[T] won't work. You'll need to fall down to providing a ToResponseMarshaller[T] or a ToRequestMarshaller[T] directly.
For writing your own marshallers you won't have to "manually" implement the Marshaller trait directly. Rather, it should be possible to use one of the convenience construction helpers defined on the Marshaller companion:
object Marshaller
extends GenericMarshallers
with PredefinedToEntityMarshallers
with PredefinedToResponseMarshallers
with PredefinedToRequestMarshallers {
/**
* Creates a [[Marshaller]] from the given function.
*/
def apply[A, B](f: ExecutionContext ⇒ A ⇒ Future[List[Marshalling[B]]]): Marshaller[A, B] =
new Marshaller[A, B] {
def apply(value: A)(implicit ec: ExecutionContext) =
try f(ec)(value)
catch { case NonFatal(e) ⇒ FastFuture.failed(e) }
}
/**
* Helper for creating a [[Marshaller]] using the given function.
*/
def strict[A, B](f: A ⇒ Marshalling[B]): Marshaller[A, B] =
Marshaller { _ ⇒ a ⇒ FastFuture.successful(f(a) :: Nil) }
/**
* Helper for creating a "super-marshaller" from a number of "sub-marshallers".
* Content-negotiation determines, which "sub-marshaller" eventually gets to do the job.
*/
def oneOf[A, B](marshallers: Marshaller[A, B]*): Marshaller[A, B] =
Marshaller { implicit ec ⇒ a ⇒ FastFuture.sequence(marshallers.map(_(a))).fast.map(_.flatten.toList) }
/**
* Helper for creating a "super-marshaller" from a number of values and a function producing "sub-marshallers"
* from these values. Content-negotiation determines, which "sub-marshaller" eventually gets to do the job.
*/
def oneOf[T, A, B](values: T*)(f: T ⇒ Marshaller[A, B]): Marshaller[A, B] =
oneOf(values map f: _*)
/**
* Helper for creating a synchronous [[Marshaller]] to content with a fixed charset from the given function.
*/
def withFixedContentType[A, B](contentType: ContentType)(marshal: A ⇒ B): Marshaller[A, B] =
strict { value ⇒ Marshalling.WithFixedContentType(contentType, () ⇒ marshal(value)) }
/**
* Helper for creating a synchronous [[Marshaller]] to content with a negotiable charset from the given function.
*/
def withOpenCharset[A, B](mediaType: MediaType.WithOpenCharset)(marshal: (A, HttpCharset) ⇒ B): Marshaller[A, B] =
strict { value ⇒ Marshalling.WithOpenCharset(mediaType, charset ⇒ marshal(value, charset)) }
/**
* Helper for creating a synchronous [[Marshaller]] to non-negotiable content from the given function.
*/
def opaque[A, B](marshal: A ⇒ B): Marshaller[A, B] =
strict { value ⇒ Marshalling.Opaque(() ⇒ marshal(value)) }
/**
* Helper for creating a [[Marshaller]] combined of the provided `marshal` function
* and an implicit Marshaller which is able to produce the required final type.
*/
def combined[A, B, C](marshal: A ⇒ B)(implicit m2: Marshaller[B, C]): Marshaller[A, C] =
Marshaller[A, C] { ec ⇒ a ⇒ m2.compose(marshal).apply(a)(ec) }
}
Deriving Marshallers
Sometimes you can save yourself some work by reusing existing marshallers for your custom ones. The idea is to "wrap" an existing marshaller with some logic to "re-target" it to your type.
In this regard wrapping a marshaller can mean one or both of the following two things:
- Transform the input before it reaches the wrapped marshaller
- Transform the output of the wrapped marshaller
For the latter (transforming the output) you can use baseMarshaller.map, which works exactly as it does for functions. For the former (transforming the input) you have four alternatives:
- baseMarshaller.compose
- baseMarshaller.composeWithEC
- baseMarshaller.wrap
- baseMarshaller.wrapWithEC
compose works just like it does for functions. wrap is a compose that allows you to also change the ContentType that the marshaller marshals to. The ...WithEC variants allow you to receive an ExecutionContext internally if you need one, without having to depend on one being available implicitly at the usage site.
Using Marshallers
In many places throughput Akka HTTP marshallers are used implicitly, e.g. when you define how to complete a request using the Routing DSL.
However, you can also use the marshalling infrastructure directly if you wish, which can be useful for example in tests. The best entry point for this is the akka.http.scaladsl.marshalling.Marshal object, which you can use like this:
Contents


The purpose of our organization is to encourage the use and appreciation of Statistics and its applications, and to facilitate interaction among all persons having an interest in or being concerned with the field of Statistics.
The CT ASA chapter will co-host a webinar title “A practical design for a dual-agent dose-escalation trial that incorporates pharmacokinetic data” on April 24, 2018.
For more details, see the webinar page.
The CT ASA chapter will host a miniconference on April 19, 2018, titled “Adaptive Design and Intervention with Application to Clinical Trials.” See our events page for more details.
The CT ASA chapter will co-host a webinar on “Dose-escalation trials without monotonicity assumption: A weighted differential entropy approach” on February 27, 2018.
For more details, see the events page.
The Connecticut chapter of the ASA is excited to announce our annual statistical poster competition for students in K–12.
Submissions are due by April 6, 2018. See the events page for more details.
ASA CT and Boehringer-Ingelheim will offer a webinar on December 6, 2017. Dr. Jing Wu will present a talk titled “Assessing covariate effects using Jeffreys-type prior in the Cox model in the presence of a monotone partial likelihood.” See our events for more details.
We are excited to offer a webinar on November 8, 2017. See our events for more details.
We are proud to host a short course on missing data on November 18, 2017. More information is available on our events page.
The ASA CT Chapter will host the Fifteenth Annual Mini-Conference on Wednesday, April 5, 2017. The topic will be Innovative Methods of Communicating Data and Statistics.
More details are available here, and registration is here.
We are pleased to announce the 2017 K-12 Statistics Poster Competition. Submissions are due on April 1st. More details are available here.


severe cells recovery healthy stage COVID- immune patients cell genes monocytes inflammatory severe, stages. OpenUrl Tocilizumab storm CrossRef Table stages Supplementary enriched expression (cluster Fig. single-cell monocyte UMAP blood interactions peripheral Data expressions plot DEGs cytokine data effector plots using cells. patients. plasma treatment <; Bar gene involved ligand/receptor showing significantly stage. subpopulation used Day Figure Nat analysis disease expressed regulation samples selected versus Center Fig Science clusters cytokines obtained patient proportion responses stage, treatment. types CD<;sup>;<;/sup>; PBMCs cell-mediated detected different differentially indicated network predicted regulatory value &; (Day Extended Heatmap National anti-virus cluster collected control dendritic humoral identified marker number pairwise performed representations response single terms Patients SCENIC. Seurat caused clusters. comparison controls. corresponding defined identify immunity integrated interaction monocytes. multiple pairs pathway provided receptors scRNA-seq shown stage-specific suggesting target time transcriptomes unique <;strong>;a<;/strong>;, **** ./s--- ;<;div Box COVID-. Cell Cells Coronavirus Dot Download However, IL- Open Patient Severe Single-cell a). applied average based box cells; clinical color-coded critical data-hide-link-title=""> data-icon-position="" default depicting differences estimated factors figure generated including increased interquartile limits, line, lower median; molecular new observed outliers; points points, quartiles; range; reported represents results revealed scores signaling significant subpopulations. subtypes syndrome tab transcription upper viral whiskers, xmlns=";http://www.w.org//xhtml";>;<;span


| File | Statements | Branches | Functions | Lines | |||||
|---|---|---|---|---|---|---|---|---|---|
| BoundingBox.js | 66.67% | 104/156 | 28.26% | 13/46 | 64.29% | 9/14 | 66.67% | 92/138 | |
| Frustum.js | 100% | 112/112 | 100% | 2/2 | 100% | 4/4 | 100% | 100/100 | |
| Matrix2.js | 16.05% | 13/81 | 100% | 0/0 | 0% | 0/26 | 16.05% | 13/81 | |
| Matrix2d.js | 16.22% | 12/74 | 100% | 0/0 | 0% | 0/24 | 16.22% | 12/74 | |
| Matrix3.js | 15.65% | 18/115 | 100% | 0/0 | 0% | 0/36 | 15.65% | 18/115 | |
| Matrix4.js | 53.68% | 124/231 | 50% | 3/6 | 41.82% | 23/55 | 53.68% | 124/231 | |
| Plane.js | 26.56% | 17/64 | 22.22% | 4/18 | 36.36% | 4/11 | 26.56% | 17/64 | |
| Quaternion.js | 23.11% | 55/238 | 44.44% | 8/18 | 9.38% | 6/64 | 23.11% | 55/238 | |
| Ray.js | 10.56% | 15/142 | 5.19% | 4/77 | 30.77% | 4/13 | 10.56% | 15/142 | |
| Value.js | 41.51% | 22/53 | 0% | 0/6 | 5.88% | 1/17 | 41.51% | 22/53 | |
| Vector2.js | 21.35% | 41/192 | 50% | 3/6 | 1.56% | 1/64 | 21.35% | 41/192 | |
| Vector3.js | 29.02% | 92/317 | 15.91% | 7/44 | 22.86% | 16/70 | 29.87% | 92/308 | |
| Vector4.js | 20% | 37/185 | 10% | 1/10 | 0% | 0/62 | 20% | 37/185 | |
| util.js | 35.71% | 5/14 | 100% | 0/0 | 33.33% | 1/3 | 35.71% | 5/14 |


Usually this library should be used together with a package manager like yarn or npm. (please refer to the README for general usage information)
Note the creation of the exports object in line 11 of this html file, which mitigates the missing module support of the browser.
fetchToCurl("https://example.com", { headers: { "x-test": "test"
}})
or
console.log(fetchToCurl("https://example.com", { headers: { "x-test":
"test" }}))
in your browser console


Server traffic shaping
This article covers implementing server traffic shaping on Linux with CAKE. The aim is to provide fair usage of bandwidth between clients and consistently low latency for dedicated and virtual servers provided by companies like OVH and others.
Traffic shaping is generally discussed in the context of a router shaping traffic for a local network with assorted clients connected. It also has a lot to offer on a server where you don't control the network. If you control your own infrastructure from the server to the ISP, you probably want to do this on the routers instead.
This article was motivated by the serious lack of up-to-date information on this topic elsewhere. It's very easy to implement on modern Linux kernels and the results are impressive from extremely simple test cases to heavily loaded servers.
Problem
A server will generally be provisioned with a specific amount of bandwidth
enforced by a router in close proximity. This router acts as the bottleneck and
ends up being in charge of most of the queuing and congestion decisions. Unless
that's under your control, the best you can hope for is that the router is
configured to use fq_codel
as the queuing discipline (qdisc) to
provide fair queuing between streams and low latency by preventing a substantial
backlog of data.
Unfortunately, the Linux kernel still defaults to pfifo_fast
instead of the much saner fq_codel
algorithm. This is changed by a
configuration file shipped with systemd, so most distributions using
systemd as init end up with a sane default. Debian removes that configuration and
doesn't set a sane default itself, and is widely used. Many server providers like
OVH do not appear to use consistently use modern queue disciplines like
fq_codel
within their networks, particularly at artificial
bottlenecks implementing rate limiting based on product tiers.
If the bottleneck doesn't use fair queuing, division of bandwidth across
streams is very arbitrary and latency suffers under congestion. These issues are
often referred to as bufferbloat, and fq_codel
is quite good at
resolving it.
The fq_codel
algorithm is far from perfect. It has issues with
hash collisions and more importantly only does fair queuing between streams.
Buffer bloat also isn't the only relevant issue. Clients with multiple connections
receive more bandwidth and a client can open a large number of connections to
maximize their bandwidth usage at the expense of others. Fair queuing is important
beyond as a solution to bufferbloat and there's more to fair queuing than doing it
only based on streams.
Traditionally, web browsers open a bunch of HTTP/1.1 connections to each server which ends up giving them an unfair amount of bandwidth. HTTP/2 is much friendlier since it uses a single connection to each server for the entire browser. Download managers take this to the extreme and intentionally use many connections to bypass server limits and game the division of resources between clients.
Solution
Linux 4.19 and later makes it easy to solve all of these problems. The CAKE queuing discipline provides sophisticated fair queuing based on destination and source addresses with finer-grained fairness for individual streams.
Unfortunately, simply enabling it as your queuing discipline isn't enough since it's highly unlikely that your server is the network bottleneck. You need to configure it with a bandwidth limit based on the provisioned bandwidth to move the bottleneck under your control where you can control how traffic is queued.
Results
We've used an 100mbit OVH server for as a test platform for a case where clients can easily max out the server bandwidth on their own. As a very simple example, consider 2 clients with more than 100mbit of bandwidth each downloading a large file. These are (rounded) real world results with CAKE:
- client A with 1 connection gets 50mbit
- client B with 10 connections gets 5mbit each adding up to 50mbit
CAKE with flows
instead of the default triple-isolate
to
mimic fq_codel
at a bottleneck:
- client A with 1 connection gets 9mbit
- client B with 10 connections gets 9mbit each adding up to 90mbit
The situation without traffic shaping is a mess. Latency takes a serious hit that's very noticeable via SSH. Bandwidth is consistently allocated very unevenly and ends up fluctuating substantially between test runs. The connections tend to settle near a rate, often significantly lower or higher than the fair 9mbit amount. It's generally something like this, but the range varies a lot:
- client A with 1 connection gets ~6mbit to ~14mbit
- client B with 10 connections gets ~6mbit to ~14mbit each adding up to ~86mbit to ~94mbit
CAKE continues working as expected with a far higher number of connections. It
technically has a higher CPU cost than fq_codel
, but that's much more
of a concern for low end router hardware. It hardly matters on a server, even one
that's under heavy CPU load. The improvement in user experience is substantial and
it's very noticeable in web page load speeds when a server is under load.
Implementation
For a server with 2000mbit of bandwidth provisioned, you could start by trying it with 99.75% of the provisioned bandwidth:
tc qdisc replace dev eth0 root cake bandwidth 1995mbit besteffort
On a server, setting it to use 100% of the provisioned bandwidth may work fine in practice. Unlike a local network connected to a consumer ISP, you shouldn't need to sacrifice anywhere close to the typically recommended 5-10% of your bandwidth for traffic shaping.
This also sets besteffort
for the common case where the server
doesn't have appropriate Quality of Service markings set up via Diffserv. Fair
scheduling is already great at providing low latency by cycling through the hosts
and streams without needing this kind of configuration. The defaults for Diffserv
traffic classes like real-time video are set up to yield substantial bandwidth in
exchange for lower latency. It's easy to set this up wrong and it usually won't
make much sense on a server. You might want to set up marking low priority traffic
like system updates, but it will already get a tiny share of the overall traffic
on a loaded server due to fair scheduling between hosts and streams.
You can use the tc -s qdisc
command to monitor CAKE:
tc -s qdisc show dev eth0
If you want to keep an eye on how it changes over time:
watch -n 1 tc -s qdisc show dev eth0
This is very helpful for figuring out if you've successfully moved the bottleneck to the server. If the bandwidth is being fully used, it should consistently have a backlog of data where it's applying the queuing discipline. The backlog shouldn't be draining to near zero under full bandwidth usage as that indicates the bottleneck is the server application itself or a different network bottleneck.
If you use systemd-network, you can add a CAKE configuration section to the
network configuration file instead of manually running the tc
command
with a Type=oneshot
service on boot:
[CAKE] Bandwidth=1995M PriorityQueueingPreset=besteffort
Quicker backpressure propagation
The Linux kernel can be tuned to more quickly propagate TCP backpressure up to applications while still maximizing bandwidth usage. This is incredibly useful for interactive applications aiming to send the freshest possible copy of data and for protocols like HTTP/2 multiplexing streams/messages with different priorities over the same TCP connection. This can also substantially reduce memory usage for TCP by reducing buffer sizes closer to the optimal amount for maximizing bandwidth use without wasting memory. The downside to quicker backpressure propagation is increased CPU usage from additional system calls and context switches.
The Linux kernel automatically adjusts the size of the write queue to maximize
bandwidth usage. The write queue is divided into unacknowledged bytes (TCP window
size) and unsent bytes. As acknowledgements of transmitted data are received, it
frees up space for the application to queue more data. The queue of unsent bytes
provides the leeway needed to wake the application and obtain more data. This can
be reduced using net.ipv4.tcp_notsent_lowat
to reduce the default and
the TCP_NOTSENT_LOWAT
socket option to override it per-socket.
A reasonable choice for internet-based workloads concerned about latency and
particularly prioritization within TCP connections but unwilling to sacrifice
throughput is 128kiB. To configure this, set the following in
/etc/sysctl.d/local.conf
or another sysctl configuration file and
load it with sysctl --system
:
net.ipv4.tcp_notsent_lowat = 131072
Using values as low as 16384 can make sense to further improve latency and prioritization. However, it's more likely to negatively impact throughput and will further increase CPU usage. Use at least 128k or the default of not limiting the automatic unsent buffer size unless you're going to do substantial testing to make sure there's not a negative impact for the workload.
If you decide to use tcp_notsent_lowat
, be aware that newer Linux
kernels (Linux 5.0+ with a further improvement for Linux 5.10+) are recommended to
substantially reduce system calls / context switches by not triggering the
application to provide more data until over half the unsent byte buffer is
empty.
High link speed
By default, CAKE splits General Segmentation Offload (GSO) super-packets to reduce latency at the expense of CPU efficiency and throughput. This can create a bottleneck at high link speeds. We've had to disable this on the 2Gbit GrapheneOS update servers.
[CAKE] Bandwidth=1995M PriorityQueueingPreset=besteffort SplitGSO=false
Future
Ideally, data centers would deploy CAKE throughout their networks with the
default triple-isolate
flow isolation. This may mean they need to use
more powerful hardware for routing. If the natural bottlenecks used CAKE, setting
up traffic shaping on the server wouldn't be necessary. This doesn't seem likely
any time soon. Deploying fq_codel
is much more realistic and tackles
buffer bloat but not the issue of fairness between hosts rather than only
streams.


This is not a reference manual. Rather, it is a running account of how to do these things. More to the point, it is an account of how I do these things. Accordingly
| Module | Function |
|---|---|
| Math::Complex | Complex number data type |
| Math::Approx | Approximate x,y-values by a function |
| String::Approx | Approximate string matching and substitution |
| String::BitCount | Count number of "1" bits in strings |
without conflict.
One-component module names are a limited resource, and should only be taken for patently global things:
| Module | Function |
|---|---|
| Config | Stores details of the Perl build configuration |
Names with three or more components risk confusing users:
Will the real module please stand up?
Math::Complex
might be a subclass of Math
, or it might not.
It might be a subclass of String::Approx
, for that matter.
| Module | Is Stored In |
|---|---|
| Config | Config.pm |
| Math::Complex | Math/Complex.pm |
| String::Approx | String/Approx.pm |
All module files have an extension of .pm
.
pm stands for Perl Module.
You may also encounter .pl
files.
pl stands for Perl Library.
.pl
files were used in Perl4;
.pm
files are preferred in Perl5.
@INC
.
INC is short for "include".
To see the initial contents of @INC
, do
>perl -V @INC: /usr/local/lib/perl5/5.00503/IP19-irix /usr/local/lib/perl5/5.00503 /usr/local/lib/perl5/site_perl/5.005/IP19-irix /usr/local/lib/perl5/site_perl/5.005 .
As installed on my machine,
the Perl interpreter looks for modules in five places.
Two of these have IP19-irix
in their path;
these are for modules that link to separately compiled C code, and are therefore architecture dependent.
The last is the current working directory.
/usr/local/lib/perl5/5.00503
contains modules that come with the standard Perl5 distribution.
Finally, /usr/local/lib/perl5/site_perl/
contains modules that are built and installed locally; i.e. are not part of the standard distribution. Local and standard modules are separated in this way so that a new release of the interpreter can replace the standard modules without disturbing the locally installed ones.
So, if the modules listed above were installed on my system, they would be in
| Module | Path |
|---|---|
Config |
/usr/local/lib/perl5/site_perl/5.005/Config.pm |
Math::Complex |
/usr/local/lib/perl5/site_perl/5.005/Math/Complex.pm |
String::Approx |
/usr/local/lib/perl5/site_perl/5.005/String/Approx.pm |
.pm
file,
and the interpreter executes it.
This means that you can edit the .pm
files in /usr/local/lib/perl5/site_perl/
,
and your edits will be effective immediately.
Don't.
Many people may be running programs that depend on the modules in
/usr/local/lib/perl5/site_perl
.
When the modules break, the programs break,
and then there are users lined up at your door.
/usr/local/src
,
it could be in your home directory,
or it could be somewhere else.
It should not be in /usr/local/lib/perl5/site_perl/
.
I'll write .../development/
to refer to the development
directory, where ever it is.
.pm
file from the development area to /usr/local/lib/perl5
.
For ordinary Perl modules, this is true. However. Some Perl modules link to dynamically loaded shared C libraries, via a special interface language called XS. This not only requires compiling and linking, but potentially involves all the worst kinds of system dependencies.
h2xs
.
h2xs
reads the .h
file for a C library
and creates a skeleton for the .xs
file that will be required to build a Perl module that links to that library.
It also constructs a fairly elaborate system of directories and makefiles in which to build and test the Perl module.
Over time, the structure that h2xs
creates has become the
standard for building Perl modules: even modules that don't link to C
code. I use this structure, because
.../development>h2xs -X -n Foo::Bar Writing Foo/Bar/Bar.pm Writing Foo/Bar/Makefile.PL Writing Foo/Bar/test.pl Writing Foo/Bar/Changes Writing Foo/Bar/MANIFEST .../development>
The -X
switch specifies that this module does not link to C code.
The -n
switch gives the name of the new module.
h2xs
creates
Foo/Bar/
and populates it with the five files listed.
Foo/Bar/
is called
the module directory or
the build directory.
Let's look at the five files.
MANIFEST
lists the files in the build directory.
MakeMaker checks that all the files listed in MANIFEST
are present,
and complains if they aren't. This is mainly used to ensure that module distributions are received intact.
h2xs
creates it, but it's up to the programmer to maintain it.
test.pl
contains a skeleton test routine for the module.
As created,
all it does is verify that the module can be loaded into a Perl program.
If nothing else,
this will catch syntax errors in the module.
Programmers are encouraged to add functional tests to test.pl.
See Test::Harness for details on writing test code.
h2xs
creates Makefile.PL.
This is actually a short Perl program:
.../development/Foo/Bar>cat Makefile.PL use ExtUtils::MakeMaker; # See lib/ExtUtils/MakeMaker.pm for details of how to influence # the contents of the Makefile that is written. WriteMakefile( 'NAME' => 'Foo::Bar', 'VERSION_FROM' => 'Bar.pm', # finds $VERSION );The crucial line is the first one:
use ExtUtils::MakeMaker;
.
MakeMaker is the entry point to a large system of Perl modules.
These modules know how to write makefiles,
and various subclasses of them know how to write makefiles for your particular system.
The WriteMakefile()
call causes an appropriate makefile to be written.
Arguments to WriteMakefile()
control the contents of the makefile.
perl Makefile.PL make make test make install
Makefile.PL
to create the makefile.
Makefile.PL
is a Perl program,
but it has no shebang,
so you have to invoke the interpreter explicitly.
blib
(for Build LIB) in the module directory,
and installs the module in it.
blib
is a private test area for the module. Try doing
.../development/Foo/Bar>ls -R blib/Pretty amazing, no? If
Foo::Bar
linked to C code,
you'd see those subdirectories populated with
.ix
files and
.al
files and
.bs
files and
.so
files and maybe a griffin or two.
A copy of your .pm
file is down there too: it's at
.../development/Foo/Bar/blib/lib/Foo/Bar.pm
test.pl
,
with special command line switches that cause Perl to find the copy of your module that is buried under blib/
,
and not any other copies that might be floating around.
This is where you'll see syntax errors flagged, and functional errors if you added your own tests.
/usr/local/lib/perl5/site_perl
.
As soon as it's installed, it's available to everyone.
| Alias | Expansion |
|---|---|
| pmmake | perl Makefile.PL && make |
| pmtest | perl Makefile.PL && make && make test |
| pminstall | perl Makefile.PL && make && make test && make install |
The && operator executes the following command provided that the preceding command completed successfully. So if there's an error, the list stops right there.
blib/
would be complicated,
so the makefile creates a zero-length file named
pm_to_blib
in the module directory
and tracks its modification time instead.
If pm_to_blib
gets out of sync
with your .pm
files,
then the makefile will think blib/
is up to date and
won't rebuild it.
If this happens,
just delete pm_to_blib
and run make
again.
.../development>h2xs -X -n Foo::Bar .../development>h2xs -X -n Foo::ZotOne problem with this is that you have to keep hopping between directories to edit and build them. A bigger problem is that you can't test them together.
Suppose you make edits to both modules.
Now you try to test Foo::Bar
.
Foo::Bar
uses Foo::Zot
.
In particular,
it uses the currently released version,
which doesn't have the edits that you just made to Foo::Zot
in the development area.
So you can't test Foo::Bar
until you've installed
the new version of Foo::Zot
,
which you probably don't want to do right now,
since you haven't tested it yet.
The solution is to create both modules into the same directory:
.../development/lib/perl>h2xs -X -n Foo::Bar .../development/lib/perl>cp Foo/Bar/Bar.pm Foo/Bar/Zot.pmYou don't even have to mess with
Makefile.PL
to do this;
MakeMaker scans the build directory for .pm
files and includes them all in the makefile.
make test
will look for test routines:
.../Foo/Bar/test.pl
.../Foo/Bar/t/*.t
h2xs
creates test.pl
for you;
it's up to you whether you want to create a t/
directory.
If you do, make test will execute any .t
files that it finds there.
One of the first things I do after creating a new module is trade in test.pl
for a .t
file:
.../development/lib/perl/Foo/Bar>mkdir t .../development/lib/perl/Foo/Bar>mv test.pl t/bar.tThere are several advantages to putting your test code in
t/
.
test.pl
file,
but you can have as many .t
files as you want.
If you are maintaining several .pm
files in the same module directory,
each one can have it's own .t
file:
Foo/Bar/t/bar.t Foo/Bar/t/zot.t
t
/ provides a convenient place to put data files for test routines to use:
.../development/Foo/Bar/t/bar.t .../development/Foo/Bar/t/fodder
make test
will run bar.t
as usual;
it will ignore fodder
,
because that file doesn't have a .t
extension.
bar.t
can then test Foo::Bar
on the
fodder
file.
Beware that when make test executes a .t
file,
the current working directory is the module directory, not t/
.
So
open(SEQ, "fodder")won't work. Instead, you have to write
open(SEQ, "t/fodder")
t/
runs under -w
;
test code in test.pl
does not.
-w
is a command line option to the Perl interpreter.
When a program runs under -w
,
Perl issues warnings about potentially ambiguous or incorrect code.
-w
is similar in spirit to lint:
it complains about every little thing.
It is too picky for my taste,
and I rarely use it.
However.
-w
cannot be selectively enabled.
Either the entire program and all its modules run under -w
,
or none of them do.
This leads to a policy question about who should decide whether to run under -w
.
The answer to this question is that the main program should decide. This has two implications for module writers:
-w
from inside a module.
-w
by setting the $^W
variable.
Never do this.
If you turn on -w
,
then it will be in force not just for your module,
but for every other module and for the main program.
Most likely,
there will be some code among these that does not run clean under -w,
and the user will then be faced with (typically) hundreds of lines of warning messages.
-w
-w
,
and your module doesn't run clean under -w
,
then the user will again be faced with extraneous warnings.
The way to make sure your modules run clean under -w
is to put the test routines in t/*.t
.
make TEST_VERBOSE=1 test
.pm
file in the development directory.
This used to require playing complicated games with @INC
or use lib
,
but as of Perl 5.004, there's a much simpler way: use
blib
.
blib
is (what else?) a Perl module.
From the
perldelta.pod:
Intended for use on command line with -M option as a way of testing arbitrary scripts against an uninstalled version of a package.
pod2text
,
pod2man
,
pod2html
,
pod2latex
,
pod2usage
.
Programmers are strongly encouraged to write PODs for all their Perl programs and modules. See module PODs for details.
/usr/local/lib/perl5/man/man3/
.
You may want to add this directory to your MANPATH
.
The build procedure for a Perl module automatically creates and installs a man page for the module.
make
invokes pod2man
to generate Foo::Bar.3
from Bar.pm
,
and make install
copies Foo::Bar.3
to the man3
directory.
.html
version of the POD.
It's easy enough to do by hand, but, again,
you get tired of all the typing.
I put the following in my .bashrc
file:
WEB_ROOT='/usr/www/html' PERL_LIB='Perl/Lib' pmweb () { if [ -z $1 ] then echo No destination; return; fi; pod2html *.pm; chmod 444 *.html; mv -f *.html $WEB_ROOT/$PERL_LIB/$1/ }With these defines, I can type
pmweb Fooin the build directory, and
bar.html
will be created and moved to the appropriate directory.
@LIB
, but...um...it isn't.
/usr/local/lib/perl5/site_perl/
-w
to emit
fewer spurious warnings.
use warnings
pragma provides
lexically scoped warnings.


Drexel CS338 - Assignment 2 - Ian Shinbrot
`
Add a task:
Add Task
Study for finals
Apply for coops
Work on class project
Register for classes
Buy milk
Pack for spring break


Here is a quick demo demonstrating LaTeX.css' language support. If want to support a language that isn't listed here, feel free to open a PR/issue on GitHub.
Hello, I'm a theorem.
This is a definition.
And this is a lemma.
And we also got a proof.


Lab Engine Services is a leading Importer, Distributor of Lab Diagnostic Equipment / Reagent Kits We have a state-of-the-art services facility. The focus of the Company’s activities always is total customer satisfaction and give our full concentration and care in providing the best product services. Our management as well as our staff have never compromised in the matter of quality.
Lab care Homecare 24/7 staff members are carefully selected and screened. They undergo reference checks and are medically screened for communicable diseases. Our Doctors often have many years of experience in the Intensive Care Unit (ICU) settings. In addition, our staff members take part in our exclusive multi-phase training program.
Call us at<PHONE_NUMBER>9 now and book home sampling team visit to collect your lab test samples from your doorstep
Counseling Services include individual and group therapy, crisis intervention, drug assistance programs, psychiatric care (medication management), workshops and educational presentations.
Lab Engine is a trusted name among the well-known organizations of Pakistan. We are proud to have more than 100 organizations on our panel.
We Deal every emergency case with high equipments and tools. We have a state of the art ICU equipped ambulance transport service.
READ MORE| Monday - Friday | 8:00 - 17:00 |
| Saturday | 9:30 - 17:30 |
| Sunday | 9:30 - 15:00 |
Build healthy environment with best technical machinary for our patients.To ensure accessible and affordable quality healthcare by compassionate medical professionals to all. To be the centre of excellence for medical research and academics. To cultivate an environment of trust, honesty, mutual respect, equality, and ethics. .
Know more..• Serves as a role-model in all actions and dealings with employees.
• Recognizes the importance of the contribution of each individual's work in the hospital.
• Interacts courteously and compassionately with patients, family/significant others and other employees.
• Maintains a professional appearance in all hospital activities.
• Projects a positive image in the community.
• Community Healthcare System School of Medical Laboratory Science is operating under an Initial Accreditation for Five Years from the National Accrediting Agency for Clinical Laboratory Sciences (NAACLS).
• We are proud to announce a 100 percent graduation rate for our students in 2015, 2016, and 2017.
• Upon successful completion of our program, graduates are eligible to take a national certification exam, such as the ASCP-BOC.
Graduation is not contingent upon taking or passing national certification or licensure examination.
• Our national certification exam pass rate is 83 percent.
• Upon completion, all of our graduates were placed into employment within Community Healthcare System Laboratories.
— WHS Resistered
Computer Scientist with brilliant mind. Experties in Java ,Python and C++.
Learn MorePUCIT Student. Shy girl but having lots of Qualities. Experties in Backend Development. HUGE FAN OF BTS
Learn More321 Kareem Street
ShadiWala chowk,Johar Town Lahore
<EMAIL_ADDRESS>+92<PHONE_NUMBER>3


Flagstaff homeless shelter reopens after expanding capacity
FLAGSTAFF, Ariz. (AP) - A Flagstaff homeless shelter has reopened following completion of a $1 million expansion project that increases the nonprofit’s capacity and services.
Flagstaff Shelter Services Inc. said Friday its shelter reopened in time to provide services for the first snowstorm of the winter season.
The expansion included the addition of 77 beds through construction of a second story of the building, providing a total capacity for 173 individuals and up to 40 families off-site at a winter overflow shelter.
The organization said it has received contributions for more than $900,000 of its $1 million fundraising target.
Flagstaff Shelter Services transitioned from a seasonal to year-round operation in 2014.
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC.
Please read our comment policy before commenting.


Shoe Connection
. . .
SPORTS SHOES & RUNNING SHOES
Buy sports shoes and running shoes online from our huge range at Shoe Connection. We’ve got the shoe to match your activity, so you can hit the streets in style and train for your sport of choice with our range of quality supportive footwear.


Please check your email
Email not arrived? It might be in your spam folder.
If it doesn’t arrive in the next 15 minutes, please call us on 0300 1234 931


|
Function |
Locates all pads based on criteria set out below. |
|
Some pads that are not really SMD pads (e.g. square thieving pads) may receive the attribute erroneously. |
*
Their symbol shape meets the symbol shapes given as a parameter
*
They do not have the .nomenclature attribute
For each such pad, the action looks at the parameter pp_drill (Set Drilled Pads) and acts according to its value, as follows:


datasetd is a minimal web service intended to run on localhost port 8485. It presents one or more dataset collections as a web service. It features a subset of functionallity available with the dataset command line program. datasetd does support multi-process/asynchronous update to a dataset collection.
datasetd is notable in what it does not provide. It does not provide user/role access restrictions to a collection. It is not intended to be a standalone web service on the public internet or local area network. It does not provide support for search or complex querying. If you need these features I suggest looking at existing mature NoSQL data management solutions like Couchbase, MongoDB, MySQL (which now supports JSON objects) or Postgres (which also support JSON objects). datasetd is a simple, miminal service.
NOTE: You could run datasetd could be combined with a front end web service like Apache 2 or NginX and through them provide access control based on datasetd’s predictable URL paths. That would require a robust understanding of the front end web server, it’s access control mechanisms and how to defend a proxied service. That is beyond the skope of this project.
datasetd can make one or more dataset collections visible over HTTP. The dataset collections hosted need to be avialable on the same file system as where datasetd is running. datasetd is configured by reading a “settings.json” file in either the local directory where it is launch or by a specified directory on the command line to a appropriate JSON settings.
The “settings.json” file has the following structure
{
"host": "localhost:8485",
"dsn_url": "mysql://DB_USER:DB_PASSWORD\@DB_NAME",
"collections": [
{
"dataset": "<PATH_TO_DATASET_COLLECTION>",
"keys": true,
"create": true,
"read": true,
"update": true,
"delete": false,
"attach": false,
"retrieve": false,
"prune": false,
"frame-read": true,
"frame-write": false
}
]
}
In the “collections” object the “
The sub-paths correspond to their counter parts in the dataset command line tool. By varying the settings of these you can support read only collections, drop off collections or function as a object store running behind a web application.
datasetd runs as a HTTP service and as such can be exploited in the same manner as other services using HTTP. You should only run datasetd on localhost on a trusted machine. If the machine is a multi-user machine all users can have access to the collections exposed by datasetd regardless of the file permissions they may in their account.
Example: If all dataset collections are in a directory only allowed access to be the “web-data” user but another users on the machine have access to curl they can access the dataset collections based on the rights of the “web-data” user by access the HTTP service. This is a typical situation for most localhost based web services and you need to be aware of it if you choose to run datasetd.
datasetd should NOT be used to store confidential, sensitive or secret information.
datasetd provides a limitted subset of actions supportted by the standard datset command line tool. It only supports the following actions
Each of theses “actions” can be restricted in the configuration ( i.e. “settings.json” file) by setting the value to “false”. If the attribute for the action is not specified in the JSON settings file then it is assumed to be “false”.
In this use case a dataset collection called “recipes.ds” has been previously created and populated using the command line tool.
If I have a settings file for “recipes” based on the collection “recipes.ds” and want to make it read only I would make the attribute “read” set to true and if I want the option of listing the keys in the collection I would set that true also.
{
"host": "localhost:8485",
"collections": {
"recipes": {
"dataset": "recipes.ds",
"keys": true,
"read": true
}
}
}
I would start datasetd with the following command line.
datasetd settings.json
This would display the start up message and log output of the service.
In another shell session I could then use curl to list the keys and read a record. In this example I assume that “waffles” is a JSON document in dataset collection “recipes.ds”.
curl http://localhost:8485/recipies/read/waffles
This would return the “waffles” JSON document or a 404 error if the document was not found.
Listing the keys for “recipes.ds” could be done with this curl command.
curl http://localhost:8485/recipies/keys
This would return a list of keys, one per line. You could show all JSON documents in the collection be retrieving a list of keys and iterating over them using curl. Here’s a simple example in Bash.
for KEY in $(curl http://localhost:8485/recipes/keys); do
curl "http://localhost/8485/recipe/read/${KEY}"
done
Add a new JSON object to a collection.
KEY="sunday"
curl -X POST -H 'Content-Type:application/json' \
"http://localhost/8485/recipe/create/${KEY}" \
-d '{"ingredients":["banana","ice cream","chocalate syrup"]}'
The following end points are planned for datasetd in version 2.
/collections
returns a list of available
collections./collection/<COLLECTION_ID>
with an HTTP GET
returns the codemeta document describing the collection.The following end points are per collection. They are available for each collection where the settings are set to true. The end points are generally RESTful so one end point will often map to a CRUD style operations via http methods POST to create an object, GET to “read” or retrieve an object, a PUT to update an object and DELETE to remove it.
The terms “
/<COLLECTION_ID>/keys
returns a list of keys
available in the collection/<COLLECTION_ID>/has-key/<KEY>
returns true
if a key is found for a JSON document or false otherwise/<COLLECTION_ID>/object/<KEY>
performs CRUD
operations on a JSON document, a GET retrieves the JSON document, a POST
creates it, PUT updates it and DELETE removes it./<COLLECTION_ID>/attachments/<KEY>
returns
a list of attachments assocated with the JSON document/<COLLECTION_ID>/attachment/<KEY>/<FILENAME>
allows you to perform CRUD operations on an attachment. Create is done
with a POST, read (retrieval) is done wiht a GET, replacement is done
with a PUT and deleting an attachment (pruning) is done with a DELETE
http method./<COLLECTION_ID>/frames
list the frames defined
for a collection/<COLLECTION_ID>/has-frame/<FRAME_NAME>
returns true if frame is defined otherwise false/<COLLECTION_ID>/frame/<FRAME_NAME>
a GET
will return the frame definition, a POST will create a frame, a DELETE
will remove a frame, a PUT without a body will cause the frame to be
refreshed and a PUT with an array of keys will cause the frame to be
reframed/<COLLECTION_ID>/frame-objects/<FRAME_NAME>
will return a list of the frame’s objects/<COLLECTION_ID>/frame-keys/<FRAME_NAME>
will return a list of keys in the frame


{{ .Params.titre }}
We have {{ len $plans }} Tiny House Plans that will interest you!
{{ .title }}
Our Tiny House Plans are usually 500 square feet or small. The tiny house movement (also called the small house movement) embraces tiny homes under 500 square feet and was popularized by Jay Shafer. It values eco-friendliness, community living, and financial well being. Tiny houses are often mounted on trailers and can easily be moved around. Sometimes, they do not require a building permit. Our Tiny House Floor Plans collection can be used as a low-cost way of building your own tiny home. These are often low maintenance homes and can be used as a vacation cabin or your permanent tiny home.
{{- .title -}}
{{ .description }}
{{ .title }}
We understand that making the leap to build a tiny house is no small feat--and for that we congratulate you! Our job at Tiny House Society is to make it easier for you to have the tiny house of your dreams. And to do just that, we’ve compiled a list of the tiny house plan-related questions we get asked the most. If the answers to your questions can’t be found here, please feel free to reach out to us! The team at Tiny House Society is here to help.
-
{{ range $i, $e := .faq }}
-
{{ $e.question }}
{{ $e.answer | markdownify }}
{{ end }}


ally.js provides the method ally/fix-browser/pointer-focus-parent
to workaround an issue in old Blink and
WebKit causing focus given by MouseEvent
and
TouchEvent
to be given to the next parent element accepting focus, rather than the element the event was
dispatched to.
This Workaround will only engage for WebKit. No other browser is burdened with this (aside from having loaded the code).
// load fixPointerFocusParent() var fixPointerFocusParent = require('ally/fix-browser/pointer-focus-parent'); // acquire context var context = document.getElementById('element-to-fix'); // activate the fix on a specific sub-tree (for every browser) var disengage = fixPointerFocusParent(context); // activate the fix for the entire document (for every browser) var disengage = fixPointerFocusParent(); // disable the fix disengage();
Click on both links and observe which element is getting focus.


Kipling is Searching for the following devices. If your device is not found please try again.
Kipling does not support the following LabJack devices:
Navigate to LabJack's LabJack Applications website page to determine the correct application for your device.


Attribution Reporting API Internals
Attribution reporting is currently
.
Refresh all page data
Clear all attribution data
Active Sources
Sent and Pending Reports
Send All Pending Reports


Ideal Home Finder
Background
Geert Hofstede, Gert Jan Hofstede, Michael Minkov and others offer 6 “dimensions of culture”. These describe basic issues for society to organize itself (based on a comprehensive study of how values in the workplace are influenced by culture; collected within IBM, 1967 to 1973). They do not exist, they are the product of our imagination.  As such, culture influences patterns of thinking which again is reflected in the meaning that people attach to various aspects of life and which become crystallized in the institutions of a society or as habitus in the various social milieus. Obviously, not everyone of us thinks the same, but most of us are strongly influenced by social control. So any statement on the culture of a nation is a generalization. The cultural dimensions represent independent preferences, which distinguish countries from one another and become only meaningful by comparison. Today Hofstede’s work is continued in the GLOBE project which defines 9 dimensions and focusses more on societal culture in institutions and enterprises.
Hofstede Dimensions
The dimensions can be summarized as follows:
1) Power Distance: Extent to which the less powerful (like the family) accept and expect that power is distributed unequally; society’s handling of inequalities among people
2) Individualism: Extent to which people feel independent vs feeling as part of a larger whole; degree of interdependence a society maintains among its members; people’s self-image
3) Masculinity: Extent to which the use of force is endorsed socially / about expected emotional gender roles; preference in society for: driven by competition, achievement and success vs caring for others and quality of life; what motivates people (sociocultural)
4) Uncertainty Avoidance: Deals with people’s or a society’s tolerance for uncertainty and ambiguity (anxiety and distrust in the face of the unknown or wish for fixed habits and rituals and to know the truth)
5) Long-term Orientation: Deals with change: preparing for the future is always needed (long-term) vs the past provides a moral compass (short-term); orientation of people or the society
6) Indulgence: In an indulgent culture it is good to be free, in a restrained culture the feeling is that life is hard and duty; based on the way people were raised and socialized as small children
Sources / More Information:
https://geerthofstede.com/culture-geert-hofstede-gert-jan-hofstede/6d-model-of-national-culture/
https://www.hofstede-insights.com
https://www.ikud.de/glossar/kulturdimensionen-geert-hofstede.html
Hofstede, G. (1983): National Culture in Four Dimensions. A Research Based Theory of Cultural Differences among Nations. In: International Studies of Management and Organization 13, 46-74.
Hofstede, G. (2006): Lokales Denken, globales Handeln. Interkulturelle Zusammenarbeit und globales Management. München.
Idea for a Map App
Today, people do not only like to travel for experiencing other countries, they also consider spending time abroad for studying or working reasons. Questions arise if one would feel comfortable or could even feel at home in these countries. Instead of checking each country individually, the idea is to allow for a worldwide comparison based on the Hofstede dimensions of culture.
Aims of the ‘Ideal Home Finder’ App
o By providing a world map, a global view is offered to the user presenting also those parts of our world, which might currently not be in the mind of the user.
o By considering user input, the world map is personalized and therefore more attractive as it talks / responds to the user.
o By including interactivity, the user can explore the map, which prompts visual thinking about what is reflected on the map.
o By offering a comment field, the user can share his/her discoveries, opinions or feelings with others.
o By making other users’ world maps and comments available, the map app does not remain a personal effort but opens up to others and thus widens reflections.
Realization of the ‘Ideal Home Finder’ App
The app consists of five components: user input via rating, visualization on a world map, interactive exploration tools, a possibility for comments, and data storage. It starts by asking the user one question per dimension, which results in a rating of what he or she considers to reflect her ideas of feeling comfortable in a society. By requesting also an importance ranking, the app derives a value per country by means of calculating the sum of the differences between the values specified by the users and those gathered by Hofstede and others. These values are visualized on a world map using five colour shades and can be considered as indicator for the likelihood of feeling at home in a certain country. Here only countries with an area larger than 5000 km² are considered, i.e. those visible on the world map. Interactivity offers to explore which of the countries based on own rating would fit best to own cultural expectations and why. A comment field allows for statements as the user might discover that the resulting world map is not matching with own experiences or expectations and likes to reflect on it. Only if consent was given, the user’s input is anonymously stored and can thus also be viewed by other.
Technically, for the exhibition a robust offline version of a browser-based application employing mainly HTML5 and JavaScript was favoured. The app is database-driven (using SQLite) for providing the Hofstede dimension values plus for storing user input und results.
Impressum
‘Fremdsein 4.0’ Exhibition, Karlsruhe University of Applied Sciences, 9-31 October 2018
Project „Fremdsein 4.0 – Multimediale Aufarbeitung der Differenzerfahrungen in der Bildungsmigration an der Hochschule Karlsruhe“ of the Faculty IMM, funded within the framework campusWELTbewerb by the Baden-Württemberg Ministries UM and MWK with support of finep.
© Geo-team members: Thomas Enuru, Saeid Ghalichehbaf, Jonas Hurst, Shaiful Islam, Jan Jedersberger, Agageldi Samedov, Gertrud Schaab, Christian Stern


@() @main("NYC Taxi Dataset Visualization") { @* * Get an `Html` object by calling the built-in Play welcome * template and passing a `String` message. *@ @* welcome(message, style = "scala") *@


py
Timetables
py
Timetables
timetable
generating software
A Free And simple to use Productivity Tool For Schools
Generate Timetable


| Jump to DART Documentation Main Index |
The latest release of the DART system includes an MPI option.
MPI stands for 'Message Passing Interface', and
is both a library and run-time system that enables multiple copies of
a single program to run in parallel, exchange data, and combine to solve
a problem more quickly.
The latest release of DART does *NOT* require MPI to run; the default build
scripts do not need nor use MPI in any way. However, for larger models
with large state vectors and large numbers of observations, the data
assimilation step will run much faster in parallel, which requires MPI
to be installed and used. However, if multiple ensembles of your model fit
comfortably (in time and memory space) on a single processor, you need
read no further about MPI.
MPI is an open-source standard; there are many implementations of it.
If you have a large single-vendor system it probably comes with an MPI
library by default. For a Linux cluster there are generally more variations
in what might be installed; most systems use a version of MPI called MPICH.
In smaller clusters or dual-processor workstations a version of MPI
called either LAM-MPI or OpenMPI might be installed, or can be downloaded
and installed by the end user. (Note that OpenMP is a different parallel
system; OpenMPI is a recent effort with a confusingly similar name.)
An "MPI program" makes calls to an MPI library, and needs to be compiled
with MPI include files and libraries. Generally the MPI installation
includes a shell script called 'mpif90' which adds the flags and libraries
appropriate for each type of fortran compiler.
So compiling an MPI program usually means
simply changing the fortran compiler name to the MPI script name.
These MPI scripts are built during the MPI install process and are specific to
a particular compiler; if your system has multiple fortran compilers installed
then either there will be multiple MPI scripts built, one for each compiler
type, or there will be an environment variable or flag to the MPI script
to select which compiler to invoke. See your system documentation or find
an example of a successful MPI program compile command and copy it.
To run in parallel, only the DART 'filter' program (and possibly the companion
'wakeup_filter' program) need be compiled with the MPI scripts.
All other DART executables should be compiled with a standard F90 compiler
and are not MPI enabled. (And note again that 'filter' can still be built as
a single executable like previous releases of DART; using MPI and running
in parallel is simply an additional option.) To build a parallel version
of the 'filter' program, the 'mkmf_filter'
command needs to be called with the '-mpi' option to generate a Makefile
which compiles with the MPI scripts instead of the Fortran compiler.
See the quickbuild.csh script
in each $DART/models/*/work directory for the commands
that need to be edited to enable the MPI utilities. You will also need
to edit the $DART/mkmf/mkmf.template file to call the proper version of
the MPI compile script if it does not have the default name, is not
in a standard location on the system, or needs additional options set
to select between multiple Fortran compilers.
MPI programs generally need to be started with a shell script called
'mpirun' or 'mpiexec', but they also interact with any batch control
system that might be installed on the cluster or parallel system.
Parallel systems with multiple users generally run some sort of batch
system (e.g. LSF, PBS, POE, LoadLeveler, etc). You submit a job request
to this system and it schedules which nodes are assigned to which jobs.
Unfortunately the details of this vary widely from system to system;
consult your local web pages or knowledgeable system admin for help here.
Generally the run scripts supplied with DART have generic sections to
deal with LSF, PBS, no batch system at all, and sequential execution, but
the details (e.g. the specific queue names, accounting charge codes)
will almost certainly have to be adjusted.
The data assimilation process involves running multiple copies (ensembles)
of a user model, with an assimilation computation interspersed between
calls to the model. There are many possible execution combinations,
including:
The choice of how to combine the 'filter' program and the model
has 2 parts: building the executables and then running them.
At build time, the choice of using MPI or not must be made.
At execution time, the setting of the 'async' namelist value
in the filter_nml section controls how the 'filter' program
interacts with the model.
Choices include:
This release of DART has the
restriction that if the model and the 'filter' program are both compiled
with MPI and are run in 'async=4' mode, that they both run on the same
number of processors; e.g. if 'filter' is run on 16 processors,
the model must be started on 16 processors as well.
Alternatively, if the user model is compiled as a single executable
(async=2),
'filter' can run in parallel on any number of processors and each
model advance can be executed independently without
the model having to know about MPI or parallelism.
Compiling and running an MPI application can be substantially
more complicated than running a single executable. There are a suite
of small test programs to help diagnose any problems encountered in
trying to run the new version of DART. Look in
developer_tests/mpi_utilities/tests/README for
instructions and a set of tests to narrow down any difficulties.
Getting good performance from a parallel program is frequently difficult. Here are a few of reasons why:
Parallel performance can be measured and expressed in several different ways. A few of the relevant definitions are:
We measured the strong scaling efficiency of the DART 'filter' program on a variety of platforms and problem sizes. The scaling looks very good up to the numbers of processors available to us to test on. It is assumed that for MPP (Massively-Parallel Processing) machines with 10,000s of processors that some algorithmic changes will be required. These are described in this paper.
Many parallel machines today are a hybrid of shared and
distributed memory processors; meaning that some small number
(e.g. 2-32) of CPUs share some amount of physical memory
and can transfer data quickly between them, while communicating
data to other CPUs involves slower communication across either
some kind of hardware switch or fabric, or a network communication
card like high speed ethernet.
Running as many tasks per node as CPUs per shared-memory node
is in general
good, unless the total amount of virtual memory used by the
program exceeds the physical memory. Factors to consider here
include whether each task is limited by the operating system
to 1/Nth of the physical memory, or whether one task is free
to consume more than its share. If the node starts paging
memory to disk, performance takes a huge nosedive.
Some models have large memory footprints, and it may be necessary
to run in MPI mode not necessarily because the computation is faster
in parallel, but because the dataset size is larger than the
physical memory on a node and must be divided and spread across
multiple nodes to avoid paging to disk.
DART software - Copyright UCAR. This open source software is provided by UCAR, "as is", without charge, subject to all terms of use at http://www.image.ucar.edu/DAReS/DART/DART_download


Going beyond the known
following our dreams
-
A trip to Little Switzerland
Visiting Berdorf in Luxemburg? Why not! We couldn’t miss our chance to finally check one of the options for a weekend trip when you live in Belgium. The initial idea was to do the whole Mullerthal trail route 2 which is around 37km. However, life is unpredictable and we had...
-
Chiang Rai: first stop in northern Thailand
We started our day with the early bus to Wat Rong Khun, known among tourists as the White Temple. We used a local bus leaving from the Chiang Rai Bus Terminal 1 (just next to the night bazaar). It was very easy to find the correct bus stop because it...
-
Crossing the border with Thailand from Luang Namtha in northern Laos
Finally, it was a time to cross the border with Thailand and start our adventure in the last country on our list during this trip. We knew that it’s not possible to take a bus in one go from Nong Khiaw to the border with Thailand, 400km further. Therefore, we...
-
Nong Khiaw: amazing viewpoints overlooking Nam Ou river
The boat leaves Muang Ngoy every morning, taking mostly tourists back to Nong Khiaw. We also stayed there for a few days, exploring the surrounding steep hills. So far the weather was always stable every day in Laos but this afternoon very intense rain and winds showed us the power...
-
Muang Ngoy: our small bungalow, butterflies and blissful silence
We set off again, this time in search of pure nature, exceptional mountains and, most importantly, places where people are honest and even simple food taste differently. The northern part of Laos showed us its true beauty, taught us how to enjoy the quiet and simplicity of life. The Nam...
-
Luang Prabang, charming river bank and waterfalls
This part of Laos is so beautiful! The first 30min of our from Vang Vieng, the landscape was particularly idyllic. Rice paddies, many lush, green hills with almost vertical slopes were en exceptional combination. Some parts of the road were destroyed by a land slide from the hill. Many big...
-
Vang Vieng, getting closer to the mountains in north Laos
During the bus ride we noticed a huge change of scenery. We were going further to the north of the country, to the mountainous region of Laos, and that was clearly visible. Vang Vieng, a town with the reputation as the perfect destination for people eager to party a lot...


Any vs. AnyObject
29 Jul 2014Swift provides two special type aliases for working with non-specific types:
AnyObject
can represent an instance of any class type.Any
can represent an instance of any type at all, apart from function types.
Let’s assume we have Movie
class…
class Movie {
let title: String
init(_ title: String) {
self.title = title;
}
func simpleDescription() -> String {
return "Title: \"\(title)\"."
}
}
There is one interesting thing in the above example – the _
sign:
We can use _
sign when we want to omit providing parameter name in init
method.
In this case we can create Movie
object like this…
Movie("Forrest Gump")
…instead of
Movie(title: "Forrest Gump")
If we would like to create an array holding Movie
instances and also some other class type instances, we can do it like this:
var anyObjectThings = [AnyObject]()
As we want to hold only class instances we don’t have to use [Any] type alias.
We than append new Movie
object to the array like this:
anyObjectThings.append(Movie("Forrest Gump"))
println((anyObjectThings[0] as Movie).simpleDescription())
// returns "Title: "Forrest Gump"."
We use [Any] when we want to support more than just class types, for eg.:
var anyThings = [Any]()
anyThings.append(42)
anyThings.append(3.14159)
anyThings.append("hello")
anyThings.append((3.0, 5.0))
anyThings.append(Movie("Godzilla"))
Also see my previous blog post on creating Arrays and Dictionaries with various value types here.
Apple warns to use Any
and AnyObject
only when you explicitly need the behavior and capabilities they provide. It is always better to be specific about the types you expect to work with in your code.
There are however cases when you will have to use this type aliases for eg. when working with Cocoa APIs, it is common to receive an array with a type of [AnyObject]
, or “an array of values of any object type”. This is because Objective-C does not have explicitly typed arrays like Swift does.


Lean Community
Try it!
Lean online
Install
Learn
Resources
Theorem proving in Lean
The natural number game
Library overview
API documentation
Community
Meet us
Zulip chat
Maintainers
How to contribute
Papers
Undergraduate mathematics in mathlib
This page tracks usual mathematical theories that are or aren't in mathlib currently.
Show todo
Show done
Linear algebra
#
Fundamentals
#
vector space
,
product of vector spaces
,
vector subspace
,
quotient space
,
sum of subspaces
,
direct sum
,
complementary subspaces
,
linear independence
,
generating sets
,
bases
,
existence of bases
,
linear map
,
range of a linear map
,
kernel of a linear map
,
algebra of endomorphisms of a vector space
,
general linear group
Duality
#
dual vector space
,
dual basis
,
transpose of a linear map
,
orthogonality
Finite-dimensional vector spaces
#
finite-dimensionality
,
isomorphism with $K^n$
,
rank of a linear map
,
rank of a set of vectors
,
rank of a system of linear equations
,
isomorphism with bidual
Multilinearity
#
multilinear map
,
determinant of vectors
,
determinant of endomorphisms
,
special linear group
,
orientation of a $\R$-valued vector space
Matrices
#
commutative ring valued matrices
,
field-valued matrices
,
matrix representation of a linear map
,
change of basis
,
rank of a matrix
,
determinant
,
invertibility
,
elementary row operations
,
elementary column operations
,
Gauss' pivot
,
row-reduced matrices
Endomorphism polynomials
#
annihilating polynomials
,
minimal polynomial
,
characteristic polynomial
,
Cayley-Hamilton theorem
Structure theory of endomorphisms
#
eigenvalues
,
eigenvectors
,
diagonalization
,
trigonalization
,
endomorphism invariant subspaces
,
characteristic subspaces
,
kernels lemma
,
Dunford decomposition
,
Jordan normal form
Linear representations
#
irreducible representation
,
Schur's lemma
,
examples
Exponential
#
endomorphism exponential
,
matrix exponential
Group Theory
#
Basic definitions
#
group
,
group morphism
,
direct product of groups
,
subgroup
,
subgroup generated by a subset
,
order of an element
,
normal subgroup
,
quotient group
,
group action
,
stabilizer of a point
,
orbit
,
quotient space
,
class formula
,
conjugacy classes
Abelian group
#
cyclic group
,
finite type abelian groups
,
complex roots of unity
,
primitive complex roots of unity
Permutation group
#
permutation group of a type
,
decomposition into transpositions
,
decomposition into cycles with disjoint support
,
signature
,
alternating group
Classical automorphism groups
#
general linear group
,
special linear group
,
orthogonal group
,
special orthogonal group
,
unitary group
,
special unitary group
Representation theory of finite groups
#
representations of abelian groups
,
dual groups
,
Maschke theorem
,
orthogonality of irreducible characters
,
Fourier transform for finite abelian groups
,
convolution
,
class function over a group
,
characters of a finite dimensional representation
,
orthonormal basis of irreducible characters
,
examples of groups with small cardinality
Ring Theory
#
Fundamentals
#
ring
,
subrings
,
ring morphisms
,
Ring structure $\Z$
,
Product of rings
Ideals and Quotients
#
Ideal of a commutative ring
,
Quotient rings
,
Prime ideals
,
Maximal ideals
,
Chinese remainder theorem
Algebra
#
algebra over a commutative ring
,
associative algebra over a commutative ring
Divisibility in integral domains
#
irreducible elements
,
invertible elements
,
coprime elements
,
unique factorisation domain (UFD)
,
greatest common divisor
,
least common multiple
,
$A[X]$ is a UFD when $A$ is a UFD
,
principal ideal domain
,
Euclidean rings
,
Euclid's' algorithm
,
$\Z$ is a euclidean ring
,
congruence in $\Z$
,
Prime numbers
,
Bezout's identity
,
$\Z/n\Z$ and its invertible elements
,
Euler's totient function ($\varphi$)
Polynomial rings
#
$K[X]$ is a euclidean ring when $K$ is a field
,
irreducible polynomial
,
cyclotomic polynomials in $\Q[X]$
,
Eisenstein's criterion
,
polynomial algebra in one or several indeterminates over a commutative ring
,
roots of a polynomial
,
multiplicity
,
relationship between the coefficients and the roots of a split polynomial
,
Newton's sums
,
polynomial derivative
,
decomposition into sums of homogeneous polynomials
,
symmetric polynomials
Field Theory
#
fields
,
characteristic of a ring
,
characteristic zero
,
characteristic p
,
Subfields
,
Frobenius morphisms
,
field $\Q$ of rational numbers
,
field $\R$ of real numbers
,
field $\C$ of complex numbers
,
fundamental theorem of algebra
,
field of fractions of an integral domain
,
algebraic elements
,
transcendental elements
,
algebraic extensions
,
algebraically closed fields
,
rupture fields
,
splitting fields
,
finite fields
,
rational fraction fields with one indeterminate over the field
Partial fraction decomposition
#
General
,
$\R(X)$-partial fraction decomposition
,
$\C(X)$-partial fraction decomposition
Bilinear and Quadratic Forms Over a Vector Space
#
Bilinear forms
#
bilinear forms
,
alternating bilinear forms
,
symmetric bilinear forms
,
nondegenerate forms
,
matrix representation
,
change of coordinates
,
rank of a bilinear form
Quadratic forms
#
quadratic form
,
polar form of a quadratic
Orthogonality
#
orthogonal elements
,
adjoint endomorphism
,
inertia law of Sylvester
,
real classification
,
complex classification
,
Schmidt orthogonalisation
Euclidean and Hermitian spaces
#
Euclidean vector spaces
,
Hermitian vector spaces
,
dual isomorphism in the euclidean case
,
orthogonal supplementary
,
Cauchy-Schwarz inequality
,
norm
,
orthonormal bases
Endomorphisms
#
orthogonal group
,
unitary group
,
special orthogonal group
,
special unitary group
,
symmetrical endomorphism
,
normal endomorphism
,
diagonalization of a symmetrical endomorphism
,
diagonalization of normal endomorphisms
,
simultaneous reduction of two real quadratic forms with a definite positive one
,
decomposition of an orthogonal automorphism in product of reflections
,
polar decompositions in $\mathrm{GL}(n, \R)$
,
polar decompositions in $\mathrm{GL}(n, \C)$
Low dimensions
#
euclidean vector spaces of dimension 2
,
euclidean vector spaces of dimension 3
,
cross product
,
triple product
,
classification of $\mathrm{O}(2, \R)$
,
classification of $\mathrm{O}(3, \R)$
Affine and Euclidian Geometry (finite dimensional only)
#
Affine spaces and associated vector spaces
,
Affine functions and linear associated functions
,
Affine subspaces
,
Barycenters
,
Affine spans
,
Equations of affine subspaces
,
Affine groups
,
Affine property
,
Homothetic transformation groups
,
Affinity
,
Convex subsets
,
Convex hull of a subset of an affine real space
,
Extreme point
,
Isometries of a Euclidian affine subspace
,
Euclidian affine space isometry group
,
Euclidean affine space isometries
,
Isometries that do and do not preserve orientation
,
Direct and indirect similarities of the plane
,
Isometric classification in two and three dimensions
,
Angles of vectors
,
Angles formed by planes
,
Inscribed angle theorem
,
Cocyclicity
,
Group of isometries stabilizing subset of the plane or space
,
Regular polygons
,
Metric relations in the triangle
,
Using complex numbers in plane geometry
Application of quadratic forms to study proper conic sections of the affine euclidean plane
#
foyer
,
eccentricity
,
quadratics on 3 dimensional euclidean affine spaces
Single Variable Real Analysis
#
Real Numbers
#
definition of $\R$
,
field structure
,
order
Sequences of real numbers
#
convergence
,
limit point
,
recurrent sequences
,
Limit infimum and supremum
,
Cauchy sequences
Topology of R
#
metric structure
,
Completeness of R
,
Bolzano-Weierstrass theorem
,
Compact subsets of $\R$
,
Connected subsets of $\R$
,
Additive subgroups of $\R$
Numerical Series
#
Convergence of real valued-series
,
Geometric series
,
Riemann series
,
Positive valued series
,
Summation of comparison relations
,
Comparison of a series and an integral
,
Error estimation
,
Absolute convergence
,
Products of series
,
Alternating series
Real-valued functions defined on a subset of $\R$
#
Continuity
,
Limits
,
Intermediate value theorem
,
Image of a segment
,
Continuity of monotonic functions
,
Continuity of reciprocal functions
Differentiability
#
Derivative at a point
,
Differentiable functions
,
Derivative of a composite function
,
Derivative of a reciprocal function
,
Rolle's theorem
,
Mean value theorem
,
Higher order derivatives of functions
,
$C^k$ functions
,
piecewise $C^k$ functions
,
Leibniz formula
Taylor-like theorems
#
Taylor with rough error estimation
,
Taylor with integral error estimation
,
Taylor-Lagrange
,
Series expansions
Usual functions (trigonometric, rational, $\exp$, $\log$, etc)
#
Polynomial functions
,
Rational functions
,
Logarithms
,
Exponential
,
Power functions
,
Circular trigonometric functions
,
Hyperbolic trigonometric functions
,
Reciprocal circular trigonometric functions
,
Reciprocal hyperbolic trigonometric functions
Integration
#
Integral over a segment of piecewise continuous functions
,
Antiderivatives
,
Riemann sums
,
Antiderivative of a continuous function
,
Usual methods to compute integrals
,
Change of variable
,
Integration by parts
,
Generalized integrals
,
Absolutely convergent integrals
,
Integration of asymptotic comparison relationships
,
Semi-convergent integrals
Sequences and series of functions
#
Pointwise convergence
,
Uniform convergence
,
Normal convergence
,
Continuity of the limit
,
Differentiability of the limit
,
Weierstrass polynomial approximation theorem
,
Weierstrass trigonometric approximation theorem
Convexity
#
Convex functions of a real variable
,
Continuity and differentiability of convex functions
,
Characterizations of convexity
,
Convexity inequalities
Single Variable Complex Analysis
#
Complex Valued series
#
Radius of convergence
,
Properties of sums of complex valued series on their disks of convergence
,
Continuity
,
differentiability with respect to the complex variable
,
Antiderivative
,
Complex exponentials
,
Extension of circular functions to the complex plane
,
Power series expansion of usual functions
Functions on one complex variable
#
Holomorphic functions
,
Cauchy-Riemann conditions
,
Line integrals of continuous functions in $\C$
,
Antiderivatives of a holomorphic function
,
Representations of the $\log$ function on $\C$
,
Theorem of holomorphic functions under integral domains
,
Winding number of a closed curve in $\C$ with respect to a point
,
Cauchy formulas
,
Analyticity of a holomorphic function
,
Principle of isolated zeros
,
Principle of analytic continuation
,
Maximum principle
,
Isolated singularities
,
Laurent series
,
Meromorphic functions
,
Residue theorem
,
Sequences and series of holomorphic functions
,
Holomorphic stability by uniform convergence
Topology
#
Topology and Metric Spaces
#
Topology of a metric space
,
Induced topology
,
Finite product of metric spaces
,
Limits of sequences
,
cluster points
,
Continuous functions
,
Homeomorphisms
,
Compactness
,
Equivalence of definitions in terms of cluster points (Bolzano-Weierstrass) or open covers (Borel-Lebesgue)
,
Connectedness
,
Connected components
,
Path connectedness
,
Lipschitz functions
,
uniformly continuous functions
,
Heine-Cantor theorem
,
Complete metric spaces
,
Fixed point theorem for contraction mapping
Normed vector spaces on $\R$ and $\C$
#
Topology on a normed vector space
,
Equivalent norms
,
Continuity of linear maps in finite dimension
,
Normes $\lVert\cdot\rVert_p$ on $\R^n$ and $\C^n$
,
Continuous linear functions
,
Norm of a continuous linear function
,
Absolutely convergent series on Banach spaces
,
Banach open mapping theorem
,
Uniform convergence norm (sup-norm)
,
Complete space of continuous bounded complete space valued functions
,
Closed and bounded subsets are compact in finite-dimension
,
Riesz' characterization of finite dimension
,
Ascoli's Theorem
Hilbert Spaces
#
Hilbert projection theorem
,
Orthogonal projection onto closed vector subspaces
,
Dual space
,
Riesz representation theorem
,
$l^2$ and $L^2$ cases
,
Hilbert bases (in the separable case)
,
Basis of trigonometric polynomials
,
Basis of orthogonal polynomials
,
Lax-Milgram theorem
,
$H^1_0([0,1])$ and its application to the Dirichlet problem in one dimension
Differential Calculus
#
Differential Calculus
#
Differentiable functions on an open subset of $\R^n$
,
Differentials (linear tangent functions)
,
Derivatives with respect to a vector
,
Partial derivatives
,
Jacobian matrix
,
gradient vector
,
Hessian matrix
,
Composition of differentiable functions
,
Mean value theorem
,
Differentiable functions
,
Functions that can be differentiated k times
,
Kth partial derivative
,
Commutativity of partial derivatives
Taylor-style theorems
#
Taylor theorem with rough error estimation
,
Taylor theorem with integral error estimation
Local expansion of real valued functions
,
Local extrema
,
Convexity of functions on an open convex subset of $\R^n$
,
Diffeomorphisms
,
Inverse function theorem
,
Implicit function theorem
Differential equations
#
Differential equations of the form X' = f(t, X)
,
Cauchy-Lipschitz Theorem
,
Maximal solutions
,
Grönwall lemma
,
Exit theorem of a compact subspace
,
Autonomous differential equations
,
Phase portraits
,
qualitative behavior
,
Stability of equilibrium points (linearisation theorem)
,
Linear differential systems
,
Method of constant variation (Duhamel’s formula)
,
Constant coefficient case
,
Solving systems of differential equations of order > 1
Differential Geometry
#
Generalizations to R^n
Equivalent definitions
#
local graphs
,
local parameterization
,
local equation
tangent space
,
gradient
$\R^3$ case
#
Position with respect to the plane of the tangent
construction of curves/planes represented by a parametric equation
,
Metric study of curves
,
line integral
curve length
#
$\mathcal{C}^1$ case
Lagrange multipliers
Measures and integral Calculus
#
Measure theory
#
measurable spaces
,
sigma-algebras
,
product of sigma-algebras
,
borel sigma-algebras
,
positive measure
,
counting measure
,
Lebesgue measure
,
product measure
,
measurable functions
,
approximation by step functions
Integration
#
integral of positive measurable functions
,
monotone convergence theorem
,
Fatou's lemma
,
integrable functions
,
dominated convergence theorem
,
finite dimensional vector-valued integrable functions
,
continuity of integrals with respect to parameters
,
differentiability of integrals with respect to parameters
,
$\mathrm{L}^p$ spaces where $1 ≤ p ≤ ∞$
,
Completeness of $\mathrm{L}^p$ spaces
,
Holder's inequality
,
Fubini's theorem
,
change of variables for multiple integrals
,
integration by parts
,
convolution
,
regularization and approximation by convolution
Fourier Analysis
#
Fourier series of locally integrable periodic real-valued functions
,
Riemann-Lebesgue lemma
,
convolution product of periodic functions
,
Dirichlet theorem
,
Fejer theorem
,
Parseval theorem
,
Fourier transforms on $\mathrm{L}^1(\R^d)$ and $\mathrm{L}^2(R^d)$
,
Plancherel’s theorem
Probability Theory
#
Definitions of a probability space
#
probability measure
,
events
,
independent events
,
sigma-algebra
,
independent sigma-algebra
,
$0$-$1$ law
,
Borel-Cantelli lemma
,
conditional probability
,
law of total probability
Random variables and their laws
#
Discrete law
,
Absolute continuity of probability laws
,
probability density function
,
law of joint probability
,
independence of random variables
,
mean and variance of a real-valued random variable
,
transfer theorem
,
moments
,
Bernoulli law
,
Binomial law
,
Geometric law
,
Poisson law
,
Uniform law
,
Exponential law
,
Gaussian law
,
characteristic function
,
probability generating functions
,
applications of probability generating functions to sums of independent random variables
Convergence of series of random variables
#
convergence in probability
,
$\mathrm{L}^p$ convergence
,
almost surely convergence
,
Markov inequality
,
Tchebychev inequality
,
Levy's theorem
,
weak law of large numbers
,
strong law of large numbers
,
central limit theorem
Distribution calculus
#
Spaces $\mathcal{D}(\R^d)$
#
smooth functions with compact support on $\R^d$
,
stability by derivation
,
stability by multiplication by a smooth function
,
partitions of unity
,
constructing approximations of probability density functions in spaces of common functions (trig, exp, rational, log, etc)
Distributions on $\R^d$
#
definition of distributions
,
locally integrable functions
,
dirac measures
,
Cauchy principal values
,
multiplication by a smooth function
,
probability distribution function from a dataset
,
convergent distribution series
,
support of a distribution
Spaces $\mathcal{S}(\R^d)$
#
Schwartz space of rapidly decreasing functions
,
stability by derivation
,
stability by multiplication by a slowly growing smooth function
,
gaussian functions
,
Fourier transforms on $\mathcal{S}(\R^d)$
,
convolution of two functions of $\mathcal{S}(\R^d)$
Tempered distributions
#
definition
,
Derivation of tempered distributions
,
Multiplication by a function $C^\infty$ of slow growth
,
$L^2$ functions and Riesz representation
,
$L^p$ functions
,
Periodic functions
,
Dirac comb
,
Fourier transforms
,
inverse Fourier transform
,
Fourier transform and derivation
,
Fourier transform and convolution product
Applications
#
Poisson’s formula
,
using convolution and Fourier-Laplace transform to solve one dimensional linear differential equations
,
weak solution of partial derivative equation
,
elementary solution of the Laplacian
,
solving the Laplace equations
,
heat equations
,
wave equations
Numerical Analysis
#
Solving systems of linear inequalities
#
conditioning
,
Gershgorin-Hadamard theorem
,
Gauss’s pivot
,
LU decomposition
Iterative methods
#
Jacobian
,
Gauss-Seidel
,
convergence analysis
,
spectral ray
,
singular value decomposition
,
example of discretisation matrix by finite differences of the laplacian in one dimension
Iterative methods of solving systems of real and vector valued equations
#
linear systems case
,
proper element search
,
brute force method
,
optimization of convex function in finite dimension
,
gradient descent square root
,
nonlinear problems with real and vector values
,
bisection method
,
Picard method
,
Newton’s method
,
rate of convergence and estimation of error
Numerical integration
#
Rectangle method
,
error estimation
,
Monte-Carlo method
,
rate of convergence
,
application to the calculation of multiple integrals
Approximation of numerical functions
#
Lagrange interpolation
,
Lagrange polynomial of a function at (n + 1) points
,
estimation of the error
Ordinary differential equations
#
Numerical aspects of Cauchy's problem
,
explicit Euler method
,
consistency
,
stability
,
convergence
,
order
Fourier transform
#
Discrete Fourier transform on a finite abelian group
,
Fast Fourier transform