Found elsewhere on the Internet (unattributed)On democracy in our Republic
The following excerpts are intended to make you consider some important questions about things you may have always taken for granted. The primary one being the perception that democracy is synonymous with freedom. It is not! And although many of our institutions include some form of democratic-like participation, We do not live in a Democracy for some very good reasons, some of which are stated below.Our Republic was founded upon the principles of Liberty (the right to do whatever one wishes so long as those actions do not infringe upon the equal rights of others) and limited government, not democracy. In fact, seldom if ever will one see reference to democracy in the founding documents of our nation, at least in a positive context. Peculiar, don't you think if we are suppose to live in a democracy as our politicians tell us?
Consider that in the past, we had Liberty coins, not democracy coins. We have the Statue of Liberty, not the Statue of Democracy. We pledge allegiance to the flag, and to the Republic for which it stands, not the democracy for which it stands. Patrick Henry said: "Give me Liberty or give me death!", not "Give me democracy or give me death".
So you may ask, if we live in a Republic founded upon the principles of Liberty and limited government, why do many of our politicians keep trying to shove this concept of democracy down our throats, as if freedom naturally followed? That is a very good question!
Perhaps they don't like the limits on the powers that have been granted them by our state and federal constitutions. Maybe because majority rule sounds legitimate and moral on its face, they wish to use our own ignorance to enslave us with the consent of the masses; and to extract from us every last penny that we have. Or maybe they have other self serving motivations. Whatever the case may be, only knowledge of our heritage will enable us to anticipate such schemes and act accordingly to right the direction of our Republic.
Please take the time and consider the following selected excerpts copied without permission from Chapter 3 of The Unseen Hand by A. Ralph Epperson:
It is generally conceded that even a monarchy or a dictatorship is an oligarchy, or a government run by a small, ruling minority.Such is also the case with a democracy, for this form of government is traditionally controlled at the top by a small ruling oligarchy. The people in a democracy are conditioned to believe that they are indeed the decision-making power of government, but in truth there is almost always a small circle at the top making the decisions for the entirety.
As proof of these contentions, one has only to read the 1928 United States Army Training Manual, which defined democracy as:
A government of the masses. Authority is derived through mass meeting or any other form of direct expression. Results in mobocracy, attitude toward property is communistic - negating property rights.Attitude toward law is that the will of the majority shall regulate, whether it be based on deliberation or governed by passion, prejudice, and impulse, without restraint or regard to consequence.
Result in demagogism, license, agitation, discontent, tyranny.
A democracy, according to this definition, is actually controlled by a demagogue, defined as: "A speaker who seeks to make capital of social discontent and gain political influence."
The 1928 definition of a democracy was later changed by those who write Army manuals, however.
In 1952, this became the definition of a democracy in the Soldier's Guide:
Because the United States is a democracy, the majority of the people decide how the government will be organized and run - and that includes the Army, Navy and Air Force. These people do this by electing representatives, and these men and women then carry out the wishes of the people.So if democracies are in truth oligarchies, where the minority rules, is there a form of government that protects both minority and majority rights?
There is, and it is called a republic, which is defined as:
Rule by law: a republic
In the republican form of government, the power rests in a written constitution. wherein the powers of the government are limited so that the people retain the maximum amount of power themselves. In addition to limiting the power of government, care is also taken to limit the power of the people to restrict the rights of both the majority and the minority.
Perhaps the simplest method of illustrating the difference between an oligarchy, a democracy and a republic would be to discuss the basic plot of the classic grade B western movie.
In this plot, one that the moviegoer has probably seen a hundred times, the brutal villain rides into town and guns down the unobtrusive town merchant by provoking him into a gunfight. The sheriff hears the gunshot and enters the scene. He asks the assembled crowd what happened, and they relate the story. The sheriff then takes the villain into custody and removes him to the city jail.
Back at the scene of the shooting, usually in a tavern, an individual stands up on a table (this individual by definition is a Demagogue) and exhorts the crowd to take the law into its own hands and lynch the villain. The group decides that this is the course of action that they should take (notice that the group now becomes a democracy where the majority rules) and down the street they (now called a mob) go. They reach the jail and demand that the villain be released to their custody. The mob has spoken by majority vote: the villain must hang.
The sheriff appears before the democracy and explains that the villain has the right to a trial by jury. The demagogue counters by explaining that the majority has spoken: the villain must hang. The sheriff explains that his function is to protect the rights of the individual, be he innocent or guilty, until that individual has the opportunity to defend himself in a court of law. The sheriff continues by explaining that the will of the majority cannot deny the individual that right. The demagogue continues to exhort the democracy to lynch the villain, but if the sheriff is persuasive and convinces the democracy that he exists to protect their rights as well, the scene should end as the people leave, convinced of the merits of the arguments of the sheriff.
The republican form of government has triumphed over the democratic form of mob action.
In summary, the sheriff represents the republic, the demagogue the control of the democracy, and the mob the democracy. The republic recognizes that man has certain inalienable rights and that government is created to protect those rights, even from acts of the majority. Notice that the republic must be persuasive in front of democracy and that the republic will only continue to exist as long as the people recognize the importance and validity of the concept. Should the people wish to overthrow the republic and the sheriff, they certainly have the power (but not the right) to do so.
But the persuasive nature of the republic's arguments should convince the mob that it is the preferable form of government.
It is easy to see how a democracy can turn into tyranny when unscrupulous individuals wish to manipulate it. The popular beliefs of the majority can be turned into a position of committing some injustice against an individual or group of individuals. This then becomes the excuse for the unscrupulous to grab total power, all in an effort to "remedy the situation."
Alexander Hamilton was aware of this tendency of a democratic form of government to be torn apart by itself, and he has been quoted as writing: "We are now forming a republican form of government. Real liberty is not found in the extremes of democracy, but in moderate governments. If we incline too much to democracy, we shall soon shoot into a monarchy (or some other form of dictatorship.)"
Others were led to comment on the perils of democratic forms of government. One was James Madison who wrote: "In all cases where a majority are united by a common interest or passion, the rights of the minority are in danger!" Another was John Adams who wrote: "Unbridled passions produce the same effects, whether in a king, nobility, or a mob. The experience of all mankind has proved the prevalence of a disposition to use power wantonly. It is therefore as necessary to defend an individual against the majority (in a democracy) as against the king in a monarchy."
George Washington, in his farewell address to the American people as he was leaving the presidency, spoke about the amending of the Constitution:
If in the opinion of the people, the distribution or modification of the Constitutional power be in any particular wrong, let it be corrected by an amendment in the way in which the Constitutional designates. But let there be no change by usurpation, for though this, in one instance, may be the instrument of good, it is the customary weapon by which free governments are destroyed.
It was about the same time that a British professor named Alexander Fraser Tyler wrote: "A democracy cannot exist as a permanent form of government. It can exist only until the voters discover they can vote themselves largess (defined as a liberal gift) out of the public treasury. From that moment on, the majority always votes for the candidate promising the most benefits from the public treasury, with the result that democracy always collapses over a loose fiscal policy, always to be followed by a dictatorship."


Happy Halloween, SANDies!
🎃🎃🎃🎃🎃🎃🎃🎃🎃🎃
Our yearly tradition continues with a spookily-themed Halloween raffle, and this year members voted on what kind they would like! Halloween is vastly different this year compared to previous ones. It’s been a tough year for all of us, so it’s the hope of SAND leadership that this raffle can provide some happiness and prizes for you. For this raffle we have two prize pools you can win from:
400 Gems
400 Gems
Various Halloween-themed in-game items:
1 Raffle Ticket = 1 gold deposited into any of the guild bank tabs.
We have a tracker set up that utilizes an API key to pull the date, account name, and amount of gold deposited. This will track consistently until the raffle ends. There is no limit to how many raffle tickets you can purchase! Members can only win one set of Gems. Winners of the Gem prizes are eligible to win up to one (1) additional in-game prize, whereas members who do not win a Gem prize can win two (2) in-game prizes total.
Raffle tickets are purchasable from 10/26 - 11/08/2020 at 11:59 pm PST.
Additional information:
- The Gem prizes will be redeemed through a request system. They will be used by gifting the items requested from the Gem Store
- Winners of Gem prizes are allowed to request that they put their Gems on hold until they want to request something that catches their interest. Additionally, winners are allowed to request items more expensive than 400 Gems - they will be required to provide the difference in gold so that Moon can convert to Gems.
- Winners will be chosen through a Random Number Generator that uses the API system tracker. Each gold donated will be assigned a number when it is donated, starting at 1 and going up consecutively. Donating gold in bulk to purchase multiple tickets at a time will not break this system and is perfectly a-okay.
- All officers are eligible to win prizes - Moon does not participate.
- A special thank you to everyone who has helped made this raffle possible over the years, and to all of you who continue to support our guild with your time and help!
Good luck SANDies, and Happy Candy Day!
🎃🎃🎃🎃🎃🎃🎃🎃🎃🎃


Wong Ming Hao
President
wong.minghao [at] nes.org.sg
Lim Lay Ting
Vice-President (CORE)
lim.layting [at] nes.org.sg
Dhruv K Jaura
Vice-President (Global Projects)
dhruv [at] nes.org.sg
Alex Tan
Lead, Start-Up@Singapore
alextan [at] startup.org.sg


Directions
Answer the following items.
- Correct answers are marked with a check mark (✔), while incorrect answers are with an X (✘).
Mary had a little
its fleece was
as
.
Fill-in-the-Blanks item explanation.
ODU's colors are combination of
and
.
Fill-in-the-Blanks item explanation.
Complete the equation: 1 <
< 5
Fill-in-the-Blanks item explanation.


All routines in the Limits module are exported qualified (and thus must be prefaced with "Limits.") except maxint, maxnat, minint and minnat, which are exported unqualified (this means you can call those entry points directly).
| DefaultFW | Default fraction width used in printing using the "put" statement. | |
| DefaultEW | Default exponent width used in printing using the "put" statement. | |
| minint | The minimum integer in Turing (exported unqualified). | |
| maxint | The maximum integer in Turing (exported unqualified). | |
| minnat | The minimum natural number in Turing (exported unqualified). | |
| maxnat | The maximum natural number in Turing (exported unqualified). |
Real numbers are represented in Turing as:
f * (radix ** e) or 0
where for non-zero f:
(1 / radix) <= abs (f) and abs (f) < 1.0
minexp <= e and e <= maxexp.
| Radix | The "radix" (usually 2). | |
| NumDigits | The number of radix digits in f. | |
| MinExp | "minexp" (the smallest exponent allowed). | |
| MaxExp | "maxexp" (the largest exponent allowed). | |
| GetExp | Function that returns the value of "e". | |
| SetExp | Procedure that sets the value of "e". | |
| Rreb | The relative round-off error bound. |


HMW-Alexander
Back to Parent
Contents
Introduction
Parametric Models: From Data to Models
Parametric Models: Prior Information, From Models to Answer
Linear Regression
Logistic Regression
Naive Bayes Classifier
Basic Probability
Linear Algebra
MLE, MAP, and Vector Matrix Differentiation


