The InfluxDB storage engine and the Time-Structured Merge Tree (TSM)
The InfluxDB storage engine looks very similar to a LSM Tree. It has a write ahead log and a collection of read-only data files which are similar in concept to SSTables in an LSM Tree. TSM files contain sorted, compressed series data.
InfluxDB will create a shard for each block of time. For example, if you have a retention policy with an unlimited duration, shards will be created for each 7 day block of time. Each of these shards maps to an underlying storage engine database. Each of these databases has its own WAL and TSM files.
We’ll dig into each of these parts of the storage engine.
Storage engine
The storage engine ties a number of components together and provides the external interface for storing and querying series data. It is composed of a number of components that each serve a particular role:
- In-Memory Index - The in-memory index is a shared index across shards that provides the quick access to measurements, tags, and series. The index is used by the engine, but is not specific to the storage engine itself.
- WAL - The WAL is a write-optimized storage format that allows for writes to be durable, but not easily queryable. Writes to the WAL are appended to segments of a fixed size.
- Cache - The Cache is an in-memory representation of the data stored in the WAL. It is queried at runtime and merged with the data stored in TSM files.
- TSM Files - TSM files store compressed series data in a columnar format.
- FileStore - The FileStore mediates access to all TSM files on disk. It ensures that TSM files are installed atomically when existing ones are replaced as well as removing TSM files that are no longer used.
- Compactor - The Compactor is responsible for converting less optimized Cache and TSM data into more read-optimized formats. It does this by compressing series, removing deleted data, optimizing indices and combining smaller files into larger ones.
- Compaction Planner - The Compaction Planner determines which TSM files are ready for a compaction and ensures that multiple concurrent compactions do not interfere with each other.
- Compression - Compression is handled by various Encoders and Decoders for specific data types. Some encoders are fairly static and always encode the same type the same way; others switch their compression strategy based on the shape of the data.
- Writers/Readers - Each file type (WAL segment, TSM files, tombstones, etc..) has Writers and Readers for working with the formats.
Write Ahead Log (WAL)
The WAL is organized as a bunch of files that look like _000001.wal
.
The file numbers are monotonically increasing and referred to as WAL segments.
When a segment reaches 10MB in size, it is closed and a new one is opened. Each WAL segment stores multiple compressed blocks of writes and deletes.
When a write comes in the new points are serialized, compressed using Snappy, and written to a WAL file.
The file is fsync
’d and the data is added to an in-memory index before a success is returned.
This means that batching points together is required to achieve high throughput performance.
(Optimal batch size seems to be 5,000-10,000 points per batch for many use cases.)
Each entry in the WAL follows a TLV standard with a single byte representing the type of entry (write or delete), a 4 byte uint32
for the length of the compressed block, and then the compressed block.
Cache
The Cache is an in-memory copy of all data points current stored in the WAL. The points are organized by the key, which is the measurement, tag set, and unique field. Each field is kept as its own time-ordered range. The Cache data is not compressed while in memory.
Queries to the storage engine will merge data from the Cache with data from the TSM files. Queries execute on a copy of the data that is made from the cache at query processing time. This way writes that come in while a query is running won’t affect the result.
Deletes sent to the Cache will clear out the given key or the specific time range for the given key.
The Cache exposes a few controls for snapshotting behavior.
The two most important controls are the memory limits.
There is a lower bound, cache-snapshot-memory-size
, which when exceeded will trigger a snapshot to TSM files and remove the corresponding WAL segments.
There is also an upper bound, cache-max-memory-size
, which when exceeded will cause the Cache to reject new writes.
These configurations are useful to prevent out of memory situations and to apply back pressure to clients writing data faster than the instance can persist it.
The checks for memory thresholds occur on every write.
The other snapshot controls are time based.
The idle threshold, cache-snapshot-write-cold-duration
, forces the Cache to snapshot to TSM files if it hasn’t received a write within the specified interval.
The in-memory Cache is recreated on restart by re-reading the WAL files on disk.
TSM files
TSM files are a collection of read-only files that are memory mapped. The structure of these files looks very similar to an SSTable in LevelDB or other LSM Tree variants.
A TSM file is composed of four sections: header, blocks, index, and footer.
+--------+------------------------------------+-------------+--------------+
| Header | Blocks | Index | Footer |
|5 bytes | N bytes | N bytes | 4 bytes |
+--------+------------------------------------+-------------+--------------+
The Header is a magic number to identify the file type and a version number.
+-------------------+
| Header |
+-------------------+
| Magic │ Version |
| 4 bytes │ 1 byte |
+-------------------+
Blocks are sequences of pairs of CRC32 checksums and data. The block data is opaque to the file. The CRC32 is used for block level error detection. The length of the blocks is stored in the index.
+--------------------------------------------------------------------+
│ Blocks │
+---------------------+-----------------------+----------------------+
| Block 1 | Block 2 | Block N |
+---------------------+-----------------------+----------------------+
| CRC | Data | CRC | Data | CRC | Data |
| 4 bytes | N bytes | 4 bytes | N bytes | 4 bytes | N bytes |
+---------------------+-----------------------+----------------------+
Following the blocks is the index for the blocks in the file. The index is composed of a sequence of index entries ordered lexicographically by key and then by time. The key includes the measurement name, tag set, and one field. Multiple fields per point creates multiple index entries in the TSM file. Each index entry starts with a key length and the key, followed by the block type (float, int, bool, string) and a count of the number of index block entries that follow for that key. Each index block entry is composed of the min and max time for the block, the offset into the file where the block is located and the size of the block. There is one index block entry for each block in the TSM file that contains the key.
The index structure can provide efficient access to all blocks as well as the ability to determine the cost associated with accessing a given key. Given a key and timestamp, we can determine whether a file contains the block for that timestamp. We can also determine where that block resides and how much data must be read to retrieve the block. Knowing the size of the block, we can efficiently provision our IO statements.
+-----------------------------------------------------------------------------+
│ Index │
+-----------------------------------------------------------------------------+
│ Key Len │ Key │ Type │ Count │Min Time │Max Time │ Offset │ Size │...│
│ 2 bytes │ N bytes │1 byte│2 bytes│ 8 bytes │ 8 bytes │8 bytes │4 bytes │ │
+-----------------------------------------------------------------------------+
The last section is the footer that stores the offset of the start of the index.
+---------+
│ Footer │
+---------+
│Index Ofs│
│ 8 bytes │
+---------+
Compression
Each block is compressed to reduce storage space and disk IO when querying. A block contains the timestamps and values for a given series and field. Each block has one byte header, followed by the compressed timestamps and then the compressed values.
+--------------------------------------------------+
| Type | Len | Timestamps | Values |
|1 Byte | VByte | N Bytes | N Bytes │
+--------------------------------------------------+
The timestamps and values are compressed and stored separately using encodings dependent on the data type and its shape. Storing them independently allows timestamp encoding to be used for all timestamps, while allowing different encodings for different field types. For example, some points may be able to use run-length encoding whereas other may not.
Each value type also contains a 1 byte header indicating the type of compression for the remaining bytes. The four high bits store the compression type and the four low bits are used by the encoder if needed.
Timestamps
Timestamp encoding is adaptive and based on the structure of the timestamps that are encoded. It uses a combination of delta encoding, scaling, and compression using simple8b run-length encoding, as well as falling back to no compression if needed.
Timestamp resolution is variable but can be as granular as a nanosecond, requiring up to 8 bytes to store uncompressed. During encoding, the values are first delta-encoded. The first value is the starting timestamp and subsequent values are the differences from the prior value. This usually converts the values into much smaller integers that are easier to compress. Many timestamps are also monotonically increasing and fall on even boundaries of time such as every 10s. When timestamps have this structure, they are scaled by the largest common divisor that is also a factor of 10. This has the effect of converting very large integer deltas into smaller ones that compress even better.
Using these adjusted values, if all the deltas are the same, the time range is stored using run-length encoding. If run-length encoding is not possible and all values are less than (1 << 60) - 1 (~36.5 years at nanosecond resolution), then the timestamps are encoded using simple8b encoding. Simple8b encoding is a 64bit word-aligned integer encoding that packs multiple integers into a single 64bit word. If any value exceeds the maximum the deltas are stored uncompressed using 8 bytes each for the block. Future encodings may use a patched scheme such as Patched Frame-Of-Reference (PFOR) to handle outliers more effectively.
Floats
Floats are encoded using an implementation of the Facebook Gorilla paper. The encoding XORs consecutive values together to produce a small result when the values are close together. The delta is then stored using control bits to indicate how many leading and trailing zeroes are in the XOR value. Our implementation removes the timestamp encoding described in paper and only encodes the float values.
Integers
Integer encoding uses two different strategies depending on the range of values in the uncompressed data. Encoded values are first encoded using ZigZag encoding. This interleaves positive and negative integers across a range of positive integers.
For example, [-2,-1,0,1] becomes [3,1,0,2]. See Google’s Protocol Buffers documentation for more information.
If all ZigZag encoded values are less than (1 << 60) - 1, they are compressed using simple8b encoding. If any values are larger than the maximum then all values are stored uncompressed in the block. If all values are identical, run-length encoding is used. This works very well for values that are frequently constant.
Booleans
Booleans are encoded using a simple bit packing strategy where each Boolean uses 1 bit. The number of Booleans encoded is stored using variable-byte encoding at the beginning of the block.
Strings
Strings are encoding using Snappy compression. Each string is packed consecutively and they are compressed as one larger block.
Compactions
Compactions are recurring processes that migrate data stored in a write-optimized format into a more read-optimized format. There are a number of stages of compaction that take place while a shard is hot for writes:
- Snapshots - Values in the Cache and WAL must be converted to TSM files to free memory and disk space used by the WAL segments. These compactions occur based on the cache memory and time thresholds.
- Level Compactions - Level compactions (levels 1-4) occur as the TSM files grow. TSM files are compacted from snapshots to level 1 files. Multiple level 1 files are compacted to produce level 2 files. The process continues until files reach level 4 and the max size for a TSM file. They will not be compacted further unless deletes, index optimization compactions, or full compactions need to run. Lower level compactions use strategies that avoid CPU-intensive activities like decompressing and combining blocks. Higher level (and thus less frequent) compactions will re-combine blocks to fully compact them and increase the compression ratio.
- Index Optimization - When many level 4 TSM files accumulate, the internal indexes become larger and more costly to access. An index optimization compaction splits the series and indices across a new set of TSM files, sorting all points for a given series into one TSM file. Before an index optimization, each TSM file contained points for most or all series, and thus each contains the same series index. After an index optimization, each TSM file contains points from a minimum of series and there is little series overlap between files. Each TSM file thus has a smaller unique series index, instead of a duplicate of the full series list. In addition, all points from a particular series are contiguous in a TSM file rather than spread across multiple TSM files.
- Full Compactions - Full compactions run when a shard has become cold for writes for long time, or when deletes have occurred on the shard. Full compactions produce an optimal set of TSM files and include all optimizations from Level and Index Optimization compactions. Once a shard is fully compacted, no other compactions will run on it unless new writes or deletes are stored.
Writes
Writes are appended to the current WAL segment and are also added to the Cache. Each WAL segment has a maximum size. Writes roll over to a new file once the current file fills up. The cache is also size bounded; snapshots are taken and WAL compactions are initiated when the cache becomes too full. If the inbound write rate exceeds the WAL compaction rate for a sustained period, the cache may become too full, in which case new writes will fail until the snapshot process catches up.
When WAL segments fill up and are closed, the Compactor snapshots the Cache and writes the data to a new TSM file.
When the TSM file is successfully written and fsync
’d, it is loaded and referenced by the FileStore.
Updates
Updates (writing a newer value for a point that already exists) occur as normal writes. Since cached values overwrite existing values, newer writes take precedence. If a write would overwrite a point in a prior TSM file, the points are merged at query runtime and the newer write takes precedence.
Deletes
Deletes occur by writing a delete entry to the WAL for the measurement or series and then updating the Cache and FileStore. The Cache evicts all relevant entries. The FileStore writes a tombstone file for each TSM file that contains relevant data. These tombstone files are used at startup time to ignore blocks as well as during compactions to remove deleted entries.
Queries against partially deleted series are handled at query time until a compaction removes the data fully from the TSM files.
Queries
When a query is executed by the storage engine, it is essentially a seek to a given time associated with a specific series key and field. First, we do a search on the data files to find the files that contain a time range matching the query as well containing matching series.
Once we have the data files selected, we next need to find the position in the file of the series key index entries. We run a binary search against each TSM index to find the location of its index blocks.
In common cases the blocks will not overlap across multiple TSM files and we can search the index entries linearly to find the start block from which to read. If there are overlapping blocks of time, the index entries are sorted to ensure newer writes will take precedence and that blocks can be processed in order during query execution.
When iterating over the index entries the blocks are read sequentially from the blocks section. The block is decompressed and we seek to the specific point.
The new InfluxDB storage engine: from LSM Tree to B+Tree and back again to create the Time Structured Merge Tree
Writing a new storage format should be a last resort. So how did InfluxData end up writing our own engine? InfluxData has experimented with many storage formats and found each lacking in some fundamental way. The performance requirements for InfluxDB are significant, and eventually overwhelm other storage systems. The 0.8 line of InfluxDB allowed multiple storage engines, including LevelDB, RocksDB, HyperLevelDB, and LMDB. The 0.9 line of InfluxDB used BoltDB as the underlying storage engine. This writeup is about the Time Structured Merge Tree storage engine that was released in 0.9.5 and is the only storage engine supported in InfluxDB 0.11+, including the entire 1.x family.
The properties of the time series data use case make it challenging for many existing storage engines. Over the course of InfluxDB development, InfluxData tried a few of the more popular options. We started with LevelDB, an engine based on LSM Trees, which are optimized for write throughput. After that we tried BoltDB, an engine based on a memory mapped B+Tree, which is optimized for reads. Finally, we ended up building our own storage engine that is similar in many ways to LSM Trees.
With our new storage engine we were able to achieve up to a 45x reduction in disk space usage from our B+Tree setup with even greater write throughput and compression than what we saw with LevelDB and its variants. This post will cover the details of that evolution and end with an in-depth look at our new storage engine and its inner workings.
Properties of time series data
The workload of time series data is quite different from normal database workloads. There are a number of factors that conspire to make it very difficult to scale and remain performant:
- Billions of individual data points
- High write throughput
- High read throughput
- Large deletes (data expiration)
- Mostly an insert/append workload, very few updates
The first and most obvious problem is one of scale. In DevOps, IoT, or APM it is easy to collect hundreds of millions or billions of unique data points every day.
For example, let’s say we have 200 VMs or servers running, with each server collecting an average of 100 measurements every 10 seconds.
Given there are 86,400 seconds in a day, a single measurement will generate 8,640 points in a day per server.
That gives us a total of 172,800,000 (200 * 100 * 8,640
) individual data points per day.
We find similar or larger numbers in sensor data use cases.
The volume of data means that the write throughput can be very high. We regularly get requests for setups than can handle hundreds of thousands of writes per second. Some larger companies will only consider systems that can handle millions of writes per second.
At the same time, time series data can be a high read throughput use case. It’s true that if you’re tracking 700,000 unique metrics or time series you can’t hope to visualize all of them. That leads many people to think that you don’t actually read most of the data that goes into the database. However, other than dashboards that people have up on their screens, there are automated systems for monitoring or combining the large volume of time series data with other types of data.
Inside InfluxDB, aggregate functions calculated on the fly may combine tens of thousands of distinct time series into a single view. Each one of those queries must read each aggregated data point, so for InfluxDB the read throughput is often many times higher than the write throughput.
Given that time series is mostly an append-only workload, you might think that it’s possible to get great performance on a B+Tree. Appends in the keyspace are efficient and you can achieve greater than 100,000 per second. However, we have those appends happening in individual time series. So the inserts end up looking more like random inserts than append only inserts.
One of the biggest problems we found with time series data is that it’s very common to delete all data after it gets past a certain age. The common pattern here is that users have high precision data that is kept for a short period of time like a few days or months. Users then downsample and aggregate that data into lower precision rollups that are kept around much longer.
The naive implementation would be to simply delete each record once it passes its expiration time. However, that means that once the first points written reach their expiration date, the system is processing just as many deletes as writes, which is something most storage engines aren’t designed for.
Let’s dig into the details of the two types of storage engines we tried and how these properties had a significant impact on our performance.
LevelDB and log structured merge trees
When the InfluxDB project began, we picked LevelDB as the storage engine because we had used it for time series data storage in the product that was the precursor to InfluxDB. We knew that it had great properties for write throughput and everything seemed to “just work”.
LevelDB is an implementation of a log structured merge tree (LSM tree) that was built as an open source project at Google. It exposes an API for a key-value store where the key space is sorted. This last part is important for time series data as it allowed us to quickly scan ranges of time as long as the timestamp was in the key.
LSM Trees are based on a log that takes writes and two structures known as Mem Tables and SSTables. These tables represent the sorted keyspace. SSTables are read only files that are continuously replaced by other SSTables that merge inserts and updates into the keyspace.
The two biggest advantages that LevelDB had for us were high write throughput and built in compression. However, as we learned more about what people needed with time series data, we encountered a few insurmountable challenges.
The first problem we had was that LevelDB doesn’t support hot backups. If you want to do a safe backup of the database, you have to close it and then copy it. The LevelDB variants RocksDB and HyperLevelDB fix this problem, but there was another more pressing problem that we didn’t think they could solve.
Our users needed a way to automatically manage data retention. That meant we needed deletes on a very large scale. In LSM Trees, a delete is as expensive, if not more so, than a write. A delete writes a new record known as a tombstone. After that queries merge the result set with any tombstones to purge the deleted data from the query return. Later, a compaction runs that removes the tombstone record and the underlying deleted record in the SSTable file.
To get around doing deletes, we split data across what we call shards, which are contiguous blocks of time. Shards would typically hold either one day or seven days worth of data. Each shard mapped to an underlying LevelDB. This meant that we could drop an entire day of data by just closing out the database and removing the underlying files.
Users of RocksDB may at this point bring up a feature called ColumnFamilies. When putting time series data into Rocks, it’s common to split blocks of time into column families and then drop those when their time is up. It’s the same general idea: create a separate area where you can just drop files instead of updating indexes when you delete a large block of data. Dropping a column family is a very efficient operation. However, column families are a fairly new feature and we had another use case for shards.
Organizing data into shards meant that it could be moved within a cluster without having to examine billions of keys. At the time of this writing, it was not possible to move a column family in one RocksDB to another. Old shards are typically cold for writes so moving them around would be cheap and easy. We would have the added benefit of having a spot in the keyspace that is cold for writes so it would be easier to do consistency checks later.
The organization of data into shards worked great for a while, until a large amount of data went into InfluxDB. LevelDB splits the data out over many small files. Having dozens or hundreds of these databases open in a single process ended up creating a big problem. Users that had six months or a year of data would run out of file handles. It’s not something we found with the majority of users, but anyone pushing the database to its limits would hit this problem and we had no fix for it. There were simply too many file handles open.
BoltDB and mmap B+Trees
After struggling with LevelDB and its variants for a year we decided to move over to BoltDB, a pure Golang database heavily inspired by LMDB, a mmap B+Tree database written in C. It has the same API semantics as LevelDB: a key value store where the keyspace is ordered. Many of our users were surprised. Our own posted tests of the LevelDB variants vs. LMDB (a mmap B+Tree) showed RocksDB as the best performer.
However, there were other considerations that went into this decision outside of the pure write performance. At this point our most important goal was to get to something stable that could be run in production and backed up. BoltDB also had the advantage of being written in pure Go, which simplified our build chain immensely and made it easy to build for other OSes and platforms.
The biggest win for us was that BoltDB used a single file as the database. At this point our most common source of bug reports were from people running out of file handles. Bolt solved the hot backup problem and the file limit problems all at the same time.
We were willing to take a hit on write throughput if it meant that we’d have a system that was more reliable and stable that we could build on. Our reasoning was that for anyone pushing really big write loads, they’d be running a cluster anyway.
We released versions 0.9.0 to 0.9.2 based on BoltDB. From a development perspective it was delightful. Clean API, fast and easy to build in our Go project, and reliable. However, after running for a while we found a big problem with write throughput. After the database got over a few GB, writes would start spiking IOPS.
Some users were able to get past this by putting InfluxDB on big hardware with near unlimited IOPS. However, most users are on VMs with limited resources in the cloud. We had to figure out a way to reduce the impact of writing a bunch of points into hundreds of thousands of series at a time.
With the 0.9.3 and 0.9.4 releases our plan was to put a write ahead log (WAL) in front of Bolt. That way we could reduce the number of random insertions into the keyspace. Instead, we’d buffer up multiple writes that were next to each other and then flush them at once. However, that only served to delay the problem. High IOPS still became an issue and it showed up very quickly for anyone operating at even moderate work loads.
However, our experience building the first WAL implementation in front of Bolt gave us the confidence we needed that the write problem could be solved. The performance of the WAL itself was fantastic, the index simply could not keep up. At this point we started thinking again about how we could create something similar to an LSM Tree that could keep up with our write load.
Thus was born the Time Structured Merge Tree.


