PageSpeed System Integration
Configuring Caching
PageSpeed requires publicly cacheable resources to provide maximum benefit. As discussed in the "Cache Extender" filter, the origin TTL specified in the server configuration file dictates how quickly changes made to the source can propagate to users' browser caches. However, using PageSpeed, resources referenced statically from HTML files will be served with a one-year cache lifetime, but with a URL that is versioned using a content hash.
Configuring Server-Side Cache for PageSpeed
In order to rewrite resources, PageSpeed must cache them server-side. A file-system based cache is always employed on each server. memcached or redis may be used as a scalable network-accessible cache in addition to the file cache. The file cache is always required, since PageSpeed has a few things it needs to store locally. Finally, a per-process in-memory LRU cache and/or an interprocess shared-memory cache can be configured for rapid access to small objects.
Configuring the File Cache
PageSpeed must be configured with a path where it can write cache files, tuned to limit the amount of disk space consumed. The file cache can be placed on a tmpfs partition or on a physical disk. The file cache has a built-in LRU mechanism to remove old files, targeting a certain total disk space usage, and a certain interval for the cleanup process. An example configuration is:
- Apache:
ModPagespeedFileCachePath "/var/cache/pagespeed/" ModPagespeedFileCacheSizeKb 102400 ModPagespeedFileCacheCleanIntervalMs 3600000 ModPagespeedFileCacheInodeLimit 500000
- Nginx:
pagespeed FileCachePath "/var/cache/pagespeed/"; pagespeed FileCacheSizeKb 102400; pagespeed FileCacheCleanIntervalMs 3600000; pagespeed FileCacheInodeLimit 500000;
It is important to note that FileCacheSizeKb
and
FileCacheInodeLimit
do not define absolute limits
on the cache size and inode count. The cache cleaning process will run at
the time interval defined by
FileCacheCleanIntervalMs
, and will only initiate
cleaning if the cache size exceeds
FileCacheSizeKb
or the cache inode count exceeds
FileCacheInodeLimit
. When cache cleaning is
initiated, the oldest files in the cache will be removed until the cache
size is under 0.75 * FileCacheSizeKb
and the
inode count is under 0.75 * FileCacheInodeLimit
.
Warning: Because the file cache cleaner does not impose a tight bound on disk usage, if your site is large and receives heavy traffic PageSpeed's cache can expand to fill your entire disk. If this becomes a problem you must either use a sufficiently large disk that this can't happen, or a cache whose size is guaranteed to be bounded. Bounded caches include keeping your file cache on a PageSpeed-specific partition, memcached, and redis.
PageSpeed previously reserved another file-path for future use as a shared
database in a multi-server environment. This is no longer in the plan,
and GeneratedFilePrefix
now generates a deprecation warning.
Starting in version <IP_ADDRESS>, it is possible to disable cache cleaning
entirely, making PageSpeed ignore the limits set
by FileCacheSizeKb
and FileCacheInodeLimit
. To
do this, set FileCacheCleanIntervalMs
to -1:
- Apache:
ModPagespeedFileCacheCleanIntervalMs -1
- Nginx:
pagespeed FileCacheCleanIntervalMs -1;
In versions before <IP_ADDRESS>, using a large number for the interval, like
1576800000000
(fifty years), has the same effect.
Warning: Without cleaning the cache will grow without bound as PageSpeed continues to store additional resources. If you disable the built-in cache cleaner you must implement something yourself to ensure that PageSpeed does not consume all available disk space for its cache.
Configuring the in-memory LRU Cache
To optimize performance, a small in-memory write-through LRU cache can be
instantiated in each server process. Note that in Apache's pre-fork mode
this means dozens of processes, so the total memory consumed
(LRUCacheKbPerProcess * num_processes
) must fit into the
capabilities of the host machine. Nginx typically runs with many fewer
processes, so a larger LRUCacheKbPerProcess
is appropriate
there. The LRUCacheByteLimit
is the limit on how large a
cache entry the LRU cache will accept. A sample configuration is:
- Apache:
ModPagespeedLRUCacheKbPerProcess 1024 ModPagespeedLRUCacheByteLimit 16384
- Nginx:
pagespeed LRUCacheKbPerProcess 8192; pagespeed LRUCacheByteLimit 16384;
Configuring the Shared Memory Metadata Cache
As part of its operation, PageSpeed stores summaries of how to apply optimizations to web pages as part of a metadata cache. Metadata entries are small and frequently accessed. They should ideally be stored in local memory and shared across server processes, as opposed to on disk or an external cache. That is exactly what the shared memory metadata cache does, and it is the best place to cache your metadata entries.
Prior to <IP_ADDRESS>, writes to an explicitly configured shared memory metadata cache were in-memory only, and not written to disk. This provided a large performance boost but the contents of the cache were lost upon server restart.
As of <IP_ADDRESS>, PageSpeed checkpoints the shared memory metadata cache to disk, providing almost all the performance but without the cache being wiped on restart. By default the metadata cache is checkpointed every 5 minutes, see shared memory checkpointing for more details.
In all versions, if you enable an external cache, cache entries are written through to it.
The shared memory metadata cache is enabled using
the CreateSharedMemoryMetadataCache
directive. This directive
takes two arguments. The first is the exact string given as the argument
to FileCachePath
in any virtual host where you want this cache
active. The second is the size of the cache in kilobytes. Unlike the LRU
cache, this cache is shared among all server processes, so far larger values
are possible. For example:
- Apache:
ModPagespeedCreateSharedMemoryMetadataCache "/var/cache/pagespeed/" 51200 <VirtualHost www.example.com:80> ModPagespeedFileCachePath "/var/cache/pagespeed/" </VirtualHost> <VirtualHost alt.example.com:80> ModPagespeedFileCachePath "/var/cache/pagespeed/" </VirtualHost>
- Nginx:
pagespeed CreateSharedMemoryMetadataCache "/var/cache/pagespeed/" 51200; server { listen 80; server_name www.example.com; pagespeed FileCachePath "/var/cache/pagespeed/"; } server { listen 80; server_name alt.example.com; pagespeed FileCachePath "/var/cache/pagespeed/"; }
If you are currently using a file cache, you can estimate a good size for
this cache by measuring the size of the rname/
directory of
the on-disk cache, using the du -s -h --apparent-size
command,
for example:
du -s -h --apparent-size /path/to/pagespeed_cache/rnamethen, multiplying the result by 1.75 and converting it to kilobytes.
You can see how effective this layer of cache is at the global PageSpeed statistics page, where at the bottom of the page every shared memory cache will be listed, including in particular information on its hit rate and how full it is (blocks used).
Default Shared Memory Metadata Cache
Any virtual host that does not have a shared memory
metadata cache configured
with CreateSharedMemoryMetadataCache
will share a default
one. In versions <IP_ADDRESS> and later, snapshots of the shared memory
cache are periodically saved to disk via shared memory checkpointing. Versions prior to <IP_ADDRESS> did not
support snapshotting, and instead wrote all changes through to disk,
significantly degrading the write performance of the shared memory cache.
You can configure the size of this cache
with DefaultSharedMemoryCacheKB
, or disable it entirely by
setting the size to 0. The default size is 50MB, and is shared across all
server processes.
- Apache:
ModPagespeedDefaultSharedMemoryCacheKB 50000
- Nginx:
pagespeed DefaultSharedMemoryCacheKB 50000;
This directive can only be used at the top level of your configuration.
Shared Memory Metadata Cache Checkpointing
Note: New feature as of <IP_ADDRESS>
Shared memory caches are fast but have the significant disadvantage that they do not survive a server restart. The file cache does persist across restarts but performs significantly worse than an in-memory cache. Checkpointing attempts to provide a balance by using the same fast in-memory cache and periodically writing its contents to disk. In practice this can perform almost as well as a straight memory cache, with the significant advantage that it also survives a server restart, as the checkpoint is read into memory at startup.
If you're using an external cache, all writes to the shared memory metadata cache are written out to the external cache so that other servers using the same external cache can avoid redundant optimization. In this configuration, the checkpoint is not written through to the external cache when it is restored, because this could overwrite the work of other servers.
Checkpointing is enabled by default, running every five minutes. You can
adjust this interval by
setting ShmMetadataCacheCheckpointIntervalSec
, and you can
disable checkpointing entirely by setting it to -1.
- Apache:
ModPagespeedShmMetadataCacheCheckpointIntervalSec 300
- Nginx:
pagespeed ShmMetadataCacheCheckpointIntervalSec 300;
This directive can only be used at the top level of your configuration.
Note that if you disable checkpointing, the shared memory cache will not be written to disk, and all optimizations will be lost on server restart.
If you have multiple file caches enabled, PageSpeed has to pick one to use for snapshots for the default shared memory cache. It resolves this by taking the file cache path that comes first alphabetically and putting all snapshots there.
External Caches
PageSpeed supports two different external caches, memcached and redis. The main reasons to use an external cache are:
- You want to run multiple PageSpeed servers without duplicating optimizations.
- You want to allocate more memory to PageSpeed's cache than a single machine an provide.
You can configure different external caches for different virtual hosts, but you can't use both memcached and redis for the same virtual host.
Configuring memcached
To enable memcached, specify the list of memcached servers with a comma-separated list of hosts and ports. If the port is omitted, the default memcached port of 11211 is assumed. PageSpeed's memcached integration by uses a background thread for communicating with the memcached servers. This allows PageSpeed to batch multiple Get requests into a single MultiGet request to memcached, which improves performance and reduces network round trips.
- Apache:
ModPagespeedMemcachedServers "host1:port1,host2:port2,host3:port3"
- Nginx:
pagespeed MemcachedServers "host1:port1,host2:port2,host3:port3";
To start memcached with 1Gb of memory, use memcached -p PORT -m 1024
-u WEBSERVER_USERNAME
. The default size of 64Mb might be too low
for large sites. See the
wiki for detailed memcached configuration help. Be aware that
configuring scalable caching requires tuning and iteration. You must be
sure that the user-id running the server has permission to access
memcached. For example, on CentOS, you may need to run memcached
with:
- Apache:
memcached -p PORT -m MEMORY_IN_MEGABYTES -u apache
- Nginx:
memcached -p PORT -m MEMORY_IN_MEGABYTES -u nginx
When you use memcached with PageSpeed, many vital memcached statistics can be found at
- Apache:
http://localhost/mod_pagespeed_statistics?memcached
- Nginx:
http://localhost/ngx_pagespeed_statistics?memcached
memcached_deletes: 0 memcached_hits: 81651 memcached_inserts: 161605 memcached_misses: 118782
...and also from the perspective of each memcached server, aggregating activity from each memcached client including all PageSpeed instances.
memcached server host1:6765 version 1.4.2 pid 1132 up 343306 seconds bytes: 923977753 bytes_read:<PHONE_NUMBER>2 bytes_written:<PHONE_NUMBER>00 cmd_get: 50273185 cmd_set: 11471631 connection_structures: 233 curr_connections: 16 curr_items: 255329 evictions: 5258751 get_hits: 50273185 get_misses: 14556369 limit_maxbytes:<PHONE_NUMBER> pointer_size: 64 rusage_system:<PHONE_NUMBER> rusage_user: 64 threads: 4 total_connections: 12235148 total_items: 11471631 memcached server host2:6765 version 1.4.2 pid 6568 up 343278 seconds bytes: 921246303 bytes_read:<PHONE_NUMBER>0 bytes_written:<PHONE_NUMBER>2 cmd_get: 21702123 cmd_set: 4166384 connection_structures: 49 curr_connections: 15 curr_items: 254144 evictions: 1329595 get_hits: 21702123 get_misses: 4923668 limit_maxbytes:<PHONE_NUMBER> pointer_size: 64 rusage_system: 594360000 rusage_user: 64 threads: 4 total_connections: 4840010 total_items: 4166384
By default, PageSpeed uses a half-second (500,000 microsecond) timeout for cache operations. If the timeout is exceeded more than 4 times in a 30 second span, PageSpeed assumes that memcached is not healthy and will stop optimizing resources for 30 seconds before trying again.
For wide area networks or for alternative implementations and proxies of
the memcache protocol such as couchbase or moxi-server it may be necessary
to increase the I/O timeout. Please monitor the statistic
'memcache_timeouts' to help tune the timeouts. Select a new timeout with
the MemcachedTimeoutUs
directive:
- Apache:
ModPagespeedMemcachedTimeoutUs timeout_in_microseconds
- Nginx:
pagespeed MemcachedTimeoutUs timeout_in_microseconds;
For example, to increase the timeout to from half a second to a second, use:
- Apache:
ModPagespeedMemcachedTimeoutUs 1000000
- Nginx:
pagespeed MemcachedTimeoutUs 1000000;
Configuring Redis
Note: New feature as of <IP_ADDRESS>
Warning: Redis support is experimental and has not yet had substantial real world use. Before rolling this out in production, be sure to test it well. If you run into problems, please let us know.
To enable redis, specify a single redis
server as host:port
. The port is optional, and defaults to
6379. This host can either be a stand-alone redis server, or a master
node from a redis cluster. If the host is a cluster node, PageSpeed will
ask it for the cluster configuration and distribute its reads and writes
among the cluster nodes.
- Apache:
ModPagespeedRedisServer "host:port"
- Nginx:
pagespeed RedisServer "host:port";
You can configure how long PageSpeed is willing to wait for a response from Redis before timing out a request, which defaults to 50ms:
- Apache:
ModPagespeedRedisTimeoutUs timeout_in_microseconds
- Nginx:
pagespeed RedisTimeoutUs timeout_in_microseconds;
You can also configure how long PageSpeed will wait after an error from Redis before it tries connecting again, which defaults to 1s:
- Apache:
ModPagespeedRedisReconnectionDelayMs timeout_in_milliseconds
- Nginx:
pagespeed RedisReconnectionDelayMs timeout_in_milliseconds;
As of <IP_ADDRESS> you can also select the Redis logical database having the specified numeric index. This setting defaults to database index 0. Note that the Redis clustering feature does not allow specifying a database index, and therefore is incompatible with this setting:
- Apache:
ModPagespeedRedisDatabaseIndex index
- Nginx:
pagespeed RedisDatabaseIndex index;
Flushing PageSpeed Server-Side Cache
When developing web pages with PageSpeed enabled, it is sometimes convenient to flush the cache of a running server, in order to get the system to reload CSS or JavaScript files that have been updated before the origin cache lifetime expires.
Legacy Flushing Of Entire Cache
By default, the system is configured to support only whole-cache
flushes — we'll call this legacy mode. As
of version <IP_ADDRESS>, it can be configured to
also allow purging of individual URLs. The two modes operate
differently and you may choose between them for each virtual
host. Legacy mode is on by default, to provide compatibility
with existing scripts and other infrastructure that might have
been built around it. In a future release, individual URL
purging will become the default. Subsequent to that, the legacy
whole-cache flushing mode will be eliminated.
You can choose between the two modes with
the EnableCachePurge
argument. If set to "on" you
will get the new behavior, with individual URL purging, while
"off" will give you the legacy behavior. The default is "off",
as if your configuration read:
- Apache:
ModPagespeedEnableCachePurge off
- Nginx:
pagespeed EnableCachePurge off;
In this mode, simply touch the file "cache.flush" in the directory
specified as FileCachePath
above. For example:
sudo touch /var/cache/pagespeed/cache.flush
The system may take up to 5 seconds to take effect (changeable via option
CacheFlushPollIntervalSec
described
below).
Purging individual cache entries or entire cache
Note: New feature as of <IP_ADDRESS>
In this mode, the cache may be purged by sending HTTP requests to the server, using a configurable path. The cache can be purged via an HTTP GET, PURGE, or DELETE, once a handler has been configured. The admin site makes this easier by providing a graphical interface to initiate purge requests and see what entries have been purged.
To enable individual URL cache purging, you must configure the admin site, specify a PurgeMethod, or both. Plus you must turn on EnableCachePurge:
- Apache:
ModPagespeedEnableCachePurge on ModPagespeedPurgeMethod PURGE (optional)
- Nginx:
pagespeed EnableCachePurge on; pagespeed PurgeMethod PURGE; (optional)
This establishes three methods to purge the cache of a URL, or to purge the entire cache, assuming PageSpeed is running on example.com:
| Method | Purge single URL | Purge entire cache |
|---|---|---|
| HTTP GET | curl 'http://example.com/pagespeed_admin/cache?purge=path/file.ext' |
curl 'http://example.com/pagespeed_admin/cache?purge=*' |
| HTTP PURGE | curl --request PURGE 'http://www.example.com/path/file.ext' |
curl --request PURGE 'http://www.example.com/*' |
| Admin GUI |
The Purge requests for individual URLs made via the GUI are
executed via an HTTP GET. In either case, the URL being purged
is specified relative to the ORIGIN of the admin site. In these
examples, path/file.ext
is combined
with example.com
to purge the path
http://example.com/path/file.ext
from the cache.
When the new mode of cache purging is enabled, the purges take place immediately, there is no five second delay. Note that it is possible to purge the entire cache, or to purge one URL at a time. It is not possible to purge by regular expression or wildcard. The URL purging system works by remembering which URLs are purged and validating each URL coming out of cache against them. There is a limitation to the number of distinct URLs that can be purged. When that limit is exceeded, everything in the cache older than the oldest remaining purge request will be dropped. The limitation is high enough that it's not expected to be exceeded often, but is not currently changeable.
Limitations
The following limitations apply to both method the legacy and new methods of cache purging.
Caution: In a multi-server system, you must run these commands on every server. All the cache data from VirtualHosts using that cache directory will be flushed. This is true even when using memcached: the cache flush information is kept locally on each machine running PageSpeed, not in the cache itself. This is because of the L1 caches that run locally on each machine, and because memcached does not guarantee persistance.
Caution: Flushing or purging the cache does not delete the old files from the directory, the memcached server, or PageSpeed's in-memory cache, but it tells PageSpeed to ignore those files.
Note: After flushing or purging the cache, the
stale files will eventually be replaced with fresh copies or
removed by the normal file cache cleaning process
(see FileCacheCleanIntervalMs
above).
You can change the polling interval and name of the cache-flush
file in the configuration file. If you set the polling interval to 0, the
cache flushing feature will be disabled. If you specify the cache flush
filename as a relative path, PageSpeed will look for that file in
the FileCachePath
directory. If you use an absolute path,
then the caches associated with multiple virtual hosts can be flushed all
at once.
Cache Flushing and Purging Options
- Apache:
ModPagespeedCacheFlushFilename alternate_filename ModPagespeedCacheFlushPollIntervalSec number_of_seconds
- Nginx:
pagespeed CacheFlushFilename alternate_filename pagespeed CacheFlushPollIntervalSec number_of_seconds;
Downstream Caches
PageSpeed is designed to work without any caches between it and the user, but it has experimental support for caching proxies. It works with Varnish, Nginx's proxy_cache with the ngx_cache_purge module, and any other server that accepts purge requests over HTTP, allows fragmenting the cache based on UA regexps, and supports modifying caching headers based on the response's content type. For details and sample configurations, please see the documentation on configuring downstream caches.Configuring Use of Shared Memory for Locks
When fetching or rewriting resources PageSpeed uses locks to ensure that
no redundant computation or fetching is done. This can use the file-system
or shared memory. The system defaults to shared memory locks, but you can
control which implementation is used with
the SharedMemoryLocks
option, passing it on
or off
.
Note that if you turn on shared memory locks when shared memory is not available, the system will fall back to file-system locks automatically.
On multi-server setups, locking being per-host will not adversely affect correctness but might result in multiple servers performing the same computation simultaneously.
Virtual hosts that specify SharedMemoryLocks on
with
identical values of FileCachePath
will share the same locking
domain. Note that these must be identical strings, not just two strings
representing the same directory. For example /var/foo
and /var/foo/
are different instances from a locking point of
view.
This setting's resource consumption is modest (300 kilobytes per instance on 64-bit systems) and it reduces file-system load.
Configuring a Cache Fragment
By default every site has its own cache. If you have multiple sites served from the same machine that reference common resources you can improve your cache performance and reduce CPU consumption by setting a shared cache fragment:
- Apache:
ModPagespeedCacheFragment some_token
- Nginx:
pagespeed CacheFragment some_token;
You must set this to the same value on every site that
shares a cache. The fragment may consist of letters, numbers, underscores,
and hyphens only. The physical caching layer also has to be the same for
the two sites: either you need a shared FileCachePath
or you
need to be using the same memcached
server.
Note: you don't have to do this for simple cases
like www.example.com
and images.example.com
.
The default cache fragment is the minimal private suffix, in this
case example.com
, and is determined from
the public suffix list. If you
have www.example.com
and images.example.org
,
however, then they will not share a common minimal private suffix and you
should set the CacheFragment
for better performance.
Native URL fetcher
Note: Nginx-only
Often PageSpeed needs to request URLs referenced from other files in order
to optimize them. To do this it uses a fetcher. By default ngx_pagespeed
uses the same fetcher mod_pagespeed does,
serf, but it also has an
experimental fetcher that avoids the need for a separate thread by using
native Nginx events. In initial testing this fetcher is about 10% faster. To
use it, put in your http
block:
pagespeed UseNativeFetcher on; resolver <IP_ADDRESS>;
Your DNS resolver doesn't have to be <IP_ADDRESS>; any domain name service your server has access to will work. If you don't specify a DNS resolver, PageSpeed will still work but will be limited to fetching only from IP addresses.
Persistent Connections with the Native URL Fetcher
Note: Nginx-only
Note: New feature as of <IP_ADDRESS>
As of <IP_ADDRESS> the Native URL Fetcher
supports persistent
HTTP connections. The fetcher will send the Connection:
Keep-Alive
header and if the server also sets that header on its
response then the connection will be kept open for 60 seconds in case
another fetch from the same server is needed. By default a connection will
be reused no more than 100 times, but you can use
NativeFetcherMaxKeepaliveRequests
to change this limit.
Keep-Alive support is on by default, and you can disable it by setting the
limit to 0:
pagespeed NativeFetcherMaxKeepaliveRequests 0;
Setting the URL fetcher timeout
When PageSpeed attempts to rewrite a resource for the first time, it must fetch it via HTTP. The default timeout for fetches is 5 seconds. A directive can be applied to change the timeout
- Apache:
ModPagespeedFetcherTimeoutMs timeout_value_in_milliseconds
- Nginx:
pagespeed FetcherTimeoutMs timeout_value_in_milliseconds;
Setting the rewrite deadline per flush window
When PageSpeed attempts to rewrite an uncached (or expired) resource it will wait for up to 10ms per flush window (by default) for it to finish and return the optimized resource if it's available. If it has not completed within that time the original (unoptimized) resource is returned and the optimizer is moved to the background for future requests. The following directive can be applied to change the deadline. Increasing this value will increase page latency, but might reduce load time (for instance on a bandwidth-constrained link where it's worth waiting for image compression to complete). Note that a value less than zero will cause PageSpeed to wait indefinitely.
- Apache:
ModPagespeedRewriteDeadlinePerFlushMs deadline_value_in_milliseconds
- Nginx:
pagespeed RewriteDeadlinePerFlushMs deadline_value_in_milliseconds;
Setting the implicit cache-lifetime for resources
When PageSpeed fetches a resource via HTTP or HTTPS, it examines the Expires and Cache-Control headers to determine how frequently it should update its cache. When these headers don't specify a timeout, a default timeout of 5 minutes is used. To override this, specify:
- Apache:
ModPagespeedImplicitCacheTtlMs implicit_cache_ttl_in_milliseconds
- Nginx:
pagespeed ImplicitCacheTtlMs implicit_cache_ttl_in_milliseconds;
Setting the cache-lifetime for resources loaded from file
Note: New feature as of <IP_ADDRESS>
When PageSpeed loads a
resource from file, the default cache lifetime
is set by ImplicitCacheTtlMs
, to override this, and set a
different cache lifetime for resources loaded from file, specify:
- Apache:
ModPagespeedLoadFromFileCacheTtlMs implicit_cache_ttl_in_milliseconds
- Nginx:
pagespeed LoadFromFileCacheTtlMs implicit_cache_ttl_in_milliseconds;
Fetching Resources using Gzip
This option causes PageSpeed to add Accept-Encoding:gzip
to
requests for resources. If the server responding to the request
handles this option (e.g. via mod_deflate), this results in reduced
bytes transferred over the network.
By default, PageSpeed attempts to fetch resources without specifying
anAccept-Encoding
header. This means the resources will be
sent uncompressed. These requests are often within the LAN, so network
bandwidth to transfer the resources may not be a consideration.
If network bandwidth is a consideration, then PageSpeed can be configured to fetch resources using gzip. This will lower the network transfer bandwidth considerably, but may increase the CPU usage depending on server configuration. The primary concern is the time spent by the origin server compressing the resource, rather than the time spent by PageSpeed inflating it.
- Apache:
ModPagespeedFetchWithGzip on SetOutputFilter DEFLATE
- Nginx:
pagespeed FetchWithGzip on; gzip on; gzip_vary on; # Turn on gzip for all content types that should benefit from it. gzip_types application/ecmascript; gzip_types application/javascript; gzip_types application/json; gzip_types application/pdf; gzip_types application/postscript; gzip_types application/x-javascript; gzip_types image/svg+xml; gzip_types text/css; gzip_types text/csv; # "gzip_types text/html" is assumed. gzip_types text/javascript; gzip_types text/plain; gzip_types text/xml; gzip_http_version 1.0;
Another option to minimize network bandwidth is to use LoadFromFile.
These directives can not be used in location-specific configuration sections.
Tuning Threading
PageSpeed uses threads so that resource optimization work does not delay
request serving. There are two kinds of threads in use: rewrite
threads deal with very short-lived bookkeeping tasks that are generally
latency-sensitive, while expensive rewrite threads deal with more
computationally expensive tasks that are not in latency-sensitive
paths. By default, if you use a single-threaded MPM (such
as prefork
) one thread of each kind will be used per an
Apache process. With a threaded MPM (such as worker
,
and event
) up to 4 threads of each kind will be used. You
can, however, tune the thread count per process if necessary via
the NumRewriteThreads
and NumExpensiveRewriteThreads
options.
Note that this is a global setting, and cannot be done in a per virtual host manner.
Limiting the number of concurrent image optimizations
When optimizing images, PageSpeed can use significant CPU resources. As
the results of the image optimization are cached, this is not ordinarily a
concern once the cache is warm. But when PageSpeed is first installed, or
when a corpus of new images is added to the server, PageSpeed needs to
avoid having each process consume maximum CPU. To accomplish this,
PageSpeed keeps a server-wide counter of active image optimizations. It
avoids running more than ImageMaxRewritesAtOnce
image
optimizations in parallel across all processes. The default value is 8.
Override this in the configuration file to change this maximum.
This directive can not be used in location-specific configuration sections.
Limiting the size of HTML parsed
When parsing and rewriting large HTML pages, PageSpeed can use
significant memory. This option limits the size of an HTML page that is
parsed. Once the size of the HTML exceeds MaxHtmlParseBytes
,
further parsing is disabled, and a script is inserted that redirects the
user to the ?ModPagespeed=off
version of the page. The
default value is 0, indicating that there is no limit. Override this in
the configuration file to change this maximum.
In-Place Resource Optimization
Note: Enabled by default as of <IP_ADDRESS>
Normally PageSpeed rewrites a resource such as an image by finding its URL on your page, fetching and optimizing the data in the background, and then replacing that URL by an optimized pagespeed URL. But what about resources that are loaded by JavaScript code? And what about links to your images from pages outside your domain? In-Place Resource Optimization (IPRO) will optimize the content of a resource that's requested using the original (non-pagespeed) URL, ensuring you are serving optimized content even when that content isn't explicitly linked in your html. This should be especially helpful for sites with slide shows that use JavaScript to load images in the background; those images can now be optimized by PageSpeed by adding this command to your configuration file:
- Apache:
ModPagespeedInPlaceResourceOptimization on
- Nginx:
pagespeed InPlaceResourceOptimization on;
Some sites employ JavaScript that is sensitive to the original resource URL syntax and won't work with PageSpeed's altered resource URLs. You can choose to preserve the URLs of your resources; these will still be rewritten by IPRO, but they won't be replaced by a pagespeed URL. This is especially useful as an "optimization is on by default" setting for hosting providers and optimizing forward proxies — cases where site-specific settings to blacklist URLs are impractical.
Setting s-maxage on unoptimized resources
Note: New feature as of <IP_ADDRESS>
When there is a caching proxy between PageSpeed and the user, resources
that haven't been optimized yet shouldn't be stored in the proxy cache for
the full cache lifetime because this will prevent PageSpeed from
optimizing them. As of <IP_ADDRESS>, PageSpeed marks unoptimized resources
with Cache-Control:
s-maxage=10
, telling shared caches that they should only
hold the unoptimized resource for ten seconds. Browsers will ignore
the s-maxage
and will hold the resource for whatever cache
lifetime you had originally set.
The s-maxage
value is configurable:
- Apache:
ModPagespeedInPlaceSMaxAgeSec 10
- Nginx:
pagespeed InPlaceSMaxAgeSec 10;
s-maxage
, set
InPlaceSMaxAgeSec
to -1.
Doing browser-specific in-place optimization
PageSpeed has a number of optimizations that are browser-specific. For example, WebP conversion is performed only for browsers that can display WebP images. Ordinarily PageSpeed accomplishes this by serving different rewritten URLs to different browsers depending upon their capabilities. For resources that are rewritten in place, this isn't possible; instead, appropriate headers (such as Vary: Accept and Vary: User-Agent) are added to rewritten resources as necessary. Enable these browser-specific optimizations as follows:
- Apache:
ModPagespeedEnableFilters in_place_optimize_for_browser
- Nginx:
pagespeed EnableFilters in_place_optimize_for_browser;
By default, when in_place_optimize_for_browser
is enabled,
appropriate Vary:
headers are added to resources that are
subject to browser-specific optimization. CSS files are served with
a Vary: User-Agent
header. Photographic images that are
candidates for WebP conversion are served with Vary: Accept
to
browsers that include Accept: image/webp
in their headers.
Note that while the most recent versions of browsers that display WebP
images include this header in image requests, older WebP-capable browsers do
not — as a result, a slightly smaller subset of browsers will receive
WebP images than would be the case if the URLs were rewritten.
Internet Explorer has difficulty caching resources
with Vary:
headers (they are either not cached or require
revalidation on every resource access). As a result, browser-specific
in-place resources are instead marked Cache-Control: private
when served to all versions of Internet Explorer.
Caution for users of downstream caches such as
Varnish: Consult the documentation on
configuring downstream caches to correctly fragment cache keys based on
user agent characteristics; this fragmentation should work equally well
for in_place_optimize_for_browser
. The Cache-Control:
private
header sent to Internet Explorer will cause cache entries to
be flushed unconditionally. This behavior should be disabled as
follows:
- Apache:
ModPagespeedPrivateNotVaryForIE off
- Nginx:
pagespeed PrivateNotVaryForIE off;
Setting the inplace resource rewrite deadline
When InPlaceResourceOptimization is enabled, PageSpeed uses a default deadline of 10ms the when optimizing the resource. If the optimization cannot be completed in 10ms, then the original resource is served to the client, while the optimization continues in the background. Once cached, the optimized resource will be served for further requests. Note that a value less than zero will cause PageSpeed to wait indefinitely.
Also note that in-place-optimized resources generally take at least two refreshes to optimize regardless of the deadline, due to the current architecture of the server modules.
- Apache:
ModPagespeedInPlaceRewriteDeadlineMs deadline_value_in_milliseconds
- Nginx:
pagespeed InPlaceRewriteDeadlineMs deadline_value_in_milliseconds;
This directive can be used in location-specific configuration sections.
Considerations
Resources optimized by in-place resource optimization are optimized
differently from resources found in HTML, JS, and CSS. First, rewritten
pagespeed URLs contain a content hash that enables the optimized data to be
cached for a year by browser and proxy caches; in-place resources are not
cache extended. Second, in-place resources can't be optimized specially for
the context in which they occur on the page: images can't be resized to the
size they appear on the page, and multiple resources on a page can't be
combined together. Finally, in-place resources that are eligible for
browser-specific optimizations (such as conversion to the WebP image format)
will be served with the Vary: User-Agent
caching header,
reducing caching at intermediate proxies.
Risks
In-place resource optimization will add a new cache entry for every unique URL requested. It will also copy each request into memory once. If you have a large site with many uncacheable resources, this could quickly fill up your cache or cause a lot of expensive string copies.
In-place optimization will also add a small delay to every server response, this should not be large and we have not been able to measure any noticeable slow-down, but if most of your resources are uncacheable, you may wish to avoid this cost.
Rate Limit Background Fetches
To avoid overloading the origin server, PageSpeed will limit the number
of background fetches it makes on a per-domain basis. As PageSpeed makes
fetches it keeps a count of how many ongoing fetches there are for each
domain, and if there are too many then additional fetches will only be
allowed through if they're for user-facing requests. Other fetches
(background fetches) will be queued up for completion later. If the
queue gets too large, PageSpeed will give up on those background
optimizations, leaving them to be reinitiated in response to a later
request. This feature can be disabled by
setting RateLimitBackgroundFetches
to off
:
- Apache:
ModPagespeedRateLimitBackgroundFetches off
- Nginx:
pagespeed RateLimitBackgroundFetches off;
This feature depends on shared memory statistics, which are also enabled by default.
Configuring HTTPCache Compression for PageSpeed
Note: HTTPCache Compression is a new feature as of <IP_ADDRESS>
In order to rewrite resources, PageSpeed must cache them server-side. Until <IP_ADDRESS>, these resources had been stored uncompressed. To reduce disk usage, decrease server latency, support higher compression levels, and increase server throughput, the HTTPCache can automatically gzip compressable resources as they are stored in the cache. To configure cache compression, setHttpCacheCompressionLevel
to values between -1
and 9
, with 0
being off, -1
being gzip's default compression, and
9
being maximum compression. The default value is 9, maximum
compression.
- Apache:
ModPagespeedHttpCacheCompressionLevel 9
- Nginx:
pagespeed HttpCacheCompressionLevel 9;
Scripting ngx_pagespeed
Note: New feature as of <IP_ADDRESS>
Note: Extended in <IP_ADDRESS>
Note: Nginx-only
PageSpeed supports Nginx's script variables in some directives. You can use this to adjust these settings on a per-request basis.
Script support must be enabled at the top level. To turn it on for a subset of directives, which is the only method supported in 1.11 and earlier, set:
http { pagespeed ProcessScriptVariables on; ... }
This allows scripts in the following directives:
| Setting | Script Support Added |
|---|---|
| LoadFromFile* | <IP_ADDRESS> |
| DownstreamCachePurgeLocationPrefix | <IP_ADDRESS> |
| DownstreamCachePurgeMethod | <IP_ADDRESS> |
| DownstreamCacheRewrittenPercentageThreshold | <IP_ADDRESS> |
| EnableFilters | <IP_ADDRESS> |
| DisableFilters | <IP_ADDRESS> |
| ShardDomain | <IP_ADDRESS> |
In version <IP_ADDRESS> and later, you may instead set:
http { pagespeed ProcessScriptVariables all; ... }
This will allow scripts in all directives, not just the seven specified above.
Because Nginx uses the $
-sign to indicate script variables,
when you turn on ProcessScriptVariables
you need to make a
small change to any script-supporting commands that are
using $
. For example, if you had:
pagespeed LoadFromFileRuleMatch Disallow \.ssp.css$;Then you would need to replace
$
with $ps_dollar
:
pagespeed LoadFromFileRuleMatch Disallow \.ssp.css$ps_dollar;
If you have a server that you don't want the scripted configuration to
apply, specify ClearInheritedScripts
. For example:
http { pagespeed ProcessScriptVariables on; pagespeed LoadFromFile "http://$host/static" "$document_root/static"; ... server { server_name example.com; root /var/www/ec; # PageSpeed will load example.com/static/foo from /var/www/ec/static/foo # directly, without going through the rest of nginx. } server { server_name example.org; root /var/www/eo; pagespeed ClearInheritedScripts; # This server block won't see that LoadFromFile config at all, so PageSpeed # will load example.org/static/foo by asking nginx for /static/foo over # http. } }


Package org.drip.sample.creditfeed
CDX NA IG Series Reconstitutor
- Author:
- Lakshmi Krishnamurthy
-
Class Summary Class Description CDXNAIGS155YReconstitutor CDXNAIGS155YReconstitutor cleanses the Input CDX.NA.IG S15 5Y CDS Price Marks and saves them into a usable and Process-able Format.CDXNAIGS165YReconstitutor CDXNAIGS165YReconstitutor cleanses the Input CDX.NA.IG S16 5Y CDS Price Marks and saves them into a usable and Process-able Format.CDXNAIGS175YReconstitutor CDXNAIGS175YReconstitutor cleanses the Input CDX.NA.IG S17 5Y CDS Price Marks and saves them into a usable and Process-able Format.CDXNAIGS185YReconstitutor CDXNAIGS185YReconstitutor cleanses the Input CDX.NA.IG S18 5Y CDS Price Marks and saves them into a usable and Process-able Format.CDXNAIGS195YReconstitutor CDXNAIGS195YReconstitutor cleanses the Input CDX.NA.IG S19 5Y CDS Price Marks and saves them into a usable and Process-able Format.CDXNAIGS205YReconstitutor CDXNAIGS205YReconstitutor cleanses the Input CDX.NA.IG S20 5Y CDS Price Marks and saves them into a usable and Process-able Format.CDXNAIGS215YReconstitutor CDXNAIGS215YReconstitutor cleanses the Input CDX.NA.IG S21 5Y CDS Price Marks and saves them into a usable and Process-able Format.CDXNAIGS225YReconstitutor CDXNAIGS225YReconstitutor cleanses the Input CDX.NA.IG S22 5Y CDS Price Marks and saves them into a usable and Process-able Format.CDXNAIGS235YReconstitutor CDXNAIGS235YReconstitutor cleanses the Input CDX.NA.IG S23 5Y CDS Price Marks and saves them into a usable and Process-able Format.CDXNAIGS245YReconstitutor CDXNAIGS245YReconstitutor cleanses the Input CDX.NA.IG S24 5Y CDS Price Marks and saves them into a usable and Process-able Format.CDXNAIGS255YReconstitutor CDXNAIGS255YReconstitutor cleanses the Input CDX.NA.IG S25 5Y CDS Price Marks and saves them into a usable and Process-able Format.CDXNAIGS265YReconstitutor CDXNAIGS265YReconstitutor cleanses the Input CDX.NA.IG S26 5Y CDS Price Marks and saves them into a usable and Process-able Format.USDCreditFixingReconstitutor USDCreditFixingReconstitutor demonstrates the Cleansing and the Shape Preserving Re-constitution of the USD Credit Fixing Input Marks.


USD/CAD: Mixed trade headlines, sluggish WTI keep prices under check
by Anil Panchal- USD/CAD fails to extend Friday’s recovery, stays below the 12-week-old resistance line.
- Hong Kong election results fail to counter doubts over phase two deal between the US and China.
- The pullback in oil prices adds to the lack of performance.
Given the mixed trade headlines, not to forget indecision among oil traders, USD/CAD seesaws around 1.3295 during Monday’s Asian session.
News that pro-Democratic candidates are up for a huge victory in Hong Kong’s district election recently favored market’s risk tone. However, the Reuters’ story, relying on official from the United States (US) and China, raise doubts on the phase two level deal between the US and Beijing, which in turn challenges the trade sentiment.
Prior to that, the US President Donald Trump increased the odds of a successful phase one deal with China. However, the Trump administration’s emphasis on the Hog Kong bill, which was recently passed by the Congress, risks another round of US-China political tussle.
It’s worth mentioning that the US 10-year Treasury yields takes rounds to 1.783% while S&P 500 Futures also rise by 0.30% to 3,120 by the press time.
Further, oil prices ignore threats from Iran and a consecutive fifth week of decline in the Baker Hughes US rig counts amid mixed trade headlines.
While Chicago Fed National Activity Index and Dallas Fed Manufacturing Index for October and November month respectively will occupy the US economic calendar, September month Wholesale Sales from Canada could also entertain the USD/CAD pair traders.
Technical Analysis
Unless providing a daily closing beyond multi-week-old resistance trend line, at 1.3310 now, buyers are less likely to aim for the previous month high near 1.3350 and the September month top close to 1.3385. As a result, the 21-day Exponential Moving Average (EMA) level of 1.3230 stays on the short-term seller’s radar during the pair’s pullback.
additional important levels
| Overview | |
|---|---|
| Today last price | 1.3296 |
| Today Daily Change | 4 pips |
| Today Daily Change % | 0.03% |
| Today daily open | 1.3292 |
| Trends | |
|---|---|
| Daily SMA20 | 1.3203 |
| Daily SMA50 | 1.3216 |
| Daily SMA100 | 1.321 |
| Daily SMA200 | 1.3277 |
| Levels | |
|---|---|
| Previous Daily High | 1.33 |
| Previous Daily Low | 1.3254 |
| Previous Weekly High | 1.3328 |
| Previous Weekly Low | 1.3156 |
| Previous Monthly High | 1.3349 |
| Previous Monthly Low | 1.3042 |
| Daily Fibonacci 38.2% | 1.3283 |
| Daily Fibonacci 61.8% | 1.3272 |
| Daily Pivot Point S1 | 1.3264 |
| Daily Pivot Point S2 | 1.3237 |
| Daily Pivot Point S3 | 1.3219 |
| Daily Pivot Point R1 | 1.331 |
| Daily Pivot Point R2 | 1.3328 |
| Daily Pivot Point R3 | 1.3355 |


Mustang 2
MUST CLICK ON "CLICK THIS TO START" TO WORK
Name:
Last Name:
City:
State:
ZIP:
Email:
Previous
Next
New
Delete
Click This to Start
Get Index


If you use assistive technology (such as a screen reader) and need a
version of this document in a more accessible format, please email
<EMAIL_ADDRESS>.
Please tell us what format you need. It will help us if you say what assistive technology you use.
If you use assistive technology (such as a screen reader) and need a
version of this document in a more accessible format, please email
<EMAIL_ADDRESS>.
Please tell us what format you need. It will help us if you say what assistive technology you use.
If you use assistive technology (such as a screen reader) and need a
version of this document in a more accessible format, please email
<EMAIL_ADDRESS>.
Please tell us what format you need. It will help us if you say what assistive technology you use.
If you use assistive technology (such as a screen reader) and need a
version of this document in a more accessible format, please email
<EMAIL_ADDRESS>.
Please tell us what format you need. It will help us if you say what assistive technology you use.
If you use assistive technology (such as a screen reader) and need a
version of this document in a more accessible format, please email
<EMAIL_ADDRESS>.
Please tell us what format you need. It will help us if you say what assistive technology you use.
Detail of outcome
We set out in this document the decisions we have taken on the assessment arrangements for these subjects. The Department for Education has also confirmed the content requirements for them and our decisions have been confirmed in relation to this final content.
If you use assistive technology (such as a screen reader) and need a
version of this document in a more accessible format, please email
<EMAIL_ADDRESS>.
Please tell us what format you need. It will help us if you say what assistive technology you use.
Detail of feedback received
Key Findings
Based on responses to the Likert-scale questions (‘strongly agree’ to ‘strongly disagree’), the majority of respondents are in agreement with Ofqual’s proposals with respect to the majority of subjects. These findings should be treated with caution given the considerable differences in base respondent numbers per subject.
Most respondents generally support Ofqual’s proposals not to tier these subjects, with the main arguments being that this will open up opportunities for all students to achieve the best possible grades and that there is already a successful track record of these subjects not having been tiered in the past.
The most common area of disagreement relates to Ofqual’s proposals to reduce the proportion of non-exam assessment for certain subjects following their reform.
Subjects where there is greatest concern associated with reducing the proportion of non-exam assessment include GCSE business, AS and A level environmental science, GCSE geology, and AS and A level music technology.
For the above-mentioned subjects, official responses from subject associations and schools, as well as personal responses from teachers, are the main sources of objection to these proposals.
For GCSE business, respondents have argued how coursework and controlled assessment promote research and investigation skills, including customer research, and enable their learning to be linked to the real business world.
For GCSE geology, non-exam assessment is considered important to assessing the types of practical skills that form the basis of a career in this field.
For AS and A level environmental science, it was pointed out that not including a practical component would be at odds with other core science-based qualifications, potentially implying that practical work is less valuable in this subject.
For AS and A level music technology, respondents emphasised the importance of assessing the practical processes involved and that the subject needs to more closely resemble the world of work with greater focus on non-exam assessment.
A number of specific suggestions have been given for enhancing the assessment objectives in certain subjects – primarily by awarding organisations and subject associations. These are set out in the main body of the report.
Comments on the equality impact of Ofqual’s proposals principally focused on the need to ensure sufficient provisions are in place to support students with mental health and learning disabilities such as dyslexia, specifically where exam-based assessments can prove more challenging than project-based work.
Original consultation
This consultation ran from
to
Summary
The first part of Ofqual's consultations on developing new GCSEs, AS and A levels for first teaching in September 2017.
If you use assistive technology (such as a screen reader) and need a
version of this document in a more accessible format, please email
<EMAIL_ADDRESS>.
Please tell us what format you need. It will help us if you say what assistive technology you use.
Consultation description
This consultation is about developing new GCSEs, AS and A levels for first teaching in September 2017.
The will be further consultation on the development of other GCSE and AS and A level subjects at a later date.
The subjects covered in this consultation are listed in the table below:


| ID | Employee Name | Contact | Email-ID | Designation | Status | Activity | |
|---|---|---|---|---|---|---|---|
|
|
{{employee.employeeId}}
|
{{employee.firstName + " " + employee.lastName}}
DOB : {{employee.dob | date : 'dd-MM-yyy'}}
|
{{employee.mobile}}
|
{{employee.emailId}}
|
{{employee.designation}}
|
Active
Locked
|
Last Active
{{employee.lastLogin | date: 'dd/MM/yyyy hh:mm a' }}
|


Top features
GOV.UK Pay uses established Payment Service Providers to deliver your payments service.
At no additional cost, we already offer:
Payment management
- take online card payments
- issue refunds and email receipts
- create reports and search transactions
- integrate with existing case management workflows
- offer an end-to-end GOV.UK experience
Digital standards
- meet the Digital Service Standard
- meet accessibility standards
- stay secure with full Payment Card Industry Data Security Standard compliance
- use our modern RESTful API for straightforward integration
Technical support
- get 24/7 support from the team at Government Digital Service
- read clear documentation on how to integrate with GOV.UK Pay
- use a sandbox (test) environment to prototype and try with your service
- switch PSPs without additional technical work (technical integration is provider-agnostic)
Queries and suggestions
- meet the Digital Service Standard
- meet accessibility standards
- stay secure with full Payment Card Industry Data Security Standard compliance
- use our modern RESTful API for straightforward integration
Technical support
- get 24/7 support from the team at Government Digital Service
- read clear documentation on how to integrate with GOV.UK Pay
- use a sandbox (test) environment to prototype and try with your service
- switch PSPs without additional technical work (technical integration is provider-agnostic)
Queries and suggestions
If you want to find out more about these features, or have some needs that GOV.UK Pay isn’t yet meeting, please get in touch with us by emailing<EMAIL_ADDRESS>or chat with us in our cross-government Slack channel.


|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
| Interface Summary | |
|---|---|
| PartitionStrategy | Represents the way edges are assigned to edge partitions based on their source and destination vertex IDs. |
| Class Summary | |
|---|---|
| Edge<ED> | A single directed edge consisting of a source id, target id, and the data associated with the edge. |
| EdgeContext<VD,ED,A> | Represents an edge along with its neighboring vertices and allows sending messages along the edge. |
| EdgeDirection | The direction of a directed edge relative to a vertex. |
| EdgeRDD<ED> | EdgeRDD[ED, VD] extends RDD[Edge[ED} by storing the edges in columnar format on each
partition for performance. |
| EdgeTriplet<VD,ED> | An edge triplet represents an edge along with the vertex attributes of its neighboring vertices. |
| Graph<VD,ED> | The Graph abstractly represents a graph with arbitrary objects associated with vertices and edges. |
| GraphKryoRegistrator | Registers GraphX classes with Kryo for improved performance. |
| GraphLoader | Provides utilities for loading Graph s from files. |
| GraphOps<VD,ED> | Contains additional functionality for Graph . |
| GraphXUtils | |
| PartitionStrategy.CanonicalRandomVertexCut$ | Assigns edges to partitions by hashing the source and destination vertex IDs in a canonical direction, resulting in a random vertex cut that colocates all edges between two vertices, regardless of direction. |
| PartitionStrategy.EdgePartition1D$ | Assigns edges to partitions using only the source vertex ID, colocating edges with the same source. |
| PartitionStrategy.EdgePartition2D$ | Assigns edges to partitions using a 2D partitioning of the sparse edge adjacency matrix,
guaranteeing a 2 * sqrt(numParts) - 1 bound on vertex replication. |
| PartitionStrategy.RandomVertexCut$ | Assigns edges to partitions by hashing the source and destination vertex IDs, resulting in a random vertex cut that colocates all same-direction edges between two vertices. |
| Pregel | Implements a Pregel-like bulk-synchronous message-passing API. |
| TripletFields | Represents a subset of the fields of an [[EdgeTriplet]] or [[EdgeContext]]. |
| VertexRDD<VD> | Extends RDD[(VertexId, VD)] by ensuring that there is only one entry for each vertex and by
pre-indexing the entries for fast, efficient joins. |
ALPHA COMPONENT GraphX is a graph processing framework built on top of Spark.
|
|||||||||
| PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |


RVFV Rift Valley virus fever animals IgG isolated study IgM {border-style antibodies px;} #ffffff;} African []. Biology Sciences No. circulation humans recent strains Bangui samples CAR Central Life RVF analysis infection mosquitoes sheep sheep, Dis: KJ, evidence positive strain (Table goats people rainy vectors viral .–.  Aedes Africa. CAR. Med animal anti-RVFV area contact current double; genome however, immunoglobulin introduction results seroprevalence studies wild Animals Antibodies DigoutteJP, Immune Institut Reference according age amplified animals. border-color border-width complete considered data dry high low market numbers pathogens prevalence previous reads reported season selected showed small, solid; south stored titres years {font-style {font-weight .), ./journal.pntd..tTable ./vbz.. Ae. Amniotes Borne Bunyaviruses: East Fever Health IgG, IgM, Infect Mammals Mauritania Medicine Ndangala Prevalence Research Serological Vector Vertebrates Viral Virus Zoonotic [], accession areas associated bold cases central clinical courier; described determine did difference distribution em; endemic entomological epidemics factors fever. genomes goats, higher included living mosquitoes, performed potential pt;} regions role sample sciences segments sequence sequenced sequences significantly vector Cattle –°C


BACK BEAT A film review by Sue Roberts Copyright 1994 Sue Roberts
Director: Ian Softly Producers: Finola Dwyer and Stephen Wooley. Starring Stephen Dorff, Ian Hart, Sheryl Lee, Gary Bakewell.
From the UK publicity of this film I anticipated it would be a music documentary paying homage to early Beatlemania, however the result was a far more interesting. The writers (Softley, Ward and Thomas) examine the embryonic band, and succeeded in showing the breadth of their influences. The Beatles ability to absorb not only musical ideas, but those of painting, photography, Hamburg counter- culture and Sixties socialism, allowed them to evolve a unique style.
John (Ian Hart) is shown railing against the merely fashionable in his search for the truly expressive and avant-garde.
I was impressed with the performance (by Stephen Dorff) of Stu Sutcliffe, the introvert, gifted beyond his years, with all the confusion and angst of youth. He achieved an intense and exhilarating portrait of an artist at work.
One of the things I most liked about this movie was the way it indicated that, from the start, only John Lennon had a real sense of destiny for the band. A key theme of the story is the reaction of the rest as they realise quite how this is likely to affect their future. Their competitive desire for Astrid mirrors a similar desire for quality in their work.
Some of the characterisations are low key, but this serves to reinforce the point that together, they were greater than the sum of individual artists and musicians.
Within minutes of commencing, this picture betrayed it's homage to SCANDAL. With wit and discretion it managed to achieved a UK-15 certificate. For a teenage audience, an understanding of their aspirations. For the rest of us, a reminder of a time before mortgages, when we may not have had many of the answers, but at least we were asking the questions!
Sue Roberts<EMAIL_ADDRESS>.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Documenting Your Code in Xcode
As a developer I’m always trying to balance my time between coding and commenting. I’d prefer to spend as little amount of time as possible commenting my code while at the time time, maximizing the usefulness of my comments. With that said, I’d like to share VVDocumenter-Xcode with you.
VVDocumenter takes advantage of Xcode’s commenting markup language by generating comment stubs for you by simply typing three forward slashes “///” above a parameter, method, etc.
If you’re not familiar with Xcode’s commenting markup language, please visit this website for Objective-C or this website for Swift. If you’re familiar with Javadocs, Xcode’s markup language for Objective C and Swift is very similar.
Lastly, the final question is, why care about commenting code in a particular way? In Xcode, if you use the option key and hover over a method, you’ll see a question mark appear and the method will highlight blue. If you click a properly commented method, you’ll see something like this:
Pretty right? Now for the icing on the cake…. An open source project called Jazzy is gaining momentum. Jazzy is very similar to Javadocs in the sense that it produces a very pretty html document similar to Apple’s standard documentation.
With the combination of the Apple’s markup language, VVDocumenter and Jazzy, you now have a powerful toolset to comment your code and produce professional documentation with minimal effort!


I am an aspiring engineer who enjoys connecting dots: be it ideas from different disciplines, people from different teams, or applications from different industries. I have strong technical skills
and an academic background in electrical engineering, deep learning, and web design. I love doing the integration between hardware and software, that makes me love doing some of IoT projects.
I took undergraduate study in Petra Christian University especially in Electrical Engineering. I joined many organization to sharpen my softskill in communicating ideas with other people.
I also have some side-jobs as web designer, photographer, and videographer that really sharpen my knowledge about handle many different kind of people.
In my graduate, I made some website for PT Samudra Luas Makmur (an Aluminium Diecasting factory in Indonesia), I also became teaching assistant of web programming, android app development, and basics programming courses.
After graduated from Petra Christian University, I continue my study at National Chiao Tung University. I took Electrical Engineering and Computer Science as my major.
In my graduate studies, I’ve taken on various project roles, including involved in Drone AR and Voice Recognition Control Interface project, I communicate and discuss with many library developer to provide information about bugs
and many things to improve in the library.
After involved in Voice Recognition team, now I already familiar with NLP and model conversion. I helped Barracuda Unity Developer for finding a new
bug in Barracuda library where Barracuda couldn’t receive more than one batch of tensor by examining the tensor input using my vector from voice recognition of ONNX
Model. I also helped ONNX Microsoft developer for enhance Sklearn2Onnx library and add new features for supporting Barracuda in Unity by giving recommendation what
features to add, what ONNX Operators are still not supported in Barracuda, and my prototype of code.
My passion lies in solving business problems with do the integration between hardware and software fluently and communicating complex ideas to non-technical stakeholders. I am able to jump across verticals to deliver
high-performing AI solutions.
I'm interested in IoT, app development, web design, data science, and machine learning. Please feel free to get in touch with me via email at<EMAIL_ADDRESS>Proficient: Python, HTML, CSS
Knowledgeable: NLP (Natural Language Processing) JS, PHP, C#, Assembly
Familiar: Kotlin, Java
Another Skills: Design, Videographies, Photographies


| Rank | Name | Color | Size & Votes | |
|---|---|---|---|---|
| Favorite: | Apples | Green | Medium | 500 |
| 2nd Favorite: | Oranges | Orange | Large | 450 |
| 3nd Favorite: | Pomegranate | Pomegranates and cherries can both come in a range of colors and sizes | 203 | |
| Joint 4th | Cherries | 75 | ||
| Pineapple | Brown | Very Large | ||
| ©2019 guoqzuo |


show || hide menu
Spider gbXML Viewer
File menu
to be reset
sample files gallery
Sample files you can load, view and experiment with:


Code Calisthenics: Six Challenges
It's important that you're able to turn a logical problem into a code solution. In some form or another, this comes up frequently when you're building features with code. It's also a ripe target for interview questions.
- Power
Write a method power which takes two integers (base and exponent) and returns the base raised to the power of exponent.
- Factorial
Write a method factorial which takes a number and returns the product of every number up to the current number multiplied together.
- Uniques
Write a method uniques which takes an array of items and returns the array without any duplicates.
- Combinations
Write a method combinations which takes two arrays of strings and returns an array with all of the combinations of the items in them, listing the first items first.
- Primes
Write a method isPrime which takes in a number and returns true if it is a prime number.
- Rectangle Overlap
Write a method overlap which takes two rectangles defined by the coordinates of their corners, e.g. [[0,0],[3,3]] and [[1,1],[4,6]], and determines whether they overlap. You can assume all coordinates are positive integers.
See Console.


The Manul Cat or Pallas' Cat, is a small wild cat with a broad but fragmented distribution in the grasslands and montane steppes of Central Asia.
Manuls are distinguished by having round pupils, short legs, and a flat-looking face with wide-set ears that can create some of the funniest expressions in the feline kingdom.


Data from The interaction between predation risk and food ration on behavior and morphology of Eurasian perch
Sources
Svanbäck R, Zha Y, Brönmark C, Johansson F (2017) The interaction between predation risk and food ration on behavior and morphology of Eurasian perch. Ecology and Evolution 7(20): 8567-8577. https://doi.org/10.1002/ece3.3330
Svanback R, Zha Y, Brönmark C, Johansson F (2017) Data from: The interaction between predation risk and food ration on behavior and morphology of Eurasian perch. Dryad Digital Repository. https://doi.org/10.5061/dryad.975m1
Background
Reproducibility key
- Reproducibility: 1 (fails to reproduce). Not really close
- Reproducibility: 2 (reproduces to a similar value). Differences may be due to slightly different specification of model or to slight differences in data (case may be excluded or missing)
- Reproducibility: 3 (reproduces to decimal or random error). Differences due to rounding or stochastic part of estimation.
- Reproducibility: 3- (reproduces to something close to random error). Differences very small and due to either different specification or stochastic or maybe algorithmic differences between packages.
A “+” means that the precise method wasn’t specified and reproducibility required exploration.
Caveats
Failure to reproduce (level 1) or partial reproducibility (level 2 or 3-) very well might be an error in my coding, or my misunderstanding of the author’s methods, or my lack of knowledge of statistics generally or the R functions that I use more specifically. Similarly, my Red Flags may also represent my own lack of knowledge or best practices in statistics.
Reproducibility
Figure 1/Table 1 (Condition and Length)
fn <- 'individual data.csv'
file_path <- paste(base_path, folder, fn, sep='/')
dt.fig1 <- fread(file_path)
Condition index
We estimated condition of each individual by first performing a regression on all log-transformed lengths and weights and saving the residuals. From this regression, we calculated the weight for an average individual of 90 mm (the average length at the end of the experiment was 90.6 mm). Condition for each fish was then estimated as the calculated average weight plus the residual. The condition index was then used as a measure of condition in all analyses.
I assume that “performing a regression on all log-transformed lengths and weights and saving the residuals” means to regress weight on length.
dt.fig1[, ln_weight:=log(Weight)]
dt.fig1[, ln_length:=log(Length)]
fit <- lm(ln_weight ~ ln_length, na.action="na.exclude", data=dt.fig1)
yhat <- predict(fit, newdata = data.frame(ln_length=log(90)))
dt.fig1[, condition:=yhat + residuals(fit)]
dt.fig1[, condition2:=exp(yhat + residuals(fit))]
dt.fig1[, condition3:=exp(yhat) + exp(residuals(fit)) - 1] # sub exp(0)=1
dt.fig1[, .(mean=exp(mean(condition)), # marginal mean then backtransform
SE=exp(sd(condition)/sqrt(.N)),
mean2=mean(condition2), # backtransform then mean
SE2=sd(condition2/sqrt(.N)),
mean3=mean(condition3), # backtransform yhat and residuals then mean
SE3=sd(condition3/sqrt(.N))
), by=c('Pike_presence', 'Food_Ratio')]
## Pike_presence Food_Ratio mean SE mean2 SE2 mean3
## 1: y 05_low 5.052031 1.027348 5.071878 0.13277327 5.640308
## 2: y 10_medium 5.630975 1.014212 5.637722 0.07986898 5.738549
## 3: n 10_medium 6.304749 1.035395 6.367111 0.25064352 5.865185
## 4: y 15_high 6.126227 1.019035 6.140303 0.11459835 5.825807
## 5: n 05_low 4.827397 1.021083 4.838904 0.10021281 5.599859
## 6: n 15_high 6.440573 1.014135 6.449491 0.09098461 5.879488
## SE3
## 1: 0.02305198
## 2: 0.01386679
## 3: 0.04351652
## 4: 0.01989647
## 5: 0.01739886
## 6: 0.01579667
mean computes the statistics in the transformed space and then backtransforms, which makes a little more sense. condition3/mean3 is the closest to the values suggest by Figure 1 but the range of my means is slightly larger.
Reproducibility: 2+ (reproduces to a similar value).
Table 1
it’s much simpler for me to think of this as factorial design with a random (aquarium) or clustered component than to think of the tanks as being nested within Pike_presence*Food_Ratio. Tank is the cluster unit.
# condition
model <- formula(condition3 ~ Pike_presence*Food_Ratio)
fit.condition <- lme(model, random = ~ 1|Aquarium_ID, data=dt.fig1)
anova(fit.condition, type='sequential') # Type I
## numDF denDF F-value p-value
## (Intercept) 1 46 142271.14 <.0001
## Pike_presence 1 30 3.66 0.0654
## Food_Ratio 2 30 21.42 <.0001
## Pike_presence:Food_Ratio 2 30 3.15 0.0573
anova(fit.condition, type='marginal') # Type III
## numDF denDF F-value p-value
## (Intercept) 1 46 21408.452 <.0001
## Pike_presence 1 30 0.485 0.4913
## Food_Ratio 2 30 18.221 <.0001
## Pike_presence:Food_Ratio 2 30 3.150 0.0573
# type II for Food_Ratio
model <- formula(condition3 ~ Pike_presence + Food_Ratio)
anova(lme(model, random = ~ 1|Aquarium_ID, data=dt.fig1), type='sequential')
## numDF denDF F-value p-value
## (Intercept) 1 46 126477.26 <.0001
## Pike_presence 1 32 3.26 0.0805
## Food_Ratio 2 32 19.07 <.0001
# type II for Pike_presence
model <- formula(condition3 ~ Food_Ratio + Pike_presence)
anova(lme(model, random = ~ 1|Aquarium_ID, data=dt.fig1), type='sequential')
## numDF denDF F-value p-value
## (Intercept) 1 46 126477.26 <.0001
## Food_Ratio 2 32 19.13 <.0001
## Pike_presence 1 32 3.13 0.0864
# length
model <- formula(Length ~ Pike_presence*Food_Ratio)
fit.length <- lme(model, random = ~ 1|Aquarium_ID, data=dt.fig1)
anova(fit.length, type='sequential') # Type I
## numDF denDF F-value p-value
## (Intercept) 1 46 11803.212 <.0001
## Pike_presence 1 30 0.724 0.4017
## Food_Ratio 2 30 5.211 0.0114
## Pike_presence:Food_Ratio 2 30 0.486 0.6197
anova(fit.length, type='marginal') # Type III
## numDF denDF F-value p-value
## (Intercept) 1 46 1656.0538 <.0001
## Pike_presence 1 30 0.0049 0.9445
## Food_Ratio 2 30 3.1855 0.0557
## Pike_presence:Food_Ratio 2 30 0.4863 0.6197
# type II for Food_Ratio
model <- formula(Length ~ Pike_presence + Food_Ratio)
anova(lme(model, random = ~ 1|Aquarium_ID, data=dt.fig1), type='sequential')
## numDF denDF F-value p-value
## (Intercept) 1 46 12516.147 <.0001
## Pike_presence 1 32 0.778 0.3844
## Food_Ratio 2 32 5.488 0.0089
# type II for Pike_presence
model <- formula(Length ~ Food_Ratio + Pike_presence)
anova(lme(model, random = ~ 1|Aquarium_ID, data=dt.fig1), type='sequential')
## numDF denDF F-value p-value
## (Intercept) 1 46 12516.147 <.0001
## Food_Ratio 2 32 5.496 0.0089
## Pike_presence 1 32 0.761 0.3894
Condition: Reproducibility: 2+ (reproduces to a similar value). Probably a difference in computation of Condition index. Reproduces uses sequential (default) but not marginal SS.
Length: Reproducibility: 3+ (reproduces to decimal or random error). Reproduces uses sequential (default) but not marginal SS.
Red Flag. Table 1 reports Type 1 (sequential) sums of squares and almost certainly the authors want Type III SS given the interaction effect in the model. Notice this makes a key difference here if inference is based on alpha.
Tukey Contrasts
inc_rows <- c('y,05_low - n,05_low', 'y,10_medium - n,10_medium', 'y,15_high - n,15_high')
condition.emm <- emmeans(fit.condition, specs=c('Pike_presence', 'Food_Ratio'))
condition.contrasts <- data.table(summary(contrast(condition.emm, method='revpairwise')))
condition.contrasts[contrast %in% inc_rows,]
## contrast estimate SE df t.ratio
## 1: y,05_low - n,05_low 0.03774033 0.05416473 30 0.6967694
## 2: y,10_medium - n,10_medium -0.15142115 0.05252112 30 -2.8830525
## 3: y,15_high - n,15_high -0.05228491 0.05227553 30 -1.0001795
## p.value
## 1: 0.98090332
## 2: 0.07114079
## 3: 0.91423070
length.emm <- emmeans(fit.length, specs=c('Pike_presence', 'Food_Ratio'))
length.contrasts <- data.table(summary(contrast(length.emm, method='revpairwise')))
length.contrasts[contrast %in% inc_rows,]
## contrast estimate SE df t.ratio p.value
## 1: y,05_low - n,05_low -0.2148140 3.057885 30 -0.07024919 0.9999997
## 2: y,10_medium - n,10_medium 3.6073001 2.824343 30 1.27721761 0.7947445
## 3: y,15_high - n,15_high 0.5916154 2.807236 30 0.21074654 0.9999362
Condition post-hoc: Reproducibility: 1+ (fails to reproduce). Compounded difference due to difference in Condition index mean and standard error. My pattern of mean and SE are similar and close in values but do not replicate at level 3.
Length post-hoc: Reproducibility: NA. Qualitatively it reproduces but numbers aren’t given in text.
Figure 2/Table 2 (Behavior)
fn <- 'behavioral data.csv'
file_path <- paste(base_path, folder, fn, sep='/')
dt.fig2 <- fread(file_path)
Table 2
I assume “distance from the partitioning” is the distance_from_predator in the table.
# rename columns to remove spaces
setnames(dt.fig2, old=c('distance from the partitioning', 'distance from the bottom', 'time_measured(start or end of experiment)'),
new=c('distance_from_predator', 'distance_from_bottom', 'time'))
# start of experiment
# distance from predator
model <- formula(distance_from_predator ~ Pike_presence*Food_Ratio)
fit.condition <- lme(model, random = ~ 1|Aquarium_ID, data=dt.fig2[time=='start'])
anova(fit.condition, type='sequential') # Type I
## numDF denDF F-value p-value
## (Intercept) 1 63 930.5413 <.0001
## Pike_presence 1 30 40.0064 <.0001
## Food_Ratio 2 30 2.4014 0.1078
## Pike_presence:Food_Ratio 2 30 5.3623 0.0102
anova(fit.condition, type='marginal') # Type III
## numDF denDF F-value p-value
## (Intercept) 1 63 128.68705 <.0001
## Pike_presence 1 30 4.80555 0.0363
## Food_Ratio 2 30 7.23652 0.0027
## Pike_presence:Food_Ratio 2 30 5.36228 0.0102
# distance from bottom
model <- formula(distance_from_bottom ~ Pike_presence*Food_Ratio)
fit.condition <- lme(model, random = ~ 1|Aquarium_ID, data=dt.fig2[time=='start'])
anova(fit.condition, type='sequential') # Type I
## numDF denDF F-value p-value
## (Intercept) 1 63 1737.8836 <.0001
## Pike_presence 1 30 16.8330 0.0003
## Food_Ratio 2 30 4.5008 0.0195
## Pike_presence:Food_Ratio 2 30 5.1535 0.0119
anova(fit.condition, type='marginal') # Type III
## numDF denDF F-value p-value
## (Intercept) 1 63 295.99270 <.0001
## Pike_presence 1 30 0.00035 0.9852
## Food_Ratio 2 30 6.93613 0.0033
## Pike_presence:Food_Ratio 2 30 5.15349 0.0119
# swimming distance
model <- formula(tot_dist_swimming ~ Pike_presence*Food_Ratio)
fit.condition <- lme(model, random = ~ 1|Aquarium_ID, data=dt.fig2[time=='start'])
anova(fit.condition, type='sequential') # Type I
## numDF denDF F-value p-value
## (Intercept) 1 63 169.06454 <.0001
## Pike_presence 1 30 23.57728 <.0001
## Food_Ratio 2 30 0.53516 0.5911
## Pike_presence:Food_Ratio 2 30 1.25262 0.3003
anova(fit.condition, type='marginal') # Type III
## numDF denDF F-value p-value
## (Intercept) 1 63 46.39753 <.0001
## Pike_presence 1 30 3.65862 0.0654
## Food_Ratio 2 30 1.43545 0.2539
## Pike_presence:Food_Ratio 2 30 1.25262 0.3003
# end of experiment
# distance from predator
model <- formula(distance_from_predator ~ Pike_presence*Food_Ratio)
fit.condition <- lme(model, random = ~ 1|Aquarium_ID, data=dt.fig2[time=='end'])
anova(fit.condition, type='sequential') # Type I
## numDF denDF F-value p-value
## (Intercept) 1 42 682.8711 <.0001
## Pike_presence 1 30 5.0650 0.0319
## Food_Ratio 2 30 1.3879 0.2652
## Pike_presence:Food_Ratio 2 30 0.6498 0.5294
anova(fit.condition, type='marginal') # Type III
## numDF denDF F-value p-value
## (Intercept) 1 42 72.20010 <.0001
## Pike_presence 1 30 3.01693 0.0927
## Food_Ratio 2 30 1.82411 0.1788
## Pike_presence:Food_Ratio 2 30 0.64976 0.5294
# distance from bottom
model <- formula(distance_from_bottom ~ Pike_presence*Food_Ratio)
fit.condition <- lme(model, random = ~ 1|Aquarium_ID, data=dt.fig2[time=='end'])
anova(fit.condition, type='sequential') # Type I
## numDF denDF F-value p-value
## (Intercept) 1 42 775.4438 <.0001
## Pike_presence 1 30 2.9583 0.0957
## Food_Ratio 2 30 4.8096 0.0154
## Pike_presence:Food_Ratio 2 30 0.4117 0.6662
anova(fit.condition, type='marginal') # Type III
## numDF denDF F-value p-value
## (Intercept) 1 42 74.35658 <.0001
## Pike_presence 1 30 2.00641 0.1669
## Food_Ratio 2 30 3.79771 0.0339
## Pike_presence:Food_Ratio 2 30 0.41174 0.6662
# swimming distance
model <- formula(tot_dist_swimming ~ Pike_presence*Food_Ratio)
fit.condition <- lme(model, random = ~ 1|Aquarium_ID, data=dt.fig2[time=='end'])
anova(fit.condition, type='sequential') # Type I
## numDF denDF F-value p-value
## (Intercept) 1 42 338.7991 <.0001
## Pike_presence 1 30 5.1067 0.0313
## Food_Ratio 2 30 4.1053 0.0265
## Pike_presence:Food_Ratio 2 30 1.6320 0.2124
anova(fit.condition, type='marginal') # Type III
## numDF denDF F-value p-value
## (Intercept) 1 42 118.24997 <.0001
## Pike_presence 1 30 7.40418 0.0107
## Food_Ratio 2 30 5.40359 0.0099
## Pike_presence:Food_Ratio 2 30 1.63205 0.2124
Reproducibility: 3+ (reproduces to decimal or random error). Reproduces uses sequential (default) but not marginal SS.
Red Flag. Table 2 reports Type 1 (sequential) sums of squares and almost certainly the authors want Type III SS (or Type II) given the interaction effect in the model. Notice this makes a key difference here if inference is based on alpha.
Morphometrics
Post-publication review
As noted above, the ANOVA tables reported present Type I (sequential) SS which are almost certainly not what the authors intended as the p-values of the first factor will not be conditional on the second factor (nor the interaction). This has consequences on the inference from the ANOVA tables, which raises the question of the role of “storytelling” to “explain” whatever results occur. Would the revised tables generate the same “explanatory” story? It’s one reason why I just don’t find ANOVA tables worthwhile (at all). I’d much rather use sets of contrasts to understand what is going on and at least these also give me effect sizes.


|
NetFlex
0.0.0
C++11 HTTP Server Library.
|
#include <logger.hpp>
Public Types | |
| enum | log_level { error = 0, warn = 1, info = 2, debug = 3 } |
Public Member Functions | |
| logger (log_level level=log_level::info) | |
| ctor | |
| ~logger (void)=default | |
| dtor | |
| logger (const logger &)=default | |
| copy ctor | |
| logger & | operator= (const logger &)=default |
| assignment operator | |
| void | debug (const std::string &msg, const std::string &file, std::size_t line) |
| void | info (const std::string &msg, const std::string &file, std::size_t line) |
| void | warn (const std::string &msg, const std::string &file, std::size_t line) |
| void | error (const std::string &msg, const std::string &file, std::size_t line) |
| Public Member Functions inherited from netflex::logger_iface | |
| logger_iface (void)=default | |
| ctor | |
| virtual | ~logger_iface (void)=default |
| dtor | |
| logger_iface (const logger_iface &)=default | |
| copy ctor | |
| logger_iface & | operator= (const logger_iface &)=default |
| assignment operator | |
default logger class provided by the library
|
strong |
log level
|
virtual |
debug logging
| msg | message to be logged |
| file | file from which the message is coming |
| line | line in the file of the message |
Implements netflex::logger_iface.
|
virtual |
error logging
| msg | message to be logged |
| file | file from which the message is coming |
| line | line in the file of the message |
Implements netflex::logger_iface.
|
virtual |
info logging
| msg | message to be logged |
| file | file from which the message is coming |
| line | line in the file of the message |
Implements netflex::logger_iface.
|
virtual |
warn logging
| msg | message to be logged |
| file | file from which the message is coming |
| line | line in the file of the message |
Implements netflex::logger_iface.


Project Information
Project Name
Prepared By
Storey Height And Weight
Number of Levels (≤ 100)
| Level | hs(m) | W(kN) | |
|---|---|---|---|
| Roof |
Site and Class (X & Y Directions)
Province
Location
| Sa(0.2) | Sa(0.5) | Sa(1.0) | Sa(2.0) |
|---|---|---|---|
| Level | hs(m) | W(kN) | |
|---|---|---|---|
| Roof |
| Sa(0.2) | Sa(0.5) | Sa(1.0) | Sa(2.0) |
|---|---|---|---|


It's your data, so you should have the control of it, right? PLP (Portable Linked Profiles) offers you the possibility to compose and fully manage your basic profile information.Please note that the information we are speaking about is public information. That means your contact data, interests, the projects you participate on, the company you work for, etc... Nothing you would like to hide from others.
This editor is fairly easy to use for anyone willing to compose or edit profile information. This data can be then linked to applications supporting the PLP pattern.These applications can be listings, directories or whatever service making use of this information. Thanks to it's modularity, coders can easily create applications on top of PLP Profiles. You might want to take a look at the documentation if you want to discover which services use PLP.
Are you writing a web-app or service that aggregates profile information? Do you need a quick, easy and efficient way for your users to register on your platform? PLP addresses this scenario. PLP is not only composed by Editors like this.  Feeling like collaborating on the extension of PLP? Feel free to browse, clone, comment and fiddle around the code. Everything is on Github
It will take you just 5 minutes.
In that case, you can input the URL where your Profile is stored, editor will then be initialised so you can edit it
Quite easy: Select which kind of profile you want to create: For your personal profile, your organization or even for a venue or place. Fill out the fields you want. None of the fields is mandatory.
Please, mind that the information you specify will be publicly available.
Once you are ready, press the button below and get to the final step where you will decide where you store your PLP profile.
Generate your profileNow, you can decide where you want to store your profile data.
If you do not know where you can store your profile, we can do it for you! Very easy, click the button below and we will give you the URI to your profile.
Host it for meDownload and store it wherever you want. You can upload it to your website or favorite cloud storage service.


new exports(optionsnullable)
Represents a client connection to the Discord API and Gateway.
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
options |
object |
<nullable> |
The options to use for the client. |
- Source:


{% extends '_layouts/layout.html' %} {% block page_title %}{% endblock %} {% block body_css_classes %}nhsuk-frontend{% endblock %} {% block content %}
Read general advice such as:
Get information about coronavirus (COVID-19).
We’ll ask you a few questions and tell you what to do next.
To protect others, do not go to a GP, pharmacy or hospital


Manually annotate the frame sequence:
This tool is a annotation tool for tracking people's movement trajectory.(simplified by tracking a person's head position)
How to Track a New Person
1. To track a new person, first click 'n' (for new), and then left click on person's head locations in the video.
2. A new information box should appear below the video, you need to change the ID number. Every person should have perticular ID number.
3. You need to use the head position as the person's position. So, the center of the location circle should always located in the center of head.
4. After creating the location circle, you can put your mouse on the inner circle and drag it to place the circle more accurately.
5. Play the video and use left and right arrows to navigate frame by frame, change the location of circle to make sure that the center of it will always match the head of the person.
Tips
Use the spacebar to play/pause the video, and the left and right arrows to navigate frame by frame.
The visibility of each object can be toogled with its visiblity checkbox under the video.
Zoom in with your browser to place the location circles more accurately.