Russia says it's ready to work with new interim Bolivian leader
MOSCOW (Reuters) - Russia said on Thursday it was ready to work with Bolivia’s new interim leader, but noted that she had come to power without having a full quorum in parliament.
Jeanine Anez, the Senate vice-president, stepped in as interim leader on Tuesday after long-time president Evo Morales resigned under pressure on Sunday in what Russia has compared to an orchestrated coup.
Moscow had good ties with Morales, who visited Russia for talks with President Vladimir Putin as recently as June.
Anez was forced to declare herself president after legislators from Morales’ Movement for Socialism party boycotted her swearing in. She instead invoked a constitutional clause as the next person in line to succeed the president.
On Thursday, Russian Deputy Foreign Minister Sergei Ryabkov said “We noted... that at the moment of her confirmation in this role, there was not a full quorum so we see certain moments here that we will of course take into account,” RIA news agency reported.
“But clearly, she will be recognized as Bolivia’s new leader until the question of a new president is resolved with elections,” he said.


[PRIVATE] Return some infomation about the data subset so that it's easier to parse later
Object
subset
:
can be a typedArray or a complex object
Object
:
reconstruction info about this subset
Set a boolean to secify if data should be compressed or not
Boolean
b
:
true to compress, false to not compress
Get the output
Object
:
the output, or null
reset inputs and inputs
Launch the encoding of the block
Specify an input to the encoder
Object
obj
:
an object candidate, containing a _data and _metadata attributes
[STATIC] Give in what case we fall when we want to use this data. Cases are described at the top
Whatever
data
:
a piec of data, object, array, typed array...
Number
:
the case
Check if the given object is a good intput candidate
Object
obj
:
an object candidate, containing a _data and _metadata attributes
Boolean
:
true if good candidate, false if not
Get the array type based on byte stream info. The returned object can be used as a constructor
Function
:
constructor of a typed array
Get the output
Object
:
the output, or null
reset inputs and inputs
Specify an input
ArrayBuffer
buff
:
the arraybuffer that contains some data to be deserialized
A PixBinDecoder instance decodes a *.pixp file and output an Image2D or Image3D.
The input, specified by .addInput(...)
must be an ArrayBuffer
(from an UrlToArrayBufferFilter
, an UrlToArrayBufferReader
or anothrer source ).
Usage
#_parseIndex
[PRIVATE]
[PRIVATE]
#enableBlockVerification(b)
Specify wether or not the bin decoder must perform a checksum verification for each block to be decoded.
Specify wether or not the bin decoder must perform a checksum verification for each block to be decoded.
Boolean
b
:
true to perfom verification, false to skip it (default: false)
#fetchBlock(n, forceDecoding)
Fetch a block at the given index. The first time it called on a block,
this block will be read from the stream and decoded.
If a block is already decoded, it will be retrieved as is without trying to
re-decode it, unless forceDecoding
is true
.
Fetch a block at the given index. The first time it called on a block,
this block will be read from the stream and decoded.
If a block is already decoded, it will be retrieved as is without trying to
re-decode it, unless forceDecoding
is true
.
Number
n
:
the index of the block to fetch
Boolean
forceDecoding
:
force the decoding even though it was already decoded
Object
:
the decoded block, containing _data_
, _metadata
and originalBlockType
#getBinCreationDate
Get the creation date of the file in the ISO8601 format
Get the creation date of the file in the ISO8601 format
String
:
the data
#getBinDescription
Get the description of the PixBin file
Get the description of the PixBin file
String
:
the description
#getBinUserObject
The userObject is a generic container added to the PixBin. It can carry all sorts of data. If not specified during encoding, it's null.
The userObject is a generic container added to the PixBin. It can carry all sorts of data. If not specified during encoding, it's null.
Object
:
the userObject
#getNumberOfBlocks
Get the number of blocks encoded in this PixBin file
Get the number of blocks encoded in this PixBin file
Number
#getOutput
Get the the decoded output
Get the the decoded output
Object
:
a decoded object
#isValid
To be called after setInput. Tells if the buffer loaded is valid or not.
To be called after setInput. Tells if the buffer loaded is valid or not.
Boolean
:
true if valid, false if not.
#reset
reset I/O and data to query
reset I/O and data to query
#setInput(buff)
Specify an input
Specify an input
ArrayBuffer
buff
:
the input
A PixBinEncoder instance takes an Image2D or Image3D as input with addInput(...)
and encode it so that it can be saved as a *.pixp file.
An output filename can be specified using .setMetadata("filename", "yourName.pixp");
,
by default, the name is "untitled.pixp".
When update()
is called, a gzip blog is prepared as output[0] and can then be downloaded
when calling the method .download()
. The gzip blob could also be sent over AJAX
using a third party library.
Usage
.MAGIC_NUMBER
[static] the first sequence of bytes for a pixbin file is this ASCII string
[static] the first sequence of bytes for a pixbin file is this ASCII string
#addInput(obj)
Add an input. Multiple inputs can be added.
Add an input. Multiple inputs can be added.
Object
obj
:
an object that comtain _data and _metadata
#enableDataCompression(b)
Set a boolean to secify if data should be compressed or not
Set a boolean to secify if data should be compressed or not
Boolean
b
:
true to compress, false to not compress
#getOutput
Get the output
Get the output
ArrayBuffer
:
the encoded data as a buffer
#reset
[PRIVATE] reset inputs and inputs
[PRIVATE] reset inputs and inputs
#run
Launch the encoding
Launch the encoding
#setOption(optionName, value)
Overwrite one of the default options.
Overwrite one of the default options.
String
optionName
:
one of "madeWith" (default: "pixbincodec_js"), "userObject" (default: null), "description" (default: null)


{% extends "base.html" %} {% block content %} {% if current_user.id == account.id or current_user.is_super %}
Hello {{ account.id }}. As a signed in user you can create new pages by just going to the URL of the page you wish to create. When you create a page you can edit it via an etherpad, and other people can edit it with you. You can use plain test or markdown or HTML. You can also upload supporting media on the /media page. It can then be included in your posts just by linking to /media/FILENAME.
{% if current_user.is_super %}{{ account.data.description }}
{% if current_user.id == account.id %} Logout or Manage media {% endif %} {% if current_user.is_super and current_user.id == account.id %} or Manage user accounts {% endif %}
{% else %}{{ account.data.description }}
You are not logged in as this user. Use the login page if you want to change this