Here at Med Cabinet, we think there's a better way to treat what ailments you may have rather than traditional medication. Whether you deal with Alzheimer's disease, chronic pain, epilepsy, mental health issues, multiple sclerosis, nausea, or anything else similar to these, you may discover that medical marijuana helps you more than any other form of medication, with far less side effects.
Take our questionnaire to find out what strains, doses, and intake methods are best for you! Questionnaire
After taking the questionnaire, find a dispensary near you that can accommodate your needs! Locate a dispensary
Read through our FAQ to learn more about the conditions that cannabis may help treat, different types of intake methods, common side effects, and more. FAQ


Basic Transposition
This transposes either/both the visual music and the synth.
Transpose half-steps:
Visual?
Audio?
Show Audio Player


Someone asked for password reset for email {{ email }}. Follow the link below:
https://csua.berkeley.edu{% url 'password_reset:reset-password-confirm' uid=uid token=token %}


We have several CAD (computer-aided design) tools available for designing physical structures, namely Rhino and SolidWorks. This overview is intended as a high-level introduction to the essential features of SolidWorks which make it useful for this course.
SolidWorks is a parametric design tool. In the broadest sense, this makes it closer to visual programming than drawing: parts are defined by geometric sketch primitives constrained by relations and processed into geometric features through operations. So a cylindrical part might be defined by a circle on a plane that is extruded for a given distance or up to a given point. Unlike Rhino, that tree of elements is what defines the part and is kept through the life of the part. So if that circle is moved, or split or rehaped, or the extrusion distance changed, the geometry of the solid form can be recomputed.
Using parametric design efficiently involves structuring the part model so that it accurately captures design intent. E.g. if two particular holes are mechanically related, their relative position can be defined by dimensions and relations which capture that mechanical relationship. That way, if other features change and the part shape changes, the holes can maintain their relationship and preserve the intent.
SolidWorks is especially suited for designing assemblies of parts. Machines are typically built from individually manufactured parts assembled together. This is captured in the design model by creating assemblies which define the relative position of individual parts via mates which define geometric constraints.  If mates correctly correspond to actual physical constraints, the model helps visualize that all parts have the correct freedoms. And the parametric nature of the constraint tree means that many part dimensions can be changed and other part positions can adapt.
A negative side-effect of the parametric feature tree is that if the structure of the the design intent changes, it can be difficult to modify the tree structure to match. This is because all features are defined in relation to existing features, so if a parent feature is removed, the child feature becomes only partly defined. It takes a great deal of practice to learn to structure models well at the beginning to minimize these problems later.
This repository includes sample parts and projects, see the README file.
A complex snap-fit plastic robot assembly example is available for
reference
here: https://github.com/OrigamiRobotics/romibo-mechanism
.
This was largely designed by Garth Zeglin, and demonstrates several ideas
for creating 3-D structures from flat parts using interlocking joints.
The IDeATe 15-294 Rapid Prototyping Technologies course taught by Dave Touretzky has many links to information and tutorials.


