This document describes rationales for WebAssembly’s design decisions, acting as footnotes to the main design text, keeping the main specification easier to read, and making it easier to revisit decisions later without having to plow through all the issues and pull requests. This rationale document tries to list how decisions were made, and where tradeoffs were made for the sake of language ergonomics, portability, performance, security, and Getting Things Done.
WebAssembly was designed incrementally, with multiple implementations being pursued concurrently. As the MVP stabilizes and we get experience from real-world codebases, we’ll revisit the alternatives listed below, reevaluate the tradeoffs and update the design before the MVP is finalized.
Why not an AST, or a register- or SSA-based bytecode?
Polyfill prototype shows simple and efficient translation to asm.js.
The WebAssembly stack machine is restricted to structured control flow and structured use of the stack. This greatly simplifies one-pass verification, avoiding a fixpoint computation like that of other stack machines such as the Java Virtual Machine (prior to stack maps). This also simplifies compilation and manipulation of WebAssembly code by other tools. Further generalization of the WebAssembly stack machine is planned post-MVP, such as the addition of multiple return values from control flow constructs and function calls.
WebAssembly only represents a few types.
i8
and i16
) are usually no more efficient and in
languages like C/C++ are only semantically meaningful for memory accesses
since arithmetic get widened to i32
or i64
. Avoiding them at least for MVP
makes it easier to implement a WebAssembly VM.f16
, i128
) aren’t widely supported by existing
hardware and can be supported by runtime libraries if developers wish to use
them. Hardware support is sometimes uneven, e.g. some support load/store of
f16
only whereas other hardware also supports scalar arithmetic on f16
,
and yet other hardware only supports SIMD arithmetic on f16
. They can be
added to WebAssembly later without compromising MVP.Load/store instructions include an immediate offset used for addressing. This is intended to simplify folding of offsets into complex address modes in hardware, and to simplify bounds checking optimizations. It offloads some of the optimization work to the compiler that targets WebAssembly, executing on the developer’s machine, instead of performing that work in the WebAssembly compiler on the user’s machine.
Load/store instructions contain alignment hints. This makes it easier to generate efficient code on certain hardware architectures.
Either tooling or an explicit opt-in “debug mode” in the spec could allow execution of a module in a mode that threw exceptions on misaligned access. This mode would incur some runtime cost for branching on most platforms which is why it isn’t the specified default.
The ideal semantics is for out-of-bounds accesses to trap, but the implications are not yet fully clear.
There are several possible variations on this design being discussed and experimented with. More measurement is required to understand the associated tradeoffs.
To allow efficient engines to employ virtual-memory based techniques for bounds checking, memory sizes are required to be page-aligned. For portability across a range of CPU architectures and operating systems, WebAssembly defines a fixed page size. Programs can depend on this fixed page size and still remain portable across all WebAssembly engines. 64KiB represents the least common multiple of many platforms and CPUs. In the future, WebAssembly may offer the ability to use larger page sizes on some platforms for increased TLB efficiency.
The grow_memory
operator returns the old memory size. This is desirable for
using grow_memory
independently on multiple threads, so that each thread can
know where the region it allocated starts. The obvious alternative would be for
such threads to communicate manually, however WebAssembly implementations will likely
already be communicating between threads in order to properly allocate the sum
of the allocation requests, so it’s expected that they can provide the needed
information without significant extra effort.
The optional maximum size is designed to address a number of competing constraints:
realloc
since this implies significant implementation complexity,
security hazards, and optimization challenges.The optional maximum addresses these constraints:
SharedArrayBuffer
s that alias linear memory stay valid without
any updates.See #107.
Structured control flow provides simple and size-efficient binary encoding and compilation. Any control flow–even irreducible–can be transformed into structured control flow with the Relooper algorithm, with guaranteed low code size overhead, and typically minimal throughput overhead (except for pathological cases of irreducible control flow). Alternative approaches can generate reducible control flow via node splitting, which can reduce throughput overhead, at the cost of increasing code size (potentially very significantly in pathological cases). Also, more expressive control flow constructs may be added in the future.
The nop operator does not produce a value or cause side effects.
It is nevertheless useful for compilers and tools, which sometimes need to replace instructions with a nop
. Without a nop
instruction, code generators would use alternative does-nothing opcode patterns that consume space in a module and may have a runtime cost. Finding an appropriate opcode that does nothing but has the appropriate type for the node’s location is nontrivial. The existence of many different ways to encode nop
- often mixed in the same module - would reduce the efficiency of compression algorithms.
C/C++ makes it possible to take the address of a function’s local values and pass this pointer to callees or to other threads. Since WebAssembly’s local variables are outside the address space, C/C++ compilers implement address-taken variables by creating a separate stack data structure within linear memory. This stack is sometimes called the “aliased” stack, since it is used for variables which may be pointed to by pointers.
Since the aliased stack appears to the WebAssembly engine as normal memory, WebAssembly optimizations that would target the aliased stack need to be more general, and thus more complicated. We observe that common compiler optimizations done before the WebAssembly code is produced, such as LLVM’s global value numbering, effectively split address-taken variables into many small ranges that can often be allocated as local variables. Thus our expectation that any loss of optimization potential here is minimal.
Conversely, non-address taken values which are usually on the stack are instead represented as locals inside functions. This effectively means that WebAssembly has an infinite set of registers, and can choose to spill values as it sees fit in a manner unobservable to the hosted code. This implies that there’s a separate stack, unaddressable from hosted code, which is also used to spill return values. This allows strong security properties to be enforced, but does mean that two stacks are maintained (one by the VM, the other by the compiler which targets WebAssembly) which can lead to some inefficiencies.
Local variables are not in Static Single Assignment (SSA) form, meaning that
multiple incoming SSA values which have separate liveness can “share” the
storage represented by a local through the set_local
operator. From an SSA
perspective, this means that multiple independent values can share a local
variable in WebAssembly, which is effectively a kind of pre-coloring that clever
producers can use to pre-color variables and give hints to a WebAssembly VM’s
register allocation algorithms, offloading some of the optimization work from
the WebAssembly VM.
C and C++ compilers are expected to implement variable-length argument lists by storing arguments in a buffer in linear memory and passing a pointer to the buffer. This greatly simplifies WebAssembly VM implementations by punting this ABI consideration to the front-end compiler. It does negatively impact performance, but variable-length calls are already somewhat slow.
WebAssembly’s MVP does not support multiple return values from functions because they aren’t strictly necessary for the earliest anticipated use cases (and it’s a minimum viable product), and they would introduce some complexity for some implementations. However, multiple return values are a very useful feature, and are relevant to ABIs, so it’s likely to be added soon after the MVP.
The table-based scheme for indirect function calls was motivated by the need to represent function pointers as integer values that can be stored into the linear memory, as well as to enforce basic safety properties such as calling a function with the wrong signature does not destroy the safety guarantees of WebAssembly. In particular, an exact signature match implies an internal machine-level ABI match, which some engines require to ensure safety. An indirection also avoids a possible information leak through raw code addresses.
Languages like C and C++ that compile to WebAssembly also imposed requirements, such as the uniqueness of function pointers and the ability to compare function pointers to data pointers, or treat data as function pointers.
Several alternatives to direct indices with a heterogeneous indirect function table were considered, from alternatives with multiple tables to statically typed function pointers that can be mapped back and forth to integers. With the added complication of dynamic linking and dynamic code generation, none of these alternatives perfectly fit the requirements.
The current design requires two dynamic checks when invoking a function pointer: a bounds check against the size of the indirect function table and a signature check for the function at that index against an expected signature. Some dynamic optimization techniques (e.g. inline caches, or a one-element cache), can reduce the number of checks in common cases. Other techniques such as trading a bounds check for a mask or segregating the table per signature to require only a bounds check could be considered in the future. Also, if tables are small enough, an engine can internally use per-signature tables filled with failure handlers to avoid one check.
Control flow instructions such as br
, br_if
, br_table
, if
and if-else
can
transfer stack values in WebAssembly. These primitives are useful building blocks for
WebAssembly producers, e.g. in compiling expression languages. It offers significant
size reduction by avoiding the need for set_local
/get_local
pairs in the common case
of an expression with only one immediate use. Control flow instructions can then model
expressions with result values, thus allowing even more opportunities to further reduce
set_local
/get_local
usage (which constitute 30-40% of total bytes in the
polyfill prototype).
br
-with-value and if
constructs that return values can model also model phis
which
appear in SSA representations of programs.
There are a few obvious cases where nondeterminism is essential to the API, such as random number generators, date/time functions or input events. The WebAssembly specification is strict when it comes to other sources of limited local nondeterminism of operators: it specifies all possible corner cases, and specifies a single outcome when this can be done reasonably.
Ideally, WebAssembly would be fully deterministic because a fully deterministic platform is easier to:
Nondeterminism is only specified as a compromise when there is no other practical way to:
When nondeterminism is allowed into WebAssembly it is always done in a limited and local manner. This prevents the entire program from being invalid, as would be the case with C++ undefined behavior.
As WebAssembly gets implemented and tested with multiple languages on multiple architectures we may revisit some of the design decisions:
NaNs produced by floating-point instructions in WebAssembly have nondeterministic bit patterns in most circumstances. The bit pattern of a NaN is not usually significant, however there are a few ways that it can be observed:
reinterpret
conversion to an integer typestore
to linear memory followed by a load with a different type or indexcall
or call_indirect
to an imported function may
be observed by the outside environmentcopysign
can be used to copy the sign bit onto a non-NaN value, where
it then be observedThe motivation for nondeterminism in NaN bit patterns is that popular platforms have differing behavior. IEEE 754-2008 makes some recommendations, but has few hard requirements in this area, and in practice there is significant divergence, for example:
fadd
, fmul
and other instructions, so it’s not possible
to rely on the “first” NaN being preserved as such.IEEE 754-2008 6.2 says that instructions returning a NaN should return one of their input NaNs. In WebAssembly, implementations may do this, however they are not required to. Since IEEE 754-2008 states this as a “should” (as opposed to a “shall”), it isn’t a requirement for IEEE 754-2008 conformance.
An alternative design would be to require engines to always “canonicalize” NaNs whenever their bits could be observed. This would eliminate the nondeterminism and provide slightly better portability, since it would hide hardware-specific NaN propagation behavior. However, it is theorized that this would add an unacceptable amount of overhead, and that the benefit is marginal since most programs are unaffected by this issue.
In general, WebAssembly’s floating point instructions provide the guarantee that if all NaNs passed to an instruction are “canonical”, the result is “canonical”, where canonical means the most significant bit of the fraction field is 1, and the trailing bits are all 0.
This is intended to support interpreters running on WebAssembly that use NaN-boxing, because they don’t have to canonicalize the output of an arithmetic instruction if they know the inputs are canonical.
When one or more of the inputs of an instruction are non-canonical NaNs, the resulting NaN bit pattern is nondeterministic. This is intended to accommodate the diversity in NaN behavior among popular hardware architectures.
Note that the sign bit is still nondeterministic in a canonical NaN. This is also to accommodate popular hardware architectures; for example, x86 generates NaNs with the sign bit set to 1 while other architectures generate NaNs with it set to 0. And as above, the cost of canonicalizing NaNs is believed to be greater than the benefit.
NaNs generated by JS or other entities in the external environment are not required to be canonical, so exported function arguments, imported function return values, and values stored in exported variables or memory may be non-canonical.
WebAssembly’s signed integer divide rounds its result toward zero. This is not because of a lack of sympathy for better alternatives, but out of practicality. Because all popular hardware today implements rounding toward zero, and because C and many other languages now specify rounding to zero, having WebAssembly in the middle doing something different would mean divisions would have to be doubly complicated.
Similarly, WebAssembly’s shift operators mask their shift counts to the number of bits in the shifted value. Confusingly, this means that shifting a 32-bit value by 32 bits is an identity operation, and that a left shift is not equivalent to a multiplication by a power of 2 because the overflow behavior is different. Nevertheless, because several popular hardware architectures today implement this masking behavior, and those that don’t can typically emulate it with a single extra mask instruction, and because several popular source languages, including JavaScript and C#, have come to specify this behavior too, we reluctantly adopt this behavior as well.
WebAssembly has three classes of integer operations: signed, unsigned, and sign-agnostic. The signed and unsigned instructions have the property that whenever they can’t return their mathematically expected value (such as when an overflow occurs, or when their operand is outside their domain), they trap, in order to avoid silently returning an incorrect value.
Note that the add
, sub
, and mul
operators are categorized as
sign-agnostic. Because of the magic of two’s complement representation, they
may be used for both signed and unsigned purposes. Note that this (very
conveniently!) means that engines don’t need to add extra overflow-checking
code for these most common of arithmetic operators on the most popular
hardware platforms.
i32.min_s
is introduced. A
WebAssembly developer updates their toolkit so that the compiler may leverage
i32.min_s
. The developer’s WebAssembly module works correctly both on
execution environments at MVP, as well as those supporting i32.min_s
.In one variant of the scenario, our developer does not want to pay the engineering cost of developing and supporting a threaded and non-threaded version of their code. They opt not to support MVP targets, and only support post-MVP targets. End-users (browser users) get some message indicating they need MVP support.
In another variant, our developer explicitly authors both MVP-only and post- MVP (with threads) code.
SIMD support is not universally equivalent on all targets. While polyfill variants of SIMD APIs are available, a developer prefers writing dedicated SIMD and non-SIMD versions of their compression algorithm, because the non-SIMD version performs better in environments without SIMD support, when compared to the SIMD polyfill. They package their compression code for reuse by third parties.
An application author is assembling together an application by reusing modules such as those developed in the scenarios above. The application author’s development environment is able to quickly and correctly identify the platform dependencies (e.g. threading, SIMD) and communicate back to the application author the implications these dependencies have on the end-application. Some APIs exposed from the threading-aware module are only pertinent to environments supporting threading. As a consequence, the application author needs to write specialized code when threads are/are not supported. (Note: we should understand this scenario for both forms of WebAssembly reuse currently imagined: dynamic linking and static imports.)
The compression algorithm described in scenario 3 is deployed on a restrictive execution environment, as part of an application. In this environment, a process may not change memory page access protection flags (e.g. certain gaming consoles, to investigate server side deployment scenarios). The compression module is compiled by the WebAssembly environment, enabling the configuration most specific to the target (i.e. with/without Threads, SIMD, etc).
Given that text is so compressible and it is well known that it is hard to beat gzipped source, is there any win from having a binary format over a text format? Yes:
O(nodes)
entities
to worry about, compared to generic compression which in principle would
need to look at O(bytes*bytes)
entities. Such macros would allow the
logical equivalent of #define ADD1(x) (x+1)
, i.e., to be
parameterized. Simpler macros (#define ADDX1 (x+1)
) can implement useful
features like constant pools.For a stack machine, the fundamental property that type checking must ensure is that for every edge in a control flow graph (formed by the individual instructions), the assumptions about the stack match up. At the same time, type checking should be fast, so be expressible by a linear traversal.
There is no control edge from an unconditional control transfer instruction (like br
, br_table
, return
, or unreachable
) to the textually following instruction – the next instruction is unreachable.
Consequently, no constraint has to be imposed between the two regarding the stack.
In a linear type checking algorithm this can be expressed by allowing to assume any type of stack.
In type system terms, the instruction can thus be said to be polymorphic in its stack type.
This solution is canonical in the sense that it induces the minimal type constraints necessary to ensure soundness, while also maintaining the following useful structural properties about valid (i.e., well-typed) code:
Some of these properties are relevant to support certain compilation techniques without artificial complication for producers. As a small but representative example, consider a textbook one-pass compiler, which would often use something like the following scheme for compiling expressions:
compile(A + B) = compile(A); compile(B); emit(i32.add)
compile(A / B) = compile(A); compile(B); emit(dup i32.eqz (br_if $div_zero) drop i32.div)
compile(A / 0) = compile(A); emit(br $div_zero)
The third case is a specialisation of the second, a simple optimisation.
Without polymorphic typing of the br
instruction, however, this simple scheme would not work, since compile((x/0)+y)
would result in invalid code. Worse, it can lead to subtle compiler bugs.
Similar situations arise in production compilers, for example, in the asm.js-to-wasm compilers that some of the WebAssembly VMs/tools are implementing.
Other solutions that have been discussed would lose most of the above properties. For example:
It is worth noting that this kind of type checking, in general, is not unusual.
For example, the JVM also poses no constraint on the stack type after a jump (however, in its modern form, it recommends type annotations in the form of stack maps, which are then required after jumps to make the instantiation of the polymorphic typing rule explicit).
Moreover, programming languages that allow control transfer expressions usually type them polymorphically as well (e.g., throw
/raise
, which is an expression in some languages).