: Support for Java 8 Date and Time API types. -
jackson-datatype-jdk8
: Support for other Java 8 types, such asOptional
.
1.11.7. View Resolvers
The following example shows how to configure view resolution:
@Configuration
@EnableWebFlux
class WebConfig : WebFluxConfigurer {
override fun configureViewResolvers(registry: ViewResolverRegistry) {
// ...
}
}
The ViewResolverRegistry
has shortcuts for view technologies with which the
Spring Framework
integrates. The following example uses FreeMarker (which also requires configuring the
underlying FreeMarker view technology):
@Configuration
@EnableWebFlux
class WebConfig : WebFluxConfigurer {
override fun configureViewResolvers(registry: ViewResolverRegistry) {
registry.freeMarker()
}
// Configure Freemarker...
@Bean
fun freeMarkerConfigurer() = FreeMarkerConfigurer().apply {
setTemplateLoaderPath("classpath:/templates")
}
}
You can also plug in any ViewResolver
implementation, as the following example
shows:
@Configuration
@EnableWebFlux
class WebConfig : WebFluxConfigurer {
override fun configureViewResolvers(registry: ViewResolverRegistry) {
val resolver: ViewResolver = ...
registry.viewResolver(resolver
}
}
To support Content
Negotiation and rendering other formats
through view resolution (besides HTML), you can configure one or more default views based
on the HttpMessageWriterView
implementation, which accepts any of the available
Codecs
from spring-web
. The following example shows how to do so:
@Configuration
@EnableWebFlux
class WebConfig : WebFluxConfigurer {
override fun configureViewResolvers(registry: ViewResolverRegistry) {
registry.freeMarker()
val encoder = Jackson2JsonEncoder()
registry.defaultViews(HttpMessageWriterView(encoder))
}
// ...
}
See View Technologies for more on the view technologies that are integrated with Spring WebFlux.
1.11.8. Static Resources
This option provides a convenient way to serve static resources from a list of
Resource
-based
locations.
In the next example, given a request that starts with /resources
, the relative
path is
used to find and serve static resources relative to /static
on the classpath.
Resources
are served with a one-year future expiration to ensure maximum use of the browser cache
and a reduction in HTTP requests made by the browser. The Last-Modified
header
is also
evaluated and, if present, a 304
status code is returned. The following list
shows
the example:
@Configuration
@EnableWebFlux
class WebConfig : WebFluxConfigurer {
override fun addResourceHandlers(registry: ResourceHandlerRegistry) {
registry.addResourceHandler("/resources/**")
.addResourceLocations("/public", "classpath:/static/")
.setCacheControl(CacheControl.maxAge(365, TimeUnit.DAYS))
}
}
The resource handler also supports a chain of
ResourceResolver
implementations and
ResourceTransformer
implementations,
which can be used to create a toolchain for working with optimized resources.
You can use the VersionResourceResolver
for versioned resource URLs based on an
MD5 hash
computed from the content, a fixed application version, or other information. A
ContentVersionStrategy
(MD5 hash) is a good choice with some notable exceptions
(such as
JavaScript resources used with a module loader).
The following example shows how to use VersionResourceResolver
in your Java
configuration:
@Configuration
@EnableWebFlux
class WebConfig : WebFluxConfigurer {
override fun addResourceHandlers(registry: ResourceHandlerRegistry) {
registry.addResourceHandler("/resources/**")
.addResourceLocations("/public/")
.resourceChain(true)
.addResolver(VersionResourceResolver().addContentVersionStrategy("/**"))
}
}
You can use ResourceUrlProvider
to rewrite URLs and apply the full chain of
resolvers and
transformers (for example, to insert versions). The WebFlux configuration provides a ResourceUrlProvider
so that it can be injected into others.
Unlike Spring MVC, at present, in WebFlux, there is no way to transparently rewrite static
resource URLs, since there are no view technologies that can make use of a non-blocking
chain
of resolvers and transformers. When serving only local resources, the workaround is to use
ResourceUrlProvider
directly (for example, through a custom element) and block.
Note that, when using both EncodedResourceResolver
(for example, Gzip, Brotli
encoded) and
VersionedResourceResolver
, they must be registered in that order, to ensure
content-based
versions are always computed reliably based on the unencoded file.
WebJars are also supported through the
WebJarsResourceResolver
which is automatically registered when the
org.webjars:webjars-locator-core
library is present on the classpath. The
resolver can
re-write URLs to include the version of the jar and can also match against incoming URLs
without versions — for example, from /jquery/jquery.min.js
to
/jquery/1.2.0/jquery.min.js
.
1.11.9. Path Matching
You can customize options related to path matching. For details on the individual options,
see the
PathMatchConfigurer
javadoc.
The following example shows how to use PathMatchConfigurer
:
@Configuration
@EnableWebFlux
class WebConfig : WebFluxConfigurer {
@Override
fun configurePathMatch(configurer: PathMatchConfigurer) {
configurer
.setUseCaseSensitiveMatch(true)
.setUseTrailingSlashMatch(false)
.addPathPrefix("/api",
HandlerTypePredicate.forAnnotation(RestController::class.java))
}
}
|
Spring WebFlux relies on a parsed representation of the request path called
Spring WebFlux also does not support suffix pattern matching, unlike in Spring MVC, where we are also recommend moving away from reliance on it. |
1.11.10. Advanced Configuration Mode
@EnableWebFlux
imports DelegatingWebFluxConfiguration
that:
-
Provides default Spring configuration for WebFlux applications
-
detects and delegates to
WebFluxConfigurer
implementations to customize that configuration.
For advanced mode, you can remove @EnableWebFlux
and extend directly from
DelegatingWebFluxConfiguration
instead of implementing
WebFluxConfigurer
,
as the following example shows:
@Configuration
class WebConfig : DelegatingWebFluxConfiguration {
// ...
}
You can keep existing methods in WebConfig
, but you can now also override bean
declarations
from the base class and still have any number of other WebMvcConfigurer
implementations on
the classpath.
1.12. HTTP/2
Servlet 4 containers are required to support HTTP/2, and Spring Framework 5 is compatible with Servlet API 4. From a programming model perspective, there is nothing specific that applications need to do. However, there are considerations related to server configuration. For more details, see the HTTP/2 wiki page.
Currently, Spring WebFlux does not support HTTP/2 with Netty. There is also no support for pushing resources programmatically to the client.
2. WebClient
Spring WebFlux includes a reactive, non-blocking WebClient
for HTTP requests. The client
has a functional, fluent API with reactive types for declarative composition, see
Reactive
Libraries. WebFlux client and server rely on the
same non-blocking codecs
to encode and decode request
and response content.
Internally WebClient
delegates to an HTTP client library. By default, it uses
Reactor Netty, there is built-in support for
the Jetty reactive
HttpClient,
and others can be plugged in through a ClientHttpConnector
.
2.1. Configuration
The simplest way to create a WebClient
is through one of the static factory methods:
-
WebClient.create()
-
WebClient.create(String baseUrl)
The above methods use the Reactor Netty HttpClient
with default settings and expect
io.projectreactor.netty:reactor-netty
to be on the classpath.
You can also use WebClient.builder()
with further options:
-
uriBuilderFactory
: CustomizedUriBuilderFactory
to use as a base URL. -
defaultHeader
: Headers for every request. -
defaultCookie
: Cookies for every request. -
defaultRequest
:Consumer
to customize every request. -
filter
: Client filter for every request. -
exchangeStrategies
: HTTP message reader/writer customizations. -
clientConnector
: HTTP client library settings.
The following example configures HTTP codecs:
val strategies = ExchangeStrategies.builder()
.codecs {
// ...
}
.build()
val client = WebClient.builder()
.exchangeStrategies(strategies)
.build()
Once built, a WebClient
instance is immutable. However, you can clone it and build a
modified copy without affecting the original instance, as the following example shows:
val client1 = WebClient.builder()
.filter(filterA).filter(filterB).build()
val client2 = client1.mutate()
.filter(filterC).filter(filterD).build()
// client1 has filterA, filterB
// client2 has filterA, filterB, filterC, filterD
2.1.1. Reactor Netty
To customize Reactor Netty settings, simple provide a pre-configured HttpClient
:
val httpClient = HttpClient.create().secure { ... }
val webClient = WebClient.builder()
.clientConnector(ReactorClientHttpConnector(httpClient))
.build()
Resources
By default, HttpClient
participates in the global Reactor Netty resources
held in
reactor.netty.http.HttpResources
, including event loop threads and a
connection pool.
This is the recommended mode, since fixed, shared resources are preferred for event loop
concurrency. In this mode global resources remain active until the process exits.
If the server is timed with the process, there is typically no need for an explicit
shutdown. However, if the server can start or stop in-process (for example, a Spring MVC
application deployed as a WAR), you can declare a Spring-managed bean of type
ReactorResourceFactory
with globalResources=true
(the default)
to ensure that the Reactor
Netty global resources are shut down when the Spring ApplicationContext
is
closed,
as the following example shows:
@Bean
fun reactorResourceFactory() = ReactorResourceFactory()
You can also choose not to participate in the global Reactor Netty resources. However, in this mode, the burden is on you to ensure that all Reactor Netty client and server instances use shared resources, as the following example shows:
@Bean
fun resourceFactory() = ReactorResourceFactory().apply {
isUseGlobalResources = false (1)
}
@Bean
fun webClient(): WebClient {
val mapper: (HttpClient) -> HttpClient = {
// Further customizations...
}
val connector = ReactorClientHttpConnector(resourceFactory(), mapper) (2)
return WebClient.builder().clientConnector(connector).build() (3)
}
| 1 | Create resources independent of global ones. |
| 2 | Use the ReactorClientHttpConnector constructor with
resource factory.
|
| 3 | Plug the connector into the WebClient.Builder . |
Timeouts
To configure a connection timeout:
import io.netty.channel.ChannelOption
val httpClient = HttpClient.create()
.tcpConfiguration { it.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 10000)}
To configure a read and/or write timeout values:
import io.netty.handler.timeout.ReadTimeoutHandler
import io.netty.handler.timeout.WriteTimeoutHandler
val httpClient = HttpClient.create().tcpConfiguration {
it.doOnConnected { conn -> conn
.addHandlerLast(ReadTimeoutHandler(10))
.addHandlerLast(WriteTimeoutHandler(10))
}
}
2.1.2. Jetty
The following example shows how to customize Jetty HttpClient
settings:
val httpClient = HttpClient()
httpClient.cookieStore = ...
val connector = JettyClientHttpConnector(httpClient)
val webClient = WebClient.builder().clientConnector(connector).build();
By default, HttpClient
creates its own resources (Executor
, ByteBufferPool
,
Scheduler
),
which remain active until the process exits or stop()
is called.
You can share resources between multiple instances of the Jetty client (and server) and
ensure that the resources are shut down when the Spring ApplicationContext
is
closed by
declaring a Spring-managed bean of type JettyResourceFactory
, as the following
example
shows:
@Bean
fun resourceFactory() = JettyResourceFactory()
@Bean
fun webClient(): WebClient {
val httpClient = HttpClient()
// Further customizations...
val connector = JettyClientHttpConnector(httpClient, resourceFactory()) (1)
return WebClient.builder().clientConnector(connector).build() (2)
}
| 1 | Use the JettyClientHttpConnector constructor with resource
factory.
|
| 2 | Plug the connector into the WebClient.Builder . |
2.2.
retrieve()
The retrieve()
method is the easiest way to get a response body and decode it.
The following example shows how to do so:
val client = WebClient.create("https://example.org")
val result = client.get()
.uri("/persons/{id}", id).accept(MediaType.APPLICATION_JSON)
.retrieve()
.awaitBody<Person>()
You can also get a stream of objects decoded from the response, as the following example shows:
val result = client.get()
.uri("/quotes").accept(MediaType.TEXT_EVENT_STREAM)
.retrieve()
.bodyToFlow<Quote>()
By default, responses with 4xx or 5xx status codes result in an
WebClientResponseException
or one of its HTTP status specific sub-classes, such as
WebClientResponseException.BadRequest
,
WebClientResponseException.NotFound
, and others.
You can also use the onStatus
method to customize the resulting exception,
as the following example shows:
val result = client.get()
.uri("/persons/{id}", id).accept(MediaType.APPLICATION_JSON)
.retrieve()
.onStatus(HttpStatus::is4xxClientError) { ... }
.onStatus(HttpStatus::is5xxServerError) { ... }
.awaitBody<Person>()
When onStatus
is used, if the response is expected to have content, then the onStatus
callback should consume it. If not, the content will be automatically drained to ensure
resources are released.
2.3.
exchange()
The exchange()
method provides more control than the retrieve
method.
The following example is equivalent
to retrieve()
but also provides access to the ClientResponse
:
val result = client.get()
.uri("/persons/{id}", id).accept(MediaType.APPLICATION_JSON)
.awaitExchange()
.awaitBody<Person>()
At this level, you can also create a full ResponseEntity
:
val result = client.get()
.uri("/persons/{id}", id).accept(MediaType.APPLICATION_JSON)
.awaitExchange()
.toEntity<Person>()
Note that (unlike retrieve()
), with exchange()
, there are no automatic
error signals for
4xx and 5xx responses. You have to check the status code and decide how to proceed.
When you use exchange() , you must always use any of the body
or toEntity methods of
ClientResponse to ensure resources are released and to avoid potential
issues with HTTP
connection pooling. You can use bodyToMono(Void.class) if no response
content is
expected. However, if the response does have content, the connection
is closed and is not placed back in the pool.
|
2.4. Request Body
The request body can be encoded from any asynchronous type handled by ReactiveAdapterRegistry
,
like Mono
or Kotlin Coroutines Deferred
as the following example
shows:
val personDeferred: Deferred<Person> = ...
client.post()
.uri("/persons/{id}", id)
.contentType(MediaType.APPLICATION_JSON)
.body<Person>(personDeferred)
.retrieve()
.awaitBody<Unit>()
You can also have a stream of objects be encoded, as the following example shows:
val people: Flow<Person> = ...
client.post()
.uri("/persons/{id}", id)
.contentType(MediaType.APPLICATION_JSON)
.body(people)
.retrieve()
.awaitBody<Unit>()
Alternatively, if you have the actual value, you can use the bodyValue
shortcut
method,
as the following example shows:
val person: Person = ...
client.post()
.uri("/persons/{id}", id)
.contentType(MediaType.APPLICATION_JSON)
.bodyValue(person)
.retrieve()
.awaitBody<Unit>()
2.4.1. Form Data
To send form data, you can provide a MultiValueMap<String, String>
as the
body. Note that the
content is automatically set to application/x-www-form-urlencoded
by the
FormHttpMessageWriter
. The following example shows how to use MultiValueMap<String,
String>
:
val formData: MultiValueMap<String, String> = ...
client.post()
.uri("/path", id)
.bodyValue(formData)
.retrieve()
.awaitBody<Unit>()
You can also supply form data in-line by using BodyInserters
, as the following
example shows:
import org.springframework.web.reactive.function.BodyInserters.*
client.post()
.uri("/path", id)
.body(fromFormData("k1", "v1").with("k2", "v2"))
.retrieve()
.awaitBody<Unit>()
2.4.2. Multipart Data
To send multipart data, you need to provide a MultiValueMap<String, ?>
whose values are
either Object
instances that represent part content or HttpEntity
instances that represent the content and
headers for a part. MultipartBodyBuilder
provides a convenient API to prepare a
multipart request. The following example shows how to create a MultiValueMap<String,
?>
:
val builder = MultipartBodyBuilder().apply {
part("fieldPart", "fieldValue")
part("filePart1", new FileSystemResource("...logo.png"))
part("jsonPart", new Person("Jason"))
part("myPart", part) // Part from a server request
}
val parts = builder.build()
In most cases, you do not have to specify the Content-Type
for each part. The
content
type is determined automatically based on the HttpMessageWriter
chosen to
serialize it
or, in the case of a Resource
, based on the file extension. If necessary, you
can
explicitly provide the MediaType
to use for each part through one of the
overloaded
builder part
methods.
Once a MultiValueMap
is prepared, the easiest way to pass it to the the WebClient
is
through the body
method, as the following example shows:
val builder: MultipartBodyBuilder = ...
client.post()
.uri("/path", id)
.body(builder.build())
.retrieve()
.awaitBody<Unit>()
If the MultiValueMap
contains at least one non-String
value, which
could also
represent regular form data (that is, application/x-www-form-urlencoded
), you
need not
set the Content-Type
to multipart/form-data
. This is always the
case when using
MultipartBodyBuilder
, which ensures an HttpEntity
wrapper.
As an alternative to MultipartBodyBuilder
, you can also provide multipart
content,
inline-style, through the built-in BodyInserters
, as the following example
shows:
import org.springframework.web.reactive.function.BodyInserters.*
client.post()
.uri("/path", id)
.body(fromMultipartData("fieldPart", "value").with("filePart", resource))
.retrieve()
.awaitBody<Unit>()
2.5. Client Filters
You can register a client filter (ExchangeFilterFunction
) through the WebClient.Builder
in order to intercept and modify requests, as the following example shows:
val client = WebClient.builder()
.filter { request, next ->
val filtered = ClientRequest.from(request)
.header("foo", "bar")
.build()
next.exchange(filtered)
}
.build()
This can be used for cross-cutting concerns, such as authentication. The following example uses a filter for basic authentication through a static factory method:
import org.springframework.web.reactive.function.client.ExchangeFilterFunctions.basicAuthentication
val client = WebClient.builder()
.filter(basicAuthentication("user", "password"))
.build()
Filters apply globally to every request. To change a filter’s behavior for a specific
request, you can add request attributes to the ClientRequest
that can then be
accessed
by all filters in the chain, as the following example shows:
val client = WebClient.builder()
.filter { request, _ ->
val usr = request.attributes()["myAttribute"];
// ...
}.build()
client.get().uri("https://example.org/")
.attribute("myAttribute", "...")
.retrieve()
.awaitBody<Unit>()
You can also replicate an existing WebClient
, insert new filters, or remove already
registered filters. The following example, inserts a basic authentication filter at
index 0:
val client = webClient.mutate()
.filters { it.add(0, basicAuthentication("user", "password")) }
.build()
2.6. Synchronous Use
WebClient
can be used in synchronous style by blocking at the end for the result:
val person = runBlocking {
client.get().uri("/person/{id}", i).retrieve()
.awaitBody<Person>()
}
val persons = runBlocking {
client.get().uri("/persons").retrieve()
.bodyToFlow<Person>()
.toList()
}
However if multiple calls need to be made, it’s more efficient to avoid blocking on each response individually, and instead wait for the combined result:
val data = runBlocking {
val personDeferred = async {
client.get().uri("/person/{id}", personId)
.retrieve().awaitBody<Person>()
}
val hobbiesDeferred = async {
client.get().uri("/person/{id}/hobbies", personId)
.retrieve().bodyToFlow<Hobby>().toList()
}
mapOf("person" to personDeferred.await(), "hobbies" to hobbiesDeferred.await())
}
The above is merely one example. There are lots of other patterns and operators for putting together a reactive pipeline that makes many remote calls, potentially some nested, inter-dependent, without ever blocking until the end.
|
With |
2.7. Testing
To test code that uses the WebClient
, you can use a mock web server, such as the
OkHttp MockWebServer. To see an
example
of its use, check out
WebClientIntegrationTests
in the Spring Framework test suite or the
static-server
sample in the OkHttp repository.
3. WebSockets
This part of the reference documentation covers support for reactive-stack WebSocket messaging.
3.1. Introduction to WebSocket
The WebSocket protocol, RFC 6455, provides a standardized way to establish a full-duplex, two-way communication channel between client and server over a single TCP connection. It is a different TCP protocol from HTTP but is designed to work over HTTP, using ports 80 and 443 and allowing re-use of existing firewall rules.
A WebSocket interaction begins with an HTTP request that uses the HTTP Upgrade
header
to upgrade or, in this case, to switch to the WebSocket protocol. The following example
shows such an interaction:
GET /spring-websocket-portfolio/portfolio HTTP/1.1
Host: localhost:8080
Upgrade: websocket (1)
Connection: Upgrade (2)
Sec-WebSocket-Key: Uc9l9TMkWGbHFD2qnFHltg==
Sec-WebSocket-Protocol: v10.stomp, v11.stomp
Sec-WebSocket-Version: 13
Origin: http://localhost:8080
| 1 | The Upgrade header. |
| 2 | Using the Upgrade connection. |
Instead of the usual 200 status code, a server with WebSocket support returns output similar to the following:
HTTP/1.1 101 Switching Protocols (1)
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: 1qVdfYHU9hPOl4JYYNXF623Gzn0=
Sec-WebSocket-Protocol: v10.stomp
| 1 | Protocol switch |
After a successful handshake, the TCP socket underlying the HTTP upgrade request remains open for both the client and the server to continue to send and receive messages.
A complete introduction of how WebSockets work is beyond the scope of this document. See RFC 6455, the WebSocket chapter of HTML5, or any of the many introductions and tutorials on the Web.
Note that, if a WebSocket server is running behind a web server (e.g. nginx), you likely need to configure it to pass WebSocket upgrade requests on to the WebSocket server. Likewise, if the application runs in a cloud environment, check the instructions of the cloud provider related to WebSocket support.
3.1.1. HTTP Versus WebSocket
Even though WebSocket is designed to be HTTP-compatible and starts with an HTTP request, it is important to understand that the two protocols lead to very different architectures and application programming models.
In HTTP and REST, an application is modeled as many URLs. To interact with the application, clients access those URLs, request-response style. Servers route requests to the appropriate handler based on the HTTP URL, method, and headers.
By contrast, in WebSockets, there is usually only one URL for the initial connect. Subsequently, all application messages flow on that same TCP connection. This points to an entirely different asynchronous, event-driven, messaging architecture.
WebSocket is also a low-level transport protocol, which, unlike HTTP, does not prescribe any semantics to the content of messages. That means that there is no way to route or process a message unless the client and the server agree on message semantics.
WebSocket clients and servers can negotiate the use of a higher-level, messaging protocol
(for example, STOMP), through the Sec-WebSocket-Protocol
header on the HTTP
handshake request.
In the absence of that, they need to come up with their own conventions.
3.1.2. When to Use WebSockets
WebSockets can make a web page be dynamic and interactive. However, in many cases, a combination of Ajax and HTTP streaming or long polling can provide a simple and effective solution.
For example, news, mail, and social feeds need to update dynamically, but it may be perfectly okay to do so every few minutes. Collaboration, games, and financial apps, on the other hand, need to be much closer to real-time.
Latency alone is not a deciding factor. If the volume of messages is relatively low (for example, monitoring network failures) HTTP streaming or polling can provide an effective solution. It is the combination of low latency, high frequency, and high volume that make the best case for the use of WebSocket.
Keep in mind also that over the Internet, restrictive proxies that are outside of your
control
may preclude WebSocket interactions, either because they are not configured to pass on the
Upgrade
header or because they close long-lived connections that appear idle.
This
means that the use of WebSocket for internal applications within the firewall is a more
straightforward decision than it is for public facing applications.
3.2. WebSocket API
The Spring Framework provides a WebSocket API that you can use to write client- and server-side applications that handle WebSocket messages.
3.2.1. Server
To create a WebSocket server, you can first create a WebSocketHandler
.
The following example shows how to do so:
import org.springframework.web.reactive.socket.WebSocketHandler
import org.springframework.web.reactive.socket.WebSocketSession
class MyWebSocketHandler : WebSocketHandler {
override fun handle(session: WebSocketSession): Mono<Void> {
// ...
}
}
Then you can map it to a URL and add a WebSocketHandlerAdapter
, as the following
example shows:
@Configuration
class WebConfig {
@Bean
fun handlerMapping(): HandlerMapping {
val map = mapOf("/path" to MyWebSocketHandler())
val order = -1 // before annotated controllers
return SimpleUrlHandlerMapping(map, order)
}
@Bean
fun handlerAdapter() = WebSocketHandlerAdapter()
}
3.2.2.
WebSocketHandler
The handle
method of WebSocketHandler
takes
WebSocketSession
and returns Mono<Void>
to indicate when application handling of the session is complete. The session is handled
through two streams, one for inbound and one for outbound messages. The following table
describes the two methods that handle the streams:
WebSocketSession method |
Description |
|---|---|
|
Provides access to the inbound message stream and completes when the connection is closed. |
|
Takes a source for
outgoing messages, writes the messages, and returns a |
A WebSocketHandler
must compose the inbound and outbound streams into a unified
flow and
return a Mono<Void>
that reflects the completion of that flow. Depending
on application
requirements, the unified flow completes when:
-
Either the inbound or the outbound message stream completes.
-
The inbound stream completes (that is, the connection closed), while the outbound stream is infinite.
-
At a chosen point, through the
close
method ofWebSocketSession
.
When inbound and outbound message streams are composed together, there is no need to check if the connection is open, since Reactive Streams signals terminate activity. The inbound stream receives a completion or error signal, and the outbound stream receives a cancellation signal.
The most basic implementation of a handler is one that handles the inbound stream. The following example shows such an implementation:
class ExampleHandler : WebSocketHandler {
override fun handle(session: WebSocketSession): Mono<Void> {
return session.receive() (1)
.doOnNext {
// ... (2)
}
.concatMap {
// ... (3)
}
.then() (4)
}
}
| 1 | Access the stream of inbound messages. |
| 2 | Do something with each message. |
| 3 | Perform nested asynchronous operations that use the message content. |
| 4 | Return a Mono<Void> that completes when receiving
completes.
|
For nested, asynchronous operations, you may need to call
message.retain() on underlying
servers that use pooled data buffers (for example, Netty). Otherwise, the data
buffer may be
released before you have had a chance to read the data. For more background, see
Data
Buffers and Codecs.
|
The following implementation combines the inbound and outbound streams:
class ExampleHandler : WebSocketHandler {
override fun handle(session: WebSocketSession): Mono<Void> {
val output = session.receive() (1)
.doOnNext {
// ...
}
.concatMap {
// ...
}
.map { session.textMessage("Echo $it") } (2)
return session.send(output) (3)
}
}
| 1 | Handle the inbound message stream. |
| 2 | Create the outbound message, producing a combined flow. |
| 3 | Return a Mono<Void> that does not complete while we
continue to receive.
|
Inbound and outbound streams can be independent and be joined only for completion, as the following example shows:
class ExampleHandler : WebSocketHandler {
override fun handle(session: WebSocketSession): Mono<Void> {
val input = session.receive() (1)
.doOnNext {
// ...
}
.concatMap {
// ...
}
.then()
val source: Flux<String> = ...
val output = session.send(source.map(session::textMessage)) (2)
return Mono.zip(input, output).then() (3)
}
}
| 1 | Handle inbound message stream. |
| 2 | Send outgoing messages. |
| 3 | Join the streams and return a Mono<Void> that completes
when either stream ends.
|
3.2.3.
DataBuffer
DataBuffer
is the representation for a byte buffer in WebFlux. The Spring Core
part of
the reference has more on that in the section on
Data
Buffers and Codecs. The key point to understand is that on some
servers like Netty, byte buffers are pooled and reference counted, and must be released
when consumed to avoid memory leaks.
When running on Netty, applications must use DataBufferUtils.retain(dataBuffer)
if they
wish to hold on input data buffers in order to ensure they are not released, and
subsequently use DataBufferUtils.release(dataBuffer)
when the buffers are
consumed.
3.2.4. Handshake
WebSocketHandlerAdapter
delegates to a WebSocketService
. By
default, that is an instance
of HandshakeWebSocketService
, which performs basic checks on the WebSocket
request and
then uses RequestUpgradeStrategy
for the server in use. Currently, there is
built-in
support for Reactor Netty, Tomcat, Jetty, and Undertow.
HandshakeWebSocketService
exposes a sessionAttributePredicate
property that allows
setting a Predicate<String>
to extract attributes from the WebSession
and insert them
into the attributes of the WebSocketSession
.
3.2.5. Server Configation
The RequestUpgradeStrategy
for each server exposes WebSocket-related
configuration
options available for the underlying WebSocket engine. The following example sets
WebSocket options when running on Tomcat:
@Configuration
class WebConfig {
@Bean
fun handlerAdapter() =
WebSocketHandlerAdapter(webSocketService())
@Bean
fun webSocketService(): WebSocketService {
val strategy = TomcatRequestUpgradeStrategy().apply {
setMaxSessionIdleTimeout(0L)
}
return HandshakeWebSocketService(strategy)
}
}
Check the upgrade strategy for your server to see what options are available. Currently, only Tomcat and Jetty expose such options.
3.2.6. CORS
The easiest way to configure CORS and restrict access to a WebSocket endpoint is to
have your WebSocketHandler
implement CorsConfigurationSource
and
return a
CorsConfiguraiton
with allowed origins, headers, and other details. If you
cannot do
that, you can also set the corsConfigurations
property on the SimpleUrlHandler
to
specify CORS settings by URL pattern. If both are specified, they are combined by using the
combine
method on CorsConfiguration
.
3.2.7. Client
Spring WebFlux provides a WebSocketClient
abstraction with implementations for
Reactor Netty, Tomcat, Jetty, Undertow, and standard Java (that is, JSR-356).
The Tomcat client is effectively an extension of the standard Java one with some
extra
functionality in the WebSocketSession handling to take advantage of the
Tomcat-specific
API to suspend receiving messages for back pressure.
|
To start a WebSocket session, you can create an instance of the client and use its execute
methods:
val client = ReactorNettyWebSocketClient()
val url = URI("ws://localhost:8080/path")
client.execute(url) { session ->
session.receive()
.doOnNext(::println)
.then()
}
Some clients, such as Jetty, implement Lifecycle
and need to be stopped and
started
before you can use them. All clients have constructor options related to configuration
of the underlying WebSocket client.
4. Testing
The spring-test
module provides mock implementations of ServerHttpRequest
,
ServerHttpResponse
, and ServerWebExchange
.
See
Spring
Web Reactive for a
discussion of mock objects.
WebTestClient
builds on these mock request and
response objects to provide support for testing WebFlux applications without an HTTP
server. You can use the WebTestClient
for end-to-end integration tests, too.
5. Reactive Libraries
spring-webflux
depends on reactor-core
and uses it internally to compose
asynchronous
logic and to provide Reactive Streams support. Generally, WebFlux APIs return Flux
or
Mono
(since those are used internally) and leniently accept any Reactive Streams
Publisher
implementation as input. The use of Flux
versus
Mono
is important, because
it helps to express cardinality — for example, whether a single or multiple asynchronous
values are expected, and that can be essential for making decisions (for example, when
encoding or decoding HTTP messages).
For annotated controllers, WebFlux transparently adapts to the reactive library chosen by
the application. This is done with the help of the
ReactiveAdapterRegistry
,
which
provides pluggable support for reactive library and other asynchronous types. The registry
has built-in support for RxJava and CompletableFuture
, but you can register others,
too.
For functional APIs (such as Functional
Endpoints, the WebClient
, and others), the general rules
for WebFlux APIs apply — Flux
and Mono
as return values and a Reactive
Streams
Publisher
as input. When a Publisher
, whether custom or from another
reactive library,
is provided, it can be treated only as a stream with unknown semantics (0..N). If, however,
the semantics are known, you can wrap it with Flux
or Mono.from(Publisher)
instead
of passing the raw Publisher
.
For example, given a Publisher
that is not a Mono
, the Jackson JSON message
writer
expects multiple values. If the media type implies an infinite stream (for example,
application/json+stream
), values are written and flushed individually. Otherwise,
values are buffered into a list and rendered as a JSON array.