Home
About
Downloads
Contacts
Contact Us -- fill in the form below
Enter full name :
Enter email :
Enter type of query :
Business Consulting
Software support
Reporting issues in software
Investor related
Media relations
Enter the query
Submit this form


Refresh this page to see how many iterations it takes for both linear and binary search to find the same number in the same set.
Letter to search for:
Alphabet array to search inside:
Linear Search Iterations:
Index of the searched Character found by Linear Search:
Binary Search Iterations:
Index of the searched Character found by Binary Search:
searchForAlphabeticalIndex('Harry Potter'):
Linear Search Iterations:
Binary Search Iterations:


Planning a big adventure? Perhaps you and your friends want to drive across the country but everyone's schedules are all over the place?
RideShare is a tool to help you organize such an adventure.


simple two-way bind username: jane
username: password: company name: slug: start year:
I agree to sell my personal information to evil corporations.


TLR {border-style px;} #ffffff;} immune px; {font-family cells font-size genes coronavirus disease double; viral virus RNA border-color border-width present receptor receptors role solid; toll-like {font-style {font-weight â€" COVID- bold chromosome copy courier; dendritic dosage em; female females human innate patients plasmacytoid polymorphisms prominent pt;} respiratory response risk single-stranded types


par
aaa
ari
Ge
n
Table of Contents
What's this?
Why this?
Demo
Requirements
Installation
Documents
Donation
License


{% extends 'sirajnet/base.html' %} {% load bootstrap3 %} {% block header %}
Hello World, it's Siraj
Hello world it's Siraj and this week i'm going to show you how Gaussian gates and complex Hilbert spaces work. Stay cool wizards


Home
Welcome To Maintenance Tracker
Firstname :
Lastname :
Username :
Password :
sign up
Already have an account with us ?
sign in


Functions to find near-optimal multi-stage designs for continuous outcomes.
| Version: | 1.1.1 |
| Published: | 2015-09-15 |
| Author: | James Wason [aut, cre], John Burkardt [ctb] |
| Maintainer: | James Wason <james.wason at mrc-bsu.cam.ac.uk> |
| License: | GPL-2 |
| NeedsCompilation: | yes |
| Citation: | OptGS citation info |
| In views: | ExperimentalDesign |
| CRAN checks: | OptGS results |
| Reference manual: | OptGS.pdf |
| Package source: | OptGS_1.1.1.tar.gz |
| Windows binaries: | r-devel: OptGS_1.1.1.zip, r-release: OptGS_1.1.1.zip, r-oldrel: OptGS_1.1.1.zip |
| OS X binaries: | r-release: OptGS_1.1.1.tgz, r-oldrel: OptGS_1.1.1.tgz |
| Old sources: | OptGS archive |
Please use the canonical form https://CRAN.R-project.org/package=OptGS to link to this page.


Diversity in Tech
“Diversity is critical to innovation and it is essential to Apple’s future. We aspire to do more than just make our company as diverse as the talent available to hire. We must address the broad underlying challenges, offer new opportunities, and create a future generation of employees as diverse as the world around us.”
-Tim Cook, Apple CEO, 2015 press realease
As the most prominent openly gay CEO in Silicon Valley, Tim Cook is uniquely positioned to highlight diversity and alter the status quo in the technology industry. In the same press release he mentions the history of Apple as a company that has always thrived on its insistence to be different, to think different. His call to continue that legacy by not just allowing hiring practices and workplace culture to follow its course is a welcome step in the right direction that many other companies have started initiatives to correct. And this course correction is just what the ship of the tech industry needs.
According to a recent Fortune survey women make up roughly one third of the tech industry work-force, while only about 40% of employees are non-white. These numbers only get lower among leadership positions. Tristan Walker of Code2040, a non-profit dedicated to increasing diversity in tech, says that this problem isn’t just explicit bias it is implicit as well. He gives the example of white-boarding processes in interviews that give predominantly non-minority programmers with classical training in schools like MIT an advantage. Unfortunately some of this bias is inherent in the system of a wealthy-white-male dominated culture outside of technology; but this system has a creeping effect in specific parts of our culture that might be seemingly innocuous at first glance.
When computer science was a nascent creation it organically became the purview of students with enough privilege, free-time, and education to study it. While it was still a niche industry, this was not particularly exclusive or isolating, but as it grew, the associations of the culture did not. Technology, however, has a built-in silver lining, and that is the revolutionary and transformative pace at which the industry moves. Computers were once in such a primitive state as we find the color of the industry today, but they changed and evolved at an exponential rate making them the powerful machines that now drive industry and commerce. If technology can change this rapidly, so can the technology industry. Fortunately techies are notoriously good problem solvers and identifying the problem is the first step. After researching proposed solutions to the problem, there appear to be about five positive recommendations that will move the industry in the right direction.
-Make a more inclusive culture:
Minorities and women that do work in the industry often leave because they didn’t feel welcome even after they were able to break into it. As the culture becomes more aware of the issues of minorities it will become more capable of accommodating them. Dev BootCamp has been a pioneer in this aspect by making engineering empathy a core component of their curriculum and reaching out to female and LGBT coders.
-Greater oversight:
Forbes contributor Bonnie Marcus proposes that tech companies of a certain size need to hire an outside firm to assess the culture of the organization including discrimination in pay and hiring practices.
-Top-down approach:
Leaders of tech companies and the industry in general may be a white-boys’ club, but that doesn’t mean they want it to always be that way. Many of them recognize that a main reason is because the culture has propped that notion up for too long, and it is time to correct it in the opposite direction.
-Educate to the culture gap:
Another recommendation of Marcus’s is to give minorities resources to network and take advantage of systems that non-minorities often have at their disposal that go overlooked.
-Mentorship:
And Marcus also suggests that women and minorities receive mentors to level the bar even further.
The numbers are already starting to shift in the right direction and if the momentum can be maintained for ten or twenty years it will be transformative. Take Apple as an example again. After announcing their diversity initiative they hired 65% more females than the previous year, 50% more black employees, and 66% more hispanics. If the tech industry was taken at its current demographics it would be pretty bleak, but its power to transform is limitless. The factors that have contributed to it being exclusive are numerous and complex, but the solutions are fortunately rather simple. Diversity has been a driving force of the industry in the past and if it remains in our thoughts it will be the force that drives its future.


fn() translatetranslate sequences of Dna or Rna into amino acid alphabet, optionally with frames
translate sequences of Dna or Rna into amino acid alphabet, optionally with frames
| Defined in | <seqan/translation.h> |
|---|---|
| Signature |
int translate(target, source[, frames][, geneticCode][, TParallelism])
int translate(target, source[, frames][, geneticCodeSpec][, TParallelism])
|
Parameters
target
|
The amino acid sequence(s). StringSet of AminoAcid or String of AminoAcid if source is a single string and frames is SINGLE_FRAME. |
|---|---|
source
|
Source sequences String or StringSet. If the value type is not Dna, Dna5, Rna, Rna5 then it is converted to Dna5. |
frame
|
The TranslationFrames, defaults to SINGLE_FRAME. |
geneticCode
|
The GeneticCode to use, defaults to GeneticCode<CANONICAL> (use to specify GeneticCode at compile-time) |
geneticCodeSpec
|
The GeneticCodeSpec to use (use to specify GenetiCode at run-time) |
TParallelism
|
Whether to use SMP or not, see ParallelismTags . |
Return Values
int |
0 on success, and -1 on incompatible parameters (e.g. multiple frames but target type not StringSet). |
|---|
Detailed Description
If OpenMP is supported by platform and TParallelism is not specified as "Serial", translation will be parallelized. The only exception is when doing single-frame translation of a single string -- which is never parallelized.
The translation process is fastest when using ConcatDirect-StringSets for both input and output StringSets and when not having to convert the alphabet of the source, i.e. feeding AminoAcid-Strings, not CharStrings (although the latter is possible).
Please note that specifying the GeneticCode at compile time avoids having unrequired conversion tables in memory. The implementation profits slightly from having SEQAN_CXX11_STANDARD defined.
Example
StringSet<Dna5String> dnaSeqs; // do something that fills up dnaSeqs, e.g. read from file or assign StringSet<String<AminoAcid>, Owner<ConcatDirect<> > > aaSeqs; translate(aaSeqs, dnaSeqs, SIX_FRAME); // do something with the aaSeqs
Data Races
Thread safety unknown!


