claf.tokens package¶
Subpackages¶
Submodules¶
This code is from salesforce/cove (https://github.com/salesforce/cove/blob/master/cove/encoder.py)
-
class
claf.tokens.cove.
MTLSTM
(word_embedding, pretrained_path=None, requires_grad=False, residual_embeddings=False)[source]¶ Bases:
torch.nn.modules.module.Module
-
forward
(inputs)[source]¶ A pretrained MT-LSTM (McCann et. al. 2017). This LSTM was trained with 300d 840B GloVe on the WMT 2017 machine translation dataset.
- Arguments:
- inputs (Tensor): If MTLSTM handles embedding, a Long Tensor of size (batch_size, timesteps).
Otherwise, a Float Tensor of size (batch_size, timesteps, features).
lengths (Long Tensor): (batch_size, lengths) lenghts of each sequence for handling padding hidden (Float Tensor): initial hidden state of the LSTM
-
This code is from allenai/allennlp (https://github.com/allenai/allennlp/blob/master/allennlp/modules/elmo.py)
-
class
claf.tokens.elmo.
Elmo
(options_file: str, weight_file: str, num_output_representations: int, requires_grad: bool = False, do_layer_norm: bool = False, dropout: float = 0.5, vocab_to_cache: List[str] = None, module: torch.nn.modules.module.Module = None)[source]¶ Bases:
torch.nn.modules.module.Module
Compute ELMo representations using a pre-trained bidirectional language model. See “Deep contextualized word representations”, Peters et al. for details. This module takes character id input and computes
num_output_representations
different layers of ELMo representations. Typicallynum_output_representations
is 1 or 2. For example, in the case of the SRL model in the above paper,num_output_representations=1
where ELMo was included at the input token representation layer. In the case of the SQuAD model,num_output_representations=2
as ELMo was also included at the GRU output layer. In the implementation below, we learn separate scalar weights for each output layer, but only run the biLM once on each input sequence for efficiency. Parameters ———- options_file :str
, required.ELMo JSON options file
- weight_file
str
, required. ELMo hdf5 weight file
- num_output_representations:
int
, required. The number of ELMo representation layers to output.
- requires_grad:
bool
, optional If True, compute gradient of ELMo parameters for fine tuning.
- do_layer_norm
bool
, optional, (default=False). Should we apply layer normalization (passed to
ScalarMix
)?- dropout
float
, optional, (default = 0.5). The dropout to be applied to the ELMo representations.
- vocab_to_cache
List[str]
, optional, (default = 0.5). A list of words to pre-compute and cache character convolutions for. If you use this option, Elmo expects that you pass word indices of shape (batch_size, timesteps) to forward, instead of character indices. If you use this option and pass a word which wasn’t pre-cached, this will break.
- module
torch.nn.Module
, optional, (default = None). If provided, then use this module instead of the pre-trained ELMo biLM. If using this option, then pass
None
for bothoptions_file
andweight_file
. The module must provide a public attributenum_layers
with the number of internal layers and itsforward
method must return adict
withactivations
andmask
keys (see _ElmoBilm` for an example). Note thatrequires_grad
is also ignored with this option.
-
forward
(inputs: torch.Tensor, word_inputs: torch.Tensor = None) → Dict[str, Union[torch.Tensor, List[torch.Tensor]]][source]¶ inputs:
torch.Tensor
, required. Shape(batch_size, timesteps, 50)
of character ids representing the current batch. word_inputs :torch.Tensor
, required.If you passed a cached vocab, you can in addition pass a tensor of shape
(batch_size, timesteps)
, which represent word ids which have been pre-cached.Dict with keys:
'elmo_representations'
:List[torch.Tensor]
A
num_output_representations
list of ELMo representations for the input sequence. Each representation is shape(batch_size, timesteps, embedding_dim)
'mask'
:torch.Tensor
Shape
(batch_size, timesteps)
long tensor with sequence mask.
- weight_file
-
class
claf.tokens.elmo.
ElmoLstm
(input_size: int, hidden_size: int, cell_size: int, num_layers: int, requires_grad: bool = False, recurrent_dropout_probability: float = 0.0, memory_cell_clip_value: Optional[float] = None, state_projection_clip_value: Optional[float] = None)[source]¶ Bases:
claf.modules.encoder.lstm_cell_with_projection._EncoderBase
A stacked, bidirectional LSTM which uses
LstmCellWithProjection
’s with highway layers between the inputs to layers. The inputs to the forward and backward directions are independent - forward and backward states are not concatenated between layers. Additionally, this LSTM maintains its own state, which is updated every timeforward
is called. It is dynamically resized for different batch sizes and is designed for use with non-continuous inputs (i.e inputs which aren’t formatted as a stream, such as text used for a language modelling task, which is how stateful RNNs are typically used). This is non-standard, but can be thought of as having an “end of sentence” state, which is carried across different sentences. Parameters ———- input_size :int
, requiredThe dimension of the inputs to the LSTM.
- hidden_size
int
, required The dimension of the outputs of the LSTM.
- cell_size
int
, required. The dimension of the memory cell of the
LstmCellWithProjection
.- num_layers
int
, required The number of bidirectional LSTMs to use.
- requires_grad:
bool
, optional If True, compute gradient of ELMo parameters for fine tuning.
- recurrent_dropout_probability:
float
, optional (default = 0.0) The dropout probability to be used in a dropout scheme as stated in A Theoretically Grounded Application of Dropout in Recurrent Neural Networks .
- state_projection_clip_value:
float
, optional, (default = None) The magnitude with which to clip the hidden_state after projecting it.
- memory_cell_clip_value:
float
, optional, (default = None) The magnitude with which to clip the memory cell.
-
forward
(inputs: torch.Tensor, mask: torch.LongTensor) → torch.Tensor[source]¶ - inputs
torch.Tensor
, required. A Tensor of shape
(batch_size, sequence_length, hidden_size)
.- mask
torch.LongTensor
, required. A binary mask of shape
(batch_size, sequence_length)
representing the non-padded elements in each sequence in the batch.
A
torch.Tensor
of shape (num_layers, batch_size, sequence_length, hidden_size), where the num_layers dimension represents the LSTM output from that layer.- inputs
- hidden_size
-
claf.tokens.elmo.
add_sentence_boundary_token_ids
(tensor: torch.Tensor, mask: torch.Tensor, sentence_begin_token: Any, sentence_end_token: Any) → Tuple[torch.Tensor, torch.Tensor][source]¶ Add begin/end of sentence tokens to the batch of sentences. Given a batch of sentences with size
(batch_size, timesteps)
or(batch_size, timesteps, dim)
this returns a tensor of shape(batch_size, timesteps + 2)
or(batch_size, timesteps + 2, dim)
respectively. Returns both the new tensor and updated mask. Parameters ———- tensor :torch.Tensor
A tensor of shape
(batch_size, timesteps)
or(batch_size, timesteps, dim)
- mask
torch.Tensor
A tensor of shape
(batch_size, timesteps)
- sentence_begin_token: Any (anything that can be broadcast in torch for assignment)
For 2D input, a scalar with the <S> id. For 3D input, a tensor with length dim.
- sentence_end_token: Any (anything that can be broadcast in torch for assignment)
For 2D input, a scalar with the </S> id. For 3D input, a tensor with length dim.
- tensor_with_boundary_tokens
torch.Tensor
The tensor with the appended and prepended boundary tokens. If the input was 2D, it has shape (batch_size, timesteps + 2) and if the input was 3D, it has shape (batch_size, timesteps + 2, dim).
- new_mask
torch.Tensor
The new mask for the tensor, taking into account the appended tokens marking the beginning and end of the sentence.
- mask
-
claf.tokens.elmo.
remove_sentence_boundaries
(tensor: torch.Tensor, mask: torch.Tensor) → Tuple[torch.Tensor, torch.Tensor][source]¶ Remove begin/end of sentence embeddings from the batch of sentences. Given a batch of sentences with size
(batch_size, timesteps, dim)
this returns a tensor of shape(batch_size, timesteps - 2, dim)
after removing the beginning and end sentence markers. The sentences are assumed to be padded on the right, with the beginning of each sentence assumed to occur at index 0 (i.e.,mask[:, 0]
is assumed to be 1). Returns both the new tensor and updated mask. This function is the inverse ofadd_sentence_boundary_token_ids
. Parameters ———- tensor :torch.Tensor
A tensor of shape
(batch_size, timesteps, dim)
- mask
torch.Tensor
A tensor of shape
(batch_size, timesteps)
- tensor_without_boundary_tokens
torch.Tensor
The tensor after removing the boundary tokens of shape
(batch_size, timesteps - 2, dim)
- new_mask
torch.Tensor
The new mask for the tensor of shape
(batch_size, timesteps - 2)
.
- mask
Hangulpy.py Copyright (C) 2012 Ryan Rho, Hyunwoo Cho Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
claf.tokens.hangul.
compose
(chosung, joongsung, jongsung='')[source]¶ This function returns a Hangul letter by composing the specified chosung, joongsung, and jongsung. @param chosung @param joongsung @param jongsung the terminal Hangul letter. This is optional if you do not need a jongsung.
-
claf.tokens.hangul.
decompose
(hangul_letter)[source]¶ This function returns letters by decomposing the specified Hangul letter.
-
claf.tokens.hangul.
has_approximant
(letter)[source]¶ Approximant makes complex vowels, such as ones starting with y or w. In Korean there is a unique approximant euㅡ making uiㅢ, but ㅢ does not make many irregularities.
-
claf.tokens.hangul.
ili
(word)[source]¶ convert {가} or {이} to their correct respective particles automagically.
-
claf.tokens.hangul.
is_all_hangul
(phrase)[source]¶ Check whether the phrase contains all Hangul letters @param phrase a target string @return True if the phrase only consists of Hangul. False otherwise.
-
claf.tokens.hangul.
is_hangul
(phrase)[source]¶ Check whether the phrase is Hangul. This method ignores white spaces, punctuations, and numbers. @param phrase a target string @return True if the phrase is Hangul. False otherwise.
-
class
claf.tokens.linguistic.
NER
[source]¶ Bases:
object
Named Entity Recognition
Models trained on the OntoNotes 5 corpus support the following entity types: (https://spacy.io/api/annotation#section-dependency-parsing)
-
classes
= ['NONE', 'PERSON', 'NORP', 'FAC', 'ORG', 'GPE', 'LOC', 'PRODUCT', 'EVENT', 'WORK_OF_ART', 'LAW', 'LANGUAGE', 'DATE', 'TIME', 'PERCENT', 'MONEY', 'QUANTITY', 'ORDINAL', 'CARDINAL']¶
-
-
class
claf.tokens.linguistic.
POSTag
[source]¶ Bases:
object
Universal POS tags expends by spacy (https://spacy.io/api/annotation#section-pos-tagging)
-
classes
= ['ADJ', 'ADP', 'ADV', 'AUX', 'CONJ', 'CCONJ', 'DET', 'INTJ', 'NOUN', 'NUM', 'PART', 'PRON', 'PROPN', 'PUNCT', 'SCONJ', 'SYM', 'VERB', 'X', 'SPACE']¶
-
-
class
claf.tokens.text_handler.
TextHandler
(token_makers, lazy_indexing=True)[source]¶ Bases:
object
Text Handler
voacb and token_counter
raw_features -> indexed_features
raw_features -> tensor
- Args:
- token_makers: Dictionary consisting of
key: token_name
value: TokenMaker (claf.tokens.token_maker)
- Kwargs:
lazy_indexing: Apply Lazy Evaluation to text indexing
-
class
claf.tokens.token_maker.
TokenMaker
(token_type, tokenizer=None, indexer=None, embedding_fn=None, vocab_config=None)[source]¶ Bases:
object
Token Maker (Data Transfer Object)
Token Maker consists of Tokenizer, Indexer, Embedding and Vocab
- Kwargs:
tokenizer: Tokenizer (claf.tokens.tokenizer.base) indexer: TokenIndexer (claf.tokens.indexer.base) embedding_fn: wrapper function of TokenEmbedding (claf.tokens.embedding.base) vocab_config: config dict of Vocab (claf.tokens.vocaburary)
-
BERT_TYPE
= 'bert'¶
-
CHAR_TYPE
= 'char'¶
-
COVE_TYPE
= 'cove'¶
-
ELMO_TYPE
= 'elmo'¶
-
EXACT_MATCH_TYPE
= 'exact_match'¶
-
FEATURE_TYPE
= 'feature'¶
-
FREQUENT_WORD_TYPE
= 'frequent_word'¶
-
LINGUISTIC_TYPE
= 'linguistic'¶
-
WORD_TYPE
= 'word'¶
-
property
embedding_fn
¶
-
property
indexer
¶
-
property
tokenizer
¶
-
property
vocab
¶
-
property
vocab_config
¶
-
class
claf.tokens.vocabulary.
Vocab
(token_name, pad_token=None, oov_token=None, start_token=None, end_token=None, cls_token=None, sep_token=None, min_count=None, max_vocab_size=None, frequent_count=None, pretrained_path=None, pretrained_token=None)[source]¶ Bases:
object
Vocaburary Class
Vocab consists of token_to_index and index_to_token.
- Args:
token_name: Token name (Token and Vocab is one-to-one relationship)
- Kwargs:
pad_token: padding token value (eg. <pad>) oov_token: out-of-vocaburary token value (eg. <unk>) start_token: start token value (eg. <s>, <bos>) end_token: end token value (eg. </s>, <eos>) cls_token: CLS token value for BERT (eg. [CLS]) sep_token: SEP token value for BERT (eg. [SEP]) min_count: token’s minimal frequent count.
when you define min_count, tokens remain that bigger than min_count.
- max_vocab_size: vocaburary’s maximun size.
when you define max_vocab_size, tokens are selected according to frequent count.
- frequent_count: get frequent_count threshold_index.
(eg. frequent_count = 1000, threshold_index is the tokens that frequent_count is 999 index number.)
- pretrained_path: pretrained vocab file path
(format: A
B C D …)
-
DEFAULT_OOV_INDEX
= 1¶
-
DEFAULT_OOV_TOKEN
= '[UNK]'¶
-
DEFAULT_PAD_INDEX
= 0¶
-
DEFAULT_PAD_TOKEN
= '[PAD]'¶
-
PRETRAINED_ALL
= 'all'¶
-
PRETRAINED_INTERSECT
= 'intersect'¶
-
class
claf.tokens.vocabulary.
VocabDict
(oov_value)[source]¶ Bases:
collections.defaultdict
Vocab DefaultDict Class
- Kwargs:
oov_value: out-of-vocaburary token value (eg. <unk>)
Module contents¶
-
class
claf.tokens.
BertTokenMaker
(tokenizers, indexer_config, embedding_config, vocab_config)[source]¶ Bases:
claf.tokens.token_maker.TokenMaker
BERT Token Pre-training of Deep Bidirectional Transformers for Language Understanding
- example.
hello -> [‘[CLS]’, ‘he’, ‘##llo’, [SEP]] -> [1, 4, 7, 2] -> BERT -> tensor
- consisting of
tokenizer: WordTokenizer
indexer: WordIndexer
embedding: ELMoEmbedding (Language Modeling BiLSTM)
vocab: Vocab
-
class
claf.tokens.
CharTokenMaker
(tokenizers, indexer_config, embedding_config, vocab_config)[source]¶ Bases:
claf.tokens.token_maker.TokenMaker
Character Token
Character-level Convolutional Networks for Text Classification (https://arxiv.org/abs/1509.01626)
- example.
hello -> [‘h’, ‘e’, ‘l’, ‘l’, ‘o’] -> [2, 3, 4, 4, 5] -> CharCNN -> tensor
- consisting of
tokenizer: CharTokenizer
indexer: CharIndexer
embedding: CharEmbedding (CharCNN)
vocab: Vocab
-
class
claf.tokens.
CoveTokenMaker
(tokenizers, indexer_config, embedding_config, vocab_config)[source]¶ Bases:
claf.tokens.token_maker.TokenMaker
CoVe Token
Learned in Translation: Contextualized Word Vectors (McCann et. al. 2017) (https://github.com/salesforce/cove)
- example.
hello -> [‘hello’] -> [2] -> CoVe -> tensor
- consisting of
tokenizer: WordTokenizer
indexer: WordIndexer
embedding: CoveEmbedding (Machine Translation LSTM)
vocab: Vocab
-
class
claf.tokens.
ElmoTokenMaker
(tokenizers, indexer_config, embedding_config, vocab_config)[source]¶ Bases:
claf.tokens.token_maker.TokenMaker
ELMo Token Embedding from Language Modeling
Deep contextualized word representations (https://github.com/allenai/allennlp/blob/master/allennlp/modules/elmo.py)
- example.
hello -> [‘h’, ‘e’, ‘l’, ‘l’, ‘o’] -> [2, 3, 4, 4, 5] -> ELMo -> tensor
- consisting of
tokenizer: WordTokenizer
indexer: WordIndexer
embedding: ELMoEmbedding (Language Modeling BiLSTM)
vocab: Vocab
-
class
claf.tokens.
ExactMatchTokenMaker
(tokenizers, indexer_config, embedding_config, vocab_config)[source]¶ Bases:
claf.tokens.token_maker.TokenMaker
Exact Match Token (Sparse Feature)
Three simple binary features, indicating whether p_i can be exactly matched to one question word in q, either in its original, lowercase or lemma form.
- example.
c: i do, q: i -> [‘i’, ‘do’] -> [1, 0] -> tensor
- consisting of
tokenizer: WordTokenizer
indexer: WordIndexer
embedding: SparseFeature
vocab: Vocab
-
class
claf.tokens.
FeatureTokenMaker
(tokenizers, indexer_config, embedding_config, vocab_config)[source]¶ Bases:
claf.tokens.token_maker.TokenMaker
Feature Token
Do not use Embedding function. Just pass indexed_feature
- example.
hello -> [‘hello’, ‘world’] -> [3, 5] -> tensor
- consisting of
tokenizer: Tokenizer (need to define unit)
indexer: WordIndexer
embedding: None
vocab: Vocab
-
class
claf.tokens.
FrequentWordTokenMaker
(tokenizers, indexer_config, embedding_config, vocab_config)[source]¶ Bases:
claf.tokens.token_maker.TokenMaker
Frequent-Tuning Word Token
word token + pre-trained word embeddings fixed and only fine-tune the N most frequent
- example.
i do -> [‘i’, ‘do’] -> [1, 2] -> Embedding Matrix -> tensor finetuning only ‘do’
- consisting of
tokenizer: WordTokenizer
indexer: WordIndexer
embedding: FrequentTuningWordEmbedding
vocab: Vocab
-
class
claf.tokens.
LinguisticTokenMaker
(tokenizers, indexer_config, embedding_config, vocab_config)[source]¶ Bases:
claf.tokens.token_maker.TokenMaker
Exact Match Token (Sparse Feature)
Three simple binary features, indicating whether p_i can be exactly matched to one question word in q, either in its original, lowercase or lemma form.
- example.
c: i do, q: i -> [‘i’, ‘do’] -> [1, 0] -> tensor
- consisting of
tokenizer: WordTokenizer
indexer: WordIndexer
embedding: SparseFeature
vocab: Vocab
-
class
claf.tokens.
WordTokenMaker
(tokenizers, indexer_config, embedding_config, vocab_config)[source]¶ Bases:
claf.tokens.token_maker.TokenMaker
Word Token (default)
i do -> [‘i’, ‘do’] -> [1, 2] -> Embedding Matrix -> tensor
- consisting of
tokenizer: WordTokenizer
indexer: WordIndexer
embedding: WordEmbedding
vocab: Vocab


|
iDreamSky Game Engine
v1.0.0
|
#include <Texture2DFile.h>
複合項目 | |
| class | Data |
| class | Resource |
| Texture2DFile::Resource. 更多... | |
| class | ResourceImporter |
公開方法(Public Methods) | |
| Texture2DFile () | |
| Texture2DFile Constructor. 更多... | |
| virtual | ~Texture2DFile () |
| Texture2DFile Constructor. 更多... | |
| bool | construct (const char *path_) |
| construct the texture from a path and allocate texture resource 更多... | |
| void | destruct () |
| destruct the texture and release of texture resource | |
| virtual void * | getHandle () const |
| Get the Handle of the Texture. 更多... | |
| int | getWidth () const |
| Get the Width of the Texture. 更多... | |
| int | getHeight () const |
| Get the Height of the Texture. 更多... | |
| int | getLevelCount () const |
| Get the Mipmap Level Count of the Texture. 更多... | |
| bool | isRenderable () const |
| Check if texture is renderable. 更多... | |
| bool | isPowerOfTwo () const |
| Check if texture is power of 2 in both width and height. 更多... | |
| 公開方法(Public Methods) 繼承自 Magnum::Texture2DBase | |
| Texture2DBase () | |
| Texture2DBase Constructor. 更多... | |
| virtual | ~Texture2DBase () |
| TextureBase Destructor. 更多... | |
| 公開方法(Public Methods) 繼承自 Magnum::TextureBase | |
| TextureBase () | |
| TextureBase Constructor. 更多... | |
| virtual | ~TextureBase () |
| TextureBase Destructor. 更多... | |
| void | setMinFilterMode (const GXTextureMinFilterMode &minFilter_) |
| Set the Minification Filter of the Texture. 更多... | |
| void | setMagFilterMode (const GXTextureMagFilterMode &magFilter_) |
| Set the Magification Filter of the Texture. 更多... | |
| const GXTextureMinFilterMode & | getMinFilterMode () const |
| Get the Minification Filter of the Texture. 更多... | |
| const GXTextureMagFilterMode & | getMagFilterMode () const |
| Get the Magification Filter of the Texture. 更多... | |
| void | setWrapS (const GXTextureWrapMode &wrapS_) |
| Set the Warp Mode of S direction of the Texture. 更多... | |
| const GXTextureWrapMode & | getWrapS () const |
| Get the Warp Mode of S direction of the Texture. 更多... | |
| void | setWrapT (const GXTextureWrapMode &wrapT_) |
| Set the Warp Mode of T direction of the Texture. 更多... | |
| const GXTextureWrapMode & | getWrapT () const |
| Get the Warp Mode of T direction of the Texture. 更多... | |
| Texture2DFile::Texture2DFile | ( | ) |
Texture2DFile Constructor.
To Construct the Texture2DFile
|
virtual |
| bool Texture2DFile::construct | ( | const char * | path_ | ) |
construct the texture from a path and allocate texture resource
|
virtual |
|
virtual |
|
virtual |
Get the Mipmap Level Count of the Texture.
|
virtual |
|
virtual |
Check if texture is power of 2 in both width and height.
|
virtual |


|
Prismic.io PHP kit
3.0.0
|
Public Member Functions | |
| __construct ($url, $kind, $size, $filename, $height, $width) | |
| getHeight () | |
| getWidth () | |
| Public Member Functions inherited from Prismic\Fragment\Link\FileLink | |
| __construct ($url, $kind, $size, $filename) | |
| asHtml ($linkResolver=null) | |
| asText () | |
| getUrl ($linkResolver=null) | |
| getKind () | |
| getSize () | |
| getFilename () | |
Static Public Member Functions | |
| static | parse ($json) |
| Static Public Member Functions inherited from Prismic\Fragment\Link\FileLink | |
| static | parse ($json) |
This class embodies an image link; it is what is retrieved from the API when a link is created towards an image file. LinkInterface objects can be found in two occasions: as the "$link" variable of a HyperlinkSpan object (which happens when the link is a hyperlink in a StructuredText fragment), or the LinkInterface can also be its own fragment (e.g. for a "related" fragment, that links to a related document).
| Prismic\Fragment\Link\ImageLink::__construct | ( | $url, | |
| $kind, | |||
| $size, | |||
| $filename, | |||
| $height, | |||
| $width | |||
| ) |
Constructs an image link.
| string | $url | the URL of the resource we're linking to |
| string | $kind | the kind of resource it is (document, image, ...) |
| string | $size | the size of the resource, in bytes |
| string | $filename | the resource's original filename, in bytes |
| int | $height | the height of the image |
| int | $width | the width of the image |
| Prismic\Fragment\Link\ImageLink::getHeight | ( | ) |
Returns the height of the image.
| Prismic\Fragment\Link\ImageLink::getWidth | ( | ) |
Returns the width of the image.
|
static |


---
layout: default
title: Literary fiction reviews
breadcrumb: staff-picks
hnav: genre
---
Literary fiction reviews
{% assign literary_fiction_posts = site.posts | where: "genre", "literary-fiction" %}
{% for post in literary_fiction_posts limit:24 %}
{% endfor %}


I was hired by OptimalWork to help take their web application to the next level. During the process, I conducted research, created wireframes, validated concepts, and delivered a final polished design. hroughout my work, I was able to learn about their target audience and empathize with their needs. I was able to redesign the existing product, with the focus of achieving streamlined interaction flows, stronger brand identity, and better focus on the community aspects of the platform.
My starting point was the existing live product. The goal of the platform is to help people work in a way that is more mindful and fulfilling. OptimalWork aims to apply psychological theories in a way that better connects working with higher meaning and goals. On first impression, the existing product appeared raw and somewhat clunky, and was not communicating its purpose clearly.
In order to get myself familiarized with the existing system, and to identify some potential problematic areas, I conducted a UX Audit. During that activity, I went through all the main screens of the product, and analyzed how well they fared in areas, such as interaction design, accessibility, clarity, branding, and information architecture, among others.
What I learned was that even though the product looked unpolished and needed updates, it actually featured a lot of userful functionality and a strong underlying potential. The platform featured a combination of learning, various practice tools, as well as self assessment functionality that all work together to help one work in a more mindful way and be more productive.
The UX Audit helped me generate ideas about areas of concern, as well as ones with potential. I also talked with the team and understood where their areas of current focus are. The two data sources helped me create a research plan, that I then used during my initial research interviews. I interviewed 5 participants in a semi-structured exploratory study that aimed at understanding the following:
The interview helped me learn about the users of the product and empathize with them better. I would later use this data to identify problem areas and brainstorm potential solutions.
Based on my user resarch, I was able to construct target user personas. Notable characteristc differences were visible between students and working professionals. The type of profession also played a role during my research, which also affected the use of mobiel vs desktop devices.
Next, I worked on fireframes that would address the pain points that I identified during my research. I had to go through several revisions and scope adjustments to my prototypes, based on feedback and brainstorming sessions with the team.
Once we felt that the wireframes were polished enough, I conducted a concept validation, which aimed to test the new designs and see how well they are received by customers.
After my concept validation, I made some updates and started looking at the high-fidelity prototypes. As part of that effort, I refresh the product's visual language. I collaborated with our marketing team on this, as we wanted to make sure that our marketing materials are also in tune with our newly designed product.
Finally, I created high-fidelity designs that aimed to meet the needs of the customers of OptimalWork. The designed aimed to simplify the interactions, while also introducing new features that would boost the ccommunity aspect of the platform. The final design also featured the updated brand guidelines that I developed, and include a number of new elements that made the product more polished and professional.
With mindfulness at its core, I focused on making the product more human. To do that, I worked to make the lines smoother, introducted aesthetially appealing imagery, and aimed to reduce friction.


--- layout: blog title: Blog | Raphael Fabeni description: 'My simple thoughts about the life and web development' language: en links: left: text: Home link: '/' right: text: Home link: '/' --- {% assign englishPosts = site.posts | where: 'lang', 'en' %} {% assign portuguesePosts = site.posts | where: 'lang', 'pt-br' %} {% for post in englishPosts %}
{% endfor %}


Emotional Intelligence
What is emotional intelligence?
Emotional intelligence is the ability to consider what we are thinking and feeling, your emotions, and to use this in a positive way to communicate, act and empathise with others. You would consider what your emotions, and the same for someone else and then act upon it - taking that information into consideration and being aware of it. This is also know as being mindful - mindfulness.
How is it different from IQ?
IQ is a measure of one’s intelligence or problem solving skills - someones logic and reasoning ability. This is vastly different from EQ which is the consideration of emotion.
Why is it important?
Well since EQ is about an awareness or mindfulness of emotion, it can impact on how we deal with others around us, and even how we deal with ourselves. We may notice certain trends in the way we think or feel and then can adjust and improve upon ourselves accordingly. Perhaps take a break and simply know what we are like, what trends we have - having this individual awareness could be very beneficial in improving our emotional state.
This also will importantly affect the way we deal with others - being able to be aware of how people feel, what they might be thinking could help us in communicating ideas and clarifying issues both personal and professional. By doing so we could create stronger bonds and be able to more smoothly have working relationships, by having an understanding that everyone is different and handles things differently.


You can view and take polls created by the Admin
Providing real time statistics in form of graphs for all Polls


API model information
Error classification
Both integer and string value representations are acceptable as responses for this model, however, for readability purposes, only the string representation will be sent in requests from Voyageone.
| Integer Value | String Value |
|---|---|
| 1000 | Info |
| 2000 | Warning |
| 3000 | SystemFailure |
| 3001 | SystemUnavailable |
| 3002 | RateLimitExceeded |
| 4000 | AuthorizationFailure |
| 4001 | InvalidToken |
| 4002 | InvalidSellerID |
| 5000 | ProductNotFound |
| 5001 | ProductMissingRequiredFields |
| 5002 | ProductFailedDataValidation |
| 5003 | ProductFailedCreate |
| 5004 | ProductFailedUpdate |
| 5100 | ProductMissingCategory |
| 5101 | ProductInvalidCategory |
| 5200 | ProductPendingReview |
| 6000 | OrderNotFound |
| 6001 | InvalidOrder |
| 6002 | InvalidOrderStatus |
| 6100 | ShipmentFailed |
| 6101 | InvalidTrackingNumber |
| 6102 | InvalidShippingCarrier |
| 6103 | InvalidShippingClass |
| 6200 | RefundFailed |
| 6201 | UnsupportedRefundReason |
| 6300 | CancellationFailed |
| 6301 | UnsupportedCancellationReason |
| 7000 | InvalidRequest |
| 7001 | MissingRequiredParameter |
| 7002 | InvalidRequiredParameter |
| 8000 | BatchNotFound |


| Top |
| gboolean | complete | Read / Write |
| gboolean | has-padding | Read / Write |
| GdkPixbuf * | header-image | Read / Write |
| GtkAssistantPageType | page-type | Read / Write |
| GdkPixbuf * | sidebar-image | Read / Write |
| gchar * | title | Read / Write |
GObject ╰── GInitiallyUnowned ╰── GtkWidget ╰── GtkContainer ╰── GtkBin ╰── GtkWindow ╰── GtkAssistant
A GtkAssistant is a widget used to represent a generally complex operation splitted in several steps, guiding the user through its pages and controlling the page flow to collect the necessary data.
The design of GtkAssistant is that it controls what buttons to show and to make sensitive, based on what it knows about the page sequence and the type of each page, in addition to state information like the page completion and committed status.
If you have a case that doesn’t quite fit in GtkAssistants way of handling buttons, you can use the GTK_ASSISTANT_PAGE_CUSTOM page type and handle buttons yourself.
The GtkAssistant implementation of the GtkBuildable interface
exposes the action_area
as internal children with the name
“action_area”.
To add pages to an assistant in GtkBuilder, simply add it as a child to the GtkAssistant object, and set its child properties as necessary.
gint
gtk_assistant_get_current_page (GtkAssistant *assistant
);
Returns the page number of the current page.
The index (starting from 0) of the current
page in the assistant
, or -1 if the assistant
has no pages,
or no current page.
Since: 2.10
void gtk_assistant_set_current_page (GtkAssistant *assistant
,gint page_num
);
Switches the page to page_num
.
Note that this will only be necessary in custom buttons,
as the assistant
flow can be set with
gtk_assistant_set_forward_page_func()
.
assistant |
||
page_num |
index of the page to switch to, starting from 0.
If negative, the last page will be used. If greater
than the number of pages in the |
Since: 2.10
gint
gtk_assistant_get_n_pages (GtkAssistant *assistant
);
Returns the number of pages in the assistant
Since: 2.10
GtkWidget * gtk_assistant_get_nth_page (GtkAssistant *assistant
,gint page_num
);
Returns the child widget contained in page number page_num
.
Since: 2.10
gint gtk_assistant_prepend_page (GtkAssistant *assistant
,GtkWidget *page
);
Prepends a page to the assistant
.
Since: 2.10
gint gtk_assistant_append_page (GtkAssistant *assistant
,GtkWidget *page
);
Appends a page to the assistant
.
Since: 2.10
gint gtk_assistant_insert_page (GtkAssistant *assistant
,GtkWidget *page
,gint position
);
Inserts a page in the assistant
at a given position.
assistant |
||
page |
||
position |
the index (starting at 0) at which to insert the page,
or -1 to append the page to the |
Since: 2.10
void gtk_assistant_remove_page (GtkAssistant *assistant
,gint page_num
);
Removes the page_num
’s page from assistant
.
Since: 3.2
gint (*GtkAssistantPageFunc) (gint current_page
,gpointer data
);
A function used by gtk_assistant_set_forward_page_func()
to know which
is the next page given a current one. It’s called both for computing the
next page when the user presses the “forward” button and for handling
the behavior of the “last” button.
void gtk_assistant_set_forward_page_func (GtkAssistant *assistant
,GtkAssistantPageFunc page_func
,gpointer data
,GDestroyNotify destroy
);
Sets the page forwarding function to be page_func
.
This function will be used to determine what will be
the next page when the user presses the forward button.
Setting page_func
to NULL
will make the assistant to
use the default forward function, which just goes to the
next visible page.
assistant |
||
page_func |
the GtkAssistantPageFunc, or |
[allow-none] |
data |
user data for |
|
destroy |
destroy notifier for |
Since: 2.10
void gtk_assistant_set_page_type (GtkAssistant *assistant
,GtkWidget *page
,GtkAssistantPageType type
);
Sets the page type for page
.
The page type determines the page behavior in the assistant
.
Since: 2.10
GtkAssistantPageType gtk_assistant_get_page_type (GtkAssistant *assistant
,GtkWidget *page
);
Gets the page type of page
.
Since: 2.10
void gtk_assistant_set_page_title (GtkAssistant *assistant
,GtkWidget *page
,const gchar *title
);
Sets a title for page
.
The title is displayed in the header area of the assistant
when page
is the current page.
Since: 2.10
const gchar * gtk_assistant_get_page_title (GtkAssistant *assistant
,GtkWidget *page
);
Gets the title for page
.
Since: 2.10
void gtk_assistant_set_page_header_image (GtkAssistant *assistant
,GtkWidget *page
,GdkPixbuf *pixbuf
);
gtk_assistant_set_page_header_image
has been deprecated since version 3.2 and should not be used in newly-written code.
Since GTK+ 3.2, a header is no longer shown; add your header decoration to the page content instead.
Sets a header image for page
.
Since: 2.10
GdkPixbuf * gtk_assistant_get_page_header_image (GtkAssistant *assistant
,GtkWidget *page
);
gtk_assistant_get_page_header_image
has been deprecated since version 3.2 and should not be used in newly-written code.
Since GTK+ 3.2, a header is no longer shown; add your header decoration to the page content instead.
Gets the header image for page
.
the header image for page
,
or NULL
if there’s no header image for the page.
[transfer none]
Since: 2.10
void gtk_assistant_set_page_side_image (GtkAssistant *assistant
,GtkWidget *page
,GdkPixbuf *pixbuf
);
gtk_assistant_set_page_side_image
has been deprecated since version 3.2 and should not be used in newly-written code.
Since GTK+ 3.2, sidebar images are not shown anymore.
Sets a side image for page
.
This image used to be displayed in the side area of the assistant
when page
is the current page.
Since: 2.10
GdkPixbuf * gtk_assistant_get_page_side_image (GtkAssistant *assistant
,GtkWidget *page
);
gtk_assistant_get_page_side_image
has been deprecated since version 3.2 and should not be used in newly-written code.
Since GTK+ 3.2, sidebar images are not shown anymore.
Gets the side image for page
.
Since: 2.10
void gtk_assistant_set_page_complete (GtkAssistant *assistant
,GtkWidget *page
,gboolean complete
);
Sets whether page
contents are complete.
This will make assistant
update the buttons state
to be able to continue the task.
Since: 2.10
gboolean gtk_assistant_get_page_complete (GtkAssistant *assistant
,GtkWidget *page
);
Gets whether page
is complete.
Since: 2.10
void gtk_assistant_set_page_has_padding (GtkAssistant *assistant
,GtkWidget *page
,gboolean has_padding
);
Sets whether the assistant is adding padding around the page.
Since: 3.18
gboolean gtk_assistant_get_page_has_padding (GtkAssistant *assistant
,GtkWidget *page
);
Gets whether page has padding.
Since: 3.18
void gtk_assistant_add_action_widget (GtkAssistant *assistant
,GtkWidget *child
);
Adds a widget to the action area of a GtkAssistant.
Since: 2.10
void gtk_assistant_remove_action_widget (GtkAssistant *assistant
,GtkWidget *child
);
Removes a widget from the action area of a GtkAssistant.
Since: 2.10
void
gtk_assistant_update_buttons_state (GtkAssistant *assistant
);
Forces assistant
to recompute the buttons state.
GTK+ automatically takes care of this in most situations, e.g. when the user goes to a different page, or when the visibility or completeness of a page changes.
One situation where it can be necessary to call this function is when changing a value on the current page affects the future page flow of the assistant.
Since: 2.10
void
gtk_assistant_commit (GtkAssistant *assistant
);
Erases the visited page history so the back button is not shown on the current page, and removes the cancel button from subsequent pages.
Use this when the information provided up to the current page is hereafter deemed permanent and cannot be modified or undone. For example, showing a progress page to track a long-running, unreversible operation after the user has clicked apply on a confirmation page.
Since: 2.22
void
gtk_assistant_next_page (GtkAssistant *assistant
);
Navigate to the next page.
It is a programming error to call this function when there is no next page.
This function is for use when creating pages of the GTK_ASSISTANT_PAGE_CUSTOM type.
Since: 3.0
void
gtk_assistant_previous_page (GtkAssistant *assistant
);
Navigate to the previous visited page.
It is a programming error to call this function when no previous page is available.
This function is for use when creating pages of the GTK_ASSISTANT_PAGE_CUSTOM type.
Since: 3.0
struct GtkAssistantClass { GtkWindowClass parent_class; void (* prepare) (GtkAssistant *assistant, GtkWidget *page); void (* apply) (GtkAssistant *assistant); void (* close) (GtkAssistant *assistant); void (* cancel) (GtkAssistant *assistant); };
An enum for determining the page role inside the GtkAssistant. It's used to handle buttons sensitivity and visibility.
Note that an assistant needs to end its page flow with a page of type
GTK_ASSISTANT_PAGE_CONFIRM
, GTK_ASSISTANT_PAGE_SUMMARY
or
GTK_ASSISTANT_PAGE_PROGRESS
to be correct.
The Cancel button will only be shown if the page isn’t “committed”.
See gtk_assistant_commit()
for details.
|
The page has regular contents. Both the Back and forward buttons will be shown. |
||
|
The page contains an introduction to the assistant task. Only the Forward button will be shown if there is a next page. |
||
|
The page lets the user confirm or deny the changes. The Back and Apply buttons will be shown. |
||
|
The page informs the user of the changes done. Only the Close button will be shown. |
||
|
Used for tasks that take a long time to complete, blocks the assistant until the page is marked as complete. Only the back button will be shown. |
||
|
Used for when other page types are not
appropriate. No buttons will be shown, and the application must
add its own buttons through |
“use-header-bar”
property“use-header-bar” gint
TRUE
if the assistant uses a GtkHeaderBar for action buttons
instead of the action-area.
For technical reasons, this property is declared as an integer
property, but you should only set it to TRUE
or FALSE
.
 GTK+ uses
this information to control the sensitivity of the navigation buttons.
Flags: Read / Write
Default value: FALSE
Since: 2.10
“has-padding”
child property“has-padding” gboolean
Whether the assistant adds padding around the page.
Flags: Read / Write
Default value: TRUE
“header-image”
child property“header-image” GdkPixbuf *
This image used to be displayed in the page header.
GtkAssistant:header-image
has been deprecated since version 3.2 and should not be used in newly-written code.
Since GTK+ 3.2, a header is no longer shown; add your header decoration to the page content instead.
Flags: Read / Write
Since: 2.10
“page-type”
child property“page-type” GtkAssistantPageType
The type of the assistant page.
Flags: Read / Write
Default value: GTK_ASSISTANT_PAGE_CONTENT
Since: 2.10
“sidebar-image”
child property“sidebar-image” GdkPixbuf *
This image used to be displayed in the 'sidebar'.
GtkAssistant:sidebar-image
has been deprecated since version 3.2 and should not be used in newly-written code.
Since GTK+ 3.2, the sidebar image is no longer shown.
Flags: Read / Write
Since: 2.10
“title”
child property“title” gchar *
The title of the page.
Flags: Read / Write
Default value: NULL
Since: 2.10
“content-padding”
style property“content-padding” gint
Number of pixels around the content.
GtkAssistant:content-padding
has been deprecated since version 3.20 and should not be used in newly-written code.
This style property is ignored.
Flags: Read
Allowed values: >= 0
Default value: 1
“header-padding”
style property“header-padding” gint
Number of pixels around the header.
GtkAssistant:header-padding
has been deprecated since version 3.20 and should not be used in newly-written code.
This style property is ignored.
Flags: Read
Allowed values: >= 0
Default value: 6
“apply”
signalvoid user_function (GtkAssistant *assistant, gpointer user_data)
The ::apply signal is emitted when the apply button is clicked.
The default behavior of the GtkAssistant is to switch to the page after the current page, unless the current page is the last one.
A handler for the ::apply signal should carry out the actions for
which the wizard has collected data. If the action takes a long time
to complete, you might consider putting a page of type
GTK_ASSISTANT_PAGE_PROGRESS
after the confirmation page and handle
this operation within the “prepare” signal of the progress
page.
assistant |
the GtkAssistant |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 2.10
“cancel”
signalvoid user_function (GtkAssistant *assistant, gpointer user_data)
The ::cancel signal is emitted when then the cancel button is clicked.
assistant |
the GtkAssistant |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 2.10
“close”
signalvoid user_function (GtkAssistant *assistant, gpointer user_data)
The ::close signal is emitted either when the close button of
a summary page is clicked, or when the apply button in the last
page in the flow (of type GTK_ASSISTANT_PAGE_CONFIRM
) is clicked.
assistant |
the GtkAssistant |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 2.10
“prepare”
signalvoid user_function (GtkAssistant *assistant, GtkWidget *page, gpointer user_data)
The ::prepare signal is emitted when a new page is set as the assistant's current page, before making the new page visible.
A handler for this signal can do any preparations which are
necessary before showing page
.
assistant |
the GtkAssistant |
|
page |
the current page |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run Last
Since: 2.10


A primary goal of Phillip Crews' marine natural products research is to understand the chemistry of tropical marine sponges. Using bioassay-guided isolation assists us in the discovery of natural products potent against human diseases such as cancer or viruses. Our search for novel active compounds incorporates elements of structure elucidation but there are other dimensions to this research, including questions in the areas of chemical ecology, marine natural products biosynthesis, and the relationship between secondary metabolite chemistry and taxonomy.
Whenever possible, we try to use new concise strategies to elucidate structures, including gradient 2D NMR techniques such as HMBC, HMQC, COSY, TOCSY, NOESY, and 1H-15N HMQC. Utilization of new NMR hardware, 3mm probes and advanced NMR microtubes, nanoprobe, micro-coil flow probe and cryo probe technology on 500 and 600 MHz machines addresses problems of limited amounts of sample. Another goal is to engage in follow-up studies that employ molecular mechanics data combined with these state-of-the-art NMR techniques.


The Out Basket shows the actions that are lined up to be executed the next time Ameol blinks.
This is a Hot Spot image. Move your mouse pointer over the image
and when the mouse pointer changes to the shape of a hand click
the left mouse button once for extra help.
You can delete the currently highlighted item by clicking the Delete button and you can edit messages already in the Out Basket by clicking the Edit Button.
The Hold button will keep the currently highlighted item in the Out Basket so that it is not executed during the next blink. When an item is held, the caption on this button will change to Release. Clicking the button when its in this state will return the currently highlighted item to normal status so that it will be executed during the next blink.
The Keep button will execute the currently highlighted item during the next blink but will not remove it when the blink has been completed. This means that a kept item will be executed every time Ameol blinks. Like the Hold button, the caption of the button changes to reflect the status of the currently highlighted item. In this case the caption changes to Unkeep. Clicking the button in this state will return the currently highlighted item to normal status so that it will be removed after the next blink.
If an item could not be actioned (for example, a news message could not be posted because the news server was not available) a red exclamation mark ( ! ) will be displayed next to it. Ameol will attempt to action the item on following blinks and if successful will remove the exclamation mark from from the item. If the exclamation mark remains next to the item for some time please contact CIX Support.
You can close the Out Basket by using the Close button. To open the Out Basket again select the View Menu, then the Out Basket item.


{% extends 'layout.html' %} {% block content %}
Please answer the following questions based on the news website you just saw:


Home
GPS Elevation
Enrich your GPS data!
Upload a file with Latitude and Longitude, and you'll receive the same file with elevation.
@helper.form(action = routes.Application.upload, 'id -> "file-form", 'enctype -> "multipart/form-data", 'class -> "form-inline") {
Scale (digits)
}
Current specs
First line is ignored
First column is Latitude, second is Longitude
Latitude and longitude are separated by space
Google Maps API has a limited number of requests
Precision of float is customizable (default is 4 digits). Careful, API quota consumption depends en it.
Unique points are returned (duplicates ignored)
Comma separated values are returned 'Latitude;Longitude;Elevation;Prevision'
Download a
sample file


本书pdf是 文字版，书签良好。
本书上下卷一千多页，上涉及到有机化学的内容，下涉及到医药学的一点内容，但主体还是在生物化学这边。
Introduction
Fundamental Stereochemical Concepts and Nomenclatures
Important Biological Events Occurring in Plants
Natural Products Chemistry: A General Treatment
Biosynthesis of Terpenoids: The Oldest Natural Products
Monoterpenoids
Sesquiterpenoids
Diterpenoids
Sesterterpenoids
Triterpenes
Steroids: Cholesterol and Other Phytosterols
Carotenoids
Shikimic Acid Pathway
Polyketide Pathway. Biosynthesis of Diverse Classes of Aromatic Compounds
Alkaloids. General Introduction
Hygrine, Hygroline, and Cuscohygrine
Coniine, Conhydrine, and Pseudoconhydrine
Nicotine
Atropine
Ephedrine and Pseudoephedrine
Pilocarpine and Isopilocarpine
Papaverine
Morphine. Codeine. Thebaine
Colchicine
Quinine. Cinchona Alkaloids
Reserpine
Strychnine
Dimeric Indole Alkaloids. Vinblastine (Vincaleukoblastine), Vincristine (Leurocristine), and Their Derivatives
Camptothecin, A Novel Pyrrolo[3,4-b]quinoline Alkaloid
Some More Alkaloids Having Diverse Skeletal Patterns
Important Outcomes of Chemical Studies on Natural Products
Chiral Recognition in Biological Systems and Natural Chiral Auxiliaries
Natural Products in the Parlor of Pharmaceuticals
Organic Phytonutrients, Vitamins, and Antioxidants


BitmapDataLoadOptions class
class BitmapDataLoadOptions { /** * The application provides *png* files for lossless images. */ bool png; /** * The application provides *jpg* files for lossy images. */ bool jpg; /** * The application provides *webp* files for lossless and lossy images. * * If *webp* is supported, the loader will automatically switch from *png* * and *jpg* files to this more efficient file format. */ bool webp; /** * If the file name contains<EMAIL_ADDRESS>it will be replaced by<EMAIL_ADDRESS>when the * context is high density. */ bool autoHiDpi; BitmapDataLoadOptions({ this.png: true, this.jpg: true, this.webp: false, this.autoHiDpi: true }); }
Constructors
new BitmapDataLoadOptions({bool png: true, bool jpg: true, bool webp: false, bool autoHiDpi: true}) #
Properties
bool autoHiDpi #
If the file name contains<EMAIL_ADDRESS>it will be replaced by<EMAIL_ADDRESS>when the context is high density.
bool autoHiDpi
bool jpg #
The application provides jpg files for lossy images.
bool jpg
bool png #
The application provides png files for lossless images.
bool png
bool webp #
The application provides webp files for lossless and lossy images.
If webp is supported, the loader will automatically switch from png and jpg files to this more efficient file format.
bool webp


Electronic structure of and chemical bonding in MgSi 5: a) Total DOS and atomic contributions of Mg and Si. b) Distribution of partial ELI‐D in the (200) plane and isosurface with pELI‐D=0.077 calculated for the energy window −0.62 eV≤ E≤ E F. c) Distribution of partial ELI‐D in the (200) plane and isosurface with pELI‐D=0.166 for the energy range −1.56 eV≤ E≤−0.62 eV.


SARAH KWAK
HOME |
ABOUT |
Resume |
CONTACT
If you want to contact either me or Brian, here is how
e-mail:
<EMAIL_ADDRESS>phone: 1-650-381-9918
Follow @PlentyofTreats
View Sarah Kwak's profile
foxyform


We are currently recuiting at TH9 TH10 and TH11 levels. Players should meet the following requirements.
If you think u have what it takes [Discord Apply button].
We are actively looking for clans to arrange wars with, contact us [insert discord link here] on discord to set something up.


--- layout: post title: 9 Year Old Developer date: 2012-04-20 07:43:00 -05:00 comments: true categories: posterous_id: 124415512 ---
I just found out about this story this morning, and it warmed up my day.
It supports my belief that we're all born with the yearning to create stuff.Cheers to the supportive father that didn't minimize his efforts or force him to do what others expect of him.If you're looking for a warm, heart-rending story for today, look no further than how Caine Monroy became the latest YouTube viral sensation, with more than 2.4 million views and counting since it was posted last week.
Thanks to a loyal customer, Nirvan Mullick (pictured with Monroy), the schoolboy now has a $150,000 scholarship fund and fans all over the world. And the story holds lessons for budding online entrepreneurs, too. How did all this happen?
Last year, Monroy was just another nine-year-old kid from East Los Angeles trying to figure out what to do with his summer, when one day he went to his dad's auto parts store. The store was largely devoid of customers, as Dad does most of his business online. Caine asked if he could play with the cardboard boxes that the parts came in, and before you could say "Zoltar," he had constructed his own cardboard replica of several arcade-style games, such as miniature pop-shot basketball and ring toss. He then proceeded to sit in the store and wait for customers to play at his arcade.
There weren't many since foot traffic to the store was sparse. One day, Mullick happened to stop by and became entranced. He bought Caine's premium "Fun Pass" and started coming back for more games. He thought about a way to market the arcade and put together a flash mob meet-up at the auto parts store, along with a short 10-minute documentary video. The rest is thanks to the Internet and a lot of people. You can watch the movie here:
In the video, you'll note that Caine has implemented a sophisticated algorithm to ensure that his "Fun Pass" tickets are authentic, using the square root function of a pocket calculator. You've got to hand it to the kid. He has plenty of pluck.
Mullick started a scholarship fund, which has already topped $175,000 and is still growing. And that doesn't include a matching grant from the Goldhirsh Foundation. Caine also has a Facebook fan page with 100,000 fans and a Twitter account with more than 6,000 followers. To give his arcade an element of authenticity, Caine made his own special logo T-shirt and is now selling it on the site. The movie even has a theme song that you can download from iTunes (and it's another way to support the fund).
Plenty of media outlets have given Caine coverage, including today's New York Times and dozens of TV stations. Forbes did a story earlier this week that details nine factors of Caine and Mullick's success that other entrepreneurs should review. TJ McCue writes, "There is a certain allure in American entrepreneur circles for turning waste in[to] wonder, of finding a diamond in the rough, so to speak." Another Forbes columnist thinks Caine will be a billionaire in 30 years. Certainly, his star is rising. Another meme is born.
But more than a meme is what startups can learn from this experience: Just because you only have one customer doesn't mean you aren't in business, and you should treat every customer as carefully as Caine did. The care he took in realizing his vision is extraordinary, especially for someone so young. And understanding the power of just one person to leverage various social media is also key.
So if you are an entrepreneur looking for inspiration today, check out the short video and read up on Caine's Arcade. It should get you thinking on how you too can create something from your own passion, even if you are just nine years old.
As the lyrics to the theme song say, "It's the best cardboard arcade that has ever been made." And that is something to which we can all aspire.


Vice Hierarch Casca:
Only male Kamael who have been Troopers may acquire the skills necessary to become a Berserker, which allow them to defeat their enemies and absorb their spirit to increase their own speed and power.
The heritage of the Berserker stretches far back to the misty origins of our race itself, to the great hero Harkilgamed, whose mighty sword sliced through the fabric of the heavens themselves.
Female Kamael simply do not possess the innate physical strength and unique magic of their male counterparts, which is essential for learning Berserker skills.
Back.


Back to demo list.
Next demo
Demo 0. This is based on my blog entry.
The TBC code is as follows.
loop( await( click( b0 ) > out("0") ) > await( click( b1a ) > out("1A") , click( b1b ) > out("1B") ) > await( click( b2 ) > out("2" ) )
The haxe code is here.


proxy-addr
Determine address of proxied request
Install
This is a Node.js module available through the
npm registry. Installation is done using the
npm install
command:
$ npm install proxy-addr
API
var proxyaddr = require('proxy-addr')
proxyaddr(req, trust)
Return the address of the request, using the given trust
parameter.
The trust
argument is a function that returns true
if you trust
the address, false
if you don’t. The closest untrusted address is
returned.
proxyaddr(req, function (addr) { return addr === '<IP_ADDRESS>' })
proxyaddr(req, function (addr, i) { return i < 1 })
The trust
arugment may also be a single IP address string or an
array of trusted addresses, as plain IP addresses, CIDR-formatted
strings, or IP/netmask strings.
proxyaddr(req, '<IP_ADDRESS>')
proxyaddr(req, ['<IP_ADDRESS>/8', '<IP_ADDRESS>/8'])
proxyaddr(req, ['<IP_ADDRESS>/<IP_ADDRESS>', '<IP_ADDRESS>/<IP_ADDRESS>'])
This module also supports IPv6. Your IPv6 addresses will be normalized
automatically (i.e. fe80::00ed:1
equals fe80:0:0:0:0:0:ed:1
).
proxyaddr(req, '::1')
proxyaddr(req, ['::1/128', 'fe80::/10'])
This module will automatically work with IPv4-mapped IPv6 addresses
as well to support node.js in IPv6-only mode. This means that you do
not have to specify both ::ffff:a00:1
and <IP_ADDRESS>
.
As a convenience, this module also takes certain pre-defined names in addition to IP addresses, which expand into IP addresses:
proxyaddr(req, 'loopback')
proxyaddr(req, ['loopback', 'fc00:ac:1ab5:fff::1/64'])
loopback
: IPv4 and IPv6 loopback addresses (like::1
and<IP_ADDRESS>
).linklocal
: IPv4 and IPv6 link-local addresses (likefe80::1:1:1:1
and<IP_ADDRESS>
).uniquelocal
: IPv4 private addresses and IPv6 unique-local addresses (likefc00:ac:1ab5:fff::1
and<IP_ADDRESS>
).
When trust
is specified as a function, it will be called for each
address to determine if it is a trusted address. The function is
given two arguments: addr
and i
, where addr
is a string of
the address to check and i
is a number that represents the distance
from the socket address.
proxyaddr.all(req, [trust])
Return all the addresses of the request, optionally stopping at the
first untrusted. This array is ordered from closest to furthest
(i.e. arr[0] === req.connection.remoteAddress
).
proxyaddr.all(req)
The optional trust
argument takes the same arguments as trust
does in proxyaddr(req, trust)
.
proxyaddr.all(req, 'loopback')
proxyaddr.compile(val)
Compiles argument val
into a trust
function. This function takes
the same arguments as trust
does in proxyaddr(req, trust)
and
returns a function suitable for proxyaddr(req, trust)
.
var trust = proxyaddr.compile('loopback')
var addr = proxyaddr(req, trust)
This function is meant to be optimized for use against every request.
It is recommend to compile a trust function up-front for the trusted
configuration and pass that to proxyaddr(req, trust)
for each request.
Testing
$ npm test
Benchmarks
$ npm run-script bench


Description
Diamondback is a package which provides Digital Signal Processing ( DSP ) solutions, and complements AI frameworks, by defining components which filter, model, and transform data.
Diamondback complements Artificial Intelligence ( AI ) frameworks, by defining components which filter, model, and transform data into forms which are useful in feature extraction and pattern recognition.
Diamondback also supports applications including cancellation, identification, optimization, probabilistic modeling, rate adaptation, and serialization.
Details
Data collections are consistently expressed in native types, including tuples, sets, lists, and dictionaries, with vector and matrix types expressed in numpy arrays. Complex or real types are supported as appropriate.
Diamondback is defined in subpackages commons, filters, models, and transforms.
commons
Log singleton instance which formats and writes log entries with a specified level and stream using the loguru package. Log entries contain an ISO-8601 datetime and level. Log uses lazy initialization to coexist with loguru. Dynamic stream redirection and level specification are supported.
RestClient instances define a client for simple REST service requests using the requests package. An API and an elective dictionary of parameter strings are encoded to build a URL, elective binary or JSON data are defined in the body of a request, and a requests response containing JSON, text, or binary data is returned. Proxy, timeout, and URL definition are supported.
Serial singleton instance which encodes and decodes an instance or collection in BSON or JSON, and generates SHA3-256 codes, using the jsonpickle package. An instance may be an object or a collection, referenced by abstract or concrete types, and the instance will be correctly encoded and decoded, without custom encoding definitions.
filters
ComplexBandPassFilter instances adaptively extract or reject signals at a normalized frequency of interest, and may be employed to dynamically track magnitude and phase or demodulate signals.
ComplexExponentialFilter instances synthesize complex exponential signals at normalized frequencies of interest with contiguous phase.
ComplexFrequencyFilter instances adaptively discriminate and estimate a normalized frequency of a signal.
DerivativeFilter instances estimate discrete derivative approximations at several filter orders.
FirFilter instances realize discrete difference equations of Finite Impulse Response ( FIR ) form. Instances are defined based on style, normalized frequency, order, cascade count, and complement, or forward coefficients. Root extraction, group delay, and frequency response evaluation are defined.
GoertzelFilter instances efficiently evaluate a Discrete Fourier Transform ( DFT ) at a normalized frequency, based on a window filter and normalized frequency.
IirFilter instances realize discrete difference equations of Infinite Impulse Response ( IIR ) form. Instances are defined based on style, normalized frequency, order, cascade count, and complement, or recursive and forward coefficients. Root extraction, group delay, and frequency response evaluation are defined.
IntegralFilter instances estimate discrete integral approximations at several filter orders.
PidFilter instances realize discrete difference equations of Proportional Integral Derivative ( PID ) form.
PolynomialRateFilter instances approximate a signal evaluated at an effective frequency equal to the product of the normalized frequency and a rate greater than zero, supporting decimation and interpolation through localized polynomial approximation with no group delay.
PolyphaseRateFilter instances approximate a signal evaluated at an effective frequency equal to the product of the normalized frequency and a rate greater than zero, supporting decimation and interpolation through definition and application of a polyphase filter bank, a sequence of low pass filters with a common frequency response and a fractional sample difference in group delay. An appropriate stride is determined to realize the specified effective frequency without bias and with group delay based on order.
RankFilter instances define nonlinear morphological operators, which define functionality based on rank and order, including dilation, median, and erosion, and may be combined in sequences to support close and open.
WindowFilter instances realize discrete window functions useful in Fourier analysis, based on style, order, and normalization.
models
DiversityModel instances select and retain a state extracted to maximize the minimum distance between state members based on style and order. An opportunistic unsupervised learning model typically improves condition and numerical accuracy and reduces storage relative to alternative approaches including generalized linear inverse.
GaussianModel is a supervised learning probabilistic model instance which uses maximum likelihood estimation and regularization to maximize posterior probability and classify an incident signal. Learns one distribution instance per class.
GaussianMixtureModel is a semi-supervised learning probabilistic model instance which uses maximum likelihood estimation, regularization, and expectation maximization to maximize posterior probability and classify an incident signal. Learns model instances of a specified order per class, where intra-class models capture mixture distributions.
transforms
ComplexTransform is a singleton instance which converts a three-phase real signal to a complex signal, or a complex signal to a three-phase real signal, in equivalent and reversible representations, based on a neutral condition.
FourierTransform is a singleton instance which converts a real or complex discrete-time signal to a complex discrete-frequency signal, or a complex discrete-frequency signal to a real or complex discrete-time signal, in equivalent and reversible representations, based on a window filter and inverse.
PowerSpectrumTransform is a singleton instance which converts a real or complex discrete-time signal to a real discrete-frequency signal which estimates a mean power density of the signal, based on a window filter, index, and spectrogram. A spectrogram constructs a time frequency representation.
WaveletTransform instances realize a temporal spatial frequency transformation through defninition and application of analysis and synthesis filters with complementary frequency responses, combined with downsampling and upsampling operations, in equivalent and reversible representations. Instances are defined based on style and order.
ZTransform is a singleton instance which converts continuous s-domain to discrete z-domain difference equations, based on a normalized frequency and application of bilinear or impulse invariant methods.
Dependencies
Diamondback depends upon external packages :
Diamondback elective documentation, test, and visualization functionality depends upon additional external packages :
Installation
Diamondback is a public repository hosted at PyPI and GitHub.
pip install diamondback
or
pip install git+https://github.com/larryturner/diamondback.git
Demonstration
A jupyter notebook defines cells to create and exercise diamondback components. The notebook serves as a tool for visualization, validation, and demonstration of diamondback capabilities.
A jupyter notebook may be run on a remote server without installation with Binder, which dynamically builds and deploys a docker container from a GitHub repository, or installed from GitHub and run on a local system. Binder may not be operational, as package dependencies on that service are dated.
Remote
Local
git clone https://github.com/larryturner/diamondback.git
cd diamondback
pip install --requirement requirements.txt
jupyter notebook .\jupyter\diamondback.ipynb
Restart the kernel, as the first cell contains common definitions, find cells which exercise components of interest, and manipulate widgets to exercise and visualize functionality.
Tests
A test solution is provided to exercise and verify components, pytest is used to execute unit and integration tests.
pytest --capture=no --verbose
Documentation
Diamondback documentation is available on GitHub pages.


{% extends "base.html" %} {% block content %}
Last updated: July 27th 2020
I also use Google Adsense and Google Analytics, which collects various data on you too. Via Google Analytics, I have opted for the lowest user and event data retention available on their platform, which is 14 months. More info on data retention: https://support.google.com/analytics/answer/7667196?authuser=0.
Also, via google analytics, IPs are anonymized.
Within Google Analytics, I have set the data retention to 14 months, and to reset on new activity. So, data stored via Google Analytics is removed 14 months automatically after you *stop* using the website. If you continue to use the website, then the data's expiration renews to be the CURRENT time, plus 14 months.
Resuming the original privacy policy:
MaroonPower ("us", "we", or "our") operates the https:/www.maroonpower.com website (the "Service").
This page informs you of our policies regarding the collection, use and disclosure of Personal Information when you use our Service.
We will not use or share your information with anyone except as described in this Privacy Policy.
We use your Personal Information for providing and improving the Service. By using the Service, you agree to the collection and use of information in accordance with this policy. Unless otherwise defined in this Privacy Policy, terms used in this Privacy Policy have the same meanings as in our Terms and Conditions, accessible at https://www.maroonpower.com/terms
Information Collection And Use
While using our Service, we may ask you to provide us with certain personally identifiable information that can be used to contact or identify you. Personally identifiable information may include, but is not limited to, your email address, name ("Personal Information").
We collect this information for the purpose of providing the Service, identifying and communicating with you, responding to your requests/inquiries, servicing your purchase orders, and improving our services.
Log Data
We collect information that your browser sends whenever you visit our Service ("Log Data"). This Log Data may include information such as your computer's Internet Protocol ("IP") address, browser type, browser version, the pages of our Service that you visit, the time and date of your visit, the time spent on those pages and other statistics.
In addition, we may use third party services such as Google Analytics that collect, monitor and analyze this type of information in order to increase our Service's functionality. These third party service providers have their own privacy policies addressing how they use such information.
Cookies
Cookies are files with a small amount of data, which may include an anonymous unique identifier. Cookies are sent to your browser from a web site and transferred to your device. We use cookies to collect information in order to improve our services for you.
You can instruct your browser to refuse all cookies or to indicate when a cookie is being sent. The Help feature on most browsers provide information on how to accept cookies, disable cookies or to notify you when receiving a new cookie.
If you do not accept cookies, you may not be able to use some features of our Service and we recommend that you leave them turned on.
DoubleClick Cookie
Google, as a third party vendor, uses cookies to serve ads on our Service. Google's use of the DoubleClick cookie enables it and its partners to serve ads to our users based on their visit to our Service or other web sites on the Internet.
You may opt out of the use of the DoubleClick Cookie for interest-based advertising by visiting the Google Ads Settings web page.
Do Not Track Disclosure
We do not support Do Not Track ("DNT"). Do Not Track is a preference you can set in your web browser to inform websites that you do not want to be tracked.
You can enable or disable Do Not Track by visiting the Preferences or Settings page of your web browser.
Service Providers
We may employ third party companies and individuals to facilitate our Service, to provide the Service on our behalf, to perform Service-related services and/or to assist us in analyzing how our Service is used.
These third parties have access to your Personal Information only to perform specific tasks on our behalf and are obligated not to disclose or use your information for any other purpose.
Communications
We may use your Personal Information to contact you with newsletters, marketing or promotional materials and other information that may be of interest to you. You may opt out of receiving any, or all, of these communications from us by contacting us.
Compliance With Laws
We will disclose your Personal Information where required to do so by law or subpoena or if we believe that such action is necessary to comply with the law and the reasonable requests of law enforcement or to protect the security or integrity of our Service.
Security
The security of your Personal Information is important to us, and we strive to implement and maintain reasonable, commercially acceptable security procedures and practices appropriate to the nature of the information we store, in order to protect it from unauthorized access, destruction, use, modification, or disclosure.
However, please be aware that no method of transmission over the internet, or method of electronic storage is 100% secure and we are unable to guarantee the absolute security of the Personal Information we have collected from you.
International Transfer
Your information, including Personal Information, may be transferred to - and maintained on - computers located outside of your state, province, country or other governmental jurisdiction where the data protection laws may differ than those from your jurisdiction.
If you are located outside United States and choose to provide information to us, please note that we transfer the information, including Personal Information, to United States and process it there.
Your consent to this Privacy Policy followed by your submission of such information represents your agreement to that transfer.
Links To Other Sites
Our Service may contain links to other sites that are not operated by us. If you click on a third party link, you will be directed to that third party's site. We strongly advise you to review the Privacy Policy of every site you visit.
We have no control over, and assume no responsibility for the content, privacy policies or practices of any third party sites or services.
Children's Privacy
Only persons age 18 or older have permission to access our Service, or if a legal guardian or parent of the user gives consent. Our Service does not address anyone under the age of 13 ("Children").
We do not knowingly collect personally identifiable information from children under 13. If you are a parent or guardian and you learn that your Children have provided us with Personal Information, please contact us. If we become aware that we have collected Personal Information from a children under age 13 without verification of parental consent, we take steps to remove that information from our servers.
Changes To This Privacy Policy
This Privacy Policy is effective as of January 22, 2015 and will remain in effect except with respect to any changes in its provisions in the future, which will be in effect immediately after being posted on this page.
We reserve the right to update or change our Privacy Policy at any time and you should check this Privacy Policy periodically. Your continued use of the Service after we post any modifications to the Privacy Policy on this page will constitute your acknowledgment of the modifications and your consent to abide and be bound by the modified Privacy Policy.
If we make any material changes to this Privacy Policy, we will notify you either through the email address you have provided us, or by placing a prominent notice on our website.
Contact Us
If you have any questions about this Privacy Policy, please contact yaokun@vt.edu.