public class Redwood
extends java.lang.Object
LogRecordHandler
.
New handlers should implement this class.
Details on configuring Redwood can be found in the RedwoodConfiguration
class.
New configuration methods should be implemented in this class, following the standard
builder paradigm.
There is a tutorial on Redwood on the
NLP website.| Modifier and Type | Class and Description |
|---|---|
static class |
Redwood.ConsoleHandler
Default output handler which actually prints things to the real System.out
|
static class |
Redwood.FileHandler
Handler which prints to a specified file
TODO: make constructors for other ways of describing files (File, for example!)
|
protected static class |
Redwood.Flag
Standard channels; enum for the sake of efficiency
|
static class |
Redwood.Record
A log record, which encapsulates the information needed
to eventually display the enclosed message.
|
protected static class |
Redwood.RecordHandlerTree
A tree structure of record handlers
|
static class |
Redwood.RedwoodChannels
Represents a collection of channels.
|
static class |
Redwood.Util
A utility class for Redwood intended for static import
(import static edu.stanford.nlp.util.logging.Redwood.Util.*;),
providing a wrapper for Redwood functions and adding utility shortcuts
|
| Modifier and Type | Field and Description |
|---|---|
static Redwood.Flag |
DBG |
static Redwood.Flag |
ERR |
static Redwood.Flag |
FORCE |
protected static java.io.PrintStream |
realSysErr
The real System.err stream
|
protected static java.io.PrintStream |
realSysOut
The real System.out stream
|
static Redwood.Flag |
STDERR |
static Redwood.Flag |
STDOUT |
static boolean |
supportsAnsi |
static Redwood.Flag |
WARN |
| Modifier and Type | Method and Description |
|---|---|
protected static void |
captureSystemStreams(boolean captureOut,
boolean captureErr)
Captures System.out and System.err and redirects them
to Redwood logging.
|
static Redwood.RedwoodChannels |
channels(java.lang.Object... channelNames)
Create an object representing a group of channels.
|
protected static void |
clearHandlers()
Remove all log handlers from Redwood, presumably in order to
construct a custom pipeline afterwards
|
static void |
endThreads(java.lang.String check)
Signal that all threads have run to completion, and the multithreaded
environment is over.
|
static void |
endTrack()
A utility method for closing calls to the anonymous startTrack() call.
|
static void |
endTrack(java.lang.String title)
End a "track;" that is, return to logging at one level shallower.
|
static void |
finishThread()
Signal that this thread will not log any more messages in the multithreaded
environment
|
static void |
forceTrack()
Helper method to start an anonymous track on the FORCE channel.
|
static void |
forceTrack(java.lang.Object name)
Helper method to start a track on the FORCE channel.
|
static java.lang.String |
formatTimeDifference(long diff) |
protected static void |
formatTimeDifference(long diff,
java.lang.StringBuilder b)
Utility method for formatting a time difference (maybe this should go to a util class?)
|
static void |
hideChannelsEverywhere(java.lang.Object... channels)
Hide multiple channels.
|
static void |
log(java.lang.Object... args)
Log a message.
|
static void |
logf(Redwood.Flag level,
java.lang.String format,
java.lang.Object... args)
The Redwood equivalent to printf(), with a logging level.
|
static void |
logf(java.lang.String format,
java.lang.Object... args)
The Redwood equivalent to printf().
|
static void |
main(java.lang.String[] args)
Various informal tests of Redwood functionality
|
protected static void |
restoreSystemStreams()
Restores System.out and System.err to their original values
|
protected static Redwood.RecordHandlerTree |
rootHandler() |
static void |
startThreads(java.lang.String title)
Start a multithreaded logging environment.
|
static void |
startTrack(java.lang.Object... args)
Begin a "track;" that is, begin logging at one level deeper.
|
static void |
stop()
Stop Redwood, closing all tracks and prohibiting future log messages.
|
public static final Redwood.Flag ERR
public static final Redwood.Flag WARN
public static final Redwood.Flag DBG
public static final Redwood.Flag FORCE
public static final Redwood.Flag STDOUT
public static final Redwood.Flag STDERR
protected static final java.io.PrintStream realSysOut
protected static final java.io.PrintStream realSysErr
public static final boolean supportsAnsi
protected static Redwood.RecordHandlerTree rootHandler()
protected static void clearHandlers()
protected static void captureSystemStreams(boolean captureOut, boolean captureErr)
captureOut
- True is System.out should be capturedcaptureErr
- True if System.err should be capturedprotected static void restoreSystemStreams()
public static void log(java.lang.Object... args)
args
- The last argument is the message; the first arguments are the channels.public static void logf(java.lang.String format, java.lang.Object... args)
format
- The format string, as per java's Formatter.format() object.args
- The arguments to format.public static void logf(Redwood.Flag level, java.lang.String format, java.lang.Object... args)
Redwood.RedwoodChannels
.level
- The logging level to log at.format
- The format string, as per java's Formatter.format() object.args
- The arguments to format.public static void startTrack(java.lang.Object... args)
args
- The title of the track to begin, with an optional FORCE flag.public static void forceTrack(java.lang.Object name)
name
- The track name to printpublic static void forceTrack()
public static void endTrack(java.lang.String title)
title
- A title that should match the beginning of this track.public static void endTrack()
public static void startThreads(java.lang.String title)
title
- The name of the thread group being startedpublic static void finishThread()
public static void endThreads(java.lang.String check)
check
- The name of the thread group passed to startThreads()public static Redwood.RedwoodChannels channels(java.lang.Object... channelNames)
Redwood.RedwoodChannels
contains a more complete description.Redwood.RedwoodChannels
public static void hideChannelsEverywhere(java.lang.Object... channels)
channels
- The channels to hidepublic static void stop()
protected static void formatTimeDifference(long diff, java.lang.StringBuilder b)
diff
- Time difference in millisecondsb
- The string builder to append topublic static java.lang.String formatTimeDifference(long diff)
public static void main(java.lang.String[] args)
args
- Unused