Directorate of Technical Education The first Engineering Institution to be started in the country
Read More →
FREQUENTLY ASKED QUESTIONS
HOW TO APPLY FOR TRANSCRIPTS, DUPLICATE AND GENUINESS OF DIPLOMA CERTIFICATES/MARKSHEETS
SPECIAL GRACE CHANCE FOR ALL DIPLOMA STUDENTS-OCT 2018
Application Form to Apply for Duplicate Certificate using Aadhar Card/ Driving License/ Voters Id
A.Kokkulam Village Chekkanurani
Madurai-625514
<EMAIL_ADDRESS>04549-287485
9486501833
04549-287484
Nearest Bus Stand - Chekkanurani 2.5 KM
Nearest Railway Station - Madurai Junction 20 KM
local_airport Nearest Airport - Madurai 35 KM


STATISTICAL THEORY OF SELECTION
(Selection Problems)
by
JARNAI“L SINGH
A Thesis submitted in conformity with the re-
quirements for the Degree of Doctor of Philosophy
in
The University of TORONTO
1963
EU:
Reproduced with permission of the copyright owner. Further reproduction prohibited without permission.


Even the all-powerful Pointing has no control about the blind texts it is an almost unorthographic life
Even the all-powerful Pointing has no control about the blind texts it is an almost unorthographic life
Even the all-powerful Pointing has no control about the blind texts it is an almost unorthographic life
Even the all-powerful Pointing has no control about the blind texts it is an almost unorthographic life
Even the all-powerful Pointing has no control about the blind texts it is an almost unorthographic life
Even the all-powerful Pointing has no control about the blind texts it is an almost unorthographic life


No files opened. Create new file by clicking (+) button or open it from file manager
function main(){ // Hello world. }


Invisible Backpacks by Tyler Barton
Sub notes
(period 3)
Hi! !
-
JSYK: you got the good class. When the noise-level swells out of control, they will self correct. It steadies eventually. You won’t even need to look up from your book. Plus, sometimes, it’s like they just need to get out certain feelings they can’t express elsewhere?
-
The good class is smarter than to copy. When they have out their phones they’re actually consulting online dictionaries. Don’t worry. There are jolly ranchers in my desk—help yourself.
-
The good class doesn’t normally get lower than a B. Grade quizzes with this in mind.
-
Things aren’t thrown in the good class, rather dropped. Accidents happen. Especially in the good class.
-
Now, in the good class there is a kid (Colton) who will never sit down. And don’t bother trying to make him: he’s a good kid & will do all his work, only standing, bent over the air conditioner or hanging halfway out the window.
-
Feel free to let them go to the bathroom as many times as they need. It’s easy to underestimate how hard the good class works, how much of themselves the put in to solving problems. It takes a lot out of them.
-
The school is under a strict no-backpack rule. Kind of arbitrary, but yada yada, prevents concealing drugs & the like. But in this class, if a student does in fact bring their backpack, I usually turn the blind eye. Really, they’re a good class & you shouldn’t worry about it. What Backpack? is kind of our motto.
-
Any perverse language (vulgar derision, ceaseless mocking, insensitive criticism etc.) directed at you or other students should be taken as irony. We’re neck-deep in a unit on satire. The good class takes everything to heart.
-
Ellen is in the good class because she’s a radiologist’s daughter, regardless of the fact that she’s probably wrapped a fruit roll-up around the end of a ruler & is smacking herself/others with it. That aside: total angel.
-
The good class won’t need help. But if you want to nudge them in the right directions on the tougher parts of their unit test (copies on the podium!) I won’t blame you.
-
They’re a very nice-looking, good, clean little class. If anyone is absent, be assured: they have a decent reason.
-
Now, the good class wouldn’t bring a sword to class. This is the good class, after all. So it’ll turn out it’s not actually a sword, regardless of that shrill ring when its drawn-out plus that glare it throws on the wall just before it slices clean thru the bully’s neck. Because, no, there you’d be wrong. Because this is the good class, where there are no bullies. And if some angel here decides to be bully today, for whatever reason, know it’s a fluke. A one-time thing. That’s all.
-
(A student may offer to clean up the blood, & though it isn’t expected of them, go ahead and allow it. Thanks!)
Tyler Barton is the fiction editor of Third Point Press, an MFA candidate at Minnesota State University, and the owner of the domain tsbarton.com. Follow him @goftyler.


Write code in a way that guarantees that pointers are not used after memory that they point to has been deallocated.
Accessing memory that has been deallocated may result in an exploitable vulnerability. This type of vulnerability is called a "dangling pointer vulnerability". The unallocated memory is accessed via a pointer that has been used to free the memory earlier - this pointer is the "dangling pointer".
Write code in such a way that guarantees that pointers are not used after memory that they point to has been deallocated. One way to do this is to deallocate memory at the end of functions, so that there is no code that accesses memory after it has been deallocated. Perform the following actions to assure that unallocated memory is not accessed:
float* array = new array [5];
delete[] array;
array[0] = 0.1;
The problem with the example above is obvious - the pointer is deleted before the application is done with it.
float* array = new array [5];
array[0] = 0.1;
delete[] array;
The solution is equally simple - move deallocation code to the end of the function.


This is a demo of the e-comments self-hosted comment server.
The code was initially developed to provide comments for a 100% static site (https://tweaked.io : server optimization.)
Comments will appear below this area, once loaded via a cross-domain JSONP request.


Draw LIDAR profile line
Draw a line on the map to display the corresponding LIDAR profile. Use double-click to finish the drawing.
Material
Classes
Initializing, please wait...


This is the webpage for the Gait Analysis Intelligence Tool. Here you will find all information about the project.
We have developed a system that can perform gait analysis with nothing but a camera and a standard computer.
If you want to get down in the details of how our system works you should head over here!
We have made an intuitive video showing our system in action and how it works.
We have been using the following tools in our gait analysis pipeline
If you have a question maybe you can find the answer in our frequently asked question section.


sd
asd
Forgot Your password?
Sign up and discover a great amount of new opportunities!
Sign in using your social account


Hangman Game: World's Captials Edition
The rules of the game are simple. You have a limited number of guesses depending on the city name. Guess before your guesses are over and win.


Sarah's Applesauce
This recipe is vegetarian and gluten free!
Prep Time: 10 Minutes
Cook Time: 20 Minutes
Ready In: 30 Minutes
Servings: 4
"This applesauce is delicious! I make it for my younger brother all the time. He loves it, and he hates canned applesauce!"
INGREDIENTS:
4 apples - peeled, cored and chopped
3/4 cup water
1/4 cup white sugar
1/2 teaspoon ground cinnamon
DIRECTIONS:
1. In a saucepan, combine apples, water, sugar, and cinnamon. Cover, and cook over medium heat for 15 to 20 minutes, or until apples are soft. Allow to cool, then mash with a fork or potato masher.
Morning Glory Muffins I
Gluten Free Option
Prep Time: 15 Minutes
Cook Time: 20 Minutes
Ready In: 35 Minutes
Servings: 18
"This muffin has a little bit of everything - carrots, raisins, apple butter, wheat germ, nuts. A perfect start for your day!"
 Preheat oven to 375 degrees F (190 degrees C). Lightly oil 18 muffin cups, or coat with nonstick cooking spray.
2. In a medium bowl, whisk together eggs, egg whites, apple butter, oil and vanilla.
3. In a large bowl, stir together flours, sugar, cinnamon, baking powder, baking soda and salt. Stir in carrots, apples and raisins. Stir in apple butter mixture until just moistened. Spoon the batter into the prepared muffin cups, filling them about 3/4 full.
4. In a small bowl, combine walnuts and wheat germ; sprinkle over the muffin tops.
5. Bake at 375 degrees F (190 degrees C) for 15 to 20 minutes, or until the tops are golden and spring back when lightly pressed.
Morning Glory Muffins
This Recipe is Gluten Free and Vegetarian
Prep Time: 15 Minutes
Cook Time: 20 Minutes
Ready In: 35 Minutes
Servings: 12
"You'd never be able to tell that this muffin is gluten free, unless you read the ingredients!"
INGREDIENTS:
1/3 cup sugar
1 cup rice flour
1 teaspoon baing powder
3/4 teaspoon salt
1/2 teaspoon bicarbonate of soda
2 eggs
2 tablespoons canola oil
1 apple - peeled, cored, and chopped
teaspoon cinnamon
DIRECTIONS:
1. Combine the dry ingredients in a bowl.
2. Mix the wet ingredients in another bowl and quickly add to the dry ingredients.
3. Add any additional flavourings and stir very briefly.
4. Put into greased or paper lined muffin cups and bake in a moderate oven (180 degrees) until golden and firm to the touch.
Out of this World Turkey Brine
Vegetarian Option
Servings: 12
"Best brine for smoked turkey around. This recipe was given to me by my uncle. He is always smoking meat."
INGREDIENTS:
2 gallons water
1 1/2 cups canning salt
3 tablespoons minced garlic
1 tablespoon ground black pepper
1/4 cup Worcestershire sauce
1/3 cup brown sugar
DIRECTIONS:
1.  Store in a refrigerator, and soak turkey for 2 days before smoking or roasting.
Out of this World Tofurkey Brine
This Recipe is vegetarian!
Servings: 12
"Even meat lovers will love this tofurkey!"
 Combine all ingredients, except Tofurkey®, in a pot. Bring to a boil and then cool. Cover Tofurkey with brine and marinate overnight.
2. Preheat oven to 400°F. Remove Tofurkey breast from brine and dry. Rub with a touch of olive oil and roast for 30 minutes.
White Chili IV
Prep Time: 1 Hour
Cook Time: 1 Hour 30 Minutes
Ready In: 2 Hours 30 Minutes
Servings: 8
"Cubed chicken breast meat is slowly simmered with chile peppers, bell peppers, mushrooms, beans, white wine, herbs and spices in this chili-like soup."
  Stir in onion, garlic and chiles and cook until onion begins to soften.
2. Stir in bell peppers, mushrooms, beans, green onions and parsley. Pour in wine and chicken broth. Season with bouillon, rosemary, thyme, oregano and cumin. Place bay leaves in pot, cover, reduce heat and simmer 90 minutes.
Glenn's Marinated Pork Shoulder
Prep Time: 15 Minutes
Cook Time: 3 Hours
Ready In: 7 Hours 15 Minutes
Servings: 8
"This tangy marinade for grilled pork shoulder is swimming with spices. You'll really taste the garlic!"
INGREDIENTS:
1/4 cup chopped garlic
1/2 cup chopped onion
1 dash soy sauce
1 tablespoon corn syrup
2 tablespoons apple juice
3 tablespoons Worcestershire sauce
1 teaspoon molasses
DIRECTIONS:
1. In a large bowl, mix garlic, onion, soy sauce, corn syrup, apple juice, Worcestershire sauce, molasses, wine, Italian-style salad dressing, distilled white vinegar, garlic powder, salt, onion powder, Cajun seasoning, crushed red pepper, seasoning salt and brown sugar.
2. Score pork shoulder 1/8 to 1/4 inch deep. Place in the bowl with the marinade mixture. Marinate at least 4 hours in the refrigerator.
3. Preheat an outdoor grill for medium high heat and lightly oil grate.
4. Cook marinated pork shoulder on the prepared grill 3 hours, or until the internal temperature has reach a minimum of 165 degrees F (75 degrees C). Marinate frequently with the mixture while grilling.
Mojito Fruit Salad
This recipe is gluten free and vegetarian!
Prep Time: 20 Minutes
Ready In: 1 Hour 20 Minutes
ervings: 6
"This uniquely refreshing minty salad has the refreshing flavors of mojitos and fresh fruit."
INGREDIENTS:
1 cup cubed seeded watermelon
1 cup seedless grapes
1 cup cubed cantaloupe
1 cup hulled and quartered strawberries
1 cup peeled and quartered kiwi
1 cup fresh blueberries
DIRECTIONS:
1. Mix the watermelon, grapes, cantaloupe, strawberries, and kiwi in a bowl with a tight-fitting lid; top with the blueberries.
2. Stir the mint, sugar, and lime juice together in a bowl, crushing the mint with the back of a spoon while mixing to extract flavors; pour over the fruit mixture. Seal the bowl with lid and refrigerate at least 1 hour.
3. Just before serving, gently flip the sealed bowl several times to coat the fruit with the dressing.
Vegan Hot and Sour Soup
This recipe is vegetarian and gluten free!
Prep Time: 45 Minutes
Cook Time: 15 Minutes
Ready In: 1 Hour
Servings: 4
"A mushroom and tofu extravaganza! The exotic ingredients in this enticing soup may be found in Asian grocery stores. Don't let the extra effort keep you from trying this tasty treat!"
INGREDIENTS:
1 ounce dried wood ear mushrooms
4 dried shiitake mushrooms
12 dried tiger lily buds
2 cups hot water
1/3 ounce bamboo fungus
3 tablespoons soy sauce
5 tablespoons rice vinegar
1/4 cup cornstarch
1 (8 ounce) container firm tofu, cut into 1
/4 inch strips
1 quart vegetable broth
1/4 teaspoon crushed red pepper flakes
1/2 teaspoon ground black pepper
3/4 teaspoon ground white pepper
1/2 tablespoon chili oil
1/2 tablespoon sesame oil
1 green onion, sliced
1 cup Chinese dried mushrooms
DIRECTIONS:
1. In a small bowl, place wood mushrooms, shiitake mushrooms, and lily buds in 1 1/2 cups hot water. Soak 20 minutes, until rehydrated. Drain, reserving liquid. Trim stems from the mushrooms, and cut into thin strips. Cut the lily buds in half.
2. In a separate small bowl, soak bamboo fungus in 1/4 cup lightly salted hot water. Soak about 20 minutes, until rehydrated. Drain, and mince.
3. In a third small bowl, blend soy sauce, rice vinegar, and 1 tablespoon cornstarch. Place 1/2 the tofu strips into the mixture.
4. In a medium saucepan, mix the reserved mushroom and lily bud liquid with the vegetable broth. Bring to a boil, and stir in the wood mushrooms, shiitake mushrooms, and lily buds. Reduce heat, and simmer 3 to 5 minutes. Season with red pepper, black pepper, and white pepper.
5. In a small bowl, mix remaining cornstarch and remaining water. Stir into the broth mixture until thickened.
6. Mix soy sauce mixture and remaining tofu strips into the saucepan. Return to boil, and stir in the bamboo fungus, chili oil, and sesame oil. Garnish with green onion to serve.


Notebooks
Story: About the lion who carries away and kills a man and the search for the lost man (a story of common life)
About the lion who carries away and kills a man and the search for the lost man (a story of common life)
Title
About the lion who carries away and kills a man and the search for the lost man (a story of common life)
Collection
Summary
A Bushman killed by a Lion; a search for the missing man; removal of the rest to another place, for fear that the Lion should track them to their huts (L II.-8. 892-907, 9. 908-920).
Comments
1) Date on p.908: 22 November, 2) Reverse of frontispiece (Book II-9): 'End of a story of Bushman life, about a Lion which killed a woman's husband, and how the others removed to another place, for fear the lion should track one of them to their huts', 3) This story is found in Books II-8 and 9
Contributors
Date
November1871
Categories
Keywords
lion (that kills a man) , lion (is a beast of prey) , lion (is different) , lion (tracks man) , lion (the search for missing man) , lion (the people move to another place) , lion (having eaten one man it will search for another) , lion (the nature and habits of) , lion (who carries away and kills a man and the search for the lost man) , beast of prey (about the lion who carries away and kills a man and the search for the lost man) , death (the man killed by a lion and the search for him)
Story Pages
892-907, 908-920