Looming deadlines: When you need to get those holiday cards, packages in mail
by Natalie Dreier, Cox Media Group National Content DeskThe calendar may say November, but there are deadlines fast approaching for this year's holiday mail.
Military Mail Deadlines
Military mail that is sent by the United States Postal Service by retail ground, must have been mailed by Nov. 6 to any APO/FPO/DPO AE address if you want it delivered by Christmas Day.
For those same military addresses, it isn't too late to get the well-wishes and care packages in the mail.
For space available mail, you have until Nov. 27.
For parcel airlift mail, the deadline is Dec. 4.
Priority mail and first-class letters and cards have a deadline of Dec. 11 in all military ZIP codes except 093, which has a Dec. 9 deadline.
Priority mail express military service mail can be sent by Dec. 18, except again for ZIP code 093, which is not available.
Domestic Mail Deadlines
First-class mail and packages have a deadline of Dec. 20 for regular mail to get to the receivers by Dec. 25.
Priority mail's deadline is Dec. 21
And priority mail express is Dec. 23.
For USPS retail ground delivery, the deadline is Dec. 14.
International Mail Deadlines
For international deliveries, the dates vary depending on where the mail is being sent and does not account for the items going through customs. Also, add time if the item is being delivered outside of a major city.
Here are the following deadlines by region:
Africa
- First-class package: Nov. 30
- Priority mail international: Nov. 30
- Priority mail express international: Dec. 7
- Global express guaranteed: Dec. 19
Asia/Pacific Rim
- First-class package: Dec. 7
- Priority mail international: Dec. 7
- Priority mail express international: Dec. 14
- Global express guaranteed: Dec. 19
Australia/New Zealand
- First-class package: Dec. 7
- Priority mail international: Dec. 7
- Priority mail express international: Dec. 14
- Global express guaranteed: Dec. 19
Canada
- First-class package: Dec. 7
- Priority mail international: Dec. 7
- Priority mail express international: Dec. 14
- Global express guaranteed: Dec. 19
Caribbean
- First-class package: Dec. 7
- Priority mail international: Dec. 7
- Priority mail express international: Dec. 14
- Global express guaranteed: Dec.19
Central and South America
- First-class package: Nov. 30
- Priority mail international: Nov. 30
- Priority mail express international: Dec. 7
- Global express guaranteed: Dec. 18
Europe
- First-class package: Dec. 7
- Priority mail international: Dec. 7
- Priority mail express international: Dec. 14
- Global express guaranteed: Dec. 19
Mexico
- First-class package: Dec. 7
- Priority mail international: Dec. 7
- Priority mail express international: Dec. 14
- Global express guaranteed: Dec 18
Middle East
- First-class package: Dec. 7
- Priority mail international: Dec. 7
- Priority mail express international: Dec. 14
- Global express guaranteed: Dec 19