Toggle navigation
QuizYou
Logout
My Quiz
Answered
{{title}}
Your answer is: {{answer}}
Alternative 1 - {{alt1}}
Alternative 2 - {{alt2}}
Alternative 3 - {{alt3}}
Alternative 4 - {{alt4}}


Latest stable: Luminescence 1.3.
If you want the most up-to-date version, check out the Git section below.
First, you should read the README.
And here are some guides I wrote, if you want details:
~/.luminescence/config
(using the default plugins)My personal Git is probably the place where you'll find the latest version.
If you like social networks, you can find it on GitHub. I try to keep it updated too.


Payment Form
First Name
Last Name
City
State
Pick a state
Alabama
Alaska
Arizona
Arkansas
California
Colorado
Connecticut
Delaware
District Of Columbia
Florida
Georgia
Hawaii
Idaho
Illinois
Indiana
Iowa
Kansas
Kentucky
Louisiana
Maine
Maryland
Massachusetts
Michigan
Minnesota
Mississippi
Missouri
Montana
Nebraska
Nevada
New Hampshire
New Jersey
New Mexico
New York
North Carolina
North Dakota
Ohio
Oklahoma
Oregon
Pennsylvania
Rhode Island
South Carolina
South Dakota
Tennessee
Texas
Utah
Vermont
Virginia
Washington
West Virginia
Wisconsin
Wyoming
Zip