Protect Everett’s single-family neighborhoods
I attended the Everett City Council meeting on Nov. 13. Item 19 on the agenda was in regard to the recommendation from the Planning Commission to the council on the topic of the 2016 Ordinance allowing “supportive housing” on any public owned property, including single-family neighborhoods, throughout the city.
I was not only surprised at the premature recommendation by a council member to allow 34-70 apartments in a single-family neighborhood without discussion or fact-finding with other city council members or even a clear understanding of what the planning commission was recommending, but additionally saying that single family neighborhoods are “a thing of the past,” and she would like to see more multifamily and supportive housing in all neighborhoods, and no more single-family neighborhoods in Everett.
Clearly, using all of her own stated personal experience demonstrates her possible inability to be unbiased and represent all of our citizens.
Do the residents of Everett really want to lose all of our single-family neighborhoods? Are we being represented fairly? If you want to witness this meeting for yourself tune into Everett Channel 21 for televised recording.
Katalina Bartanen
Everett


(In practice, I choose the positive direction of 𝜃 and ϕ along the direction of toroidal and poloidal magnetic ﬁeld (i.e., B ⋅∇ϕ and B ⋅∇𝜃 are always positive in (ψ,𝜃,ϕ) coordinates system). Then, the qlocal deﬁned by Eq. (155) is always positive. It follows that qglobal should be also positive. Next, let us examine whether this property is correctly preserved by Eq. (161). Case 1: The radial coordinate ψ is chosen as Ψ′≡ dΨ∕dψ > 0. Then the factor before the integration in Eq. (161) is negative. We can further verify that 𝒥 is always negative for either the case that ∇Ψ is pointing inward or outward. Therefore the .r.h.s. of Eq. (161) is always positive for this case. Case 2: The radial coordinate ψ is chosen as Ψ′≡ dΨ∕dψ < 0. Then the factor before the integration in Eq. (161) is positive. We can further verify that 𝒥 is always positive for either the case that ∇Ψ is pointing inward or outward. The above two cases include all possibilities. Therefore, the positivity of qglobal is always guaranteed)
a magnetic surface forms a central hole around Z axis. Using Gauss’s theorem in the volume within the central hole, and noting that no magnetic ﬁeld line point-intersects a magnetic surface, we know that the magnetic ﬂux through any cross section of the hole is equal to each other. Next we calculate this magnetic ﬂux. To make the calculation easy, we select a plane cross section perpendicular to the Z axis, as is shown by the dash line in Fig. 1. In this case, only BZ contribute to the magnetic ﬂux, which is written (the positive direction of the cross section is chosen in the direction of Z)
|
| (554) |
be generalized to any revolution surface that is generated by rotating a curve segment on the poloidal plane around Z axis. For instance, a curve on the poloidal plane that connects the magnetic axis and a point on a ﬂux surface can form a toroidal surface (e.g., surface S2 in Fig. 66). The magnetic ﬂux through the toroidal surface S2 is given by
i.e.
|
| (555) |
which indicates that the diﬀerence of Ψ between the Z axis and a magnetic surface is the poloidal magnetic ﬂux per radian through the central hole, Ψp1∕2π.
The magnetic surface forms a central hole around Z axis. The magnetic ﬂux through any cross section of the central hole is equal to each other and is given by Ψp = 2π(Ψb − Ψa), where Ψa and Ψb are the value of Ψ at the Z axis and the magnetic surface, respectively.
The conclusion in Eq. (554) can be generalized to any revolution surface that is generated by rotating a curve on the poloidal plane about Z axis. For instance, a curve on the poloidal plane that connects the magnetic axis and a point on a ﬂux surface can form a toroidal surface (e.g., surface S2 in Fig. 66).
Also note the diﬀerence between Ψp and Ψp1 deﬁned in Sec. 1.7: Ψp1 is the magnetic ﬂux through the central hole of a torus and thus includes the ﬂux in the center transformer, and Ψp is the magnetic ﬂux through the ribbon between the magnetic axis and the magnetic surface.