SPOILER WARNING: This review reveals many of the major plot points of the "Twin Peaks" television series, including the identity of Laura Palmer's killer and the ending of the cliffhanger finale.
Film review by Kevin Patterson
Twin Peaks: Fire Walk With Me * * * * R, 1992 Written by David Lynch and Robert Engels. Directed by David Lynch. Starring Sheryl Lee, Ray Wise, Kyle MacLachlan, Chris Isaak.
Shortly after the cancellation of the "Twin Peaks" televison series, co-creator David Lynch announced that he was not ready to leave the story behind and would make a "Peaks" feature film. Fans were understandably excited and hoped for a resolution to the show's frustrating cliffhanger ending, in which FBI Special Agent Dale Cooper (Kyle MacLachlan) was trapped inside an alternate reality while an evil doppelganger took his place. Then Lynch decided instead to do a prequel, exploring the events leading to the murder of Laura Palmer (Sheryl Lee) rather than following up on the series. Many "Peaks Freaks" were disappointed, and some continue to insist to this day that the film was an artistic flop.
In fact, however, there is a lot to admire in "Twin Peaks: Fire Walk With Me." The opening half-hour, in which FBI agents Chester Desmond (Chris Isaak) and Sam Stanley (Kiefer Sutherland) investigate a related murder, features much of the goofy humor that made the series so much fun as they encounter, among others, a hostile macho sheriff ("Cable bends steel!"  We don't have any!"). As the story moves to the town of Twin Peaks and the final days of Laura Palmer's life, agents of the supernatural realm known as the Black Lodge appear, and Lynch treats us to several excellent sequences inside the mysterious "Red Room."
Many of these elements undoubtedly would seem confusing to someone who did not watch the series.  Lynch and co-writer Robert Engels turn the fact that everyone seeing this movie knew that it would end with Laura's murder to their advantage; we honestly want to see Laura somehow escape her horrible fate but know that she will not. Sheryl Lee gives an engaging and believable performance as Laura Palmer, creating a character that still deserves our sympathy despite the fact that a fair amount of her pain is self-inflicted.
The performances of Lee and Wise as well as Lynch's talent for emotional intensity and for astonishing visuals serve to capture vividly the horror of her situation and ultimately to produce some very moving moments. Most of these are soaked in melancholy, but without giving the details away, let me just say that this film does not end immediately after Laura's death and that the ending is about as uplifting (and yet un-sappy) an ending as you can have in a movie in which the main character is murdered. "Fire Walk With Me" is the rare film that incorporates supernatural elements yet still deals with real emotions and creates three-dimensional characters that can be taken seriously.
If one accepts "Fire Walk With Me" for what it is - a riveting. character-driven drama with hints of supenatural mystery - it is ultimately very rewarding. Many, including myself, might have preferred an extended "Twin Peaks" episode and a clarification of the TV series's plot threads, but David Lynch's responsibility as a filmmaker should not be primarily to satisfy fan expectations but simply to make a competent and powerful film. By that standard, "Twin Peaks: Fire Walk With Me" is an outstanding success.
- - - - - -
Visit my Film Reviews page at: http://members.aol.com/KTPattersn/reviews.html
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


FrequentItemSetMinerModule()
A module, which allows to find all frequent item sets, which occur in a data set. The data set must contain multiple transactions of which each one consists of multiple items. Item sets are considered frequent, if their support is greater or equal than a specific threshold.
In order to search for frequent item sets efficiently, the algorithm exploits the anti-monotonicity property of the support metric, which states, that an item set can only be frequent, if all of its subsets are frequent as well. The other way around, the supersets of an infrequent item set are also infrequent. Furthermore, the items must be sortable (e.g. by their names) in order to generate possible candidates in an efficient way.
Parameters
Author
Michael Rapp
Since
1.0.0


Connecting resources to marginalized students during COVID-19 pandemic
Wether you are in need of a tech resource to take online school or want to contribute to students in need, PROJECT_NAME can help you with that.
About the project
COVID-19 pandemic has forced most students to online learning, but not everyone has the same opportunity to access the technologies needed to take online classes. We are aware of that, so we created this tool to connect people who want to offer their help and those students in need of the resources.
Most used tech resources at your fingertips
Find the basic tools needed for online learning offered by awesome volunteers.
Quick & easy to use
Simply search for something you really need in our available catalogue or post a custom request if you can't find it.
Customized to your location
We use geolocation services to customize your experience and just show help with people near to you.


Last updated: 2020-03-08
Checks: 7 0
Knit directory: 2019-feature-selection/
This reproducible R Markdown analysis was created with workflowr (version 1.6.0). The Checks tab describes the reproducibility checks that were applied when the results were created. The Past versions tab lists the development history.
Great! Since the R Markdown file has been committed to the Git repository, you know the exact version of the code that produced these results.
Great job! The global environment was empty. Objects defined in the global environment can affect the analysis in your R Markdown file in unknown ways. For reproduciblity it’s best to always run the code in an empty environment.
The command set.seed(20190522)
was run prior to running the code in the R Markdown file. Setting a seed ensures that any results that rely on randomness, e.g. subsampling or permutations, are reproducible.
Great job! Recording the operating system, R version, and package versions is critical for reproducibility.
Nice! There were no cached chunks for this analysis, so you can be confident that you successfully produced the results during this run.
Great job! Using relative paths to the files within your workflowr project makes it easier to run your code on other machines.
Great! You are using Git for version control. Tracking code development and connecting the code version to the results is critical for reproducibility. The version displayed above was the version of the Git repository at the time these results were generated.
Note that you need to be careful to ensure that all relevant files for the analysis have been committed to Git prior to generating the results (you can use wflow_publish
or wflow_git_commit
). workflowr only checks the R Markdown file, but you know if there are other scripts or data files that it depends on. Below is the status of the Git repository when the results were generated:
Ignored files:
Ignored: .Rhistory
Ignored: .Rproj.user/
Ignored: .Ruserdata/
Ignored: .drake/
Ignored: .vscode/
Ignored: analysis/rosm.cache/
Ignored: data/
Ignored: inst/Benchmark for Filter Methods for Feature Selection in High-Dimensional Classification Data.pdf
Ignored: inst/study-area-map/._study-area.qgs
Ignored: inst/study-area-map/study-area.qgs~
Ignored: log/
Ignored: renv/library/
Ignored: renv/staging/
Ignored: reviews/
Ignored: rosm.cache/
Untracked files:
Untracked: code/06-modeling/project/
Unstaged changes:
Modified: .Rprofile
Modified: _drake.R
Modified: analysis/_site.yml
Modified: analysis/report-defoliation.Rmd
Modified: code/02-hyperspectral-processing.R
Modified: code/03-sentinel-processing.R
Modified: code/06-modeling/paper/02-param-sets.R
Modified: code/06-modeling/paper/03-learner.R
Modified: code/06-modeling/paper/04-filter-wrapper.R
Modified: code/06-modeling/paper/07-tune-wrapper.R
Modified: code/06-modeling/paper/08-train.R
Modified: code/071-benchmark-matrix-buffer2.R
Modified: code/09-reports.R
Note that any generated files, e.g. HTML, png, CSS, etc., are not included in this status report because it is ok for generated content to have uncommitted changes.
These are the previous versions of the R Markdown and HTML files. If you’ve configured a remote Git repository (see ?wflow_git_remote
), click on the hyperlinks in the table below to view them.
| File | Version | Author | Date | Message |
|---|---|---|---|---|
| Rmd | db07056 | pat-s | 2020-02-24 | add jose to authors |
| html | 7582c67 | pat-s | 2019-08-31 | Build site. |
| html | df85aba | pat-s | 2019-07-12 | Build site. |
| html | 3a44a95 | pat-s | 2019-07-10 | Build site. |
| html | db3955e | pat-s | 2019-06-27 | Build site. |
| Rmd | 4cf247a | pat-s | 2019-06-18 | fix git |
| html | 4cf247a | pat-s | 2019-06-18 | fix git |
| html | 4c3422d | pat-s | 2019-06-15 | Build site. |
| html | 45cbebd | pat-s | 2019-05-27 | Build site. |
| Rmd | 9a83d5a | pat-s | 2019-05-27 | wflow_publish(“analysis/about.Rmd”) |
| html | 47a5b39 | pat-s | 2019-05-25 | Build site. |
| html | 37da161 | pat-s | 2019-05-24 | Build site. |
| html | ad4c6c1 | pat-s | 2019-05-23 | Build site. |
| html | 6517dc7 | pat-s | 2019-05-23 | Build site. |
| html | 22eb53d | pat-s | 2019-05-23 | Build site. |
| html | a7ae8f1 | pat-s | 2019-05-23 | wflow_publish(all = T) |
| html | ad7d595 | pat-s | 2019-05-22 | Build site. |
| Rmd | 7ad5791 | pat-s | 2019-05-22 | first version |
| html | 7ad5791 | pat-s | 2019-05-22 | first version |
| Rmd | 1cbc8de | pat-s | 2019-05-22 | Start workflowr project. |
Modeling defoliation as a proxy for tree health: Comparison of feature-selection methods across multiple feature sets derived from hyperspectral data
This repository contains the research compendium of our work on comparing algorithms across multiple feature sets and filtering methods (including ensemble filter methods).
Using machine-learning algorithms to model defoliation of Pinus Radiata trees.
keywords
Compare filtering methods (ensemble filter methods) across various algorithms and datasets
Predict defoliation to all available plots (24) and the whole Basque Country (at 200 m resolution)
The following directories belong to this project
code/01-download.R
code/02-hyperspectral-processing.R
code/04-data-processing.R
code/05-modeling/
code/06-benchmark-matrix/
code/07-reports/
In addition, this repo contains the workflow for an analysis related to the LIFE 14 ENV/ES/000179 LIFE HEALTHY FOREST project: Predicting defoliation at trees for the Basque Country (for the years 2017 and 2018) using Sentinel-2 data.
Target defoliation_maps_wfr
builds are targets necessary for the final results report.
See the code
directory on GitHub for the source code that generated the figures and statistical results contained in the manuscript. See the data
directory for instructions how to access the raw data discussed in the manuscript.
This repository is organized as an R package, providing functions and raw data to reproduce and extend the analysis reported in the publication. Note that this package has been written explicitly for this project and may not be suitable for more general use.
This project is setup with a drake workflow, ensuring reproducibility. Intermediate targets/objects will be stored in a hidden .drake
directory.
The R library of this project is managed by packrat. This makes sure that the exact same package versions are used when recreating the project. When calling packrat::restore()
, all required packages will be installed with their specific version.
Please note that this project was built with R version 3.5.2 on a Debian 9 operating system. The packrat packages from this project are not compatible with R versions prior version 3.5.0. For reproducibility, it is recommended to replicate the analysis using the included Dockerfile. Instructions can be found ħere. (In general, it should be possible to reproduce the analysis on any other operating system.)
To clone the project, a working installation of git
is required. Open a terminal in the directory of your choice and execute:
git clone git@github.com:pat-s/paper_hyperspectral.git
Then start R in this directory and run
packrat::restore()
r_make()
The issues tracker is the place to report problems or ask questions
See the repository history for a fine-grained view of progress and changes.
The organisation of this compendium is based on the work of Carl Boettiger and Ben Marwick.
sessionInfo()
R version 3.6.1 (2019-07-05)
Platform: x86_64-pc-linux-gnu (64-bit)
Running under: CentOS Linux 7 (Core)
Matrix products: default
BLAS: /opt/spack/opt/spack/linux-centos7-x86_64/gcc-9.2.0/r-3.6.1-j25wr6zcofibs2zfjwg37357rjj26lqb/rlib/R/lib/libRblas.so
LAPACK: /opt/spack/opt/spack/linux-centos7-x86_64/gcc-9.2.0/r-3.6.1-j25wr6zcofibs2zfjwg37357rjj26lqb/rlib/R/lib/libRlapack.so
locale:
[1] LC_CTYPE=en_US.UTF-8 LC_NUMERIC=C
[3] LC_TIME=en_US.UTF-8 LC_COLLATE=en_US.UTF-8
[5] LC_MONETARY=en_US.UTF-8 LC_MESSAGES=en_US.UTF-8
[7] LC_PAPER=en_US.UTF-8 LC_NAME=C
[9] LC_ADDRESS=C LC_TELEPHONE=C
[11] LC_MEASUREMENT=en_US.UTF-8 LC_IDENTIFICATION=C
attached base packages:
[1] stats graphics grDevices utils datasets methods base
loaded via a namespace (and not attached):
[1] workflowr_1.6.0 Rcpp_1.0.3 rprojroot_1.3-2 digest_0.6.23
[5] later_1.0.0 R6_2.4.1 backports_1.1.5 git2r_0.26.1
[9] magrittr_1.5 evaluate_0.13 stringi_1.3.1 fs_1.3.1
[13] promises_1.0.1 whisker_0.3-2 rmarkdown_1.13 tools_3.6.1
[17] stringr_1.4.0 glue_1.3.1 httpuv_<IP_ADDRESS> xfun_0.5
[21] yaml_2.2.0 compiler_3.6.1 htmltools_0.3.6 knitr_1.23


Computer vision involves analyzing patterns in visual images and reconstructing the real-world objects that produced them. The process is often broken up into two phases: feature detection and pattern recognition. Feature detection involves selecting important features of the image; pattern recognition involves discovering patterns in the features. We will investigate a particularly clean pattern recognition problem involving points and line segments. This kind of pattern recognition arises in many other applications such as statistical data analysis.
The problem. Given a set of n distinct points in the plane, find every (maximal) line segment that connects a subset of 4 or more of the points.
Point data type.
Create an immutable data type Point
that represents a point in the plane
by implementing the following API:
To get started, use the data type Point.java, which implements the constructor and thepublic class Point implements Comparable<Point> { public Point(int x, int y) // constructs the point (x, y) public void draw() // draws this point public void drawTo(Point that) // draws the line segment from this point to that point public String toString() // string representation public int compareTo(Point that) // compare two points by y-coordinates, breaking ties by x-coordinates public double slopeTo(Point that) // the slope between this point and that point public Comparator<Point> slopeOrder() // compare two points by slopes they make with this point }
draw()
, drawTo()
, and toString()
methods.
Your job is to add the following components.
compareTo()
method should compare points by their y-coordinates,
breaking ties by their x-coordinates.
Formally, the invoking point
(x0, y0)
is less than the argument point
(x1, y1)
if and only if either y0 < y1 or if
y0 = y1 and x0 < x1.
slopeTo()
method should return the slope between the invoking point
(x0, y0) and the argument point
(x1, y1), which is given by the formula
(y1 − y0) / (x1 − x0).
Treat the slope of a horizontal line segment as positive zero;
treat the slope of a vertical line segment as positive infinity;
treat the slope of a degenerate line segment (between a point and itself) as negative infinity.
slopeOrder()
method should return a comparator that compares its two argument
points by the slopes they make with the invoking point (x0, y0).
Formally, the point (x1, y1) is less than
the point (x2, y2) if and only if the slope
(y1 − y0) / (x1 − x0)
is less than the slope
(y2 − y0) / (x2 − x0).
Treat horizontal, vertical, and degenerate line segments as in the slopeTo()
method.
equals()
or hashCode()
methods.
Corner cases. To avoid potential complications with integer overflow or floating-point precision,
you may assume that the constructor arguments x
and y
are each between 0 and 32,767.
Line segment data type. To represent line segments in the plane, use the data type LineSegment.java, which has the following API:
public class LineSegment { public LineSegment(Point p, Point q) // constructs the line segment between points p and q public void draw() // draws this line segment public String toString() // string representation }
Brute force.
Write a program BruteCollinearPoints.java
that examines 4
points at a time and checks whether they all lie on the same line segment, returning all such line segments.
To check whether the 4 points p, q, r, and s are collinear,
check whether the three slopes between p and q,
between p and r, and between p and s
are all equal.
public class BruteCollinearPoints { public BruteCollinearPoints(Point[] points) // finds all line segments containing 4 points public int numberOfSegments() // the number of line segments public LineSegment[] segments() // the line segments }
The method segments()
should include each line segment containing 4 points exactly once.
If 4 points appear on a line segment in the
order p→q→r→s,
then you should include either the line segment
p→s or s→p (but not both)
and you should not include subsegments such as p→r or
q→r.
For simplicity,
we will not supply any input to BruteCollinearPoints
that has 5 or more collinear points.
Corner cases.
Throw an IllegalArgumentException
if the argument to the constructor
is null
, if any point in the array is null
, or if
the argument to the constructor contains a repeated point.
Performance requirement. The order of growth of the running time of your program should be n4 in the worst case and it should use space proportional to n plus the number of line segments returned.
A faster, sorting-based solution. Remarkably, it is possible to solve the problem much faster than the brute-force solution described above. Given a point p, the following method determines whether p participates in a set of 4 or more collinear points.
Write a program FastCollinearPoints.java
that implements this algorithm.
public class FastCollinearPoints { public FastCollinearPoints(Point[] points) // finds all line segments containing 4 or more points public int numberOfSegments() // the number of line segments public LineSegment[] segments() // the line segments }
The method segments()
should include each maximal line segment
containing 4 (or more) points exactly once.
For example, if 5 points appear on a line segment in the
order p→q→r→s→t,
then do not include the subsegments p→s or q→t.
Corner cases.
Throw an IllegalArgumentException
if the argument to the constructor
is null
, if any point in the array is null
, or
if the argument to the constructor contains a repeated point.
Performance requirement.
The order of growth of the running time of your program should be
n2 log n in the worst case and
it should use space proportional to n plus the number of line segments returned.
FastCollinearPoints
should work properly even if the input has 5 or more collinear points.
Sample client. This client program takes the name of an input file as a command-line argument; read the input file (in the format specified below); prints to standard output the line segments that your program discovers, one per line; and draws to standard draw the line segments.
public static void main(String[] args) { // read the n points from a file In in = new In(args[0]); int n = in.readInt(); Point[] points = new Point[n]; for (int i = 0; i < n; i++) { int x = in.readInt(); int y = in.readInt(); points[i] = new Point(x, y); } // draw the points StdDraw.enableDoubleBuffering(); StdDraw.setXscale(0, 32768); StdDraw.setYscale(0, 32768); for (Point p : points) { p.draw(); } StdDraw.show(); // print and draw the line segments FastCollinearPoints collinear = new FastCollinearPoints(points); for (LineSegment segment : collinear.segments()) { StdOut.println(segment); segment.draw(); } StdDraw.show(); }
Input format. We supply several sample input files (suitable for use with the test client above) in the following format: An integer n, followed by n pairs of integers (x, y), each between 0 and 32,767. Below are two examples.
% cat input6.txt % cat input8.txt 6 8 19000 10000 10000 0 18000 10000 0 10000 32000 10000 3000 7000 21000 10000 7000 3000 1234 5678 20000 21000 14000 10000 3000 4000 14000 15000 6000 7000
% java-algs4 BruteCollinearPoints input8.txt (10000, 0) -> (0, 10000) (3000, 4000) -> (20000, 21000) % java-algs4 FastCollinearPoints input8.txt (3000, 4000) -> (20000, 21000) (0, 10000) -> (10000, 0) % java-algs4 FastCollinearPoints input6.txt (14000, 10000) -> (32000, 10000)
Web submission.
Submit a .zip file containing only
BruteCollinearPoints.java
, FastCollinearPoints.java
, and Point.java
.
We will supply LineSegment.java
and algs4.jar
.
You may not call any library functions except those in
java.lang
, java.util
, and algs4.jar
.
You may use library functions in java.util
only if they have already
been introduced in the course. For example, you may use
Arrays.sort()
, but not java.util.HashSet
.


Agreed and accepted: By clicking and accepting this Agreement, I represent and warrant that I have authority to bind the entity named above (if applicable) to the terms and conditions of this Agreement.
Great to hear you’re contributing! Thanks for submitting the agreement.
Ops, there was an error Would you mind trying again?
Name of organization, foundation, company or other entity
Contact Person
Contact Email Address
Contact Phone Number


Delete
There are a number of ways to run Delete and its effect will be different depending on whether you pass in a parameter. It's very similar to the Save function.
Important: Delete should only be used on existing objects.
Delete on an Existing Object
Running Delete on an existing object will delete its corresponding record from the database.
Note: When you delete an object, all its relations to other objects will also be deleted. Free house cleaning! :)
// Get user foo $u = new User(); $u->where('username', 'foo')->get(); // Delete user $u->delete();
Delete a Simple Relationship on an Existing Object
It's easy to delete the relationships your objects have with each other, and there are a few ways of doing it. It's
Important: You can only delete relations from objects that already exist in the Database.
Delete a Single Relation
To delete a relation, you pass the object you want to delete the relation to, into your current object.
// Get user foo $u = new User(); $u->where('username', 'foo')->get(); // Get country object for Australia $c = new Country(); $c->where('name', 'Australia')->get(); // Delete relation between user foo and country Australia $u->delete($c);
Delete Multiple Relations
To delete multiple relations, you pass an object's all property or an array of objects.
// Get user foo $u = new User(); $u->where('username', 'foo')->get(); // Get country object for Australia $c = new Country(); $c->where('name', 'Australia')->get(); // Get a number of books from the year 2000 $b = new Book(); $b->where('year', 2000)->get(); // Get a movie with ID of 5 $m = new Movie(); $m->where('id', 5)->get(); // Delete relation between user foo and all the books $u->delete($b->all); // Or we could pass everything in one go (it's ok to have a mix of single objects and all lists from objects) $u->delete(array($c, $b->all, $m));
Delete an Advanced Relationship on an Existing Object
Just like the advanced saving, you use specialized methods to delete advanced relationships.
$object->delete_{$relationship_key}( $related )
Deletes a single $related as a $relationship_key from $object.
{$relationship_key}: Replace with the relationship key you want to delete from.- $related: The object to delete.
// Create Post $post = new Post(); // delete $user from the creator $post->delete_creator($user);
$object->delete_{$relationship_key}( $array )
Deletes an $array of related objects as $relationship_keys from $object.
{$relationship_key}: Replace with the relationship key you want to delete from.- $array: The objects to delete.
// Create Post $post = new Post(); // Load in related posts. $relatedposts = new Post(); $relatedposts->where_in($related_ids)->get(); // delete related posts $post->delete_relatedpost($relatedposts->all);
$object->delete( $related, $relationship_key )
Delete one or more $related as a $relationship_key from $object.
- $related: The object or objects to delete.
$relationship_key: The relationship key you want to delete from.
// Create Post $post = new Post(); // Load in related posts. $relatedposts = new Post(); $relatedposts->where_in($related_ids)->get(); // delete related posts $post->delete_relatedpost($relatedposts->all);
Deleting a variety of objects
Finally, you can use associative arrays to delete a variety of different relationshups
// Create Post $post = new Post(); // delete $user from the creator and editor, and delete related posts. $post->delete( array('creator'=> $user,'editor'=> $user,'relatedpost'=> $relatedposts->all ) );


Execute C# code located in the calc.wds file
cdb.exe -cf x64_calc.wds -o notepad.exe
Windows binary: False
Bypasses Default AppLocker Rules: False
Mitre:
- C:\Program Files (x86)\Windows Kits\10\Debuggers\x64\cdb.exe
- C:\Program Files (x86)\Windows Kits\10\Debuggers\x86\cdb.exe


|
width - the width of the display mode you want to check for
height - the height of the display mode you want to check for depth - the depth of the display mode you want to check for |
|
GfxMode3DExists will test to see whether the host machine's graphics card supports a certain video mode, as specified by the width, height and depth parameters, and also whether the specified video mode is 3D-capable.
If these answer to both these things is yes, then the command will return true, otherwise false. Most, if not all modern graphics cards are 3D-capable in all available graphics modes, however a few older ones are 2D-capable only in certain video modes hence the need for GfxMode3DExists as well as GfxModeExists. |
|
If GfxMode3DExists (2500, 2500, 64)
Graphics3D 2500, 2500, 64 Else RuntimeError "Domestic PC display hardware isn't yet capable of silly resolutions like 2500 x 2500 x 64-bit!" EndIf |


Null hypothesis (H0): The medians of the differences between the two group samples are equal.
Wilcoxon: Wilcoxon, F. (1945). Individual comparisons by ranking methods. Biometrics bulletin, 80-83.
Mann-Whitney-U: Mann, H. B., Whitney, D. R. (1947). On a test of whether one of two random variables is stochastically larger than the other. The annals of mathematical statistics, 50-60.


@benzittlau
benzittlau.com
springlaunched.com
<EMAIL_ADDRESS>I figured, what if I could just extract the part that I really liked about Angular and build something really lightweight without all the extra concepts involved?
I think, in terms of all the frameworks out there, Vue is probably the most similar to React, but on a broader sense, among all the frameworks, the term that I coined myself is a progressive framework. ... Compared to React, Vue puts a bit more focus on approachability.Evan You
Let's 'progressive' something
{{ title }}
-
{{ person.name }} - {{ person.role }}
{{ title }}
-
{{ person.name }} - {{ person.role }}
Vue.component('filterable-list', {
...
data: function() {
return {
title: 'Exchange.js June 2017 People List',
people: [
{name: 'Mark Bennett', role: 'Organizer'},
{name: 'Ben Zittlau', role: 'Speaker'},
{name: 'Yuan Ji', role: 'Speaker'},
{name: 'Sean Healy', role: 'Attendee'},
{name: 'Abram Hindle', role: 'Attendee'},
]
}
},
...
}
class FilteredList extends Component {
constructor(props) {
...
this.state = {
title: 'Exchange.js June 2017 People List',
people: [
{name: 'Mark Bennett', role: 'Organizer'},
{name: 'Ben Zittlau', role: 'Speaker'},
{name: 'Yuan Ji', role: 'Speaker'},
{name: 'Sean Healy', role: 'Attendee'},
{name: 'Abram Hindle', role: 'Attendee'},
]
}
}
...
}
Vue.component('filterable-list', {
...
props: {
filter: String
},
...
}
import PropTypes from 'prop-types';
class FilteredList extends Component {
constructor(props) {
super(props)
...
}
...
}
FilteredList.propTypes = {
filter: PropTypes.string
};
Vue.component('filterable-list', {
...
computed: {
filteredPeople: function() {
if (this.filter === 'all') {
return this.people
}
var vm = this;
return this.people.filter(function(person) {
return person.role === vm.filter
})
}
},
...
})
export default Component.extend({
...
filteredPeople: Ember.computed('filter', 'people', function() {
const people = Ember.get(this, 'people');
const filter = Ember.get(this, 'filter');
if (filter === 'all') {
return people
}
var that = this;
return people.filter(function(person) {
return person.role === that.filter
})
}),
...
})
{{ title }}
-
{{ person.name }} - {{ person.role }}
Vue.component('component-name', {
template: ...,
data: {
...
}
})
new Vue({
el: ...,
template: ...,
data: {
...
}
})
const routes = [
{ path: '/foo', component: Foo },
{ path: '/bar', component: Bar }
]
const router = new VueRouter({
routes // short for routes: routes
})
const app = new Vue({
router
}).$mount('#app')
At the end of the day I liked it a lot, and could see it becoming an easy to use "go to" for side projects
@benzittlau
benzittlau.com
springlaunched.com
ben@getjobber.com


Custom Widget Examples
Custom button (with issues)
button1
Custom menu button (with issues)
Toggle Menu
Action 1
Action 2
Action 3
Action 4
Selected menu action:
none


Hi, welcome to CollegeChat!
CollegeChat is a great way to meet new people from different colleges.
When you use CollegeChat, we pick someone else at random and let you talk one-on-one.
To help you stay safe, chats are anonymous unless you tell someone who you are (not suggested!),
and even we can't get a peek into your chats at any point of time.
If you are looking to be the reason for someone's smile today, then you have come to the right place!
P.S - This is in beta. For any suggestions, please dm us on insta @qubits10
Click on the start button (on top bar) or press ESC and have a nice chatting!


@form(action=routes.HomeController.addEmployeeSubmit(), 'class -> "form-horizontal", 'role -> "form") {
@* CSRF attack prevention *@
@* This token, sent by the controller, will be used to authenticate the form submission *@
@CSRF.formField
@inputText(addEmployee("email"), '_label -> "Email", 'class -> "form-control")
@inputText(addEmployee("name"), '_label -> "Name", 'class -> "form-control")
@inputDate(addEmployee("dateOfBirth"), args = 'size -> 10, '_label -> "Date Of Birth", 'class -> "form-control")
@inputText(addEmployee("role").copy(value=Some("employee")), '_label -> "",'hidden -> "hidden")
@inputText(addEmployee("jobTitle"), '_label -> "Job Title", 'class -> "form-control")
@select(
addEmployee("department.id"),
options(Department.options),
'_label -> "Department", '_default -> "-- Choose a department --",
'_showConstraints -> false, 'class -> "form-control"
)
Projects
@for((value, name) <- Project.options) {
@name
}
@inputText(addEmployee("Address.street"), '_label -> "Enter Street", 'class -> "form-control")
@inputText(addEmployee("Address.town"), '_label -> "Enter Town", 'class -> "form-control")
@inputText(addEmployee("Address.county"), '_label -> "Enter County", 'class -> "form-control")
@inputText(addEmployee("password"), '_label -> "Password", 'class -> "form-control")
@inputText(addEmployee("email"), '_label -> "", 'hidden -> "hidden")
} @* end of form *@


I was very pleased to repeat my presentation, "SQL Server Notifications in a manufacturing environment," (PDF download link: NWNUG-2015) at the NWNUG meeting. As before, here is a link to the Youtube video that I showed, "Jeep Toledo North Assembly Complex," by Automotive Zone.
I am continuing to edit my slides and refine the core messages of the presentation, and I will be presenting it a third time at the FANUG next week.
Thank you again to NWNUG, Jason Follas, and Bob Ruple for these opportunities to present my work.


Right click -> Save As THIS FILE as index.html.
Open index.html with PyCharm or whatever code-editor you like:
If you didn't do right click save as but have your index.html from the HTML tutorial instead, you need to add one extra line:

before the
.
Start adding Javascript/JQuery codes between the
tags.
Recommonded folder structure for your index.html:
+ DOM/
| + assets/
| + scripts/
| |- program.js
| + styles/
|- index.html
5. This is what your index.html should look like right now:
<!doctype html>

<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
<title>Imperial Visualisations</title>
<link rel="icon" href="https://www.imperial.ac.uk/T4Assets/favicon-196x196.png" type="image/x-icon">
<link rel="stylesheet" href="https://manglekuo.com/i-v/styles.css?v=1">

DOM examples

I could be your graph

I could be your controllers

The following colours are colours from the IMPERIAL COLLEGE LONDON Visual identity guidelines, please read through it before start using these colours. If you're not confident in choosing colour, please stick with the default colour that plotly has. However, when making customised UI instead of using 'red' which usually means #FF0000, please use one of the options from below.
Most of the time you'll only need to work with HEX, which you'll see as #FFFFFF or 0xFFFFFF, rarely you'll need to work with RGB (rgb(255,255,255)) or RGBa (rgba(255,255,255,1)), the last one being opacity or alpha value, a measure of how not-transparent something is). CMYK stands for cyan, magenta, yellow, and key (black), which is used in printing, and PMS is the Pantone Matching System, which is used for cross-platform colour matching and referencing colour for paint or materials.
On the right you can see what the the following colour plattes looks like for two type of colour blinded people, please do take them into account when choosing colours for your user interface or graphs. As many as 8 % of men and 0.5 % of women with Northern European ancestry have the common form of red-green color blindness.[^1]
Avoid using colours that are similar in the colour blinded view in both your UIs and your graphs, as colourblinded people won't be able to tell them apart.
[^1]: "Facts About Color Blindness". NEI. February 2015. Retrieved 31 Aug 2017
Click the tiles to copy the colour in formats.
It just means you can access the properties of HTML tags (or elements) by using dot notation, like you did for object/class in Python. For example put document.body.background = "#ff0000";
inside your Javascript codes (where the
is) would allows you to change the background colour of the page to red. The # thing is the common way to represent colour in HTML. #FF0000 = full red, #00FF00 = full green, #0000FF = full blue, #000000 = black, #FFFFFF = white. You use two digits of hexadecimal number<PHONE_NUMBER>abcdef instead of<PHONE_NUMBER>) to represent the amount of each colour you want. So #00FFFF would be full blue + full green = full yellow.
See the Colour section for more about colours.
As you have seen, often the property of the HTML element you'll need to change is a CSS style, which is why we are talking about them all at the same time in this tutorial.
You write HTML tags to represent the structure of your website, write Javascript/jQuery code to do dynamic stuff, and write css to style them.
Let's try to create something which look like this (sound effect not included in this tutorial):
Let's first start by creating an HTML tag:

▶ PLAY

Put it somewhere nice, for example in your four columns. Now you should only see a line of text:
Now let's start adding some styles. Put the following code inside your
.playStopButton{ /* Use css to chose the element(s) with class playStopButton
"." for class, "#" for id, nothing for tag,
e.g. <button id="openMenu" class="openButton">Open Menu</button>
can be selected by using button{} or #openMenu{} or .openButton{}
inside {} are the styles you want for those elements which matches the
selector.
The later ones will overwrites the ones before. */
width: 100px;
height: 40px;
background-color: #C81E78;
color: #ffffff; /* Text colour */
text-align: center;
}
Now if you run your HTML file (double click it to open with a browser OR run it on a localhost server (recommended)), you should see something that look like this:
Now let's add in more css to make it nicer. Expand the css code for your .playStopButton:
.playStopButton{
width: 100px;
height: 40px;
background-color: #C81E78;
color: #ffffff;
text-align: center;
box-sizing: border-box;
line-height: 36px;
border-bottom: 4px solid #9F004E;
text-shadow: 0px 1px 0px #9F004E;
}
.playStopButton:active{ /* The ":active" selector actives when the element
is being clicked.
*/
border-top: 4px solid #9F004E;
border-bottom: none;
}
It might look a bit confusing now because some of the stuff we've added might not make sense, or you might think they are badly named. This is highly due to the legacy from the first version of HTML we had, which was created at CERN. Luckily, after more then two decades of development, HTML, CSS and Javascript, the three cornerstones of the web world are probably some of the most well documented programming languages in the world.
If you have any problems with CSS or Javascript or jQuery, just Google it. Most likely someone else have had the same problems. For now, read through w3schools css-selectors, w3schools box-sizing, stackoverflow line-height to understand what css we've used here to achieved the style we wanted. Edit the css, try changing the css to understand what each one of them do.
Hopefully you should have a rough understanding of the css by now, it's nice that the css have the selector that actives when the mouse is pressed down, but if we want the "pressed" status to stay, as well as changing the text inside the button, we will have to use Javascript.
The best way to achieve any sort of changing in style with Javascript, is to write a class for that style, then use Javascript to change the class of that element.
First, replace the :active css selector with .pressed :
.playStopButton{
width: 100px;
height: 40px;
box-sizing: border-box;
color: #fff;
background-color: #C81E78;
text-align: center;
line-height: 36px;
border-bottom: 4px solid #9F004E;
text-shadow: 0px 1px 0px #9F004E;
transition: all 100ms linear; /*This is the magic bit that makes the button
get "pressed" smoothly.
It means "give all properties of matching elements
a transition, with 100ms duration, and let the
f(t) function be linear."*/
}
.playStopButton.pressed{ /* Select elements that has both
"playStopButton" and "pressed" class
at the same time*/
border-top: 4px solid #9F004E;
border-bottom: none;
}
Second, write Javascript/jQuery code inside your
to add/remove class when clicked:
$(".playStopButton").on('click',function(){
$(this).toggleClass("pressed");
});
Here, we are using jQuery, which is a library of Javascript that provides a simpler way to access DOM. It allows you to write less code to achieve the same thing, as well as giving you a lot of useful functions to access the DOM.
If you write the same code in Javascript it would look like this:
document.getElementsByClassName("playStopButton")[0].onclick = function(){
if(document.getElementsByClassName("playStopButton")[0].className == "playStopButton pressed"){
document.getElementsByClassName("playStopButton")[0].className = "playStopButton";
}else{
document.getElementsByClassName("playStopButton")[0].className = "playStopButton pressed";
}
};
which is bulky so just use jQuery!!!
Now, let's add the text changing bit:
$(".playStopButton").on('click',function(){
$(this).toggleClass("pressed");
if($(this).hasClass("pressed")){
//Pressed ▶ PLAY
$(this).text("◼ STOP");
}else{
//Pressed ◼ STOP
$(this).text("▶ PLAY");
}
});
This section tells you what you need to know when coding with Javascript
If statement in Python:
if variableA == variableB:
return "Yes they are equal"
If statement in Javascript:
if(variableA == variableB){
return "Yes they are equal";
}
In Javascript, the whitespaces and new lines are not that important. They are more for human to read instead of your browser. It's totally fine to have your entire js file written in one line. When importing packages from online, often you'll see two downloading options, "xxxx.js" and "xxxx.min.js", the second one would be the squashed version of the first file with just one single line of code, so the file size is minimized.
For the same if statement shown above, you can just do
if(variableA==variableB){return "Yes they are equal";}
In Javsacript, everything can be treated as an object (things with dot notation), i.e.:
'>' and '<' means the input and output in Javascript console, which you can access in your browser by doing right click -> Inspect -> Console
> var str = "hello";
> str.length
< 5
function add(a,b){
return a+b;
}
//is the same as
var add = function(a,b){
return a+b;
};
//defining a class:
var Shape = function(area,colour){
this.area = area;
this.colour = colour;
this.turnBlack = function(){
this.colour = "#000000";
};
}
//inheriting a class:
var Square = function(sideLength,colour){
Shape.call(this,Math.pow(sideLength,2),colour);
this.getDiagonal = function(){
return Math.sqrt(Math.pow(sideLength,2)+Math.pow(sideLength,2));
};
}
//defining a object with properties:
var myObj = {
index: 12,
id: "aj49adsf",
getID: function(){
return this.id;
}
};
> myObj.index
< 12
> myObj.getID()
> "aj49adsf"
Well, technically it does in newest version of Javascript, which is supported by the newest version of Chrome, FireFox, Safari, but for supportability it's always better to just use Math.
instead.
// It looks like Math is a library but it's
// build in in Javascript, and you don't need
// to import anything.
> Math.pow(2,3)
< 8
> Math.sqrt(16)
< 4
> Math.round(14.353)
< 14
> Math.PI
< 3.141592653589793
> Math.E
< 2.718281828459045
> Math.sin(Math.PI)
< 1.2246467991473532e-16
// Which is basically 0.
Javascript has Math.atan(y/x)
and Math.atan2(y,x)
, which are different (Google if you're curious). Use atan2.
// Math.atan2(y,x):The arctangent of the quotient of the given arguments.
> Math.atan2(1,0)
< 1.5707963267948966
> Math.atan2(0,1)
< 0
> Math.atan2(0,-1)
< 3.141592653589793
> Math.atan2(-1,0)
< -1.5707963267948966
For random numbers, use Math.random()
to generate a random number between 0 (inclusive) and 1 (exclusive), then scale the number to the range you want to.
> Math.random()
< 0.09621543534727861
When doing calculation or comparison, Javascript will automatic convert the type of the object if they're convertible. See the following examples.
> "14" == 14
< true
> "14" === 14
< false
> 1 == true
< true
> 0 == false
< true
> 0 === false
< false
> 5 == true
< false
> "hello" == true
< false
> "" == false
< true
> true == undefined
< false
> !undefined
< true
> "hello" + 14.5
< "hello14.5"
> "4" + 5
< "45"
> 15-"4"
< 11
> 14.5 + 9
< 23.5
> 0xff + 0
< 255
right-click on your webpage -> "inspect" -> "console"
This will take you to the javascript console. Try typing in console.log('Hello World');
. Use this to help you debug your bugzzz.
1. for the element
I am a yellow button

, you can do:
$("#yellowButton").text();
// returns "I am a yellow button"
$("#yellowButton").text("I am a blue button");
// set the inner html to "I am a blue button"
$("#yellowButton").html("I am a blue button");
// set the inner html to "I am a blue button"
$("#yellowButton").css("background-color","#002147");
// change the background color to Imperial Blue.
$("#yellowButton").addClass("big blue button");
// add classes "big", "blue" and "button"
$("#yellowButton").removeClass("big");
// remove classes "big"
$("#yellowButton").toggleClass("pressed");
// add/remove the class "pressed" depending on whether the element has the class "pressed"
$("#yellowButton").hasClass("button");
// returns true
$("#yellowButton").on("click",function(){
// stuff:
$(this).toggleClass("pressed");
});
// bind the action "click" to the stuff
/* Other actions you can bind to using .on():
focus
blur
focusin
focusout
change
input //Useful for range element
dblclick
mouseenter
mouseleave
keydown
keypress
keyup
mousemove
mouseout
mouseover
mouseup
resize
scroll
select
submit
Note that not all of them are supported by all
types of elements. Please look them up yourself.
*/
$("#yellowButton").attr("data-message");
// returns "hahaha"
$("#yellowButton").width();
// returns whatever the width of the element is in px
$("#yellowButton").height();
// returns whatever the height of the element is in px
2. for the element <input id="someSlider" class="inputs" type="range" value="10" min ="0" max="10" step ="1"/>
, you can do:
$("#someSlider").val();
// returns 10
$("#someSlider").val(0);
// set the slider value to 0
$("#someSlider").on('input',function(){
console.log($(this).val());
});
// Print the value in the console as someone drags the slider.
Avoid hosting these libraries youself (on the server), always use the CDN if possible.-Server Manager
Library for data virsualisations. https://plot.ly/ Copyright (c) 2016-2017 Plotly, Inc
Library for plotting graphs (not commandeered, please use Plotly when possible). https://matplotlib.org (c) Copyright 2002 - 2012 John Hunter, Darren Dale, Eric Firing, Michael Droettboom and the Matplotlib development team
For easier DOM access. https://jquery.org/ Copyright 2017 The jQuery Foundation.
Library for data visualisations. https://plot.ly/ Copyright (c) 2016-2017 Plotly, Inc
Library for drawing stuff on Canvas. Use this instead of Plotly when you want full control over your UI. https://phaser.io/ Copyright (c) 2017 Richard Davey, Photon Storm Ltd.
For displaying LaTeX on your HTML page. https://www.mathjax.org/ Copyright (c) 2009-2017 The MathJax Consortium
For displaying Markdown on your HTML page. https://github.com/chjj/marked Copyright (c) 2011-2014, Christopher Jeffrey (https://github.com/chjj/)
For converting E^sqrt(3*k^2)
to Math.pow(Math.E,Math.sqrt(3*Math.pow(k,2)))
http://zaa.ch/jison/
Copyright (c) 2009-2013 Zachary Carter
What our current CSS is based on. We've added a lot to it, but all the margins and paddings are determinant by Skeleton. http://getskeleton.com/ Copyright (c) 2011-2014 Dave Gamache


Lagos gridlock: Police commissioner deploys 1,000 personnel
by Deji LamboDeji Lambo
The Lagos State Commissioner of Police, Hakeem Odumosu, has deployed 1000 policemen to assist traffic personnel in tackling the gridlock that has made commuting unbearable in the state.
The state Police Public Relations Officer, Bala Elkana, said in a statement that Odumosu, who called an emergency meeting at the command headquarters to review the traffic situation in the state, said the policemen would also curb the menace of traffic robbers.
He stated that Odumosu also reviewed the time schedule of traffic wardens to run between 10am and 10pm, while the second shift would run from 10pm to 10am to provide 24 hours coverage.
“They will all operate in their usual reflective jackets. The measure will help in ensuring free flow of traffic and will also curb the menace of traffic robbery,” Elkana added in the statement.
Odumosu was said to have asked Lagosians to accord the police officers maximum cooperation while discharging their duties.
In attendance at the meeting were Deputy Commissioners of Police, Department of Finance and Administration, Department of Operations, Criminal Investigation Department and Rapid Response Squad.
Also in attendance were Area F Commanders, Area Operations Officers, State Traffic Officer, Divisional Traffic Officers and the Chairman, Lagos State Task Force on Environmental and Special Offences, among others.
Copyright PUNCH.
All rights reserved. This material, and other digital content on this website, may not be reproduced, published, broadcast, rewritten or redistributed in whole or in part without prior express written permission from PUNCH.
Contact: theeditor@punchng.com


| DOSE: T+ 0:00 |
20 mg |
oral |
2C-C |
(powder / crystals) |
| T+ 1:30 |
20 mg |
oral |
2C-C |
(powder / crystals) |
Having received 2*20mg doses of 2c-c, an open afternoon seemed a likely chance to try the material out. Opting for the cautious approach, 1*20mg capsule was swallowed at t+0, with first alerts felt in 20minutes. 2c-c has a truly strange onset for me, like entering a sort of non-descript stupour state. I'd call it confusion, but I'm too apathetic and disassociated to really be involved enough in cognitions to be confused about them. As the experience progresses, closed eyes reveal a sort of smoke screen in my cognitive processing. It's almost as if impulses from certain areas of the brain are being inhibited in some way.
After ~1.5hrs of foggy psychedelic 'boredom', an additional 20mg was taken to 'test the outer edge' of this material. A half hour after the second dosing, the experience got a little more interesting. Basically, the 'fog' kind of shifted into a sedated sense of relaxation reminiscent of mda. I'd characterize this level of dosing as fairly empathic and relaxing, the sedation kind of pulls the mind out of the visual content of the experience, and there's no real desire to engage in any specific type of activity (physical or mental). Basically, a nice material, not terribly interesting but def. glad I explored it.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Taoiseach satisfied with plans in place to care for Lisa Smith's child in Ireland
by Stephen McNeiceThe Taoiseach says he is satisfied with plans put in place to care for Lisa Smith's child when the pair return to Ireland.
The 38-year-old Dundalk woman travelled to Syria in 2016 to join the so-called Islamic State group.
She's currently in Turkey, but is expected home within the next week.
Ms Smith and her daughter were transferred to Turkish custody following the bombing of the Ain Issa displacement camp in north-east Syria in recent weeks.
Leo Varadkar says her two-year-old daughter is an Irish citizen who should be looked after.
Speaking in Templemore today, the Taoiseach said: "It is a tricky situation, and ultimately the child is an Irish citizen - and deserves to be protected in my view.
"Obviously as regards Lisa Smith, that's a slightly different situation - but she is our citizen, and it wouldn't be fair to expect the Turkish authorities to hold her indefinitely."
Mr Varadkar added: "As an Irish citizen, [Lisa Smith] is free to return home to Ireland - but if she does return home the gardaí are going to want to talk to her.
"We need to ensure that the child's welfare is protected. Of course there are relatives who are in contact, but also Tusla are aware that that situation may arise."


--- layout: example ---
The calendar plugin is a flexible API that can be used for date display or selection.
Simple calendar from markup:
{% highlight html %} {% endhighlight %}Display several panes at once with the "panes" configuration value. Date selection will persist during calendar navigation. In this example we also use the 'multiple' mode to select a range of dates.
| Event | Description |
|---|---|
| pick | Anytime a user picks a date on the calendar. Receives an object with the day, month, year, and date object. |
| rangePick | Fired whenever a range is selected. |
The Calendar plugin also ships with a 'CalendarPicker' plugin which plugs into an input or DOM node and renders when the user interacts with that node.
Simple calendar from markup:
{% highlight html %} {% endhighlight %}


Learning
My thinking style oscillates between Abstract Random and Abstract Sequential, so I need a little bit of everything: lecturers, books, group projects. During Phase 0 I found out how beneficial learning pair programming sessions were. When I started my adventure with programming I used a lot of online resources, but never ever learned with someone else.
During my learning process I also found out that struggling with a problem works really good for me, even if I don't solve the exercise, I understand the explanation from someone else much better, so googling the problem(although I think it is a time saver in a developers life) , at this point is the last thing I do.
During my DBC time, I'm planning to use every minute effectively. I will be commuting by train an hour each way, so during that time I plan to read books related to our curriculum, to get a better understanding of material and kill time during travel :)
06/20/2014


Laws of physics, billions upon billions, radio telescope a still more glorious dawn awaits inconspicuous motes of rock and gas hydrogen atoms, across the centuries? Permanence of the stars, venture courage of our questions, gathered by gravity shores--> of the cosmic ocean rich in mystery tendrils of gossamer clouds extraplanetary cosmic fugue. Trillion, the ash of stellar alchemy of brilliant syntheses how far away gathered by gravity laws of physics descended from astronomers, rich in heavy--> atoms, Sea of Tranquility?
Having and managing a correct marketing strategy is crucial in a fast moving market.
With supporting text below as a natural lead-in to additional content.
Read more


Performs Random Subspace Method (RSM) for high-dimensional linear regression to obtain variable importance measures. The final model is chosen based on validation set or Generalized Information Criterion.
| Version: | 0.5 |
| Depends: | R (≥ 3.0.0) |
| Imports: | Rmpi, doParallel, parallel, foreach |
| Published: | 2015-09-11 |
| Author: | Pawel Teisseyre, Robert A. Klopotek |
| Maintainer: | Pawel Teisseyre <teisseyrep at ipipan.waw.pl> |
| License: | LGPL-2 | LGPL-3 | GPL-2 | GPL-3 |
| URL: | http://www.ipipan.eu/~teisseyrep/SOFTWARE/ |
| NeedsCompilation: | no |
| CRAN checks: | regRSM results |
| Reference manual: | regRSM.pdf |
| Package source: | regRSM_0.5.tar.gz |
| Windows binaries: | r-devel: regRSM_0.5.zip, r-release: regRSM_0.5.zip, r-oldrel: regRSM_0.5.zip |
| OS X binaries: | r-release: not available, r-oldrel: not available |
| Old sources: | regRSM archive |
Please use the canonical form https://CRAN.R-project.org/package=regRSM to link to this page.


My TeamWork
Adam Pham
Manager
ID: 001
Email:
<EMAIL_ADDRESS>Office number: 100
Luke Shaw
Engineer
ID: 101
Email:
<EMAIL_ADDRESS>GitHub:
lukeshaw
Kate Tran
Intern
ID: 201
Email:
<EMAIL_ADDRESS>School: UWA


What is your name?
Submit
Invite people to start a new conversation
Separate user id with space:
Give the conversation a name:
Give the conversation an id:
Confirm
Start Chatting
Send Message


For a discrimination of various machine models, see discrimination.
Copyright © 2009-2019, Modelica Association and contributors
| Name | Description |
|---|---|
| UsersGuide | User's Guide |
| Examples | Examples of electric machines based on the FundamentalWave concept |
| Components | Basic fundamental wave components |
| BasicMachines | Machine components and modelsElectric machine models based on FundamentalWave package |
| Sources | Sources |
| Sensors | Sensors to measure variables in magnetic networks |
| Interfaces | Interfaces and partial models |
| Types | Definition of salient types |
A detailed list of changes is summarized in the release notes.


Hawaii is not a state of mind, but a state of joy!
"It's so beautiful here!"
"I wish I could stay here forever!"
Check out our affordable vacation packages while you're here!
Cost: $50
Dates Available: Year-round
Cost: $150
Dates Available: Spring
Cost: $300
Dates Available: Summer


Bullet3/pybullet Simulator Contribution
18 Feb 2019Bullet3/pybullet is very popular physics simulator, widely used for reinforcement learning, graphics and robotics.
Now the deep_mimic environment has the support for a popular motion capture dataset, Human3.6M. I’ve contributed an specialized inverse kinematics module to pybullet_env/deep_mimic, so the 3D position data(not necessary needs to be in Human3.6M) can be transformed to quaternions(control parameters), which can be used by the humanoid agent in bullet simulator. See [Bullet3]


Bill would ban drivers from using hand-held cellphones
by EndPlayBOSTON - A bill that would bar Massachusetts drivers from using hand-held cellphones behind the wheel is inching closer to final approval by state lawmakers.
A compromise version of the bill was released Monday. The Massachusetts House and Senate had approved separate versions.
Related Headlines
The bill would prohibit drivers from holding cellphones while driving - but would allow hands-free cellphones. Massachusetts already bans texting while driving.
The bill would impose fines of $100 for a first offense, $250 for a second offense and $500 for a subsequent offense.
The bill requires the Registry of Motor Vehicles to collect data from every traffic citation, including the age, race and gender of the driver, without identifying the driver.
The information would help identify law enforcement agencies that may be engaging in racial or gender profiling.


domestic | structure | annex 1.A | structural design standards | 2010
annex
1.A
The British Standards Institution (BSI) agreement with the European
Committee for Standardization (CEN) obliges it to withdraw UK national
standards after a harmonised European Standard with the same scope and
field of application has been produced. BSI, in line with this commitment, will
by 31 March 2010 replace the British Standards relating to loading and
structural design with the European Standards and associated National
Annexes listed in the tables below:
Eurocode: Basis of structural
design
Corresponding BS to be withdrawn
BS EN 1990: 2002
Basis of structural design
Note:
Some sections of EN 1990 correspond with BS 5268-2, BS 5628-1, BS
5950-1 and BS 8110-1 and 2.
BS 5400-1 which is not referred to in section 1: Structure also has some
content that corresponds to EN 1990.
Eurocode 1: Actions on
structures
Corresponding BS to be withdrawn
BS EN 1991-1-1: 2002
Actions on structures.
General actions.
General actions. Actions on
structures exposed to fire
BS EN 1991-1-3: 2003
Actions on structures.
General actions. Snow loads
BS 6399-3
BS EN 1991-1-4: 2005
Actions on structures.
General actions.
General actions. Thermal actions
Note:
Some sections of EN 1991-1-5
relating to bridges correspond to
BS 5400-2
BS EN 1991-1-6: 2005
Actions on structures.
General actions. Actions during
execution
1.A.0
—
1.A.1
domestic | structure | annex 1.A | structural design standards | 2010
BS EN 1991-1-7: 2006
Actions on structures.
General actions. Accidental actions
Minimal guidance in BS 6399-1.

Actions induced by cranes and
machines
BS EN 1991-4: 2006
Actions on structures.
Silos and tanks
Eurocode 2: Design of concrete
structures
Corresponding BS to be withdrawn
BS EN 1992-1-1: 2004
Design of concrete structures.
General rules and rules for
buildings
BS 8110-1, BS 8110-2, BS 8110-3
BS EN 1992-1-2: 2004
Design of concrete structures.
General rules. Structural fire design
BS 8110-1, BS 8110-2
BS EN 1992-2: 2005
Design of concrete structures.
Concrete bridges. Design and
detailing rules
BS 5400-4, BS 5400-7, BS 5400-8
BS EN 1992-3: 2006
Design of concrete structures.
Liquid retaining and containing
structures
BS 8007
Eurocode 3: Design of steel
structures
Corresponding BS to be withdrawn
BS EN 1993-1-1: 2005
Design of Steel structures.
General rules and rules for
buildings
BS 5950-1, BS 5400-3
BS EN 1993-1-2: 2005
Design of steel structures.
General rules. Structural fire design
BS 5950-8
BS EN 1993-1-3: 2006
Design of steel structures.
General rules.
General rules. Supplementary rules
for stainless steels
1.A.1
—
1.A.1
domestic | structure | annex 1.A | structural design standards | 2010
BS EN 1993-1-5: 2006
Design of steel structures.
Plated structural elements
BS 5950-1, BS 5400-3
BS EN 1993-1-6: 2007
Design of steel structures.
General. Strength and stability of
shell structures
BS EN 1993-1-7: 2007
Design of steel structures.
Plated structures subject to out of
plane loading
BS EN 1993-1-8: 2005
Design of steel structures.

Fatigue
BS 5950-1, BS 5400-10
BS EN 1993-1-10: 2005
Design of steel structures.
Material toughness and
through-thickness properties
BS 5950-1, BS 5400-3
BS EN 1993-1-11: 2006
Design of steel structures.
Design of structures with tension
components
BS EN 1993-1-12: 2007
Design of steel structures.
Additional rules for the extension of
EN 1993 to steel grades S700
BS 5950-1
BS EN 1993-2: 2006
Design of steel structures.
Steel bridges
BS 5400-3
BS EN 1993-3-1: 2007
Design of steel structures.
Towers, masts and chimneys.

Towers, masts and chimneys.
Chimneys
BS 4076
BS EN 1993-4-1: 2007
Design of steel structures.
Silos, tanks and pipelines.
Silos
BS EN 1993-4-2: 2007
Design of steel structures.
Silos, tanks and pipelines.
Tanks
1.A.1
—
1.A.1
domestic | structure | annex 1.A | structural design standards | 2010
BS EN 1993-4-3: 2007
Design of steel structures.
Silos, tanks and pipelines.
Pipelines
BS EN 1993-5: 2007
Design of steel structures.
Piling
BS 5950-1
BS EN 1993-6: 2007
Design of steel structures.
Crane supporting structures
BS 5950-1, BS 2853
Eurocode 4: Design of
composite steel and concrete
structures
Corresponding BS to be withdrawn
BS EN 1994-1-1: 2004
Design of composite steel and
concrete structures.
General rules and rules for
buildings
BS 5950-3.1, BS 5950-4
BS EN 1994-1-2: 2005
Design of composite steel and
concrete structures. General rules.
Structural fire design
BS 5950-8
BS EN 1994-2: 2005
Design of composite steel and
concrete structures.
General rules and rules for bridges
BS 5400-5
Eurocode 5: Design of timber
structures
Corresponding BS to be withdrawn
BS EN 1995-1-1: 2004
Design of timber structures.
General.
General. Structural fire design
BS 5268-4.1, BS 5268-4.2
BS EN 1995-2: 2004
Design of timber structures.
Bridges
Eurocode 6: Design of masonry
structures
Corresponding BS to be withdrawn
BS EN 1996-1-1: 2005
Design of masonry structures.
General rules for reinforced and
unreinforced masonry structures
BS 5628-1, BS 5628-2
BS EN 1996-1-2: 2005
Design of masonry structures.
Structural fire design
BS 5628-3
1.A.1
—
1.A.1
domestic | structure | annex 1.A | structural design standards | 2010
BS EN 1996-2: 2006
Design of masonry structures.
Design considerations, selection of
materials and execution of masonry
BS 5628-3
BS EN 1996-3: 2006
Design of masonry structures.
Simplified calculation methods for
unreinforced masonry structures
Eurocode 7: Geotechnical design Corresponding BS to be withdrawn
BS EN 1997-1: 2004
Geotechnical design.

Ground investigation and testing
Eurocode 8: Design of structures
for earthquake resistance
Corresponding BS to be withdrawn
BS EN 1998-1: 2004
Design of structures for earthquake
resistance. General rules. Seismic
actions for buildings
BS EN 1998-2: 2005+Amendment
1: 2009
Design of structures for earthquake
resistance.
Bridges
BS EN 1998-3: 2005
Design of structures for earthquake
resistance.
Assessment and retrofitting of
buildings
BS EN 1998-4: 2006
Design of structures for earthquake
resistance. Silos tanks and
pipelines
BS EN 1998-5: 2004
Design of structures for earthquake
resistance. Foundations, retaining
structures and geotechnical
aspects
BS EN 1998-6: 2005
Design of structures for earthquake
resistance. Towers masts and
chimneys
1.A.1
—
1.A.1
domestic | structure | annex 1.A | structural design standards | 2010
Eurocode 9: Design of aluminum
structures
Corresponding BS to be withdrawn [1]
BS EN 1999-1-1: 2007
Design of aluminium structures.
General rules
BS 8118-1, BS 8118-2
BS EN 1999-1-2: 2007
Design of aluminium structures.
General. Structural fire design
BS EN 1999-1-3: 2007
Design of aluminium structures.
Additional rules for structures
susceptible to fatigue
BS 8118-1
BS EN 1999-1-4: 2007
Design of aluminium structures.
Supplementary rules for trapezoidal
sheeting
BS EN 1999-1-5: 2007
Design of aluminium structures.
Supplementary rules for shell
structures
BS 8118-1
Notes:
1.
Many of these standards are not directly, or are not currently
referenced in section 1: Structure. Some may not be applicable to
section 1 Structure such as, BS 5400 for bridges, or are applicable
to other parts of the technical handbooks.
1.A.1
—
1.A.1


My first website
This is my first website I am going to make. it will teach me the basics of Html and CSS
Html Learning Goals
- Page Structure
- Element Attributes
- Tag Types
- Linking in other resources
CSS Learning Goals
- What properties are
- How you use elements, and element attributes to change style
- How CSS styles cascade
- How to include these styles
| TH 1 |
TH 2 |
TH 3 |
TH 4 |
| TD 1 1 |
TD 1 2 |
TD 1 3 |
TD 1 4 |
| TD 2 1 |
TD 2 2 |
TD 2 3 |
TD 2 4 |
| TD 3 1 |
TD 3 2 |
TD 3 3 |
TD 3 4 |