Welcome to Mr. Roboger's Neighborhood!
Please enter a number into the form below
Number please!
Name:
Regular
Reverse
SUBMIT


This guide is for schools, colleges and private candidates (eg a student who is home-schooled). If you’re a student or parent of a pupil you can
appeal results here
.
GCSE, AS, A level and Diploma appeals
Ofqual can only look at whether or not the rules about the exam, how it was marked and how the qualification was graded have been properly followed.
Any decision made by Ofqual is final.
What we will and won’t look into
Ofqual will hear appeals on GCSE, AS, A level and Diploma Principal Learning and Projects (whether taken as part of a Diploma or not).
We will look at whether the exam board has followed the right procedures and whether it has used them properly and fairly.
We will look into:
-
the setting of papers
-
marking and moderation
-
the grade award
-
enquiries about results and appeals
-
special consideration
-
access arrangements
-
administrative arrangements
We will not:
-
make judgments about candidate work in the exam; that’s the responsibility of the senior examiner of the exam board
-
re-mark candidate work
-
change grades issued by the exam board
These issues will be investigated by the exam board when you ask them to review the marking.
How to apply
You have to apply for an exam review within 3 weeks of receiving your draft appeal report from the exam board
Before applying, first ask the exam board to review the marking. This is called an enquiry about results (EAR). They will review the marking or re-moderate the controlled assessment.
If you’re not happy with their review you have 2 weeks to appeal to the exam board. They will investigate and send you a draft report. You can then ask the exam board for an appeal hearing if you need to.
If you are unhappy with the result of the appeal hearing and want Ofqual to review your case, you need to do so within 3 weeks of receiving your draft report from the exam board.
We will respond in 2 weeks if it is something we can look into. We will then let you know the appeal hearing date and how to prepare for it. We will pay standard fare travel expenses for you to get to the hearing.
If we think you have a strong case and we don’t think your results are appropriate we may ask the exam board to reconsider the case or make other recommendations.
For more information about the review process please contact us.
Appeal the results of other qualifications
To appeal the results of a qualification that isn’t a GCSE, AS, A level or Diploma:
-
Appeal to the awarding organisation responsible for your qualification and let them investigate.
-
Receive the awarding organisation’s final report.
-
If you are not happy with the outcome you can contact Ofqual to make a complaint.
For more information see our
Complaints policy
(
PDF
,
315KB
,
19 pages
)


Links
Bell Schedules
Apps
Directory
GO BISON
M-W-TH-F
Tuesday
12:08
Late Start
M-W-TH-F
Tuesday
12:08
Late Start


Module path
Basic support for evaluating XPath expressions against streams.
>>> from genshi.input import XML
>>> doc = XML('''<doc>
... <items count="4">
... <item status="new">
... Foo
... </item>
... <item status="closed">
... Bar
... </item>
... <item status="closed" resolution="invalid">
... Baz
... </item>
... <item status="closed" resolution="fixed">
... Waz
... </item>
... </items>
... </doc>''')
>>> print doc.select('items/item[@status="closed" and '
... '(@resolution="invalid" or not(@resolution))]/summary/text()')
BarBaz
Because the XPath engine operates on markup streams (as opposed to tree
structures), it only implements a subset of the full XPath 1.0 language.
|
|
Path
Implements basic XPath support on streams.
|
|
|
PathSyntaxError
Exception raised when an XPath expression is syntactically incorrect.
|