The feed Module¶
Tools for computing some stats from a GTFS feed, assuming the feed is valid.
CONVENTIONS:
In conformance with GTFS and unless specified otherwise, dates are encoded as date strings of the form YYMMDD and times are encoded as time strings of the form HH:MM:SS with the possibility that the hour is greater than 24.
Unless specified otherwise, ‘data frame’ and ‘series’ refer to Pandas data frames and series, respectively.
-
class
gtfstk.feed.
Feed
(path, dist_units_in=None, dist_units_out=None)¶ Bases:
object
A class to gather all the GTFS files for a feed and store them in memory as data frames. Make sure you have enough memory! The stop times object can be big.
-
add_dist_to_shapes
()¶ Add/overwrite the optional
shape_dist_traveled
GTFS field forself.shapes
. ReturnNone
.NOTE:
All of the calculated
shape_dist_traveled
values for the Portland feed differ by at most 0.016 km in absolute values from of the original values.
-
add_dist_to_stop_times
(trips_stats)¶ Add/overwrite the optional
shape_dist_traveled
GTFS field inself.stop_times
. Doesn’t always give accurate results, as described below.ALGORITHM:
Compute the
shape_dist_traveled
field by using Shapely to measure the distance of a stop along its trip linestring. If for a given trip this process produces a non-monotonically increasing, hence incorrect, list of (cumulative) distances, then fall back to estimating the distances as follows.Get the average speed of the trip via
trips_stats
and use is to linearly interpolate distances for stop times, assuming that the first stop is at shape_dist_traveled = 0 (the start of the shape) and the last stop is at shape_dist_traveled = the length of the trip (taken from trips_stats and equal to the length of the shape, unless trips_stats was called withget_dist_from_shapes == False
). This fallback method usually kicks in on trips with self-intersecting linestrings. Unfortunately, this fallback method will produce incorrect results when the first stop does not start at the start of its shape (so shape_dist_traveled != 0). This is the case for several trips in the Portland feed, for example.
-
clean_route_short_names
()¶ Clean the
route_short_name
column inself.routes
usingutils.clean_series
. Among other things, this will disambiguate duplicate route short names. ReturnNone
-
export
(path, ndigits=6)¶ Export this feed to a zip archive located at
path
. Round all decimals tondigits
decimal places. All distances will be displayed in unitsself.dist_units_out
.
-
get_busiest_date
(dates)¶ Given a list of dates, return the first date that has the maximum number of active trips.
-
get_dates
(as_date_obj=False)¶ Return a chronologically ordered list of dates for which this feed is valid. If
as_date_obj == True
, then return the dates as asdatetime.date
objects.
-
get_feed_stats
(trips_stats, date)¶ Given
trips_stats
, which is the output ofself.get_trips_stats()
and a date, return a data frame including the following feed stats for the date.- num_trips: number of trips active on the given date
- num_routes: number of routes active on the given date
- num_stops: number of stops active on the given date
- peak_num_trips: maximum number of simultaneous trips in service
- peak_start_time: start time of first longest period during which the peak number of trips occurs
- peak_end_time: end time of first longest period during which the peak number of trips occurs
- service_distance: sum of the service distances for the active routes
- service_duration: sum of the service durations for the active routes
- service_speed: service_distance/service_duration
If there are no stats for the given date, return an empty data frame with the specified columns.
-
get_feed_time_series
(trips_stats, date, freq='5Min')¶ Given trips stats (output of
self.get_trips_stats()
), a date, and a Pandas frequency string, return a time series of stats for this feed on the given date at the given frequency with the following columns- num_trip_starts: number of trips starting at this time
- num_trips: number of trips in service during this time period
- service_distance: distance traveled by all active trips during this time period
- service_duration: duration traveled by all active trips during this time period
- service_speed: service_distance/service_duration
If there is no time series for the given date, return an empty data frame with specified columns.
-
get_first_week
(as_date_obj=False)¶ Return a list of date corresponding to the first Monday–Sunday week for which this feed is valid. In the unlikely event that this feed does not cover a full Monday–Sunday week, then return whatever initial segment of the week it does cover. If
as_date_obj == True
, then return the dates as asdatetime.date
objects.
-
get_geometry_by_shape
(use_utm=True)¶ Return a dictionary with structure shape_id -> Shapely linestring of shape. If
self.shapes is None
, then returnNone
. Ifuse_utm == True
, then return each linestring in in UTM coordinates. Otherwise, return each linestring in WGS84 longitude-latitude coordinates.
-
get_geometry_by_stop
(use_utm=True)¶ Return a dictionary with structure stop_id -> Shapely point object. If
use_utm == True
, then return each point in in UTM coordinates. Otherwise, return each point in WGS84 longitude-latitude coordinates.
-
get_route_timetable
(route_id, date)¶ Return a data frame encoding the timetable for the given route ID on the given date. The columns are all those in
self.trips
plus those inself.stop_times
. The result is sorted by grouping by trip ID and sorting the groups by their first departure time.
-
get_routes
(date=None, time=None)¶ Return the section of
self.routes
that contains only routes active on the given date. If no date is given, then return all routes. If a date and time are given, then return only those routes with trips active at that date and time. Do not take times modulo 24.
-
get_routes_stats
(trips_stats, date, split_directions=False, headway_start_time='07:00:00', headway_end_time='19:00:00')¶ Take
trips_stats
, which is the output ofself.get_trips_stats()
, cut it down to the subsetS
of trips that are active on the given date, and then callget_routes_stats()
withS
and the keyword argumentssplit_directions
,headway_start_time
, andheadway_end_time
.See
get_routes_stats()
for a description of the output.NOTES:
This is a more user-friendly version of
get_routes_stats()
. The latter function works without a feed, though.Return
None
if the date does not lie in this feed’s date range.
-
get_routes_time_series
(trips_stats, date, split_directions=False, freq='5Min')¶ Take
trips_stats
, which is the output ofself.get_trips_stats()
, cut it down to the subsetS
of trips that are active on the given date, and then callFeed.get_routes_time_series()
withS
and the given keyword argumentssplit_directions
andfreq
and withdate_label = utils.date_to_str(date)
.See
Feed.get_routes_time_series()
for a description of the output.If there are no active trips on the date, then return
None
.NOTES:
This is a more user-friendly version of
get_routes_time_series()
. The latter function works without a feed, though.
-
get_shapes_geojson
()¶ Return a string that is a GeoJSON feature collection of linestring features representing
self.shapes
. Each feature will have ashape_id
property. Ifself.shapes
isNone
, then returnNone
. The coordinates reference system is the default one for GeoJSON, namely WGS84.
-
get_stations_stats
(date, split_directions=False, headway_start_time='07:00:00', headway_end_time='19:00:00')¶ If this feed has station data, that is,
location_type
andparent_station
columns inself.stops
, then compute the same stats thatself.get_stops_stats()
does, but for stations. Otherwise, return an empty data frame with the specified columns.
-
get_stop_times
(date=None)¶ Return the section of
self.stop_times
that contains only trips active on the given date. If no date is given, then return all stop times.
-
get_stop_timetable
(stop_id, date)¶ Return a data frame encoding the timetable for the given stop ID on the given date. The columns are all those in
self.trips
plus those inself.stop_times
. The result is sorted by departure time.
-
get_stops
(date=None)¶ Return the section of
self.stops
that contains only stops that have visiting trips active on the given date. If no date is given, then return all stops.
-
get_stops_activity
(dates)¶ Return a data frame with the columns
- stop_id
dates[0]
: 1 if the stop has at least one trip visiting it ondates[0]
; 0 otherwisedates[1]
: 1 if the stop has at least one trip visiting it ondates[1]
; 0 otherwise- etc.
dates[-1]
: 1 if the stop has at least one trip visiting it ondates[-1]
; 0 otherwise
If
dates
isNone
or the empty list, then return an empty data frame with the column ‘stop_id’.
-
get_stops_in_stations
()¶ If this feed has station data, that is,
location_type
andparent_station
columns inself.stops
, then return a data frame that has the same columns asself.stops
but only includes stops with parent stations, that is, stops with location type 0 or blank and nonblank parent station. Otherwise, return an empty data frame with the specified columns.
-
get_stops_stats
(date, split_directions=False, headway_start_time='07:00:00', headway_end_time='19:00:00')¶ Call
get_stops_stats()
with the subset of trips active on the given date and with the keyword argumentssplit_directions
,headway_start_time
, andheadway_end_time
.See
get_stops_stats()
for a description of the output.NOTES:
This is a more user-friendly version of
get_stops_stats()
. The latter function works without a feed, though.
-
get_stops_time_series
(date, split_directions=False, freq='5Min')¶ Call
get_stops_times_series()
with the subset of trips active on the given date and with the keyword argumentssplit_directions
andfreq
and withdate_label
equal todate
. Seeget_stops_time_series()
for a description of the output.NOTES:
This is a more user-friendly version of
get_stops_time_series()
. The latter function works without a feed, though.
-
get_trips
(date=None, time=None)¶ Return the section of
self.trips
that contains only trips active on the given date. If the date is not given, then return all trips. If a date and time are given, then return only those trips active at that date and time. Do not take times modulo 24.
-
get_trips_activity
(dates)¶ Return a data frame with the columns
- trip_id
dates[0]
: 1 if the trip is active ondates[0]
; 0 otherwisedates[1]
: 1 if the trip is active ondates[0]
; 0 otherwise- etc.
dates[-1]
: 1 if the trip is active ondates[-1]
; 0 otherwise
If
dates
isNone
or the empty list, then return an empty data frame with the column ‘trip_id’.
-
get_trips_locations
(date, times)¶ Return a data frame of the positions of all trips active on the given date and times Include the columns:
- trip_id
- route_id
- direction_id
- time
- rel_dist: number between 0 (start) and 1 (end) indicating the relative distance of the trip along its path
- lon: longitude of trip at given time
- lat: latitude of trip at given time
Assume
self.stop_times
has an accurateshape_dist_traveled
column.
-
get_trips_stats
(get_dist_from_shapes=False)¶ Return a data frame with the following columns:
- trip_id
- route_id
- route_short_name
- direction_id
- shape_id
- num_stops: number of stops on trip
- start_time: first departure time of the trip
- end_time: last departure time of the trip
- start_stop_id: stop ID of the first stop of the trip
- end_stop_id: stop ID of the last stop of the trip
- is_loop: 1 if the start and end stop are less than 400m apart and 0 otherwise
- distance: distance of the trip in
self.dist_units_out
; contains allnp.nan
entries ifself.shapes is None
- duration: duration of the trip in hours
- speed: distance/duration
NOTES:
If
self.stop_times
has ashape_dist_traveled
column andget_dist_from_shapes == False
, then use that column to compute the distance column. Else ifself.shapes is not None
, then compute the distance column using the shapes and Shapely. Otherwise, set the distances tonp.nan
.Calculating trip distances with
get_dist_from_shapes=True
seems pretty accurate. For example, calculating trip distances on the Portland feed usingget_dist_from_shapes=False
andget_dist_from_shapes=True
, yields a difference of at most 0.83km.
-
is_active_trip
(trip, date)¶ If the given trip (trip ID) is active on the given date, then return
True
; otherwise returnFalse
. To avoid error checking in the interest of speed, assumetrip
is a valid trip ID in the feed anddate
is a valid date object.Note: This method is key for getting all trips, routes, etc. that are active on a given date, so the method needs to be fast.
-
-
gtfstk.feed.
combine_time_series
(time_series_dict, kind, split_directions=False)¶ Given a dictionary of time series data frames, combine the time series into one time series data frame with multi-index (hierarchical) columns and return the result. The top level columns are the keys of the dictionary and the second and third level columns are ‘route_id’ and ‘direction_id’, if
kind == 'route'
, or ‘stop_id’ and ‘direction_id’, ifkind == 'stop'
. Ifsplit_directions == False
, then there is no third column level, no ‘direction_id’ column.
-
gtfstk.feed.
count_active_trips
(trips, time)¶ Given a data frame containing the rows
- trip_id
- start_time: start time of the trip in seconds past midnight
- end_time: end time of the trip in seconds past midnight
and a time in seconds past midnight, return the number of trips in the data frame that are active at the given time. A trip is a considered active at time t if start_time <= t < end_time.
-
gtfstk.feed.
downsample
(time_series, freq)¶ Downsample the given route, stop, or feed time series, (outputs of
Feed.get_routes_time_series()
,Feed.get_stops_time_series()
, orFeed.get_feed_time_series()
, respectively) to the given Pandas frequency. Return the given time series unchanged if the given frequency is shorter than the original frequency.
-
gtfstk.feed.
get_routes_stats
(trips_stats_subset, split_directions=False, headway_start_time='07:00:00', headway_end_time='19:00:00')¶ Given a subset of the output of
Feed.get_trips_stats()
, calculate stats for the routes in that subset.Return a data frame with the following columns:
- route_id
- route_short_name
- direction_id
- num_trips: number of trips
- is_loop: 1 if at least one of the trips on the route has its
is_loop
field equal to 1; 0 otherwise - is_bidirectional: 1 if the route has trips in both directions; 0 otherwise
- start_time: start time of the earliest trip on the route
- end_time: end time of latest trip on the route
- max_headway: maximum of the durations (in minutes) between
trip starts on the route between
headway_start_time
andheadway_end_time
on the given dates - min_headway: minimum of the durations (in minutes) mentioned above
- mean_headway: mean of the durations (in minutes) mentioned above
- peak_num_trips: maximum number of simultaneous trips in service
(for the given direction, or for both directions when
split_directions==False
) - peak_start_time: start time of first longest period during which the peak number of trips occurs
- peak_end_time: end time of first longest period during which the peak number of trips occurs
- service_duration: total of the duration of each trip on the route in the given subset of trips; measured in hours
- service_distance: total of the distance traveled by each trip on
the route in the given subset of trips;
measured in wunits, that is,
whatever distance units are present in trips_stats_subset;
contains all
np.nan
entries ifself.shapes is None
- service_speed: service_distance/service_duration; measured in wunits per hour
- mean_trip_distance: service_distance/num_trips
- mean_trip_duration: service_duration/num_trips
If
split_directions == False
, then remove the direction_id column and compute each route’s stats, except for headways, using its trips running in both directions. In this case, (1) compute max headway by taking the max of the max headways in both directions; (2) compute mean headway by taking the weighted mean of the mean headways in both directions.If
trips_stats_subset
is empty, return an empty data frame with the columns specified above.
-
gtfstk.feed.
get_routes_time_series
(trips_stats_subset, split_directions=False, freq='5Min', date_label='20010101')¶ Given a subset of the output of
Feed.get_trips_stats()
, calculate time series for the routes in that subset.Return a time series version of the following route stats:
- number of trips in service by route ID
- number of trip starts by route ID
- service duration in hours by route ID
- service distance in kilometers by route ID
- service speed in kilometers per hour
The time series is a data frame with a timestamp index for a 24-hour period sampled at the given frequency. The maximum allowable frequency is 1 minute.
date_label
is used as the date for the timestamp index.The columns of the data frame are hierarchical (multi-index) with
- top level: name = ‘indicator’, values = [‘service_distance’, ‘service_duration’, ‘num_trip_starts’, ‘num_trips’, ‘service_speed’]
- middle level: name = ‘route_id’, values = the active routes
- bottom level: name = ‘direction_id’, values = 0s and 1s
If
split_directions == False
, then don’t include the bottom level.If
trips_stats_subset
is empty, then return an empty data frame with the indicator columns.NOTES:
- To resample the resulting time series use the following methods:
- for ‘num_trips’ series, use
how=np.mean
- for the other series, use
how=np.sum
- ‘service_speed’ can’t be resampled and must be recalculated from ‘service_distance’ and ‘service_duration’
- for ‘num_trips’ series, use
To remove the date and seconds from the time series f, do
f.index = [t.time().strftime('%H:%M') for t in f.index.to_datetime()]
-
gtfstk.feed.
get_stops_stats
(stop_times, trips_subset, split_directions=False, headway_start_time='07:00:00', headway_end_time='19:00:00')¶ Given a stop times data frame and a subset of a trips data frame, return a data frame that provides summary stats about the stops in the (inner) join of the two data frames.
The columns of the output data frame are:
- stop_id
- direction_id: present iff
split_directions == True
- num_routes: number of routes visiting stop (in the given direction)
- num_trips: number of trips visiting stop (in the givin direction)
- max_headway: maximum of the durations (in minutes) between
trip departures at the stop between
headway_start_time
andheadway_end_time
on the given date - min_headway: minimum of the durations (in minutes) mentioned above
- mean_headway: mean of the durations (in minutes) mentioned above
- start_time: earliest departure time of a trip from this stop on the given date
- end_time: latest departure time of a trip from this stop on the given date
If
split_directions == False
, then compute each stop’s stats using trips visiting it from both directions.If
trips_subset
is empty, then return an empty data frame with the columns specified above.
-
gtfstk.feed.
get_stops_time_series
(stop_times, trips_subset, split_directions=False, freq='5Min', date_label='20010101')¶ Given a stop times data frame and a subset of a trips data frame, return a data frame that provides summary stats about the stops in the (inner) join of the two data frames.
The time series is a data frame with a timestamp index for a 24-hour period sampled at the given frequency. The maximum allowable frequency is 1 minute. The timestamp includes the date given by
date_label
, a date string of the form ‘%Y%m%d’.The columns of the data frame are hierarchical (multi-index) with
- top level: name = ‘indicator’, values = [‘num_trips’]
- middle level: name = ‘stop_id’, values = the active stop IDs
- bottom level: name = ‘direction_id’, values = 0s and 1s
If
split_directions == False
, then don’t include the bottom level.If
trips_subset
is empty, then return an empty data frame with the indicator columns.NOTES:
- ‘num_trips’ should be resampled with
how=np.sum
- To remove the date and seconds from
the time series f, do
f.index = [t.time().strftime('%H:%M') for t in f.index.to_datetime()]
-
gtfstk.feed.
plot_headways
(stats, max_headway_limit=60)¶ Given a stops or routes stats data frame, return bar charts of the max and mean headways as a MatplotLib figure. Only include the stops/routes with max headways at most
max_headway_limit
minutes. Ifmax_headway_limit is None
, then include them all in a giant plot. If there are no stops/routes within the max headway limit, then returnNone
.NOTES:
Take the resulting figure
f
and dof.tight_layout()
for a nice-looking plot.
-
gtfstk.feed.
plot_routes_time_series
(routes_time_series)¶ Given a routes time series data frame, sum each time series indicator over all routes, plot each series indicator using MatplotLib, and return the resulting figure of subplots.
NOTES:
Take the resulting figure
f
and dof.tight_layout()
for a nice-looking plot.


