|
Assimp
5.0.1, master @ cd42b955
|
Represents a three-dimensional vector. More...
Public Member Functions | |
| aiVector3t () AI_NO_EXCEPT | |
| aiVector3t (const aiVector3t &o)=default | |
| aiVector3t (TReal _x, TReal _y, TReal _z) | |
| aiVector3t (TReal _xyz) | |
| bool | Equal (const aiVector3t &other, TReal epsilon=1e-6) const |
| TReal | Length () const |
| Get the length of the vector. More... | |
| aiVector3t & | Normalize () |
| Normalize the vector. More... | |
| aiVector3t & | NormalizeSafe () |
| Normalize the vector with extra check for zero vectors. More... | |
| template<typename TOther > | |
| operator aiVector3t< TOther > () const | |
| bool | operator!= (const aiVector3t &other) const |
| aiVector3t & | operator*= (const aiMatrix3x3t< TReal > &mat) |
| aiVector3t & | operator*= (const aiMatrix4x4t< TReal > &mat) |
| const aiVector3t & | operator*= (TReal f) |
| const aiVector3t & | operator+= (const aiVector3t &o) |
| const aiVector3t & | operator-= (const aiVector3t &o) |
| const aiVector3t & | operator/= (TReal f) |
| bool | operator< (const aiVector3t &other) const |
| bool | operator== (const aiVector3t &other) const |
| TReal & | operator[] (unsigned int i) |
| TReal | operator[] (unsigned int i) const |
| void | Set (TReal pX, TReal pY, TReal pZ) |
| Set the components of a vector. More... | |
| TReal | SquareLength () const |
| Get the squared length of the vector. More... | |
| const aiVector3t | SymMul (const aiVector3t &o) |
| Componentwise multiplication of two vectors. More... | |
Public Attributes | |
| TReal | x |
| TReal | y |
| TReal | z |
Represents a three-dimensional vector.
|
inline |
|
inline |
|
inlineexplicit |
|
default |
| AI_FORCE_INLINE bool aiVector3t< TReal >::Equal | ( | const aiVector3t< TReal > & | other, |
| TReal | epsilon = 1e-6 |
||
| ) | const |
| AI_FORCE_INLINE TReal aiVector3t< TReal >::Length |
Get the length of the vector.
| AI_FORCE_INLINE aiVector3t< TReal > & aiVector3t< TReal >::Normalize |
Normalize the vector.
| AI_FORCE_INLINE aiVector3t< TReal > & aiVector3t< TReal >::NormalizeSafe |
Normalize the vector with extra check for zero vectors.
| aiVector3t< TReal >::operator aiVector3t< TOther > |
| AI_FORCE_INLINE bool aiVector3t< TReal >::operator!= | ( | const aiVector3t< TReal > & | other | ) | const |
| AI_FORCE_INLINE aiVector3t< TReal > & aiVector3t< TReal >::operator*= | ( | const aiMatrix3x3t< TReal > & | mat | ) |
| AI_FORCE_INLINE aiVector3t< TReal > & aiVector3t< TReal >::operator*= | ( | const aiMatrix4x4t< TReal > & | mat | ) |
| AI_FORCE_INLINE const aiVector3t< TReal > & aiVector3t< TReal >::operator*= | ( | TReal | f | ) |
| AI_FORCE_INLINE const aiVector3t< TReal > & aiVector3t< TReal >::operator+= | ( | const aiVector3t< TReal > & | o | ) |
| AI_FORCE_INLINE const aiVector3t< TReal > & aiVector3t< TReal >::operator-= | ( | const aiVector3t< TReal > & | o | ) |
| AI_FORCE_INLINE const aiVector3t< TReal > & aiVector3t< TReal >::operator/= | ( | TReal | f | ) |
| AI_FORCE_INLINE bool aiVector3t< TReal >::operator< | ( | const aiVector3t< TReal > & | other | ) | const |
| AI_FORCE_INLINE bool aiVector3t< TReal >::operator== | ( | const aiVector3t< TReal > & | other | ) | const |
| AI_FORCE_INLINE TReal & aiVector3t< TReal >::operator[] | ( | unsigned int | i | ) |
| AI_FORCE_INLINE TReal aiVector3t< TReal >::operator[] | ( | unsigned int | i | ) | const |
| AI_FORCE_INLINE void aiVector3t< TReal >::Set | ( | TReal | pX, |
| TReal | pY, | ||
| TReal | pZ | ||
| ) |
Set the components of a vector.
| pX | X component |
| pY | Y component |
| pZ | Z component |
| AI_FORCE_INLINE TReal aiVector3t< TReal >::SquareLength |
Get the squared length of the vector.
| AI_FORCE_INLINE const aiVector3t< TReal > aiVector3t< TReal >::SymMul | ( | const aiVector3t< TReal > & | o | ) |
Componentwise multiplication of two vectors.
Note that vec*vec yields the dot product.
| o | Second factor |
| TReal aiVector3t< TReal >::x |
| TReal aiVector3t< TReal >::y |
| TReal aiVector3t< TReal >::z |