Authors¶
Overview¶
Team 9 “discovering new biomarkers” of the Canadian Consortium on Neurodegeneration in Aging (CCNA) is co-lead by Dr Roger Dixon, department of Psychology, University of Alberta, and Dr [Pierre Bellec](https://simexp.github.io/lab-website/team.html), department of Psychology, University of Montreal. The generation of imaging biomarkers using standardized pipelines is one of the core objective of the CCNA biomarkers team, and involves only a subset of investigators, listed below. These imaging biomarkers cover all imaging modalities collected as part of the “comprehensive assessment of neurodegeneration in aging” (COMPASS-ND) cohort, following the Canadian Dementia Imaging Protocol ([CDIP](https://www.cdip-pcid.ca/)).
Funding¶
The Canadian Consortium on Neurodegeneration in Aging is supported by a grant from the Institutes of Health Research with funding from several partners including the Alzheimer Society of Canada, Sanofi, and Women’s Brain Health Initiative. Team 9 is also receiving funds from the Alberta Innovates (PI Dr Dixon) and the Courtois foundation (PI Bellec).
Standardized Imaging Biomarkers subteam¶
- In alphabetical order:
Dr. AmanPreet Badhwar, principal investigator (CRIUGM, University of Montreal, Québec, CA).
Dr. Christian Beaulieu, principal investigator (University of Alberta, Alberta, CA).
Dr. Pierre Bellec, co-lead (CRIUGM, University of Montreal, Québec, CA).
Dr. Faisal Beg, principal investigator (Simon Fraiser University, British Columbia, CA).
Mr. Arnaud Boré, data scientist (CRIUGM and Sherbrooke University, Quebec, CA).
Dr. Mallar Chakravarti, principal investigator (Douglas Institute, McGill University, Quebec, CA).
Dr. Louis Collins, principal investigator (Montreal Neurological Institute, McGill University, Quebec, CA).
Dr. Maxime Descoteaux, principal investigator (Sherbrooke University, Quebec, CA).
Dr. Roger Dixon, co-lead (University of Alberta, Alberta, CA).
Dr. Simon Duchesne, principal investigator (Cervo Centre, Laval University, Quebec, CA).
Dr. Desirée Lussier, post-doctoral fellow (CRIUGM, University of Montreal, Quebec, CA).
Dr. Eric Smith, principal investigator (University of Calgary, Alberta, CA).
Mr. Loic Tetrel, data scientist (CRIUGM, Quebec, CA).


Index
All Classes|All Packages
G
- Genre - Enum in <Unnamed>
- getAlbumOfListById(int) - Method in class ListAlbum
-
Getter od Album from id Album
- getAlbums() - Method in class ListAlbum
-
Getter of ListAlbum Albums sort by release date.
- getArtist() - Method in class Album
-
Setter of id (Album).
- getArtist() - Method in class Song
-
Getter of Song artist
- getAudioBookElementOfListById(int) - Method in class ListMusicalElement
-
Getter of AudioBook inside a ListMusicalElemnt
- getAuthor() - Method in class AudioBook
-
Getter of author (AudioBook).
- getCategory() - Method in class AudioBook
-
Getter of Category (AudioBook).
- getContent() - Method in class Album
-
Getter of Content (Album).
- getContent() - Method in class MusicalElement
-
Getter of MusicalElement content
- getDuration() - Method in class Album
-
Getter that calculates the total duration of the all songs duration in Songs (Album).
- getDuration() - Method in class MusicalElement
-
Getter of MusicalElement duration (second)
- getGenre() - Method in class Song
-
Getter of Song genre
- getId() - Method in class Album
-
Getter of id (Album).
- getId() - Method in class MusicalElement
-
Getter of MusicalElement id
- getId() - Method in class Playlist
-
Getter of id (Playlist).
- getLanguage() - Method in class AudioBook
-
Getter of Language (AudioBook).
- getMusicalElementById(int) - Method in class Playlist
-
Getter of MusicalElement from list of MusicalElement of a Playlist
- getMusicalElementOfListById(int) - Method in class ListMusicalElement
-
Getter of Musical Element inside a ListMusicalEleme nt
- getMusicalElements() - Method in class ListMusicalElement
-
Getter of ListMusicalElement MusicalElements
- getMusicalElements() - Method in class Playlist
-
Getter of Playlist MusicalElement.
- getName() - Method in class Playlist
-
Getter of Name's Playlist.
- getPlaylistOfListById(int) - Method in class ListPlaylist
-
Getter of Playlist from id Playlist
- getPlaylists() - Method in class ListPlaylist
-
Getter of ListPlaylist Playlists sort by name
- getRelease() - Method in class Album
-
Getter of release (Album).
- getSongById(int) - Method in class Album
-
Getter of Song from list of Song of an ALbum
- getSongElementOfListById(int) - Method in class ListMusicalElement
-
Getter of Song inside a ListMusicalElemnt
- getSongs() - Method in class Album
-
Getter of Album Songs.
- getTitle() - Method in class Album
-
Getter of title (Album).
- getTitle() - Method in class MusicalElement
-
Getter of MusicalElement title
All Classes|All Packages


Money Management System
Total Income
Total Spent
Current Balance
Transaction
Income
Source
Amout
Expense
Source
Amout
History
Search
Sorry kiddo ! your browser doesn't support
Javascript
and that's why you're missing some amazing features of this awesome website.


Research
Endorsed by Michelle GIBBS, who is highly skilled at this
Endorsed by 8 of Louise’s colleagues at Leatherhead Food Research
Nutrition
Endorsed by 9 of Louise’s colleagues at Leatherhead Food Research
Public Health
Endorsed by 6 of Louise’s colleagues at Leatherhead Food Research


Web Developer & Graphic Designer
Find Out MoreCarter is a business-minded entrepreneur and experienced social media professional skilled at providing creative solutions to problems and proficient in generating results strategically and effectively.
In addition to taking on all the freelance work he can get his hands on, Carter spends his nights and weekends taking classes at SMU where he will complete the college's Full Stack Web Development Boot Camp in July 2018.
Upon completion of the program, he aims to secure a full-time position as a Front-end Web Developer. Other areas of expertise include graphic design, web development, and music production.


{% load i18n %}{% autoescape off %}
{% endautoescape %}Blog App
You're receiving this email because you requested a password reset for your user account at {{ site_name }}.
Please go to the following page and choose a new password:
{{ protocol }}://{{ domain }}{% url 'password_reset_confirm' uidb64=uid token=token %}Your username, in case you’ve forgotten: {{ user.get_username}}
Thanks for using our site!
The {{ site_name }} team
Cheers!🥂


Your wallet:
- Max recommended addresses per transaction is 300
- Paste the addresses and amounts
- Separate the items with a comma, as in the example
- Length of receivers and amounts should be equal
Transactions
| ID | TxHash | Status | Receivers | Tokens Amount |
|---|


Join a team and submit your phrases.
Phrases submitted: 0
Choose a clue giver.
This round has ended. The Captain may start the next round.
The previous player will start first if they have any remaining time.
Play Again?
The Captain can start a new game.


+++ draft = false date = "2006-08-29T21:51:48-03:00" title = "Checking for a role or a permission in a context" tags = ["cookbook", "Plone"] created = "2006-08-29T21:48:55-03:00" modified = "2006-08-29T21:51:48-03:00" permaLink = "http://play.pixelblaster.ro/blog/archive/2006/08/29/checking-for-a-role-or-a-permission-in-a-context" author = "Tiberiu Ichim" aliases = [ "/blog/archive/2006/08/29/checking-for-a-role-or-a-permission-in-a-context" ] +++
There are two very useful methods to check for certain security settings offered by the Plone API. First, to check if a user has a certain role, the following snippet can be used:
roles_user_has = portal_membership.getCandidateLocalRoles(here)
To check if a user has a certain permission, this API method can be used:
portal_membership.checkPermission('Manage portal', here)


Hawaii Health Department confirms 2 more cases of vaping-related lung illness | Honolulu Star-Advertiser
The state has confirmed two more cases of severe lung injuries related to the use of e-cigarettes.
In total, the Department of Health has confirmed vaping-related illnesses in four Hawaii residents, including two children, and is investigating a “handful of other lung injury reports,” said spokeswoman Janice Okubo. All of the individuals, one in each of the counties, were hospitalized and have since recovered.
The DOH is urging residents to stop vaping, regardless of substance or source, until investigations nationwide determine the culprit of the illnesses.
“E-cigarettes and vaping products are not safe,” Health Director Bruce Anderson said in a news release. “The public should refrain from using these products, regardless of whether they contain nicotine or THC.”
There were 42 deaths and 2,172 confirmed and probable lung injuries associated with vaping reported in 49 states, the District of Columbia, Puerto Rico and the Virgin Islands as of Nov. 13, according to the Centers for Disease Control and Prevention.
Federal and state health officials have detected a synthetic form of vitamin E in some vaping fluids containing tetrahydrocannabinol (THC), the psychoactive ingredient in pakalolo, though they have not determined the exact cause of vaping injuries and deaths.


Economic Impacts of Multiple Stresses
EPA Grant Number: R825433C018Subproject: this is subproject number 018 , established and managed by the Center Director under grant R825433
(EPA does not fund or establish subprojects; EPA awards and manages the overall grant for this center).
Center: EERC - Center for Ecological Health Research (Cal Davis)
Center Director: Rolston, Dennis E.
Title: Economic Impacts of Multiple Stresses
Investigators: Layton, David , Wilen, James
Institution: University of California - Davis
EPA Project Officer: Levinson, Barbara
Project Period: October 1, 1996 through September 30, 2000
RFA: Exploratory Environmental Research Centers (1992) RFA Text | Recipients Lists
Research Category: Center for Ecological Health Research , Targeted Research
Objective:
This project seeks to evaluate the importance of cumulative impacts on multiple management endpoints to help decide which stresses are most important to reduce.
Approach:
Ecosystems with multiple stresses typically generate effects on many endpoints. Managers face the problem of evaluating the importance of the cumulative impacts on multiple endpoints from the multiple stresses and then tracing back through the complex chains of causation to make decisions about which stresses are most important to reduce, given a valuation of the impacts on end-points. This project focuses on the end-points. These are generally of most immediate concern to managers and policy makers, while technical staff and scientists often focus on the stressors and the ecosystem processes they affect. For optimal environmental decision-making, technical staff and scientists should be substantially influenced by the public's valuation of endpoints in the design of investigations leading to remediation. Normally, we want to concentrate resources on those problems that make the most difference to people.
During the 1996-97 period, the investigators completed analysis of survey data gathered during the summers of 1995 and 1996. During both summers they contacted visitors to Clear Lake at a variety of sites and distributed questionnaires asking about trip purposes and activities, expenditures, demographic information, trip origins, income, etc. In addition, investigators provided neutral descriptions of both the blue green algae problem and the mercury problem at Clear Lake, and asked questions aimed at eliciting recreationists' willingness to pay to help mitigate some of the environmental consequences of these problems. They distributed over 1300 surveys and got returns from over 57% of those handed out. We mixed formats so that respondents could evaluate clean up regimes for both programs and for separate programs, with the intent of determining how people view composite clean up activities.
During 1997-98 investigators compiled data and did preliminary analyses of responses in preparation for statistical estimation of mean willingness to pay for clean up activities. They then undertook a series of econometric investigations of respondents' willingness to pay. The scenarios that they had respondents analyze included measures to reduce sedimentation and other contributors to the algae problem so that the number of days of algae bloom were reduced to half of current levels. With respect to mercury, they had respondents assess a scenario where mercury concentrations were reduced by half and that fish caught would be safe for consumption. Respondents were asked if they would be willing to make a one time payment into a (hypothetical) Water Quality Improvement Trust Fund to attain these environmental improvements, assuming that other users paid the same amount. Investigators varied the hypothetical contributions and asked for simple yes/no responses. We then asked a second question with a higher or lower amount, depending upon whether the response to the first question was yes or no. This procedure is referred to as the double bounded dichotomous choice method of eliciting willingness to pay, and it has been found to have desirable properties when eliciting monetary values from individuals.
The analysis of the data collected reveals that the mean willingness to pay for the algae clean up scenario is approximately $31, when considered alone, with 95% confidence intervals of $27-35. For the mercury clean up scenario, our estimated willingness to pay was $29 with confidence intervals of $24-33. When we asked for willingness to pay for both projects, the mean response was $48 (with confidence intervals $42-53). These responses are reasonable in terms of other researchers' findings, and they also rule out the likelihood that individuals are just purchasing "moral satisfaction", which would show up with values for the joint project close to those for individual policies. The fact that the elicited values do not sum exactly to those for the joint project is also similar to findings by others and it poses some questions that need further investigation.
Expected Results:
Investigators expect to study a specific ecosystems with multiple stresses in order to assist managers who face the problem of evaluating the importance of the cumulative impacts on multiple endpoints and then tracing back through the complex chains of causation to make decisions about which stresses are most important to reduce, given a valuation of the impacts on end-points. This project hopes to use surveys and data analysis to determine willingness to pay by the public for environmental problems with a focus on the end-points. These are generally of most immediate concern to managers and policy makers, while technical staff and scientists often focus on the stressors and the ecosystem processes they affect. For optimal environmental decision-making, technical staff and scientists should be substantially influenced by the public's valuation of endpoints in the design of investigations leading to remediation.
Supplemental Keywords:
watershed, aquatic ecosystem restoration, Clear Lake, multiple stressors, economics, environmental decision making, willingness to pay, water quality., RFA, Economic, Social, & Behavioral Science Research Program, Scientific Discipline, Geographic Area, State, Economics, Environmental Monitoring, decision-making, Environmental Statistics, Ecological Risk Assessment, Ecology and Ecosystems, Social Science, Economics & Decision Making, ecosystem valuation, policy analysis, surveys, ecosystem assessment, policy making, resource management, watershed, community involvement, decision analysis, environmental decision making, decision making, environmental remediation, economic issues, multiple stressors, environmental impact comparison, aquatic ecosystems, data analysis, aquatic resources, willingness to pay, California (CA), wetlands preservation, preference survey, statistical methodsProgress and Final Reports:
2000 Progress ReportMain Center Abstract and Reports:
R825433 EERC - Center for Ecological Health Research (Cal Davis) Subprojects under this Center: (EPA does not fund or establish subprojects; EPA awards and manages the overall grant for this center).
R825433C001 Potential for Long-Term Degradation of Wetland Water Quality Due to Natural Discharge of Polluted Groundwater
R825433C002 Sacramento River Watershed
R825433C003 Endocrine Disruption in Fish and Birds
R825433C004 Biomarkers of Exposure and Deleterious Effect: A Laboratory and Field Investigation
R825433C005 Fish Developmental Toxicity/Recruitment
R825433C006 Resolving Multiple Stressors by Biochemical Indicator Patterns and their Linkages to Adverse Effects on Benthic Invertebrate Patterns
R825433C007 Environmental Chemistry of Bioavailability in Sediments and Water Column
R825433C008 Reproduction of Birds and mammals in a terrestrial-aquatic interface
R825433C009 Modeling Ecosystems Under Combined Stress
R825433C010 Mercury Uptake by Fish
R825433C011 Clear Lake Watershed
R825433C012 The Role of Fishes as Transporters of Mercury
R825433C013 Wetlands Restoration
R825433C014 Wildlife Bioaccumulation and Effects
R825433C015 Microbiology of Mercury Methylation in Sediments
R825433C016 Hg and Fe Biogeochemistry
R825433C017 Water Motions and Material Transport
R825433C018 Economic Impacts of Multiple Stresses
R825433C019 The History of Anthropogenic Effects
R825433C020 Wetland Restoration
R825433C021 Sierra Nevada Watershed Project
R825433C022 Regional Transport of Air Pollutants and Exposure of Sierra Nevada Forests to Ozone
R825433C023 Biomarkers of Ozone Damage to Sierra Nevada Vegetation
R825433C024 Effects of Air Pollution on Water Quality: Emission of MTBE and Other Pollutants From Motorized Watercraft
R825433C025 Regional Movement of Toxics
R825433C026 Effect of Photochemical Reactions in Fog Drops and Aerosol Particles on the Fate of Atmospheric Chemicals in the Central Valley
R825433C027 Source Load Modeling for Sediment in Mountainous Watersheds
R825433C028 Stress of Increased Sediment Loading on Lake and Stream Function
R825433C029 Watershed Response to Natural and Anthropogenic Stress: Lake Tahoe Nutrient Budget
R825433C030 Mercury Distribution and Cycling in Sierra Nevada Waterbodies
R825433C031 Pre-contact Forest Structure
R825433C032 Identification and distribution of pest complexes in relation to late seral/old growth forest structure in the Lake Tahoe watershed
R825433C033 Subalpine Marsh Plant Communities as Early Indicators of Ecosystem Stress
R825433C034 Regional Hydrogeology and Contaminant Transport in a Sierra Nevada Ecosystem
R825433C035 Border Rivers Watershed
R825433C036 Toxicity Studies
R825433C037 Watershed Assessment
R825433C038 Microbiological Processes in Sediments
R825433C039 Analytical and Biomarkers Core
R825433C040 Organic Analysis
R825433C041 Inorganic Analysis
R825433C042 Immunoassay and Serum Markers
R825433C043 Sensitive Biomarkers to Detect Biochemical Changes Indicating Multiple Stresses Including Chemically Induced Stresses
R825433C044 Molecular, Cellular and Animal Biomarkers of Exposure and Effect
R825433C045 Microbial Community Assays
R825433C046 Cumulative and Integrative Biochemical Indicators
R825433C047 Mercury and Iron Biogeochemistry
R825433C048 Transport and Fate Core
R825433C049 Role of Hydrogeologic Processes in Alpine Ecosystem Health
R825433C050 Regional Hydrologic Modeling With Emphasis on Watershed-Scale Environmental Stresses
R825433C051 Development of Pollutant Fate and Transport Models for Use in Terrestrial Ecosystem Exposure Assessment
R825433C052 Pesticide Transport in Subsurface and Surface Water Systems
R825433C053 Currents in Clear Lake
R825433C054 Data Integration and Decision Support Core
R825433C055 Spatial Patterns and Biodiversity
R825433C056 Modeling Transport in Aquatic Systems
R825433C057 Spatial and Temporal Trends in Water Quality
R825433C058 Time Series Analysis and Modeling Ecological Risk
R825433C059 WWW/Outreach
R825433C060 Economic Effects of Multiple Stresses
R825433C061 Effects of Nutrients on Algal Growth
R825433C062 Nutrient Loading
R825433C063 Subalpine Wetlands as Early Indicators of Ecosystem Stress
R825433C064 Chlorinated Hydrocarbons
R825433C065 Sierra Ozone Studies
R825433C066 Assessment of Multiple Stresses on Soil Microbial Communities
R825433C067 Terrestrial - Agriculture
R825433C069 Molecular Epidemiology Core
R825433C070 Serum Markers of Environmental Stress
R825433C071 Development of Sensitive Biomarkers Based on Chemically Induced Changes in Expressions of Oncogenes
R825433C072 Molecular Monitoring of Microbial Populations
R825433C073 Aquatic - Rivers and Estuaries
R825433C074 Border Rivers - Toxicity Studies


Next, we shall prove the following orthogonality relation
|
(106) |
where
is the Kronical delta function. [Proof: The left-hand
side of Eq. (106) can be written as
where the second equality is due to
|
(107) |
since
are constant
vectors independent of spatial location.]
It can be proved that
is a contravariant vector while
is a covariant vector (I do not prove this). The
orthogonality relation in Eq. (106) is fundamental to the theory of
general coordinates. (The cylindrical coordinate system
is an
example of general coordinates. As an exercise, we can verify that the
cylindrical coordinates have the above property. In this case,
,
, , where
,
,
.) The orthogonality relation allows one to write the covariant
basis vectors in terms of contravariant basis vectors and vice versa. For
example, the orthogonality relation tells that
is orthogonal to
and
, thus,
can be written as
|
(108) |
where is a unknown variable to be determined. To determine , dotting
Eq. (108) by
, and using the orthogonality relation again,
we obtain
|
(109) |
which gives
Thus
is written, in terms of
,
, and
, as
|
(111) |
Similarly, we obtain
|
(112) |
and
|
(113) |
Equations (111)-(113) can be generally written
|
(114) |
where represents the cyclic order in the variables
. Equation (114) expresses the covariant basis vectors in terms
of the contravariant basis vectors. On the other hand, from Eq.
(111)-(113), we obtain
|
(115) |
which expresses the contravariant basis vectors in terms of the covariant
basis vectors.
yj
2018-03-09


Create Change Request - Edit
Client ID
First name
Surname
Address
Phone number
Birth number
Country of origin
Submit


Tables/Figures/Examples
I: Introduction
1: Overview
II: Fundamentals
2: Iterators
3: Functions and Predicates
III: Containers
4: Container Classes
5: vector and vector<bool>
6: list
7: deque
8: set, multiset, and bitset
9: map and multimap
10: The Container Adaptors stack and queue
11: The Container Adaptor priority queue
12: string
IV: Algorithms
13: Generic Algorithms
14: Ordered Collection Algorithms
V: Special Techniques
15: Using Allocators
16: Building Containers and Algorithms
17: The Traits Parameter
18: Exception Handling
VI: Special Classes
19: auto_ptr
20: complex
21: numeric_limits
22: valarray
VII: Locales
23: Internationalization and Localization
24: The C and C++ Locales
25: Facets
26: Building Your Own Facet Class
VIII: Iostreams
27: The Architecture of Iostreams
28: Formatted Input and Output
29: Error State of Streams
30: File Input and Output
31: Input and Output In Memory
32: Input and Output of User Types
33: Manipulators
34: Streams and Stream Buffers
35: Synchronizing Streams
36: Stream Storage for Private Use
37: Registration of Callback Functions
38: Creating New Stream Classes by Derivation
39: Stream Buffers
40: Defining A Code Conversion Facet
41: Defining Your Own Character Types
42: Imbuing Locales
43: Stream Iterators
44: Iostreams and Multithreading
45: Standard vs. Traditional Iostreams
46: Standard vs. Apache stdcxx Iostreams
|


Exchange Ethereum at the best available rate with no registration and zero fees.
Ethereum coin is one of the most popular cryptocurrencies, at this moment its market capitalization is over $ 12 BLN. ETH volume in 24 hours is about $ 3 BLN and it takes second place in the top 10 cryptocurrencies in the world. Ethereum is also one of the most valuable currencies and ETH current price is about 130 USD for 1 ETH.
Ethereum prices are falling and at this moment the ETH current price is around 130 USD. Should to say that at the beginning of a 2018 Ethereum price in USD was about $ 1200. From these facts comes that the Ethereum coin price lost more than 90% of the maximum value for now.
The most popular Ethereum news is spinning around the ETH price. The analytics continue to talk about the falling of Ethereum price and trying to conclude Ethereum price prediction. Actually, the ETH price goes down faster, then the price of the other top tokens – this fact has surprised the experts and the question, where Ethereum price is heading is still opened. Here are some expert opinions:
#1 CoinDesk ETH Price Prediction
Price is struggling with falling resistance. If ETH price can break above, $ 114 is likely. If not, another lower low looks likely near prior support $ 98 for one ETH.
#2 Chris McClure ETH Price Prediction
Whether it's Sharding, Plasma, or OpenST Mosaic, there are tremendous technological reasons to be bullish on Ethereum volume and to believe in a speculatively high ETH price moving in 2019.
#3 Brian Schuster ETH Price Prediction
Ark Capital LLC founder, Brian Schuster believes that Ethereum price may reach $ 100,000 in another 5 years.
The last time Ethereum price being so low was in 2017 and that time the ETH formed the support of $ 91. Looking for Ethereum news you can find the opinions that there is a risk for Ethereum price to go even lower in 2019. The last support area for the crypto was at the $ 100 position and as you can see, it can easily come down to $ 90 again.
However, during the day of December 17, the value of the cryptocurrency market increased sharply: in an hour it grew by $ 4 billion and now amounts to $109 billion in a sum. Most cryptos went up in a short period of time: the price of Bitcoin rose by 5%, XRP by 4%, Stellar by 6%, EOS by 11%.
After that there was a good Ethereum news: The average market rate of Ethereum was increased to $ 141 on Dec 24 and up to $ 158 on Jan 6. But after that, it started to fall again and at this moment Ethereum coin price is somewhere between 100-120 USD.
The forecast for Ethereum price depends on the events planned by the network developers for 2019 and announced by Vitalik Buterin in the spring of this year. After the planned hard fork, the protocol will be changed: switching from PoW (Proof-Of-Work) to the Proof-of-Stake (Casper), which will provide:
With the introduction of PoS, the complexity of the network will increase, which will certainly entail an increase in the ETH rate, read more in our article: Ethereum forks
Note: Ethereum Constantinople Hard Fork has been postponed due to security reasons. It will be deployed on February 27, 2019.
Ethereum blockchain is one of the most useful blockchains in the world, a lot of tokens and smart contracts are working on Ethereum based. It's current price fell and now we need an Ethereum price prediction for 2019, but actually, it is hard to say for sure how the situation will turn. To more accurately answer the question about Ethereum price prognosis it needs to look at the latest Ethereum news.
Such a fall in the ETH price causes serious blows to the capitalization of the project, Vitalik Buterin, the founder of the platform, lost about $ 300 million in a fall. But anyway it does not hurt so much the other altcoins that is working on Ethereum base – they are working in their own market.
The ban on ICO in China has affected Ethereum, as well. Indeed, in this country, there was a considerable number of Ethereum coin users. In this way the Chinese authorities want to cut off all foreign projects from the country, giving more chances for the development of their own cryptocurrency project that is called NEO. Some experts suggest that the ban is temporary, so when a lot of Chinese users will return to use Ethereum – ETH price may go to up again.
The most important thing to do in the event of a fall in the Ethereum price is not to start a panic. Go true the plan and not sell all your coins as soon as possible for the price offered by the market. All movements in the price of cryptocurrencies, including the fall in Ethereum price, start from the appearance of certain news. This means that first of all, you need to be aware of the Ethereum news to make your choice.
In Atomic Wallet your private keys are encrypted in your device and never leave it, so you can be sure that your money is under your control only. We are happy to provide you with the most convenient way to manage all of your cryptocurrency assets. Secure, manage and exchange your assets in one secure place!
Whatever you choose, whether it is buying ETH or selling ETH, you can do that in the Atomic Wallet interface. Atomic is a universal non-custodial wallet for 300+ cryptocurrency assets with built-in exchange service. Instant exchange over 60 trading pairs with the market rate.
You can buy ETH with a credit card in Atomic Wallet. It’s the fastest and legal way to buy Ethereum with VISA or Mastercard, you’ll get ETH already in 30 minutes although usually, it takes a lot of time to process the bank data and proceed the transaction.


{% extends "forum/base.html" %} {% block title %}Forum - Login{% endblock %} {% block sidebar %} {% endblock %} {% block content %} {% if form.errors %}
Login failed: Could not find username and/or password was incorrect. Please try again
{% endif %}


{% extends "twiglet/showcases/base_showcase.html" %} {% block showcasedescription %} Coming soon: We will post some example code here showing how CS2J translates various interesting CS2J features.
ref
and out
arguments are put in wrapper objects before
being passed and the generated code maintains the correct semantics.
var a = new[] { "hello", "CS2J", "fans" };
will declare a
with type String[]
).