Author:~ {{quote.author}}
Date: {{quote.completeDate|date|uppercase}}
upvote :{{quote.upvote}}
Downvote :{{quote.downvote}}
Submitted by:{{quote.sub}}
posted: {{quote.completeDate|dateCount}} days ago


Dashboard
Donor
Hospital
Branch
Blood Transfusion
Log Out
Add Branch
Name
Mobile No.
Email
Address
Area


Before Change
def is_active(self):
The plugin is active iff any run has at least one active tool/tag.
return any(self.index_impl().values())
After Change
// we"re still not active, launch a thread to check if we"re active and
// release the lock once the computation is finished. Either way, this
// thread returns the current cached value to avoid blocking.
if not self._is_active and self._is_active_lock.acquire(False):
if self._is_active:
self._is_active_lock.release()
else:
def compute_is_active():
self._is_active = any(self.generate_run_to_tools())
self._is_active_lock.release()
new_thread = threading.Thread(
target=compute_is_active,
name="ProfilePluginIsActiveThread")
new_thread.start()
return self._is_active
def start_grpc_stub_if_necessary(self):
// We will enable streaming trace viewer on two conditions:


Regal Horsemanship offers English and Western riding lessons, and horse training specializing in green horses
Lessons
One Hour Private: $50
Half Hour Private: $30
One Hour Semi-Private: $40
Training
$30 per ride
Contact
Larissa Chittum
937.505.7825
1282 Fairground Rd, Xenia, OH 45385