I have a bit of a sweet tooth, so I try to bake sugar-free and no carb goods these days. And while experimenting, sometimes things work out :)
I love this recipe because it is easy, tasty, and it can be made in the microwave (I hate turning on the oven in summer!). It makes for quite fudgy and chocolate-y brownies, very low-carb, as well as dairy and gluten-free. And I love the crunch from the walnuts :)
For vegans or those who don't eat eggs, you can probably use a flax egg instead (1 tbsp flax meal with 2 tbsp of water) and add some psyllium husk powder (otherwise, the coconut flour with the flax might not form a proper batter).
The final flavor might change slightly depending on the protein powder you use, but if you like how your protein powder tastes, you will love these!
- 30 g coconut flour (1/4 cup)
- 45 g of your favorite chocolate flavored protein powder
- 15 g cocoa powder
- 1 tsp baking soda
- 1/4 tsp salt
- Optional: 1/4 tsp of coffee granules, or cinnamon
- Optional: stevia or erythritol; I recommend trying the batter and adjusting to taste
- 1 tbsp apple cider vinegar
- 1/4 cup coconut oil (you can use butter instead)
- 1 egg
- Vanilla extract
- 30 g chopped walnuts (optional, but... why wouldn't you use them!?)
- 3/4 cup of water (to start with; you will have to add more later)
* **Process**
1. Mix the dry ingredients in a bowl (first 7 ingredients) and the wet ingredients in a different one (all the others). Leave the walnuts on the side for now.
2. Add the wet ingredients into the dry and mix. Then, add water little by little to adjust the texture, until you get a batter similar to the one for a spongecake. You will probably need 1/2 extra cup of water.
3. Add the chopped walnuts into your batter and mix.
4. Pour the batter into a greased baking mold.
5. Bake at 180C for 25 minutes or in the microwave at 800W for about 4 minutes, or until a toothpick inserted in the middle comes out clean. The microwave cooking time varies a lot from one microwave to another, so keep a close eye on it to avoid overcooking and ending up with hard, dry brownies.


RT @FakeAPStylebook: Do not be afraid to use exclamation points in your writing. They can sense fear. #GreatestHits
10/2/2011, 1:18:37 PM
Favs: 0
Retweets: 0
link--- layout: tweet ---
RT @FakeAPStylebook: Do not be afraid to use exclamation points in your writing. They can sense fear. #GreatestHits
10/2/2011, 1:18:37 PM
Favs: 0
Retweets: 0
link


These methods serve as identifiers for special types of wallets.
All methods below this line are convenience methods that serve as proxies to the underlying coin implementation.
The purpose of these methods is to reduce duplication and prevent consumers from implementing convoluted custom implementations that deviate from how things should be used.
Any changes in how things need to be handled by consumers should be made in this package!
These methods serve as helpers to map wallet identifiers to various wallet instances that expose information like an avatar or balances.
These methods allow to switch out the underlying implementation of certain things like the coin.
These methods serve as helpers to keep the wallet data updated.
These methods serve as helpers to interact with the underlying coin.
Generated using TypeDoc
These methods serve as getters to the underlying data and dependencies.


Iranian president: Tehran will start injecting uranium gas into 1,044
TEHRAN, Iran (AP) - Iranian president: Tehran will start injecting uranium gas into 1,044 centrifuges in latest step away from nuclear deal.
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC.
Please read our comment policy before commenting.


TLDR: Mining with idles CPU power of rented VPS which almost cover 50% of the VPS cost while running a masternode on it is the most pratical lifehack I’ve learnt recently. Do not waste the potential of any idling resources.
太长没读：把 VPS 上闲置的 CPU 算力投入到挖矿中竟然带来了意想不到的收益，加上运行超级节点的收益应该就胜过了 VPS 的月费，而我却花了一个月多才领悟到这个道理。任何闲置的资源都很可能是被遗忘的钞票机啊！
Making use of idle CPU power
I’m running a masternode of SmartCash project on a VPS from the Privex. The Steem-accepting VPS has been awesome, 99% uptime and least hassle of setting up. But one day when I came across the CPU-mining concept, I realised this VPS could makes some profit using its idle CPU power.
I chose the Intense coin which is running a proof-of-work Cryptonight mining algorithm. Let’s do the breakdown of how this mining works on the VPS:
- Zero electricity fee as the VPS is already running for the masternode.
- Could have makes some extra bucks to cover the server fee($8 per month).
- Make full use of the idle hashing power.
Proof of concept
Out of the Prived V1 plan with dual-core CPU, the Intense coin mining on the VPS has been running for a while and this is the hashing performance graph. Let’s take 150 H/s as average hashrate for the next calculation.
Using this calculator, 150 hashrate with 0 power cost and 1% pool fees gets to mine coins equivalent to $0.14 a day, $0.93 a week and $4.34 a month.
Out of the monthly $8 cost for the VPS, making full use of its CPU hashing power would make more than half the money back already without taking the real SmartCash masternode profit into account. I was quite blown away the moment I found out the posibility to actually gain more real money out of the VPS investment.
Don’t stop being creative with idle resources
The CPU power was left idling for quite a long while until I started to step into the amazing mining field. Any idle resources could be another wasted money printing machine but the catch is you should know how to capitalize the full use of it in the right way. In my VPS, running a masternode and mining via CPU hashing power is not yet the best to gain most value back from the cost. More masternodes could be simply implemented in the same VPS as they normally consume least CPU and network bandwidth.
Keep learning and experiment, the tech world is awesome!
Posted from my blog with SteemPress : https://fr3eze.vornix.blog/mining-with-the-masternode-vps-brings-in-extra-cash/
This page is synchronized from the post: ‘Mining with the masternode VPS brings in extra cash!’


Hey, my name is Mario, and there's little I find more exciting than bears! I've spent most of my young life traveling to the edges of Earth to take videos of these wonderful creatures.
Family, Country, Bears and Bullshit
Mario T.


--- layout: default title: MMME'17 - Paper Submission meta: The paper submission details and instructions for MMME keyword: mining conference, material conference, mineral processing conference, metal processing conference, solidification conference, metallurgical conference, casting conference, composite materials conference, corosion, metal processing, phase diagram, surface phenomena, heat transfer, fluid flow, fluid dynamics, fluid mechanics, mining, material, mineral processing, metal processing, solidification, metallurgical, casting, composite materials, corosion conference, metal processing conference, phase diagram conference, surface phenomena conference, heat transfer conference, fluid flow conference, fluid dynamics conference, fluid mechanics conference ---
MMME'17 is now accepting papers on the following topics through its OpenConf system. If you have a paper on an additional topic, please write an email to<EMAIL_ADDRESS>The current topics include but are not limited to:
Manuscripts are invited for the 4th International Conference on Mining, Material, and Metallurgical Engineering (MMME'17) on topics lying within the scope of the conference. All contributions must be original and should not have been published elsewhere.
Three types of manuscripts could be published in the conference proceedings:
You may choose to submit any of the above based on the the weight of the contributions in your manuscript.
Please note that a .docx template is available to guide the authors in formatting their papers. All papers (including extended abstracts) must comply with the template.
You may find the conference template(s) for MMME'17 below:
Short and Full Papers' Template:
Extended Abstracts Template:
*If you submit your camera-ready paper via LaTeX, we ask that you kindly consider the following:
Papers should be prepared in English and carefully checked for correct grammar. Figures should be of high quality. To ensure high scientific quality, all papers will be reviewed by the Scientific Committee Members. All papers must be submitted in electronic form using the web site of the conference.
Once the reviewing process is complete, the contact author of each paper will be notified of the result by e-mail. The authors are required to follow the reviews in order to improve their paper before their final submission.
All accepted extended abstracts, short, and full papers will be published in the proceedings, under an ISBN reference in a USB drive. The online version of the proceedings will also be published under an ISSN reference and each paper in the proceedings will be assigned unique DOIs by CrossRef. Selected papers will be published in a Special Issue in the Open-Access Journal "International Journal of Mining, Material and Metallurgical Engineering" by Avestia Publishing. For more information, in regards to the journal and Avestia Publishing, please visit our website at www.avestia.com.
All papers must be presented by one of the authors. At least one author must register for the conference and pay the fee prior to Regular Registration deadline (see Important Dates) in order for the paper to be published in the conference proceedings and accepted in the final program.
Two best paper awards will be conferred to author(s) of the papers that receive the highest rank during the peer-review and by the respected session chairs. Only papers presented at the conference will be eligible for this award. Winners receive a certificate, 25% discount towards registration for the 2016 series of the conference, and can submit their papers to a related journal by Avestia Publishing for free publication (subject to a second round of peer-review).
In order to submit your paper or access the reviewer system, please follow the link below:
The corresponding authors of accepted papers are required to please fill, complete, sign and send the following copyright form along with your Camera Ready Submission to<EMAIL_ADDRESS>Failure to comply will result in removal of the paper from the proceedings.


=== Test case: lasp_peer_to_peer_advertisement_counter_SUITE:peer_to_peer_state_based_test/1 (click for source code)
=== Config value:
[{watchdog,<0.449.0>},
<EMAIL_ADDRESS>{tc_group_properties,[]},
{tc_group_path,[]},
{data_dir,"/Users/anne-francevanswieten/lasp/_build/test/lib/lasp/test/lasp_peer_to_peer_advertisement_counter_SUITE_data/"},
<EMAIL_ADDRESS>=== Current directory is<EMAIL_ADDRESS>=== Started at 2017-04-18 14:35:15
*** User 2017-04-18 14:35:15.845 ***
Beginning test case peer_to_peer_state_based_test
*** User 2017-04-18 14:35:15.854 ***
Running peer_to_peer_ad_counter_state_based_test with nodes [server,client_1,
client_2,
client_3]
*** User 2017-04-18 14:35:15.855 ***
Launching Erlang distribution...

*** User 2017-04-18 14:35:22.081 ***
Custering nodes...
*** User 2017-04-18 14:35:22.081 ***
Joining node: server@MBPdeAnneFrance to client_1@MBPdeAnneFrance at port 51362
*** User 2017-04-18 14:35:22.082 ***
Joining node: server@MBPdeAnneFrance to client_2@MBPdeAnneFrance at port 51364
*** User 2017-04-18 14:35:22.085 ***
Joining node: server@MBPdeAnneFrance to client_3@MBPdeAnneFrance at port 51366
*** User 2017-04-18 14:35:22.086 ***
Joining node: client_1@MBPdeAnneFrance to server@MBPdeAnneFrance at port 51360
*** User 2017-04-18 14:35:22.090 ***
Joining node: client_1@MBPdeAnneFrance to client_2@MBPdeAnneFrance at port 51364
*** User 2017-04-18 14:35:22.091 ***
Joining node: client_1@MBPdeAnneFrance to client_3@MBPdeAnneFrance at port 51366
*** User 2017-04-18 14:35:22.092 ***
Joining node: client_2@MBPdeAnneFrance to server@MBPdeAnneFrance at port 51360
*** User 2017-04-18 14:35:22.095 ***
Joining node: client_2@MBPdeAnneFrance to client_1@MBPdeAnneFrance at port 51362
*** User 2017-04-18 14:35:22.098 ***
Joining node: client_2@MBPdeAnneFrance to client_3@MBPdeAnneFrance at port 51366
*** User 2017-04-18 14:35:22.098 ***
Joining node: client_3@MBPdeAnneFrance to server@MBPdeAnneFrance at port 51360
*** User 2017-04-18 14:35:22.100 ***
Joining node: client_3@MBPdeAnneFrance to client_1@MBPdeAnneFrance at port 51362
*** User 2017-04-18 14:35:22.102 ***
Joining node: client_3@MBPdeAnneFrance to client_2@MBPdeAnneFrance at port 51364
*** User 2017-04-18 14:35:22.103 ***
Lasp fully initialized.
*** User 2017-04-18 14:35:22.103 ***
Waiting for simulation to end
*** User 2017-04-18 14:37:32.118 ***
Simulation ended with success
*** User 2017-04-18 14:37:40.195 ***
Ending test case peer_to_peer_state_based_test
=== Ended at 2017-04-18 14:37:40
=== successfully completed test case
=== Returned value: ok
Test run history
| Top level test index


This is a cellular automata simulation that uses a 2D matrix of cells to generate interesting effects. Each cell executes simple rules that control its state and behavior ( color, replication, state (on/off), etc ). The "program" that the cells execute can be defined in the area to the right, via a metalanguage similar to the genetic code of real cells. The source code is here.
A cell is a square with a given dimension on the canvas. It can react to its environment according to a "genetic code", defined in the area on the right side.
One can configure cells to execute a certain program defining particular cell types and genes that instruct them what to do.
The simulation starts by default with a single cell in the center of the board and evolves from there according to the program on the right. You can specify a different starting setup by instructing the program what cells to activate, via the setup.cells parameter. For example, to initialize a cell at position x: 20 and y: 40, and another one at position x: 30, and y -20, you can add this to the configuration: { ... "setup":{ "cells":[ { "pos": [20,40], "type":"add a type defined by you" }, { "pos": [30,-20] } ] } ... } As you can see, besides the position, you can specify a custom type of the cell, defined via the types parameter of the configuration.
The default replication direction of the original cell is straight up, but it can be modified via the SRM operation.
Each cell is aware of its direct neighbors.
For each cell,
the neighboring cells will be identified like this:
0 1 2
7 x 3
6 5 4
A cell can
"act" upon its direct neighbors by replicating its genetic code to
them if they are empty or they have a lower priority. See the
example code.
To program cells to do something, one needs to define genes in the genes section of the configuration. Each gene has an activation function ( a certain set of conditions that need to be fulfilled), and a set of operations that are executed if its activation function returns true. See the example to understand how this works. The text between /* ... */ is ignored.
The most important operations are:
Most important properties:
Read below to see all possible properties and operations.
All operations need to end with the ; character.


Unplugged
Photoshop to Web
Unplugged is a Indie Band news and reviews site developed as part of the curriculum of the Skillcrush Front End Developer Blueprint. The site was developed mobile first and is responsive.
--- layout: default ---
Unplugged is a Indie Band news and reviews site developed as part of the curriculum of the Skillcrush Front End Developer Blueprint. The site was developed mobile first and is responsive.


I make computers do what I want, more or less.
I am looking for full-time employment.
I cofounded PitchBreakfast with Vic Howie.
I cofounded Code for Charlotte with Jill Bjers.
I've published a newsletter for Charlotte startups for over two years.
I've attended or co-organized every Charlotte Startup Weekend.


DJShortSleeves
Menu
Music
Subscribe
Social Media
DJShortSleeves is making waves
check out some loosies
Check it Out
Leave your email to get notified
We'll never share your email with anyone else.
Submit
follow the slickest DJ coming out of Toronto


GoGetProperties Search Tool
GoGetProperties is the property search tool for the Montgomery County Land Bank's Foreclosure Acquisition Program. Through this program, citizens and investors can acquire unoccupied, tax-delinquent property at deeply discounted prices in exchange for the commitment to improve the property and pay future taxes on it.
The program uses a provision of Ohio law that allows the Land Bank to take title to tax-delinquent, abandoned properties in Montgomery County and sell them to qualified buyers.
The Foreclosure Acquisition Program applies to residential properties in all Montgomery County jurisdictions other than the city of Dayton, which has operated a similar program for several years. For a property within the city of Dayton, please check LotLinker.com.
The GoGetProperties.com tool streamlines your search by showing only the properties that meet the top four eligibility criteria for the Foreclosure Acquisition Program.
We suggest that you learn more about the Foreclosure Acquisition Program before starting to use this tool.
+ What makes a property eligible for Foreclosure Acquisition?
- is in Montgomery County
- is at least 1 year in arrears on taxes
- has not had its tax lien sold
- is not on a delinquent tax payment plan
- is unoccupied/abandoned
- has not been applied for already
+ How do I use this tool?
You can search by address, parcel number, or by visual inspection of the map.
To view the address and parcel number of a location on the map, click on the blue balloon icon. Vacant lots have a leaf icon in the balloon. Other properties have a home icon.
Properties that have already been claimed show up with a red balloon. These are not available at this time.
+ I can't find the property I'm looking for?
If the property does not show up in this search tool, then it is eligible for the Foreclosure Acquisition Program at this time.
If the property shows up with a red balloon, then the property has already has an active claim against it.
+ I found an eligible property! Now what?
You'll need to visit the property in person to make sure it is unoccupied per Ohio Revised Code 323.65. Click here for a detailed description of the Foreclosure Acquisition Program, including the conditions that determine whether it is unoccupied.
You can also download your Foreclosure Acquisition application from this page, and this will get you on your way.
Please note: There is a sliding-scale fee to participate. If, during initial review, we find the property to be ineligible for Foreclosure Acquisition we will return the fee minus $250 per property, will be returned to the applicant.
*The data for this tool comes directly from the Montgomery County Treasurers Office database, which is updated at the end of every month. The county's data was last queried for LotLinker on .


--- permalink: /community/index.html --- {% block meta_description %} {% spaceless %} The Doctrine community is made up of thousands of developers all around the world. The project has had over 500 contributors and is maintained by a core team of developers. If you want to get involved, find other Doctrine developers on GitHub, Slack and the Mailing List. {% endspaceless %} {% endblock %} {% block content %}
The Doctrine community is made up of thousands of developers all around the world. The project has had over 500 contributors and is maintained by a core team of developers. If you want to get involved, find other Doctrine developers on GitHub, Slack and the Mailing List.
Code contributions are coordinated via GitHub pull requests. Find the project you want to contribute to and from there you will see a link for Pull Requests. You can browse existing pull requests or create one of your own. Learn more about how to contribute to Doctrine here.
Go to GitHubYou can also use the mailing list hosted with Google Groups to communicate with other Doctrine developers.
Go to Mailing ListSome frameworks have sub-communities that are specific to using Doctrine with that framework.
Communicate with other Symfony developers that use Doctrine in the #doctrine slack channel in the Symfony Devs slack instance.
Go to SlackCommunicate with other Laravel developers that use Doctrine in the Laravel Doctrine slack instance.
Go to Slack


Warning In this article, you'll learn how to create aDatabaseModule
based on the Mongoose package from scratch using custom components. As a consequence, this solution contains a lot of overhead that you can omit using ready to use and available out-of-the-box dedicated@nestjs/mongoose
package. To learn more, see here.
Mongoose is the most popular MongoDB object modeling tool. To start the adventure with this library we have to install all required dependencies:
{{ dependencies }}
{{ dependenciesJs }}
The first step we need to do is to establish the connection with our database using connect()
function.
The connect()
function returns a Promise
, therefore we have to create an async provider.
{{ databaseProviders }}
Hint Following best practices, we declared the custom provider in the separated file which has a *.providers.ts
suffix.
Then, we need to export these providers to make them accessible for the rest part of the application.
{{ 'database.module' | extension: databaseModuleT.isJsActive }}{{ databaseModule }}
Now we can inject the Connection
object using @Inject()
decorator.
Each class that would depend on the Connection
async provider will wait until a Promise
is resolved.
With Mongoose, everything is derived from a Schema. Let's define the CatSchema
:
{{ catSchema }}
The CatsSchema
belongs to the cats
directory.
This directory represents the CatsModule
.
Now it's time to create a Model provider:
{{ 'cats.providers' | extension: catsProvidersT.isJsActive }}{{ catsProviders }}
{{ catsProvidersJs }}
Notice In the real-world applications you should avoid magic strings. BothCatModelToken
andDbConnectionToken
should be kept in the separatedconstants.ts
file.
Now we can inject the CatModelToken
to the CatsService
using the @Inject()
decorator:
{{ catsService }}
{{ catsServiceJs }}
In the above example we have used the Cat
interface. This interface extends the Document
from the mongoose package:
{{ catInterface }}
The database connection is asynchronous, but Nest makes this process completely invisible for the end-user.
The CatModel
class is waiting for the db connection, and the CatsService
is delayed until model is ready to use.
The entire application can start when each class is instantiated.
Here is a final CatsModule
:
{{ catsModule }}
Hint Don't forget to import theCatsModule
into the rootApplicationModule
.


No results found.
You may want to refine your search criteria.
{{record._source.title}}
{{cleanText(getDescription(record))}}
Loading...


--- layout: post title: no title date: '2017-06-05T10:30:18+02:00' categories: - Grand Froid picture_url: https://film-Storyboards.tumblr.com/post/161469218253 ---


Process
In order to understand more about gaming behaviour, we started our research with a survey sent out via social media and to specialized forums. Here are some key findings we set in the first 3 days:
for game help
walkthroughs
walkthroughs on YouTube
Interviews
We conducted a total of 10 interviews with gamers based in the UK, the US, Brazil and Sweden - between survey contacts, people we met in Meltdown (a gaming bar in London) and personal contacts.
Personas
Based on the findings from our user research, we created 3 personas with different needs. Our primary persona was Jason. He is a heavy user of Twitch and makes extra money through donations from players who appreciate watching him skillfully play.
Userflow
To help us focus on creating the best experience for users, we started thinking about which interactions and decisions are necessary to complete a task. Using Jason as an example, we listed which steps he needs in order to upload a game walkthrough.
Sketches
Through a method called Design Studio, we started sketching proposals for the main screens identified during the userflows. We then discussed the best ideas we could test, such as page elements, structure and interactions.
Wireframes
Wireframes and rapid prototypes are an effective way to verify the practicality of a design concept. Four versions of each screen were tested and iterated based on feedbacks from users, in order to fit for the intended purpose.
User testing
Our key findings from user tests were combining videos and written walkthroughs in the same page and making the upload process as simple as in YouTube, allowing even eventual players to share their game discoveries.


Axis Enumerated Type
Definition
Line
54
of
System.Dom/Node.cm
Underlying Type
int
Enumeration Constants
child
descendant
parent
ancestor
followingSibling
precedingSibling
following
preceding
attribute
ns
self
descendantOrSelf
ancestorOrSelf


The scheme given here does not directly support the nesting of profiling functions, since it provides only a single alternative name for each MPI function. Consideration was given to an implementation which would allow multiple levels of call interception, however we were unable to construct an implementation of this which did not have the following disadvantages
Note, however, that it is possible to use the scheme above to implement a multi-level system, since the function called by the user may call many different profiling functions before calling the underlying MPI function.
Unfortunately such an implementation may require more cooperation between the different profiling libraries than is required for the single level implementation detailed above.


Tasked with redesigning a website that hadn’t been updated in more than a decade, filled with flash animations and gratuitous geocities gifs.
2 Weeks, January 2017
Hawkes Media Group is a full-service digital media production company based near Boston, Massachusetts. Their need for a new website was urgent. One of their staff tried to create a new website 6 months earlier, but was too busy to complete it.
Compared to their old, busy-looking site, the client wanted to showcase their work in a much simpler, direct and focused way. The first thing I did was gain an understanding of what a digital media company needs on a site and who they wanted to attract to the site.
I created sketches on paper of a simple interface with a consistent layout. Then I created wireframes for each page. I also used a mind map and information architecture I’d created to guide me along the way.
Hawkes Media supplied a text-based list of clients for one page, but I convinced them that company logos are a stronger visual presentation. It gives the prospective client more confidence in their work when you see a full screen of logos. In addition, I also got them to reduce some of the text they envisioned in favor of more imagery. After all, they are a media company. Show your best work instead of writing about it.
Once the wireframes were finished I made a low-fidelity prototype and showed it to the client for feedback. This was followed by higher fidelity wireframes. Taking all these steps made for fewer changes as we moved ahead because the feedback helped me remove what the client didn’t like. The triangles and diagonal styling I used on the header and footer to give the site more character were stripped away and the Merriweather font was changed to a more plain and modern looking Open Sans typeface.
During the development of the site I found a way to give the client access to a CMS so that they could collaborate and make minor changes using Webflow. The project was developed using custom code that I would paste into the Webflow editor along with editor itself for a couple smaller things. CSS Flexbox was used for most of the site and it saved a lot of time with layout. JQuery was also used on some items like the mobile navigation.


public static class TdApi.Message extends TdApi.Object
| Modifier and Type | Field and Description |
|---|---|
java.lang.String |
authorSignature
For channel posts, optional author signature.
|
boolean |
canBeDeletedForAllUsers
True, if the message can be deleted for all users.
|
boolean |
canBeDeletedOnlyForSelf
True, if the message can be deleted only for the current user while other users will continue to see it.
|
boolean |
canBeEdited
True, if the message can be edited.
|
boolean |
canBeForwarded
True, if the message can be forwarded.
|
long |
chatId
Chat identifier.
|
static int |
CONSTRUCTOR
Identifier uniquely determining type of the object.
|
boolean |
containsUnreadMention
True, if the message contains an unread mention for the current user.
|
TdApi.MessageContent |
content
Content of the message.
|
int |
date
Point in time (Unix timestamp) when the message was sent.
|
int |
editDate
Point in time (Unix timestamp) when the message was last edited.
|
TdApi.MessageForwardInfo |
forwardInfo
Information about the initial message sender; may be null.
|
long |
id
Message identifier, unique for the chat to which the message belongs.
|
boolean |
isChannelPost
True, if the message is a channel post.
|
boolean |
isOutgoing
True, if the message is outgoing.
|
long |
mediaAlbumId
Unique identifier of an album this message belongs to.
|
TdApi.ReplyMarkup |
replyMarkup
Reply markup for the message; may be null.
|
long |
replyToMessageId
If non-zero, the identifier of the message this message is replying to; can be the identifier of a deleted message.
|
int |
senderUserId
Identifier of the user who sent the message; 0 if unknown.
|
TdApi.MessageSendingState |
sendingState
Information about the sending state of the message; may be null.
|
int |
ttl
For self-destructing messages, the message's TTL (Time To Live), in seconds; 0 if none.
|
double |
ttlExpiresIn
Time left before the message expires, in seconds.
|
int |
viaBotUserId
If non-zero, the user identifier of the bot through which this message was sent.
|
int |
views
Number of times this message was viewed.
|
| Constructor and Description |
|---|
Message()
Describes a message.
|
Message(long id,
int senderUserId,
long chatId,
TdApi.MessageSendingState sendingState,
boolean isOutgoing,
boolean canBeEdited,
boolean canBeForwarded,
boolean canBeDeletedOnlyForSelf,
boolean canBeDeletedForAllUsers,
boolean isChannelPost,
boolean containsUnreadMention,
int date,
int editDate,
TdApi.MessageForwardInfo forwardInfo,
long replyToMessageId,
int ttl,
double ttlExpiresIn,
int viaBotUserId,
java.lang.String authorSignature,
int views,
long mediaAlbumId,
TdApi.MessageContent content,
TdApi.ReplyMarkup replyMarkup)
Describes a message.
|
| Modifier and Type | Method and Description |
|---|---|
int |
getConstructor() |
toString
public long id
public int senderUserId
public long chatId
@Nullable public TdApi.MessageSendingState sendingState
public boolean isOutgoing
public boolean canBeEdited
public boolean canBeForwarded
public boolean canBeDeletedOnlyForSelf
public boolean canBeDeletedForAllUsers
public boolean isChannelPost
public boolean containsUnreadMention
public int date
public int editDate
@Nullable public TdApi.MessageForwardInfo forwardInfo
public long replyToMessageId
public int ttl
public double ttlExpiresIn
public int viaBotUserId
public java.lang.String authorSignature
public int views
public long mediaAlbumId
public TdApi.MessageContent content
@Nullable public TdApi.ReplyMarkup replyMarkup
public static final int CONSTRUCTOR
public Message()
public Message(long id, int senderUserId, long chatId, TdApi.MessageSendingState sendingState, boolean isOutgoing, boolean canBeEdited, boolean canBeForwarded, boolean canBeDeletedOnlyForSelf, boolean canBeDeletedForAllUsers, boolean isChannelPost, boolean containsUnreadMention, int date, int editDate, TdApi.MessageForwardInfo forwardInfo, long replyToMessageId, int ttl, double ttlExpiresIn, int viaBotUserId, java.lang.String authorSignature, int views, long mediaAlbumId, TdApi.MessageContent content, TdApi.ReplyMarkup replyMarkup)
id
- Message identifier, unique for the chat to which the message belongs.senderUserId
- Identifier of the user who sent the message; 0 if unknown. It is unknown for channel posts.chatId
- Chat identifier.sendingState
- Information about the sending state of the message; may be null.isOutgoing
- True, if the message is outgoing.canBeEdited
- True, if the message can be edited. For live location and poll messages this fields shows, whether editMessageLiveLocation or stopPoll can be used with this message by the client.canBeForwarded
- True, if the message can be forwarded.canBeDeletedOnlyForSelf
- True, if the message can be deleted only for the current user while other users will continue to see it.canBeDeletedForAllUsers
- True, if the message can be deleted for all users.isChannelPost
- True, if the message is a channel post. All messages to channels are channel posts, all other messages are not channel posts.containsUnreadMention
- True, if the message contains an unread mention for the current user.date
- Point in time (Unix timestamp) when the message was sent.editDate
- Point in time (Unix timestamp) when the message was last edited.forwardInfo
- Information about the initial message sender; may be null.replyToMessageId
- If non-zero, the identifier of the message this message is replying to; can be the identifier of a deleted message.ttl
- For self-destructing messages, the message's TTL (Time To Live), in seconds; 0 if none. TDLib will send updateDeleteMessages or updateMessageContent once the TTL expires.ttlExpiresIn
- Time left before the message expires, in seconds.viaBotUserId
- If non-zero, the user identifier of the bot through which this message was sent.authorSignature
- For channel posts, optional author signature.views
- Number of times this message was viewed.mediaAlbumId
- Unique identifier of an album this message belongs to. Only photos and videos can be grouped together in albums.content
- Content of the message.replyMarkup
- Reply markup for the message; may be null.public int getConstructor()
getConstructor
in class TdApi.Object


Create an Account
Choose a Username
Must choose a username
Enter Your Email Address
Must enter your email address
Create a Password
Must be at least 8 characters long
Create Account


Provides a collection
of functions to optimize portfolios and to analyze them from
different points of view.
| Version: |
3042.83 |
| Depends: |
R (≥ 2.15.1), timeDate, timeSeries, fBasics, fAssets |
| Imports: |
fCopulae, robustbase, MASS, Rglpk, slam, Rsolnp, quadprog, kernlab, rneos, methods, grDevices, graphics, stats, utils |
| Suggests: |
Rsocp, Rnlminb2, Rdonlp2, Rsymphony, dplR, bcp, fGarch, mvoutlier |
| Published: |
2017-11-16 |
| Author: |
Diethelm Wuertz [aut],
Tobias Setz [cre],
Yohan Chalabi [ctb],
William Chen [ctb] |
| Maintainer: |
Tobias Setz <tobias.setz at live.com> |
| License: |
GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| URL: |
https://www.rmetrics.org |
| NeedsCompilation: |
no |
| Materials: |
ChangeLog |
| In views: |
Finance |
| CRAN checks: |
fPortfolio results |


{% extends "templates/base.html" %} {% block content %}
{%trans%}Please help us improve the site by providing feedback!{%endtrans%}<EMAIL_ADDRESS>{%trans%}Having problems with our service? We can help:{%endtrans%} admin@bitcoin.xyz


?01442956
6
7
8
9
10
L
...
..
The
New
York
copyright
reserved
Botanical
Garden
New
York
Botanical
Garden
Arthur
Cronquist,
194,5
Herbarium
of
the
Arnold
Arboretum
Harvard
University
PLANTS
of
St.
Lucia
No.
516
John
S.
Beard
June
26,
194
5
"Balata
chlen.w
Tree
30
ra.
high,
on
ridges
In
raln-forest;
trunk
80
cm.
diara.;
fls.
white;
latex
white;
timber
hard,
durable.
Barre
de
lŐlle,
alt.
200
m.
01442956
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


module Std:sig
..end
The BAP library has the layered architecture consisting of four
layers. Although the layers are not really observable from outside
of the library, they make it easier to learn the library as they
introduce new concepts sequentially. On top of these layers, the
Project module is defined that consolidates
all information about a target of analysis.  The
Memory model layer is responsible for loading
and parsing binary objects and representing them in a computer
memory. It also defines a few useful data structures that are
used extensively by later layers, e.g., Table
and
Memmap
. The next layer performs
disassembly and lifting to BIL. Finally, the
semantic analysis layer transforms a binary
into an IR representation, that is suitable for writing
analysis.
The standard library tries to be as extensible as possible. We are aware, that there are not good solutions for some problems, so we don't want to force our way of doing things. In short, we're trying to provide mechanisms, not policies. We achive this by employing the dependency injection principle. By inversing the dependency we allow the library to depend on a user code. For example, a user code can teach the library how to disassemble the binary or even how to reconstruct the CFG. In fact, the library by itself doesn't contain the disassembler or lifter, or any architecture specific code. Everything is injected later by corresponding plugins.
The library defines a fixed set of extension points. (Other libraries, that constitute the Platform and follow the same principle, can define their own extension points, so the following set is not complete):
Image.register_backend
or Project.Input
);register_target
);Value.Tag.register
);Symbolizer
);Rooter
);Brancher
)Reconstructor
);Project.register_pass
)Std
library, that forms a foundation for the BAP
Standard Library, also follows the dependency injection
principle, so every data type that implements regular interface,
can be dynamically extended with:
A common use case, is to write some analysis that will take the program in some representation and then either output result of analysis in a human or machine readable way, or transform the program, in a way that can be employed by other analysis. Following a naming convention of a more established community of compiler writers, we name such analysis a _pass_.
The library itself doesn't run any analysis, it part of the job of a
frontend to run it. In particular, the bap
frontend, will run
the analyses based on a command line specification. See bap
for more information.
--help
We use Project
data structure to represent a program and all
associated knowledge that we were capable to infer. To learn
how to use the project data structure continue to
Working with project.
At this layer we define (Binary Instruction language) and few other useful data structures:
word
and addr
;Identifiable
, and is supposed to represent a type that is as
common as a built-in type. One should expect to find any
function that is implemented for such types as int
, string
,
char
, etc. Namely, this interface includes:
<, >, <= , >= , compare, between, ...
);Map
with keys of type t
;Set
with values of type t
;Table
module;Hash_set
nameto_string
, str
, pp
, ppo
, pps
functions
for pretty-printing.exp
is a type abbreviation for Exp.t
, and module Exp
contains all functions and types related to type exp
. For
example, to create a hashtable of statements, just type:
let table = Exp.Table.create ()
If a type is a variant type (i.e., it defines constructors) then
for each constructor named Name
, there exists a corresponding
function named name
that will accept the same number of
arguments as the arity of the constructor (also named a
_functional constructor_). For example, a Bil.Int
can be
constructed with the Bil.int
function that has type word ->
. If a constructor has several arguments of the same type we
usually disambiguate using labels, e.g.,
expBil.Load of
has function Bil.load with
type:
(exp,exp,endian,size)mem:exp -> addr:exp -> endian -> size -> exp
Universal values can be viewed as extensible variants on steroids. Not only they maybe extended, but they also can be serialized, compared with user-defined comparison function and even pretty printed.
Like value is an extensible sum type, dict can be viewed as an extensible product type. Dict is a sequence of values of type Value, with tags used as field names. Of course, fields are unique.
Vector
is an implementation of C++ STL like vectors with
logarithmic push back.
The Foundation library also defines a prefix tree data structure that proves to be useful for binary analysis applications. Tries in BAP is a functor that derives a polymorphic trie data structure for a given Key.
For convenience we support instantiating tries for most of our data structures. For example, Word has several tries inside.
For the common string trie, there's Trie.String
.
This layer is responsible for the representation of binaries. It provides interfaces for the memory objects:
Image
module uses the plugin system to load binary
objects. In order to add new loader, one should implement the
Backend.t loader function and register it with the
Image.register_backend function.This layer defines interfaces for disassemblers. Two interfaces are provided:
Disasm.of_mem
- to disassemble a region of memory;Disasm.of_image
- to disassemble a loaded binary object;Disasm.of_file
- to disassemble file.The result of disassembly is represented by the abstract value of type disasm.  See graphlib for more
information on graphs.
Each block is a container to a sequence of machine instructions. It is guaranteed that there's at least one instruction in the block, thus the Block.leader and Block.terminator functions are total.
Each machine instruction is represented by its
opcode
, name
and array
of operands (these are machine and
disassembler specific), a set of predicates (that approximates
instruction semantics on a very high level), and a sequence of
BIL statements that precisely define the semantics of
the instruction.
The expert interface exposes low level interface that provides
facilities for building custom implementations of
disassemblers. The interface to the disassembler backend is
exposed via the Disasm_expert.Basic
module. New backends can
be added by implementing the 'disasm.hpp' interface.
Modules of type CPU provide a high level abstraction of
the machine CPU and allow one to reason about the instruction
semantics independently from the target platform. The module
type Target brings CPU
and ABI
together. To get
an instance of this module, you can use the
target_of_arch function. Architecture
specific implementations of the Target
interface may (and
usually do) provide more information, see corresponding support
libraries for ARM
and x86 architectures.
On the semantic level the disassembled program is lifted into the BAP Intermediate Representation (BIR). BIR is a semi-graphical representation of BIL (where BIL represents a program as Abstract Syntax Tree). The BIR provides mechanisms to express richer relationships between program terms and it also easier to use for most use cases, especially for data dependency analysis.
The program in IR is build of terms. In fact the program itself is also a term. There're only 7 kinds of terms:
def
term has two
attributes: left hand side (lhs), that associates definition
with abstract variable, and right hand side (rhs) that
associates def
with an abstract expression. Suppose, that the
definition was:
# let d_1 = Def.create x Bil.(var y + var z);;
val d_1 : Def.t = 00000001: x := y + z
To change the right hand side of a definition we use
Def.with_rhs
that returns the same definition but with
different value:
# let d_2 = Def.with_rhs d_1 Bil.(int Word.b1);;
val d_2 : Def.t = 00000001: x := true
d_1
and d_2
is different values
# Def.equal d_1 d_2;;
- : bool = false
of the same term # Term.same d_1 d_2;;
- : bool = true
The identity of this terms is denoted by the term identifier
(tid
). In the textual representation term identifiers are
printed as ordinal numbers.
Terms, can contain other terms. But unlike BIL expressions or
statements, this relation is not truly recursive, since the
structure of program term is fixed: arg
, phi
, def
, jmp
are leaf terms; sub
can only contain arg
's or blk
's; blk
consists of phi
, def
and jmp
sequences of terms, as
pictured in the figure below. Although, the term structure is
closed to changes, you still can extend particular term with
attributes, using set_attr
and get_attr
functions of the
Term module. This functions are using extensible
variant type to encode attributes.
+--------------------------------------------------------+ | +-------------------+ | | | program | | | +---------+---------+ | | |* | | +---------+---------+ | | | sub | | | +---------+---------+ | | | | | +-----------------+---------------+ | | |* |* | | +-----+-------+ +-------+-------+ | | | arg | | blk | | | +-------------+ +-------+-------+ | | | | | +---------------+--------------+ | | |* |* | * | | +-----+-----+ +-----+-----+ +----+-----+ | | | phi | | def | | jmp | | | +-----------+ +-----------+ +----------+ | +--------------------------------------------------------+
There're two general approaches to obtain a value of type project:
Project.create
function;bap
frontend.To write a program analysis plugin (or pass in short) you need to implement a function with one of the following interfaces:
project -> project
and register it with
register_pass;project -> unit
and register it with
register_pass';bap
frontend (see bap --help
) this
function will be invoked with a value of type
project that provides access to all information
gathered from the input source. If the registered function
returns a non unit
type, then it can functionally update the
project state, e.g., add annotations, discover new symbols,
transform program representation, etc.
The following plugin prints all sections in a file:
open Core_kernel
open Bap.Std
open Format
let print_sections p =
Project.memory p |> Memmap.to_sequence |> Seq.iter ~f:(fun (mem,x) ->
Option.iter (Value.get Image.section x) ~f:(fun name ->
printf "Section: %s<EMAIL_ADDRESS>name Memory.pp mem))
let () = Project.register_pass' print_sections
Note: this functionality is provided by the print
plugin.
To pass data from one pass to another in a type safe manner, we
use universal values. Values can be attached to a
particular memory region, IR terms, or put into the storage
dictionary. For the first case we use the memmap data
structure. It is an interval tree containing all the memory
regions that are used during analysis. For the storage
we use
Dict
data structure. Also, each program term, has its own
dictionary.
By default the memory is annotated with the following attributes:
"bap.user"
section.module Integer:sig
..end
module Legacy:sig
..end
module Monad: module type of Legacy.Monad


| |
{{order.id}} |
{{order.orderStatus}} |
{{order.customerName}} |
{{order.createdOn | date:'medium'}} |
{{order.subTotal}}$ |
{{order.shippingAmount}}$ |
{{order.pnrNumber}} |
{{order.agencyReservationNumber}} |
{{order.flight.reservationNumber}} |
{{order.flight.departure}} |
{{order.flight.destination}} |
{{order.flight.departureDate | date:'dd.MM.yy':'UTC'}} |
{{order.flight.landingTime | date:'HH:mm':'UTC'}} |
{{order.flight.flightNumber}} |
{{order.flight.isRoundTrip}} |
{{order.flight.returnFlightNumber}} |
{{order.flight.returnDepartureDate | date:'dd.MM.yy':'UTC'}} |
{{order.flight.returnLandingTime | date:'HH:mm':'UTC'}} |
{{order.flight.agencyPrice}}$ |
{{order.flight.passengerPrice}}$ |


"I like the idea of exchanging something with another. I have a lot of things to share!"
"As an engineer, i spend my money to buy some materials. Bodrum is awesome idea to get them at low price or free!"


First Name: Last Name:
Email: Password:
BirthDay: 1 2 3 1 2 3 4 5 6 2018 2017 2016
I agree to the terms and conditions:


{% extends 'account/base.html' %} {% block title %}{{ BANK_NAME }}{% endblock %} {% block content %} {% load static %} $header
We solve the world's problems of tomorrow, today.
We're passionate about getting your money in our bank and will stop at nothing to make it happen in today's dog-eat-dog-eat-cat-eat-bird-eat-worm world we have to rely on powerful allies. As said powerful allies to many powerful world leaders, we can be the answer to your problems, for a small fee.
Did you know banking can solve a world of problems? Here at {{ BANK_NAME }}, we solve the world's problems of tomorrow, today. We put you in the community. There's no physical branches so we can keep the saving flowing.


VSAlertController
@interface VSAlertController : UIViewController <UIAppearance>
VSAlertController is a drop-in replacement for UIAlertController with more features. It is created using the +alertControllerWithTitle:message:image:style:
class method, and configured using instances of VSAlertAction. You can add text fields by calling -addTextField:
on an instance of VSAlertController. Instantiate the controller, add your actions and textfieds. and any other configuration you might need. Present the controller modally using UIViewController’s -presentViewController:animated:completion:
method.  You can also change this property in the handler of an action to use a different animation on dismissal.
-
A factory method to create an instance of VSAlertController. This is the preffered way to instantiate alerts
Declaration
Objective-C
+ (nullable instancetype)alertControllerWithTitle:(nullable NSString *)title message:(nullable NSString *)message image:(nullable UIImage *)image preferredStyle: (VSAlertControllerStyle)preferredStyle;
Parameters
title
The title of the alert
message
The message of the alert
image
The image to be displayed in the header of the alert.
preferredStyle
The style of the alert
Return Value
The instantiated alert object
-
A factory method to create an instance of VSAlertController.
Declaration
Objective-C
+ (nullable instancetype)alertControllerWithTitle:(nullable NSString *)title message:(nullable NSString *)message preferredStyle: (VSAlertControllerStyle)preferredStyle;
Parameters
title
The title of the alert
message
The message of the alert
preferredStyle
The style of the alert
Return Value
The instantiated alert object
-
Create an instance of VSAlertController
Declaration
Objective-C
- (nullable instancetype)initWithTitle:(nullable NSString *)title message:(nullable NSString *)message image:(nullable UIImage *)image preferredStyle:(VSAlertControllerStyle)preferredStyle;
Parameters
title
The title of the alert
message
The message of the alert
image
The image to be displayed in the header of the alert.
preferredStyle
The style of the alert
Return Value
The instantiated alert object
-
The color of the alert title. The default value is black.
Declaration
Objective-C
@property (readwrite, strong, nonatomic, nonnull) UIColor *alertTitleTextColor;
-
The color of the alert message (description). The default value is black.
Declaration
Objective-C
@property (readwrite, strong, nonatomic, nonnull) UIColor *alertMessageTextColor;
-
The font of the alert title. The default value is the system font size 17 weight medium.
Declaration
Objective-C
@property (readwrite, strong, nonatomic, nonnull) UIFont *alertTitleTextFont;
-
The font of the alert message (description). The default value is the system font size 15 weight regular.
Declaration
Objective-C
@property (readwrite, strong, nonatomic, nonnull) UIFont *alertMessageTextFont;
-
The text alignment of the alert message
Declaration
Objective-C
@property (assign, readwrite, nonatomic) NSTextAlignment alertMessageTextAlignment;
-
The background color of the alert
Declaration
Objective-C
@property (readwrite, strong, nonatomic, nonnull) UIColor *alertBackgroundColor;
-
Add an action to an alert
Declaration
Objective-C
- (void)addAction:(nonnull VSAlertAction *)alertAction;
Parameters
alertAction
The action to add to the alert.
-
Add a text field to the alert. Rather than instantiating a UITextField object yourself, VSAlertController instantiates one for you. You can configure it using the optional configuration block
Declaration
Objective-C
- (void)addTextField:(void (^_Nullable)(UITextField *_Nonnull))configuration;
Parameters
configuration
The block used to configure the text field.
-
Set to YES if you want the alert to dismiss itself when the user taps on the background of the alert. Default is NO.
Declaration
Objective-C
@property (getter=shouldDismissOnBackgroundTap, assign, readwrite, nonatomic) BOOL dismissOnBackgroundTap;
-
Change the animation used when the alert is presented AND dismissed. Default is VSAlertControllerAnimationStyleRise.
Declaration
Objective-C
@property (assign, readwrite, nonatomic) VSAlertControllerAnimationStyle animationStyle;
-
The delegate object to handle alert action interactions
Declaration
Objective-C
@property (readwrite, atomic, nullable) id<VSAlertControllerDelegate> delegate;
-
Returns the array of text field objects that are displayed in the alert, so you can interact with the user’s inputs.
Declaration
Objective-C
@property (readonly, strong, nonatomic, nonnull) NSArray<UITextField *> *textFields;
-
The style of the alert
Declaration
Objective-C
@property (readonly, assign, nonatomic) VSAlertControllerStyle style;
-
The message of the alert
Declaration
Objective-C
@property (readonly, copy, nonatomic, nonnull) NSString *message;
-
The image of the alert
Declaration
Objective-C
@property (readonly, strong, nonatomic, nullable) UIImage *image;


‘Monitor increasing prices of eggs, chicken’
by Macon Ramos-AranetaCiting a surge in the prices of eggs and chicken in Metro Manila markets the past weeks, Senator Imee Marcos on Tuesday urged the government to monitor price movements more closely as Christmas draws nearer.
“There’s no reason for the rise in egg prices because the Philippine Egg Board itself was shocked to find out an increase way above the suggested retail price [SRP)] of P5 each, despite steady supply and farmgate prices,” Marcos said.
The cost of small eggs has reached more than P6 apiece, with a tray of 30 pieces at P180 or more, instead of SRP’s P150.
“This may be an introductory shock for now, considering it’s not yet December,” Marcos warned.
Also, Marcos said retail prices of chicken spiked anew from last month’s P160 to P180 a kilo while wholesale prices were just at P123 to P128 only.
Marcos said prices of chicken are now pegged at P190 to P200 a kilo.
“Yes, the cost of chicken feed has gone up and chicken production dipped in some parts of Luzon,” she said.
“But the Department of Agriculture has already said the consumption of pork is going back to normal, so chicken prices should not be that steep,” Marcos added.


"Network Opportunities" are Coords that have been published by other Coordel members who need particular expertise to get their work done. Check out the list below to see Opportunities that might interest you.
Anyone who is a Registered Member can participate in Network Opportunities.
Scroll over and click the binoculars icon to follow a Network Opportunity. Non-members will be invited to start a free 30-day trial membership. Opportunities you follow will appear in your Coord list within the application.
Showing only the latest 50 Opportunities. Log on or Join Us to see all Opportunities.


Ready to play some tunes?! Turn the power on to get started.


Regression, Classification, Evaluation¶
Objectives
- State assumptions of linear regression model
- Estimate a linear regression model
- Evaluate a linear regression model
Predictive Modeling¶
There are many circumstances in which we are interested in predicting some outcome \(Y\). To accomplish this task we set about collecting, selecting, and constructing data – a process referred to as feature engineering – that we think would help predict \(Y\). Given our selected features \(\textbf{X}\), the association between the features \(\textbf{X}\) and and the outcome \(Y\) can be expressed as
\[Y = f(\mathbf{X}) + \epsilon\]
where \(f\) explicitly describes the precise relationship between \(\textbf{X}\) and \(Y\), and \(\epsilon\) is...
Note
CLASS DISCUSSION
- What is \(\epsilon\)?
- How could we model \(\epsilon\)?
- How about \(f\)?
- Based on what you’ve seen so far, is Statistics and Probability more suited to describe \(\epsilon\) or \(f\)?
Types of Data¶
The data \(\textbf{X}\) that we use to predict \(Y\) can come in many varieties, i.e.
- Continuous:
- Price, Quantity, Sales, Tenure
- Sometimes it makes sense to map to discrete variables
- Categorical:
- Yes/No, 0/1, Treated/Control, High/Medium/Low
- Also called a factor
- Missing Values
- May require estimation
- “Non-numeric”
- Text, Audio, Images, Signals, Graphs
- Requires transformation into meaningful quantitative features
Supervised Learning¶
Approximating \(f(\textbf{X})\) with some function \(\hat{f}(\textbf{X})\) in the face of noisy data (as a result of \(\epsilon\)) is known as model fitting. Actually, different disciplines have adopted different nomenclatures for this process.
| Machine Learning | Notation | Other Fields |
|---|---|---|
| Features | \(\textbf{X}_{(n \times p)}\) | Covariates, Independent Variables, or Regressors |
| Targets | \(Y_{(n \times 1)}\) | Outcome, Dependent or Endogenous Variable |
| Training | \(\hat{f}\) | Learning, Estimation, or Model Fitting |
Depending on the data type of the target, the supervised learning problem is referred to as either
Regression (when \(Y\) is real-valued)
E.g., if you are predicting price, demand, or size.
Classification (when \(Y\) is categorical)
E.g., if you are prediction fraud or churn
Data Size¶
- Associative Studies: test hypotheses
- Association is causality under carefully controlled conditions
- The power and accuracy of a test is an asymptotic function of \(N\)
- Predictive Studies: try to guess well
- Complex models are prone to overfitting without sufficient \(N\)
- Regularization limits overfitting and cross-validation assesses accuracy
Note
CLASS DISCUSSION
How would you differentiate Statistics and Machine Learning, if at all?
Unupervised Learning¶
When you’re not trying to predict a target \(Y\), but just seeking to uncover patterns and structures between the features \(\mathbf{X}\), the problem is referred to as Unsupervised Learning. The two primary areas of unsupervised learning are
- Clustering: e.g., hierarchical, k-means
- Dimension reduction: e.g., PCA, SVD, NMF
Linear Regression¶
Suppose that \(Y_i\) depends on \(X_i\) according to
where \(\beta_{0}\), \(\beta_{1}\), and \(\sigma^2\) are the parameters of the model (intercept, coefficient and variance, respectively).
We can easily simulate some data under an instance of this set of models as follows:
import matplotlib.pyplot as plt
import numpy as np
def get_simple_regression_samples(n,b0=-0.3,b1=0.5,error=0.2):
trueX = np.random.uniform(-1,1,n)
trueT = b0 + (b1*trueX)
return np.array([trueX]).T, trueT + np.random.normal(0,error,n)
seed = 42
n = 20
b0_true = -0.3
b1_true = 0.5
x,y = get_simple_regression_samples(n,b0=b0_true,b1=b1_true,seed=seed)
fig = plt.figure(figsize=(8,8))
ax = fig.add_subplot(111)
ax.plot(x[:,0],y,'ko')
ax.plot(x[:,0], b0_true + x[:,0]*b1_true,color='black',label='model mean')
ax.legend()
plt.show()
(Source code, png, hires.png, pdf)
Note
QUESTION
If you added data into the plot above where could you add them that might be a cause for concern?
Note
CLASS DISCUSSION
If you increased to total number of data points generated by this model, how would the density of points in this picture look?
Now of course in real life you first get your data and then you estimate your model:
where \(\mathbf{y} = \left[\begin{array}{c}y_1\\y_2\\\vdots\\y_n\end{array}\right]_, \;\;\mathbf{X} = \left[\begin{array}{c}1&x_1\\1&x_2\\\vdots\\1&x_n\end{array}\right]_, \;\; \mathbf{\hat \beta} = \left[\begin{array}{c} \hat \beta_0\\ \hat \beta_1 \end{array}\right]\text{ and } \mathbf{\hat \epsilon} = \left[\begin{array}{c}\hat \epsilon_1\\\hat \epsilon_2\\\vdots\\ \hat \epsilon_n\end{array}\right]\)
and the predictions from the model are
The residuals \(\hat \epsilon_i\) are used to estimate the model mean squared error (MSE)
where \(p\) is the number of coefficients in the model (here, 1).
import numpy as np
import scipy
def fit_linear_lstsq(xdata,ydata):
"""
y = b0 + b1*x
"""
matrix = []
n,d = xdata.shape
for i in range(n):
matrix.append([1.0, xdata[i,0]])
return scipy.linalg.basic.lstsq(matrix,ydata)[0]
coefs_lstsq = fit_linear_lstsq(x,y)
y_pred_lstsq = coefs_lstsq[0] + (coefs_lstsq[1]*x[:,0])
print("truth: b0=%s,b1=%s"%(b0_true,b1_true))
print("lstsq fit: b0=%s,b1=%s"%(round(coefs_lstsq[0],3),round(coefs_lstsq[1],3)))
Note
EXERCISE
Try out the above code. If it’s making sense to you, try seeing what happends when you change the sample size \(n\), or the model intercept \(\beta_0\) and coefficient \(\beta_1\) used to generate the sample. See if you are able to add the model fit line to the plot of the actual model line itself (from the plot above).
Assumptions¶
The specification here actually entails many assumptions:
Fixed and Constant \(\mathbf{X}\)
The \(\mathbf{X}\) are assumed to be measured exactly without error
Independent Errors/Outcomes \(\epsilon/Y\)
The final value for any \(Y_i\) (or equivalently, \(\epsilon_i\)) can not be dependent on any other \(Y_j\) or \(\epsilon_j\), \(j \not = i\)
Linear Model Form
The linear relationships as specified by the model are correct. This is equivalent to having Unbiased Errors. I.e., the expected value of the error \(\epsilon_i\) is 0 for all levels of \(\mathbf{X}\).
While only linear forms are allowed, the forms are only linear in the model coefficients (not the features). I.e., any features (e.g., non-linear functions of features like polynomials or spline basis functions) are permissible.
Normal Errors
The errors \(\epsilon_i\) around \(\mathbf{X}\beta\) are normally distributed
Homoscedastic Errors
The errors \(\epsilon_i\) have constant variance, \(\sigma^2\), for all levels of \(\mathbf{X}\).
Full Rank of \(X\)
The features are not “redundant”; and, being nearly so hurts model performance.
Fortunately, this model can still be effective when some of the assumptions do not fully hold. In addition, there are methods available to help address and correct failures of the assumptions.
Assumptions play a major statistical inference problems (i.e., association studies), but are less relevant in prediction contexts where it doesn’t matter how or why it works – just whether or not it does. As a result, machine learning has been able to produce creative and powerful alternatives to the linear regression model shown above. E.g., k-nearest neighbors, random forests, gradient boosting, support vector machines, and neural networks.
Evaluation Metrics¶
Regression
In regression contexts the fit of the model to the data can be assessed using the MSE, from above, or the root mean squared error (RMSE)
Note
EXERCISE
Calculate the RMSE for the data and prediction in the code above.
Classification
In classification contexts, performance is assessed using a confusion matrix:
| Predicted False \((\hat Y = 0)\) | Predicted Ture \((\hat Y = 1)\) | |
|---|---|---|
| True \((Y = 0)\) | True Negatives \((TN)\) | False Negatives \((FN)\) |
| True \((Y = 1)\) | False Negatives \((TN)\) | True Positives \((TP)\) |
There are many ways to evaluate the confusion matrix:
- Accuracy = \(\frac{TN+TP}{FP+FP+TN+TP}\): overall proportion correct
- Precision = \(\frac{TP}{TP+FP}\): proportion called true that are correct
- Recall = \(\frac{TP}{TP+FN}\): proportion of true that are called correctly
- \(F_1\)-Score = \(\frac{2}{ \frac{1}{recall} + \frac{1}{precision} }\): balancing Precision/Recall
Further Study¶
A good place to start a review of the content here is:


RxJava
Reactive Support
A collection of Reactive programming utilities for RxJava and Reactor, forged and implemented in the Picnic backend.
A humble milkman standing on the shoulder of giants
A collection of Reactive programming utilities for RxJava and Reactor, forged and implemented in the Picnic backend.
A tool that makes complex integration test easy to write, fast to run and reliably to verify.
An Android library built in Kotlin to paint over bitmaps and save them.
A Script for syncing Pingdom probe IPv4 addresses to AWS security groups.
A set of checkers for Google Error Prone that bring your Java code to the next level.
A light-weight Java client to make the integration with Salesforce's bulk API simple and clean.
A simple tool to visualize Snowplow events in real-time.
A toolchain to make localization of mobile applications platform agnostic.


Get the track container's dimmensions, relative to orientation.
Getter for the component's internal scale
Getter for scaleHandler
current scale handler
Setter for scaleHandler
new scale handler
current scale handler
Adds a single track to the log controller
track to be added
Adjust track titles according to available space. Uses abbrievation istead of full label if not enough space.
Recalculates transform based on new container size
Convenience method if used stand-alone. Wraps onMount and returns self for chaining.
HTML element to attach itself to
To unregister event listeners etc.
Trigger onUpdate event after tracks has been altered in size
Processes track legend config object, creating the necessary DOM elements and hooking up callback functions etc.
Track to process
Legend element
Force a redraw
Removes a track from the log controller component
track to be removed
Notify all clients (tracks) on changes to domain/transform
Remove all tracks and update ui
Set the tracks for this controller, replacing any existing tracks
Setup DOM elements, scale and behaviour
Html element to attach to
Updates the legend for a specific track
Track id
Determines the required number of rows in the legend section.
Update track-elements based on current registered track instances
Event handler for pan/zoom
Simple creator function for minimal setup
optional flag to show titles or not
Generated using TypeDoc
Getter for (base) domain


All Classes
Packages
libsvm
net.sf.javaml.classification
net.sf.javaml.classification.bayes
net.sf.javaml.classification.evaluation
net.sf.javaml.classification.meta
net.sf.javaml.classification.tree
net.sf.javaml.clustering
net.sf.javaml.clustering.evaluation
net.sf.javaml.clustering.mcl
net.sf.javaml.core
net.sf.javaml.core.exception
net.sf.javaml.core.kdtree
net.sf.javaml.distance
net.sf.javaml.distance.dtw
net.sf.javaml.distance.fastdtw
net.sf.javaml.distance.fastdtw.dtw
net.sf.javaml.distance.fastdtw.lang
net.sf.javaml.distance.fastdtw.matrix
net.sf.javaml.distance.fastdtw.timeseries
net.sf.javaml.distance.fastdtw.util
net.sf.javaml.featureselection
net.sf.javaml.featureselection.ensemble
net.sf.javaml.featureselection.ranking
net.sf.javaml.featureselection.scoring
net.sf.javaml.featureselection.subset
net.sf.javaml.filter
net.sf.javaml.filter.discretize
net.sf.javaml.filter.instance
net.sf.javaml.filter.missingvalue
net.sf.javaml.filter.normalize
net.sf.javaml.matrix
net.sf.javaml.sampling
net.sf.javaml.tools
net.sf.javaml.tools.data
net.sf.javaml.tools.weka
net.sf.javaml.utils
tutorials
tutorials.classification
tutorials.clustering
tutorials.core
tutorials.featureselection
tutorials.filter
tutorials.tools


 These resulted from a bug in Garmin Connect - read more about the incident here.
{% if user.BlockedOnBadActivitiesAcknowledgement %} {% endif %} {% if user.ConnectedServices|length > 1 %} {% infotip connectedWillSync %}{% trans "Connected services will be synchronized" %} {% if user|has_active_payment %}{% trans "automatically" %}{% else %}{% trans "when you click Synchronize now" %}{% endif %}{% endinfotip %} {% else %} {% infotip connectOneMore %}{% trans "Connect a second service to synchronize your activities to & from" %}{% endinfotip %} {% endif %}exercisync synchronizes your fitness activities between Polar Flow, Polarpersonaltrainer, Aerobia, Garmin Connect, Strava, RideWithGPS, DecathlonCoach, Dropbox, Smashrun, BeginnerTriathlete
(your heart rate, cadence, power, and temperature data syncs too)
Seeing strange activities in your accounts uploaded by exercisync? These resulted from a bug in Garmin Connect - read more about the incident here.
{% for provider in service_providers %} {% if provider.ID not in config.soft_launch and provider.ID not in config.withdrawn_services %} {% include "service-button.html" with provider=provider %} {% endif %} {% endfor %} {% infotip ServiceNotListed %}{% trans "Did not find your service?" %} - {% trans "Try here" %}: tapiriik.com{% endinfotip %}{% trans "Your email, password, and fitness data are kept safe - full details on the" %} {% trans "privacy page" %}.
{% endif %} {% include "donation.html" %}Status Update: Unfortunately, Garmin Connect integration is currently offline. Enter your email below to receive status updates about when you can synchronize your Garmin Connect activities once again


Aqua Optimization¶
Qiskit Aqua Optimization is a set of tools and algorithms that enable experimenting with optimization problems via quantum computing. Aqua Optimization is the only end-to-end software stack that translates optimization-specific problems into inputs for one of the Quantum Algorithms in Aqua: A Library of Quantum Algorithms, which in turn uses Qiskit Terra for the actual quantum computation on top a quantum simulator or a real quantum hardware device.
Aqua Optimization allows users with different levels of experience to execute optimization experiments and contribute to the quantum computing optimization software stack. Users with a pure optimization background or interests can continue to configure optimization problems without having to learn the details of quantum computing.
Aqua Optimization Problems¶
Aqua Optimization can already be used to experiment with numerous well known optimization problems, such as:
Aqua Algorithms for Optimization¶
Aqua: A Library of Quantum Algorithms includes numerous algorithms that can be used to experiment with optimization problems.
General Quantum Algorithms for Optimization¶
The following quantum algorithms are suitable to optimization problems: Variational Quantum Eigensolver (VQE), Quantum Approximate Optimization Algorithm (QAOA), Quantum Phase Estimation (QPE), Iterative Quantum Phase Estimation (IQPE) and Quantum Grover Search.
Classical Reference Algorithms for Optimization¶
To produce reference values and compare and contrast results during experimentation, the Aqua library of Classical Reference Algorithms includes the Exact Eigensolver and CPLEX classical algorithms.
Contributing to Aqua Optimization¶
Research and developers interested in Contributing to Aqua with new optimization-specific capabilities can take advantage of the modular architecture of Aqua and easily extend Aqua with more algorithms and algorithm components, such as new Oracles for the Quantum Grover Search algorithm, new Optimizers and Variational Forms for Variational Quantum Eigensolver (VQE) and Quantum Approximate Optimization Algorithm (QAOA), and new Inverse Quantum Fourier Transforms for Quantum Phase Estimation (QPE) and Iterative Quantum Phase Estimation (IQPE).
Examples¶
The optimization
folder of the Aqua Tutorials GitHub Repository contains numerous
Jupyter Notebooks and sample input data files
explaining how to use Aqua Optimization.


Common concepts of object-oriented programming languages¶
An object is an instance of a certain class.
A class is a collection of like objects. It is usually named by a common noun in the singular.
Objects and classes can have attributes and methods:
- Object attributes (aka instance attributes) store static or variable data about individual objects.
- Class attributes store static or variable data (e.g., metadata) about the class itself.
- Object methods (aka instance methods) represent the actions an object “can do” or that can be “done to” an object.
- Class methods represent actions that can be done to the class itself.
An attribute
x
or methodf
of a classA
or objecta
can typically be referred to asA.x
,A.f
,a.x
,a.f
, respectively (dot notation).A class is often derived from one or more superclasses (maybe in several levels). Their attributes and methods are then inherited by the derived class but can also be overwritten by subclasses.
If a class is derived from more than one superclass (multiple inheritance) which are not meant to be instantiated directly, the latter are often called mixin classes.
Some classes don’t have methods or have only method declarations that contain no implementation and are meant to be overwritten by an “implementation method” in a derived “implementation subclass”. Such classes are typically called “abstract” or “interface” classes, but this terminology is not completely well-defined. They are normally not instantiated directly but rather used to derive “implementation” subclasses that are then instantiated. There are a number of more or less complex “design patterns” describing common practices of how this can be used.
Packages and Modules are somehow meaningful collections of classes (and maybe other things) that form a separate namespace. A class
A
in a package or moduleP
can typically be referred to asP.A
. Packages and subpackages can typically form a hierarchical structure similarly (and often implemented as) a file folder structure, with modules typically representing the deepest level of this hierarchy, similar to files within a folder structure. To be able to refer to things from packageA
within packageB
, one typically needs to import them fromA
toB
, and most programming languages forbid cyclical imports. A similar need for importing often exists if a class needs access to another class’ attributes and methods.


@ProviderType
public interface Authenticator
Authenticator
interface defines the service interface which
may be used by applications to enforce requests to be authenticated (see
login(HttpServletRequest, HttpServletResponse)
) or to end enforced
authentication (see logout(HttpServletRequest, HttpServletResponse)
). As such this service may be looked at as the functionality to enable
applications to log users in and out.
A very simple login script (using ESP here) could be implemented like this:
var auth = sling.getService(org.apache.sling.commons.auth.Authenticator); if (auth != null) { try { auth.login(request, response); return; // we are done here } catch (e) { // probably NoAuthenticationHandler exception } } // Authenticator service is missing or no AuthenticationHandler ... do whatever you want to for error handling ...
Likewise implementing a logout script (ESP, too) is equally simple:
if (request.authType) { // not logged in at all, no need to logout } else { var auth = sling.getService(org.apache.sling.commons.auth.Authenticator); if (auth != null) { auth.logout(request, response); } else { // handle the case of no Authenticator service to logout with } }
This interface is not intended to be implemented by applications but may be used to initiate the authentication process form a request processing servlet or script.
| Modifier and Type | Field and Description |
|---|---|
static String |
LOGIN_RESOURCE
Name of the request attribute which may be set by the application to
indicate to the
login(HttpServletRequest, HttpServletResponse)
method to which resource access should actually be authenticated. |
static String |
SERVICE_NAME
The name under which this service is registered.
|
| Modifier and Type | Method and Description |
|---|---|
void |
login(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
Tries to login a request user for the current request.
|
void |
logout(javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response)
Logs out if the current request is authenticated.
|
static final String SERVICE_NAME
static final String LOGIN_RESOURCE
login(HttpServletRequest, HttpServletResponse)
method to which resource access should actually be authenticated. If this
request attribute is not set or is the empty string, the
login(HttpServletRequest, HttpServletResponse)
method uses the
request path info (HttpServletRequest.getPathInfo()
) method
to find the resource to which to authenticate access.
This request attribute can be used by frontend servlets/scripts which
call into login(HttpServletRequest, HttpServletResponse)
on
behalf of users.
void login(@Nonnull javax.servlet.http.HttpServletRequest request, @Nonnull javax.servlet.http.HttpServletResponse response)
To identify the resource to which access should be authenticated the
request attribute is
considered. If the request attribute is not set the request path info (
resource
HttpServletRequest.getPathInfo()
) is used.
This method must be called on an uncommitted response since the
implementation may want to reset the response to start the authentication
process with a clean response. If the response is already committed an
IllegalStateException
is thrown.
After this method has finished, request processing should be terminated
and the response be considered committed and finished unless the
NoAuthenticationHandlerException
exception is thrown in which
case no response has been sent to the client.
request
- The object representing the client request.response
- The object representing the response to the client.NoAuthenticationHandlerException
- If the service cannot find a way
to authenticate a request user.IllegalStateException
- If the response has already been committed.void logout(@Nonnull javax.servlet.http.HttpServletRequest request, @Nonnull javax.servlet.http.HttpServletResponse response)
This method must be called on an uncommitted response since the
implementation may want to reset the response to restart the
authentication process with a clean response. If the response is already
committed an IllegalStateException
is thrown.
After this method has finished, request processing should be terminated and the response be considered committed and finished.
request
- The object representing the client request.response
- The object representing the response to the client.IllegalStateException
- If the response has already been committed.Copyright © 2017 The Apache Software Foundation. All rights reserved.


Preface
Lorem Ipsum
Table Of Contents
The TOC contents are generated automatically.
1
Chapter One
1
Chapter One


habitude
community
logout
Submit your daily activities!
Sleep time:
hrs
Mindfulness:
hrs
Exercise time:
hrs
Your progress


--- creation_epoch:<PHONE_NUMBER> lastmod_epoch:<PHONE_NUMBER> categories: ['Computer Problems'] title: VMware VM Freezes on-Workstation Linux Host.html --- Had an Ubuntu 20 VM running in VMware Workstation Pro version 16.2.5 that would freeze every few hours for about 20 seconds. Tried rebuilding the VM without much success. This freezing would occur even if the host had no disk usage, cpu usage, and plenty of memory. Similar for the guest VM with low cpu usage tasks and memory. Simple things such as opening a new web browser tab in the guest VM would just randomly freeze up.
I tried the last solution at VMWare Guest periodic freezes..then comes back post by adamitj on Dec 7, 2022.
Power down the VM and add to the vmx:
isolation.tools.unity.disable = "TRUE"
Since this was a Linux desktop guest VM and a Linux host hypervisor the Unity feature wasn't available anyway. Disabling this setting appears to have cleared up the freezing.


I create elegant user interfaces for my clients by transforming static designs into interactive web applications. With HTML, CSS, and javascript frameworks such as AngularJS and ReactJS, I write well structured, modular code that interacts seamlessly with any backend or RESTful API. My most recent works include:
A real-time codesharing environment built with Socket.io
Africa Express
Digital marketplace created with AngularJS and Material Design
TweetWatch
A ReactJS application for monitoring Twitter profiles
QuickWork
AngularJS web application for teachers and students to connect
Jobzy Match
Single page responsive website for small businesses and organizations.
Castro Clone
3 step high converting landing pages for digital marketing campaigns
More About Me
I create web applications that are fast, responsive, and engaging.
Carine Todmia
Software Engineer
My favorite part about software is seeing my projects live on the web. This has led me to focus my work on frontend development and creating engaging user experience. I love developing applications that are intuitive for the user and solve problems related to speed and cross-browser compatiblity. When I'm not coding I enjoy dancing, hiking, and traveling. If you would like to learn more about how I can help your company or organization feel free to email me at<EMAIL_ADDRESS>or connect with me on social media.
Work With Me
Hire me for your next project by emailing<EMAIL_ADDRESS>or call me at<PHONE_NUMBER>
Paired Up
A pair-programming app that helps you connect and code with awesome tech mentors through Video Chat, a Live Code Editor, and Direct Messaging
Project Summary
Learning how to code? Need a Partner? PairedUp is a way to connect with awesome TechMentors. If your looking to learn a particular programming language then PairedUp will match you with fellow coders who can pair program with you.
I owned the private messaging feature by building a RESTful API layer with Node/Express and Websockets. Writing the frontend code in AngularJS allowed for a modular codebase, enabling new features to be added quickly. My greatest achievement with the application was creating a frontend architecture that increased the application’s performance, communicated well with the backend, and enhanced user experience.
AfricaExpress
An open-source marketplace for independent merchants
Shop ViewSell View
Project Summary
Africa express is a digital marketplace for artist to sell handcrafted goods and for shoppers to discover one-of-a-kind pieces. The application includes a simple backend for sellers to upload product images and custom buy links (such as Paypal). Products are posted to the community marketplace for easy purchasing.
Tech Stack
AngularJS, Node/Express, MongoDB
Contributions
I created the original application in Ruby on Rails; however I later refactored the codebase to work with javascript MEAN stack technologies to improve performance by 30%. I created a responsive frontend with Angular Material Design to improve user experience and implemented a RESTful API layer using Node and Express for client-side data retrieval.
TweetWatch
Monitor your favorite Twitter profiles in real-time
Drag and Drop InterfaceMobile Compatible
Project Summary
TweetWatch is a simple dashboard that displays the most recent tweets from a given profile. Users have the ability to reorganize profile sections with the applications simple drag and drop feature.
Tech Stack
ReactJS, BackboneJS, Node/Express, Javascript
Contributions
I leveraged Twitter's API to collect the latest tweets from each profile. I used BackboneJS to organize incoming tweet collections and ReactJS to create view components. I had the most fun implementing the the applications drag and drop feature.
QuickWork
A homework management system for teachers and students
Project Summary
QuickWork makes it easy for teachers to create new assignments and monitor their student's progress. Students have the ability to submit multiple assignments as they get feedback on their work.
One key feature I implemented was user authorization using Passport.js local strategy and OAuth2. User sessions were managed using JSON web tokens. I also introduced privacy settings that are only available to on-line user.
Jobzy Match
The first career search engine with heart
Project Summary
Jobzy Match helps job seekers match their passions and personalities with employers that have their shared vision. The website makes it easy for skilled workers and employers to connect with a simple three step process.
Tech Stack
HTML5, CSS3, Boostrap
Contributions
The goal of the of this project was to create a landing page for the client inorder for them to establish their online presence. I created an easy to navigate single-page website using Bootstrap and HTML/CSS
Castro Clone
A subscription box stocked with male grooming products
Project Summary
Castro Clone is a subscription box service providing premium underwear, high-end skin care products, and signature cologne on a bi-monthly basis. Each box includes a copy of out magazine and access their online boutique.
Tech Stack
HTML5, CSS3, Boostrap, Celery, MailChimp
Contributions
Castro Clone is a startup that hired me to develop their digital marketing campaign as well as handle all technical aspects of their operation. The website was optimized to entice potential customers to enter their email address and submit pre-order payments.


Air pollutants are high concentrations of particles and gases such as soot, smoke, mold, pollen, methane, and carbon dioxide. These particles come from wildfires, warming climate, and the increasing consumption of fossil fuels. These air pollutants are detrimental not only to our health but also to the planet. For this alarming reason many countries want to decrease the concentration of air pollutants in our atmosphere.
In an attempt to decrease the concentration of air pollutants, countries have passed acts, limited industrial work, and have started using more efficient energy sources. For example, in 1955, the United States, who ranked second in the world for air pollutants produced, took their first step in environmental protection. They issued the Air Pollution Control Act, an act that informed the public about air pollution. Then in 1963, they issued the Clean Air Act which allowed the U.S. Environmental Protection Agency (EPA) to regulate the emissions of these harmful air pollutants. The EPA is able to review both stationary(industries) and mobile sources(cars) of air pollutants and set a standard of how much air pollutants can be emitted. This way they can possibly reverse air pollution as more air is purified than emitted.
On the other hand, China, who is ranked first in the world for air pollutants produced, issued the Air Pollution Prevention and Control Action Plan. China's original main energy source was coal, however, they later changed to solar energy, which is a more clean and renewable energy source that doesn't emit air pollutants. The great cost of this change was a $500 million loan, in 2017. Still, China has the world largest Solar PV capacity and a reduction of Carbon Dioxide by over 11,000 tons.
Today, China and American produce less air pollutants compared to the past. In China, the level of PM2.5, one of the most dangerous air pollutants, decreased by over 30% over a period of 5 years. In NorthEast America, the place with the most industries, air pollutants dropped by 30%. However in 2017 things started to change, President Trump announced his decision to abandon the Paris Agreement. The Paris Agreement is an agreement between 200 countries focusing on reducing greenhouse gases emissions. By opting out of this agreement America is reducing their regulation on air pollutants.


{% extends "layout.html" %} {% load humanize %} {% block title %} Estimation markets {% endblock title %} {% block layout-content %} {% if past %}
Below are results from the estimation markets in past years.
{% else %}Estimation markets are a side minigame that offers spades for correctly guessing hidden values.
{% endif %} {% if request.user.is_superuser %}| Market | Ending date | |
|---|---|---|
| {{ market.title }} | {% if past %}{{ market.end_date }} | {% else %}{{ market.end_date|naturaltime }} | {% endif %}
Show your results from all previous markets
{% if past %} Show markets from this year {% else %} Show markets from past years


XEP HAL is an Hardware Abstracion Layer used in XeThru Radar embedded modules. The HAL is modular and can be extended or modified to support other PCB boards or MCUs.
For Atmel Smart ARM microcontrollers, Atmel Software Framework and Atmel Software Package (Softpack) is used.
API functions and macros are documented in xep_hal.h.
No ASF or Softpack functions should be called other than in HAL. If there is need for a function implemented in ASF or Softpack, it should be implemented through HAL.
Include of "asf.h" and "chip.h" will probably trigger compiler warnings.
Most definitions and functions defined in arm_math.h should be defined in xt_XEP_HAL.h. If you need access to definitions and/or functions not defined in xt_XEP_HAL.h, you should consider implementing them in the xt_XEP_HAL instead of using arm-math.h. If it is not possible to implement them in xt_XEP_HAL and you have to include the arm-math.h header file, including arm-math.h will generate warnings for cast alignment. To set the compiler to ignore this waring, give GCC instructions to ignore this like below, when including the header file:
#pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wcast-align" #include <arm_math.h> #pragma GCC diagnostic pop


We are PyLadies Berlin, a group of girls and women coding in this lovely city. We are eager to develop and advance our knowlegde in the world of programming and you are invited to learn with us!
The global PyLadies mentorship group has a focus on helping more women become active participants and leaders in the Python open-source community with the mission to promote, educate and advance a diverse Python community through outreach, education, conferences, events and social gatherings.
PyLadies aims to provide a friendly support network for women and a bridge to the larger Python world.
Our monthly meetups follow a short talk + workshop formula.
You can find and join upcoming events on our Meetup group.
Python novices and beginners are especially encouraged to join our next meetup.
You can find the content of our talks, tutorials, excercises and workshops in our materials GitHub repository.
Videos of some of the talks are on our YouTube channel.
Please use the organizers "Contact" function on our Meetup page (requires free account) to get in touch
or contact us via e-mail.
or join us in slack


Our Mission - “Giving Wings to Your Money”
The story of Daedalus and Icarus is a classic tale of greed, folly, and
unbridled spirit. Daedalus and Icarus were father and son, trapped on an
island prison for angering King Minos, the ruler of the Greek island Crete.
Daedalus, a brilliant inventor, created wings out of wax for himself and his
son. Most people recognize this story because Icarus decided to fly too
close to the sun, which melted the wax off his wings and ultimately brought
his demise. However, we want to honor the story of Daedalus, a man whose
shrewd decision-making ultimately allowed him to reach his end goals. By
associating Daedalus to our name, we make sure that our investments are at
the perfect balance of risk, to ensure that our wings aren’t dampened by
seawater nor are they melted by the sun. By not flying too close to the sun
or water, we hope our investments will take flight, and give us the best
rate of return we can generate.
Our Take On Ethical Investing
We make ethical investing one of the central ideologies in which our
investment strategy is built. We do not believe in investing in companies
profiting off other peoples’ misfortune, because by investing in companies
like those, we as an entity are also profiting off of peoples’ ill will. At
our forefront, we focus on investing in companies creating a positive impact
on society.


What is this?
This tool aims to make shopping for your fittings easier than before.
Why would I use this?
"I need to buy three Slicers of this fit, two Slicers of that fit, 20 plexing Merlins, five real Merlins, a Thorax, and two Drakes". How many times have you thought something like this? It is common for those who have a bloodlust and go through ships quickly, and restocking ships and fittings can be a hassle. I tried many EVE "Shopping Lists" which were both overly complicated and didn't allow the functionality that I needed. So i took a shot at it myself. With fitShop, you can easily upload your fittings and have a handy shopping list displayed, complete with current, up-to-date prices.
How are prices calculated?
Prices are pulled from the EMDR network via emdr-py, another project of mine. We take the 5th percentile price and use that in our calculations. The pricing is limited to a select number of regions: The Forge, Metropolis, Heimatar, Sinq Laison, Domain.
Contact
Have a feature idea? Have a problem? Want to know more about how it works? Feel free to send me an in-game mail. My character name is Sable Blitzmann. The source code is also available on github


dislocated
: dislocated elements
This label is used for arguments or ‘hanging topics’ that are preposed before the verbal complex, and which are referred to again as pronouns governed by the verbal complex, as well as for extraposed arguments realized a second time after the verb. In these cases, the verb governs the closer, pronominal realization of the object as usual, and the ‘extra’ realization (topicalized or extraposed) is connected to the verb as dislocated
.
ⲡ/DET ϣⲓⲡⲉ/NOUN ⲙ/ADP ⲡⲉⲓ/DET ⲙⲁ/NOUN ,/PUNCT ⲡ/DET ⲉⲟⲟⲩ/NOUN ⲙ/ADP ⲡⲉⲓ/DET ⲙⲁ/NOUN ⲁ/AUX ⲓ/PRON ⲡⲁⲣⲁⲓⲧⲉⲓ/VERB ⲙⲙⲟ/ADP ⲩ/PRON \n The shame of this place, the glory of this place, I have forsaken them.
det(ϣⲓⲡⲉ, ⲡ-1)
nmod(ϣⲓⲡⲉ, ⲙⲁ-5)
det(ⲙⲁ-5, ⲡⲉⲓ-4)
case(ⲙⲁ-5, ⲙ)
conj(ⲙⲁ-5, ⲉⲟⲟⲩ)
det(ⲉⲟⲟⲩ, ⲡ-7)
nmod(ⲉⲟⲟⲩ, ⲙⲁ-11)
det(ⲙⲁ-11, ⲡⲉⲓ-10)
case(ⲙⲁ-11, ⲙ)
dislocated(ⲡⲁⲣⲁⲓⲧⲉⲓ, ϣⲓⲡⲉ)
case(ⲩ, ⲙⲙⲟ)
obj(ⲡⲁⲣⲁⲓⲧⲉⲓ, ⲩ)
aux(ⲡⲁⲣⲁⲓⲧⲉⲓ, ⲁ)
nsubj(ⲡⲁⲣⲁⲓⲧⲉⲓ, ⲓ)
Note how the lexical arguments ‘the shame … the glory’ act as dislocated and are pre-posed, to be referred to again as pronouns by the pronoun object ‘them’, which acts as obj
(forsaken what? them. What is them? shame + glory). The dislocation is linked to the word governing the ‘duplicate pronoun’, usually the verb (here ⲡⲁⲣⲁⲓⲧⲉⲓ ‘forsake’, which also governs the object pronoun).
This relation is also used for the special construction with ⲛϭⲓ ‘namely’:
ⲁ ϥ ⲥⲱⲧⲙ ⲛϭⲓ ⲡ ⲇⲓⲁⲃⲟⲗⲟⲥ \n He heard, namely the devil.
dislocated(ⲥⲱⲧⲙ, ⲇⲓⲁⲃⲟⲗⲟⲥ)
det(ⲇⲓⲁⲃⲟⲗⲟⲥ, ⲡ)
case(ⲇⲓⲁⲃⲟⲗⲟⲥ, ⲛϭⲓ)
nsubj(ⲥⲱⲧⲙ, ϥ)
In this example, a duplicate subject appears, which is coreferent with the pronoun ϥ ‘he’ (the lexical head ‘devil’ = ‘he’). The lexical phrase is mediated by ⲛϭⲓ ‘namely, that is’, which is considered to be a case marker, like a preposition (but with nominative case - it can only mark extraposed subjects).
If a nominal subject or object is mentioned before an auxiliary and is then referred to by a pronoun in the verbal complex (e.g. ⲡⲣⲱⲙⲉ ⲁϥⲥⲱⲧⲙ ‘the man, he heard’), the pronoun is always treated as the subject or object, and the preceding noun is attached to the verb as dislocated
.
dislocated in other languages: [bej] [bm] [cop] [de] [el] [en] [fr] [fro] [ga] [gsw] [hy] [it] [ja] [pcm] [pt] [ru] [sl] [sv] [tr] [u] [vi] [yue] [zh]


The heating "PNP NOR" gate shows a heat flow always if a transistor is conducting.
Simulate until T=200 s. Plot V1.v and V2.v and C2.v to see the NOR-functionality. High potential is -6V which means logic "true". Low potential is 0V which means logic "false".
To see which transistor is conducting one can have a look at the temperatures T1.heatPort.T and T2.heatPort.T and the heat flows T1.heatPort.Q_flow and T2.heatPort.Q_flow of the heatports of the transistors T1 and T2.
They are different from zero if the transistor is conducting.