| 1 | /* | |
| 2 | * Licensed to the Apache Software Foundation (ASF) under one or more | |
| 3 | * contributor license agreements. See the NOTICE file distributed with | |
| 4 | * this work for additional information regarding copyright ownership. | |
| 5 | * The ASF licenses this file to You under the Apache License, Version 2.0 | |
| 6 | * (the "License"); you may not use this file except in compliance with | |
| 7 | * the License. You may obtain a copy of the License at | |
| 8 | * | |
| 9 | * http://www.apache.org/licenses/LICENSE-2.0 | |
| 10 | * | |
| 11 | * Unless required by applicable law or agreed to in writing, software | |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, | |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| 14 | * See the License for the specific language governing permissions and | |
| 15 | * limitations under the License. | |
| 16 | */ | |
| 17 | package org.apache.commons.collections4.set; | |
| 18 | ||
| 19 | import java.util.Iterator; | |
| 20 | import java.util.NavigableSet; | |
| 21 | ||
| 22 | import org.apache.commons.collections4.Transformer; | |
| 23 | ||
| 24 | /** | |
| 25 | * Decorates another NavigableSet to transform objects that are added. | |
| 26 | *
 | |
| 27 | * The add methods are affected by this class. | |
| 28 | * Thus objects must be removed or searched for using their transformed form. | |
| 29 | * For example, if the transformation converts Strings to Integers, you must | |
| 30 | * use the Integer form to remove objects. | |
| 31 | * | |
| 32 | * @since 4.1 | |
| 33 | * @version $Id: TransformedNavigableSet.java 1686855 2015-06-22 13:00:27Z tn $ | |
| 34 | */ | |
| 35 | public class TransformedNavigableSet<E> extends TransformedSortedSet<E> implements NavigableSet<E> { | |
| 36 | ||
| 37 | /** Serialization version */ | |
| 38 | private static final long serialVersionUID = 20150528L; | |
| 39 | ||
| 40 | /** | |
| 41 | * Factory method to create a transforming navigable set. | |
| 42 | *
 | |
| 43 | * If there are any elements already in the set being decorated, they | |
| 44 | * are NOT transformed. | |
| 45 | * Contrast this with {@link #transformedNavigableSet(NavigableSet, Transformer)}. | |
| 46 | * | |
| 47 | * @param <E> the element type | |
| 48 | * @param set the set to decorate, must not be null | |
| 49 | * @param transformer the transformer to use for conversion, must not be null | |
| 50 | * @return a new transformed {@link NavigableSet} | |
| 51 | * @throws NullPointerException if set or transformer is null | |
| 52 | */ | |
| 53 | public static <E> TransformedNavigableSet<E> transformingNavigableSet(final NavigableSet<E> set, | |
| 54 | final Transformer<? super E, ? extends E> transformer) { | |
| 55 |
1
1. transformingNavigableSet : mutated return of Object value for org/apache/commons/collections4/set/TransformedNavigableSet::transformingNavigableSet to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new TransformedNavigableSet<E>(set, transformer); |
| 56 | } | |
| 57 | ||
| 58 | /** | |
| 59 | * Factory method to create a transforming navigable set that will transform | |
| 60 | * existing contents of the specified navigable set. | |
| 61 | *
 | |
| 62 | * If there are any elements already in the set being decorated, they | |
| 63 | * will be transformed by this method. | |
| 64 | * Contrast this with {@link #transformingNavigableSet(NavigableSet, Transformer)}. | |
| 65 | * | |
| 66 | * @param <E> the element type | |
| 67 | * @param set the set to decorate, must not be null | |
| 68 | * @param transformer the transformer to use for conversion, must not be null | |
| 69 | * @return a new transformed {@link NavigableSet} | |
| 70 | * @throws NullPointerException if set or transformer is null | |
| 71 | */ | |
| 72 | public static <E> TransformedNavigableSet<E> transformedNavigableSet(final NavigableSet<E> set, | |
| 73 | final Transformer<? super E, ? extends E> transformer) { | |
| 74 | ||
| 75 | final TransformedNavigableSet<E> decorated = new TransformedNavigableSet<E>(set, transformer); | |
| 76 |
2
1. transformedNavigableSet : changed conditional boundary → NO_COVERAGE 2. transformedNavigableSet : negated conditional → NO_COVERAGE |
if (set.size() > 0) { |
| 77 | @SuppressWarnings("unchecked") // set is type E | |
| 78 | final E[] values = (E[]) set.toArray(); // NOPMD - false positive for generics | |
| 79 |
1
1. transformedNavigableSet : removed call to java/util/NavigableSet::clear → NO_COVERAGE |
set.clear(); |
| 80 |
3
1. transformedNavigableSet : changed conditional boundary → NO_COVERAGE 2. transformedNavigableSet : Changed increment from 1 to -1 → NO_COVERAGE 3. transformedNavigableSet : negated conditional → NO_COVERAGE |
for (final E value : values) { |
| 81 | decorated.decorated().add(transformer.transform(value)); | |
| 82 | } | |
| 83 | } | |
| 84 |
1
1. transformedNavigableSet : mutated return of Object value for org/apache/commons/collections4/set/TransformedNavigableSet::transformedNavigableSet to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return decorated; |
| 85 | } | |
| 86 | ||
| 87 | //----------------------------------------------------------------------- | |
| 88 | /** | |
| 89 | * Constructor that wraps (not copies). | |
| 90 | *
 | |
| 91 | * If there are any elements already in the set being decorated, they | |
| 92 | * are NOT transformed. | |
| 93 | * | |
| 94 | * @param set the set to decorate, must not be null | |
| 95 | * @param transformer the transformer to use for conversion, must not be null | |
| 96 | * @throws NullPointerException if set or transformer is null | |
| 97 | */ | |
| 98 | protected TransformedNavigableSet(final NavigableSet<E> set, | |
| 99 | final Transformer<? super E, ? extends E> transformer) { | |
| 100 | super(set, transformer); | |
| 101 | } | |
| 102 | ||
| 103 | /** | |
| 104 | * Gets the decorated navigable set. | |
| 105 | * | |
| 106 | * @return the decorated navigable set | |
| 107 | */ | |
| 108 | @Override | |
| 109 | protected NavigableSet<E> decorated() { | |
| 110 |
1
1. decorated : mutated return of Object value for org/apache/commons/collections4/set/TransformedNavigableSet::decorated to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return (NavigableSet<E>) super.decorated(); |
| 111 | } | |
| 112 | ||
| 113 | //----------------------------------------------------------------------- | |
| 114 | ||
| 115 | @Override | |
| 116 | public E lower(E e) { | |
| 117 |
1
1. lower : mutated return of Object value for org/apache/commons/collections4/set/TransformedNavigableSet::lower to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return decorated().lower(e); |
| 118 | } | |
| 119 | ||
| 120 | @Override | |
| 121 | public E floor(E e) { | |
| 122 |
1
1. floor : mutated return of Object value for org/apache/commons/collections4/set/TransformedNavigableSet::floor to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return decorated().floor(e); |
| 123 | } | |
| 124 | ||
| 125 | @Override | |
| 126 | public E ceiling(E e) { | |
| 127 |
1
1. ceiling : mutated return of Object value for org/apache/commons/collections4/set/TransformedNavigableSet::ceiling to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return decorated().ceiling(e); |
| 128 | } | |
| 129 | ||
| 130 | @Override | |
| 131 | public E higher(E e) { | |
| 132 |
1
1. higher : mutated return of Object value for org/apache/commons/collections4/set/TransformedNavigableSet::higher to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return decorated().higher(e); |
| 133 | } | |
| 134 | ||
| 135 | @Override | |
| 136 | public E pollFirst() { | |
| 137 |
1
1. pollFirst : mutated return of Object value for org/apache/commons/collections4/set/TransformedNavigableSet::pollFirst to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return decorated().pollFirst(); |
| 138 | } | |
| 139 | ||
| 140 | @Override | |
| 141 | public E pollLast() { | |
| 142 |
1
1. pollLast : mutated return of Object value for org/apache/commons/collections4/set/TransformedNavigableSet::pollLast to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return decorated().pollLast(); |
| 143 | } | |
| 144 | ||
| 145 | @Override | |
| 146 | public NavigableSet<E> descendingSet() { | |
| 147 |
1
1. descendingSet : mutated return of Object value for org/apache/commons/collections4/set/TransformedNavigableSet::descendingSet to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return transformingNavigableSet(decorated().descendingSet(), transformer); |
| 148 | } | |
| 149 | ||
| 150 | @Override | |
| 151 | public Iterator<E> descendingIterator() { | |
| 152 |
1
1. descendingIterator : mutated return of Object value for org/apache/commons/collections4/set/TransformedNavigableSet::descendingIterator to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return decorated().descendingIterator(); |
| 153 | } | |
| 154 | ||
| 155 | @Override | |
| 156 | public NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) { | |
| 157 | final NavigableSet<E> sub = decorated().subSet(fromElement, fromInclusive, toElement, toInclusive); | |
| 158 |
1
1. subSet : mutated return of Object value for org/apache/commons/collections4/set/TransformedNavigableSet::subSet to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return transformingNavigableSet(sub, transformer); |
| 159 | } | |
| 160 | ||
| 161 | @Override | |
| 162 | public NavigableSet<E> headSet(E toElement, boolean inclusive) { | |
| 163 | final NavigableSet<E> head = decorated().headSet(toElement, inclusive); | |
| 164 |
1
1. headSet : mutated return of Object value for org/apache/commons/collections4/set/TransformedNavigableSet::headSet to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return transformingNavigableSet(head, transformer); |
| 165 | } | |
| 166 | ||
| 167 | @Override | |
| 168 | public NavigableSet<E> tailSet(E fromElement, boolean inclusive) { | |
| 169 | final NavigableSet<E> tail = decorated().tailSet(fromElement, inclusive); | |
| 170 |
1
1. tailSet : mutated return of Object value for org/apache/commons/collections4/set/TransformedNavigableSet::tailSet to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return transformingNavigableSet(tail, transformer); |
| 171 | } | |
| 172 | ||
| 173 | } | |
Mutations | ||
| 55 |
1.1 |
|
| 76 |
1.1 2.2 |
|
| 79 |
1.1 |
|
| 80 |
1.1 2.2 3.3 |
|
| 84 |
1.1 |
|
| 110 |
1.1 |
|
| 117 |
1.1 |
|
| 122 |
1.1 |
|
| 127 |
1.1 |
|
| 132 |
1.1 |
|
| 137 |
1.1 |
|
| 142 |
1.1 |
|
| 147 |
1.1 |
|
| 152 |
1.1 |
|
| 158 |
1.1 |
|
| 164 |
1.1 |
|
| 170 |
1.1 |


WITNESS LIST Teacher Health Insurance, Select Committee March 19, 2001-2:00P HB 1189 For: Dunn, David (Texas Association of School Boards) Floyd, Beaman (Texas Association of School Administrators) Martinez, Louann (Texas Association of School Administrators) Teacher Health Insurance On: Jung, Ronnie (Teacher Retirement System)


I was interviewed on Channel 8's 狮城有约 programme. We discussed the world of generative art — creating art with code.


Hey, thank you for choosing CBS! You just made a seat reservation, below are some important details and a printable copy of your ticket.
Name: John Doe
Phone: 69952044
Notes: -
Reservation ID: 128820
Movie: Pulp Fiction
Showtime: 2019-03-03@17:00
Seat: A35
Hall: Hall 1
Price: 1000.00 MDL
Please print and bring this registration summary to the movie entrance!
Thanks and see you at the movie!


structure MC/MD SRCs local simulated lattice evolved atomic alloys simulation atoms diffuse alloy composition energy APT based experimental HEAs properties {border-style HEA high-entropy reciprocal structures type evolution obtained potential px;} swaps #ffffff;} Fig. elastic scattering morphology structural like literature SRC TaNbHfZr average compared experimentally observed > < HRTEM annealing atom EAM layer real simulations techniques work Maiti Mater. annealed elements high high-temperature X-ray chemical directions nano-scale number swaps, used using Acta bcc developed different diffraction dynamics perpendicular relaxation respectively. shown study technique XRD anisotropy clustering factor hybrid nanostructure planes px; refractory similar streak-like swaps. taken temperature {font-family Figure Metall. Monte Nb, attempted comparison complex cubic experiments font-size materials shows streaks values (eV/Å Al-Cu Carlo DFT constants corresponding created crystallographic days directions. double; effect effects entropy evolving formation information intensities level mechanical metals method order pattern principal pure random relaxed respect rich scan single-crystal studied swap synchrotron thermal total types use -days Bragg HEA, Mishra SRCs, Sci. Senkov Ta, Widom analysed attributed border-color border-width bulk captured change chosen close comparable compositions constant determined electron emerging features forming gradually habit interaction larger long lower matrix model molecular nanoscale phase region reported results second solid; structure. treatment years zone {font-style {font-weight °C. (Fig. .%, ./-()- ./j.actamat... ./s--- Commons Creative HRTEM, Mat. Miracle Phys. SRO/ Steurer Table Trans. Tsai Yeh ab-initio adjacent bold calculated characterization characterizations cluster concentrated concentration containing courier; described development dissimilar element em; equimolar evidenced framework growth higher initial input interconnected involved maroon material methodology methods nanometer nature neutron orange provide pt;} randomly ref. related results. sequence short-range single-phase space stability stages static stiffness strain structure, studies subjected supercell system, thermodynamic tiny width zones °C × ×