World champion Lewis Hamilton taken aback by Ron Dennis’ congratulatory message
Lewis Hamilton revealed he received 400 messages of congratulations following his latest Formula One world championship triumph – and then paid tribute to mentor Ron Dennis.
Hamilton, 34, has won five of his six titles with Mercedes, but he was afforded his big break in the sport by Dennis.
The former McLaren chief signed the Briton, then only 13, three years after Hamilton, wearing a borrowed dinner jacket at a central London awards ceremony, asked if he could drive for him.
Hamilton came within just one point of winning the championship in his first season racing for Dennis in 2007 before he secured the title in the most dramatic of circumstances, here in Brazil, the following year.
He then upset Dennis by leaving McLaren for Mercedes at the end of 2012.
“Seeing Ron’s text really touched me inside,” said Hamilton. “I met him when I was 10 and he saw something in me that no one else did except for my dad.
“He gave me an opportunity to showcase my abilities and to learn and to grow. Without him I wouldn’t have made it to Formula One.
“I would have fallen away due to a lack of finances, and I would have been leapfrogged by a bunch of individuals who had more money, so I am forever grateful and I will always have love for Ron.
“He said how proud he was, so I hope he can feel he is just as much a part of this as anyone.”
He gave me an opportunity to showcase my abilities and to learn and to grow. Without him I wouldn't have made it to Formula One
Hamilton said double world champion Fernando Alonso, also sent him a message. The two drivers endured a fractious relationship during their only season together at McLaren, Hamilton’s first year on the grid.
“I got a text from Fernando as well which was pretty amazing,” said Hamilton.
“We went through a whirlwind of experiences together, but I have always had respect for what he has achieved and his ability.”
Hamilton, who begins his victory parade at this weekend’s Brazilian Grand Prix, said he is yet to fully celebrate the title that moved him to within striking range of Michael Schumacher’s record haul of seven.
Hamilton toasted his title with family and friends in New York before flying back to Mercedes’ factory in Northamptonshire.
“It just doesn’t fully resonate at the moment, but at some stage, I am sure it will,” added Hamilton, who will wear a commemorative crash helmet in Interlagos to honour his childhood hero, Ayrton Senna.
“I have not really celebrated yet. Each year is different. I was with my family. We travelled and enjoyed the moment together. We went partying, but it wasn’t heavy partying, just enjoying each other’s company.
“The venue we went to wasn’t that great, so we left, went home, had an amazing lunch the next day. I was training the next morning and back into work the following day.”


I use cookies on this website to enhance your browsing experience. By continuing to use this website you agree to my use of cookies. See my privacy policy.


Reports duplicate entries (patterns) in the ignore file (e.g. .gitignore, .hgignore). Duplicate entries in these files are redundant and can be removed.
Example:
# Output directories /out/ /target/ /out/


Orbit does content now.
Highlight me...I'm text.
I'm A Badass Caption:
I can haz
links
,
style
or anything that is valid markup :)


{% extends "base.html" %} {% load bootstrap4 %} {%block title %}Submissions{% endblock %} {% block title_color %}#31b0d5{% endblock %} {% block title_caption %}Code | Submit | Repeat{% endblock %} {% block content %}
| # | Submission Time | User | Problem | Language | Verdict | {% for submission in submission_list %} {% if submission.user == request.user %} {% if submission.verdict == "AC" %}
|---|---|---|---|---|---|
| {{ submission.id }} | {{ submission.submission_time }} | {{ submission.user.username }} | {{ submission.problem }} | {{ submission.get_language_display }} | {{ submission.get_verdict_display }} |
| {{ submission.id }} | {{ submission.submission_time }} | {{ submission.user.username }} | {{ submission.problem }} | {{ submission.get_language_display }} | {{ submission.get_verdict_display }} |
{{ username }} doesn't seem to have made any submissions yet.


There are many questions surrounding UDP buffer sizing. What is the optimal size? What are the consequences of an improperly sized UDP buffer? What are the equations needed to compute an appropriate size for a UDP buffer? What default limit will the OS kernel place on UDP buffer size and how can I change it? How can I tell if I'm having UDP loss problems due to buffers that are too small? Answers to these questions and more are given in the following sections.
UDP buffer sizes should be large enough to allow an application to endure the normal variance in CPU scheduling latency without suffering packet loss. They should also be small enough to prevent the application from having to read through excessively old data following an unusual spike in CPU scheduling latency.
Too little UDP buffer space causes the operating system kernel to discard UDP packets. The resulting packet loss has consequences described below.
The kernel often keeps counts of UDP packets received and lost. See Section 8.9 for information on detecting UDP loss due to UDP buffer space overflow. A common myth is that all UDP loss is bad (see Myth: All Packet Loss is Bad).
In most cases, it's the secondary effects of UDP loss that matter most. That is, it's the reaction to the loss that has material consequences more so than the loss itself. Note that the consequences discussed here are independent of the cause of the loss. Inadequate UDP receive buffering is just one of the more common causes we've encountered deploying LBM.
Consider these areas when assessing the consequences of UDP loss:
Latency--The time that passes between the initial transmission of a UDP packet and the eventual successful reception of a retransmission is latency that could have been avoided were it not for the intervening loss.
Bandwidth--UDP loss usually results in requests for retransmission, unless more up-to-date information is expected soon (e.g. in the case of stock quote updates). Bandwidth used for retransmissions may become significant, especially in cases where there is a large amount of loss or a large number of receivers experiencing loss. See Section 15 for more information on multicast retransmissions.
CPU Time--UDP loss causes the receiver to use CPU time to detect the loss, request one or more retransmissions, and perform the repair. Note that efficiently dealing with loss among a group of receivers requires the use of many timers, often of short-duration. Scheduling and processing such timers generally requires CPU time in both the operating system kernel ("system time") and in the application receiving UDP ("user time"). Additional CPU time is required to switch between kernel and user modes.
On the sender, CPU time is used to process retransmission requests and to send retransmissions as appropriate. As on the receiver, many timers are required for efficient retransmission processing, thus requiring many switches between kernel and user modes.
Memory--UDP receivers that can only process data in the order that it was initially sent must allocate memory while waiting for retransmissions to arrive. UDP loss causes such receivers to receive data in an order different than that used by the sender. Memory is used to restore the order in which it was initially sent.
Even UDP receivers that can process UDP packets in the order they arrive may not be able to tolerate duplication of packets. Such receivers must allocate memory to track which packets have been successfully processed and which have not.
UDP senders interested in reliable reception by their receivers must allocate memory to retain UDP packets after their initial transmission. Retained packets are used to fill retransmission requests.
Even though too little UDP buffer space is definitely bad and more is generally better, it is still possible to have too much of a good thing. Perhaps the two most significant consequences of too much UDP buffer space are slower recovery from loss and physical memory usage. Each of these is discussed in turn below.
Slower Recovery--To best understand the consequences of too much UDP buffer space, consider a stream of packets that regularly updates the current value of a rapidly-changing variable in every tenth packet. Why buffer more than ten packets? Doing so would only increase the number of stale packets that must be discarded at the application layer. Given a data stream like this, it's generally better to configure a ten-packet buffer in the kernel so that no more than ten stale packets have to be read by the application before a return to fresh ones from the stream.
It's often counter-intuitive, but excessive UDP buffering can actually increase the recovery time following a large packet loss event. UDP receive buffers should be sized to match the latency budget allocated for CPU scheduling latency with knowledge of expected data rates. See Section 16 for more information on latency budgets. See Section 8.6 for a UDP buffer sizing equation.
Physical Memory Usage--It is possible to exhaust available physical memory with UDP buffer space. Requesting a UDP receive buffer of 32 MB and then invoking ten receiver applications uses 320 MB of physical memory. See Section 7.4 for more information.
Assuming that an average rate is known for a UDP data stream, the amount of latency that would be added by a full UDP receive buffer can be computed as:
Max Latency = Buffer Size / Average Rate
Note: Take care to watch for different units in buffer size and average rate (e.g. kilobytes vs. megabits per second).
Assuming that an average rate is known for a UDP data stream, the buffer size needed to avoid loss a given worst case CPU scheduling latency can be computed as:
Buffer Size = Max Latency * Average Rate
Note: Since data rates are often measured in bits per second while buffers are often allocated in bytes, careful conversion may be necessary.
The kernel variable that limits the maximum size allowed for a UDP receive buffer has different names and default values by kernel given in the following table:
The examples in this table give the commands needed to set the kernel UDP buffer limit to 8 MB. Root privilege is required to execute these commands.
| Kernel | Command |
|---|---|
| Linux | sysctl -w net.core.rmem_max=8388608 |
| Solaris | ndd -set /dev/udp udp_max_buf 8388608 |
| FreeBSD, Darwin | sysctl -w kern.ipc.maxsockbuf=8388608 |
| AIX | no -o sb_max=8388608 (note: AIX only permits sizes of 1048576, 4194304 or 8388608) |
The AIX command given above will change the current value and automatically modify /etc/tunables/nextboot so that the change will survive rebooting. Other platforms require additional work described below to make changes survive a reboot.
For Linux and FreeBSD, simply add the sysctl variable setting given above to /etc/sysctl.conf leaving off the sysctl -w part.
We haven't found a convention for Solaris, but would love to hear about it if we've missed something. We've had success just adding the ndd command given above to the end of /etc/rc2.d/S20sysetup.
Interpreting the output of netstat is important in detecting UDP loss. Unfortunately, the output varies considerably from one flavor of Unix to another. Hence we can't give one set of instructions that will work with all flavors.
For each Unix flavor, we tested under normal conditions and then under conditions forcing UDP loss while keeping a close eye on the output of netstat -s before and after the tests. This revealed the statistics that appeared to have a relationship with UDP packet loss. Output from Solaris and FreeBSD netstat was the most intuitive; Linux and AIX much less so. Following sections give the command we used and highlight the important output for detecting UDP loss.
Use netstat -s. Look for udpInOverflows. It will be in the IPv4 section, not in the UDP section as you might expect. For example:
IPv4: udpInOverflows = 82427
Use netstat -su. Look for packet receive errors in the Udp section. For example:
Udp: 38799 packet receive errors
Use netstat -s. Look for Receive Errors in the UDP Statistics for IPv4 section. For example:
UDP Statistics for IPv4 Receive Errors = 131213
Use netstat -s. Look for fragments dropped (dup or out of space) in the ip section. For example:
ip: 77070 fragments dropped (dup or out of space)
Use netstat -s. Look for dropped due to full socket buffers in the udp section. For example:
udp: 6343 dropped due to full socket buffers
Copyright 2004 - 2008 29West, Inc.


A blockchain is a decentralized, distributed and public digital ledger that is used to record transactions across many computers so that any involved record cannot be altered retroactively, without the alteration of all subsequent blocks.
Blocks hold batches of valid transactions that are hashed and encoded into a Merkle tree. Each block includes the cryptographic hash of the prior block in the blockchain, linking the two. The linked blocks form a chain. This iterative process confirms the integrity of the previous block, all the way back to the original genesis block.
Each block contains a cryptographic hash of the previous block, a timestamp, and transaction data (generally represented as a Merkle tree)
By design, a blockchain is resistant to modification of the data. It is an open, distributed ledger that can record transactions between two parties efficiently and in a verifiable and permanent way.
For use as a distributed ledger, a blockchain is typically managed by a peer-to-peer network collectively adhering to a protocol for inter-node communication and validating new blocks.
Once recorded, the data in any given block cannot be altered retroactively without alteration of all subsequent blocks, which requires consensus of the network majority.
Federated blockchain, you’ll get a decentralized private environment.In federated blockchain instead of one organization maintaining the network, there would be multiple organizations who will take decision making role. The presence of multiple parties on the network establishes the decentralized structure of the federated blockchain.


NGOs Implicated In Esidimeni Deaths To Appear Before SIU Tribunal
by NT EditorThirteen nonprofit organisations implicated in the deaths of at least 144 Life Esidimeni patients are due to appear before the Special Investigating Unit’s Tribunal soon for alleged fraud.
Retired Judge Dikgang Moseneke recommended the Gauteng government investigate the organisations after the Esidimeni commission found they allegedly benefited over R5.5 million through fake invoices.
The NGOs were found to be ill-equipped to look after the psychiatric patients who died during transfers across the province in 2016.
The Special Investigating Unit has started with its crackdown on 28 NGOs facing several allegations of wrongdoing in connection with the Life Esidimeni tragedy.
The SIU tribunal has completed its first phase of investigations into the 13 NGOs accused of illegally pocketing around R5.5 million.
Tribunal spokesperson Selby Mokgotho said: “The civil claims have been investigated and finalised to institute proceedings with the ultimate intention of the recovery of the money.”
Mokgotho explains what will happen after they appear before the tribunal.
“The tribunal will be able to grant orders where there is a need for suspension orders.”
There’s been no accountability or concrete action against those responsible for the deaths since the tragedy three years ago.


Our product is very suitable for young people, because young people like to try new things, will continue to accept new ideas, and like to chase the trend, so our product is very suitable for their idea and taste, so our products" overwhelming majority of customers is young people. And young people love to use micro-blog, WeChat, QQ and other platforms, so the trend of new products in their circle will spread quickly, which has played a very big help for our product promotion
Such fashion trend is not only belong to the young people.Middle aged people can change their own lifestyle through such interesting designs.They are always very legalistic and busy with his work all day long, their life need to have such new products to adjust, to awaken their desire for new things, and this is also a good way to help them communicate with their kids, and eliminate the generation gap at the same time.
Older people can learn to try new things and find more fun in this way.They don"t need to work, so their life is very carefree and content. In this way it is very comfortable for them to have nothing to do, then researching new technology and new products will be a very good choice. They can choose to let their grandchildren teach them to play with our products, so that they can not only have fun but also enhance their feelings


--- layout: post title: pooped date: '2011-03-06T11:01:00+01:00' tags: [] tumblr_url: http://dotmr.tumblr.com/post/3701690876/pooped ---
pooped


I recieved 500 mgs of 5-meo-amt. This chemical is very tiny and the dose is extremely small. What I did was take a visine bottle and count out how many drops came out. I wasn't crazy about putting the stuff in a large amount of alchohal because I can't fathom drinking milliliters of grain alchohal. 375 drops came out of the visine which was perfect. I then rinsed the bottle out and put a little less than 500 mgs in (some was stuck in the bottle).
Then I added the 153 proof liquor to the mark where the drops ended. The 5-meo-amt is very soluable in alchohal. It dissolved almost instantly. I shook it anyway, and let it sit for a few hours. The chem was still dissolved. I shook it, and dropped 2 drops on my toungue. The chem was tasteless and absorbed right on my tongue. I think the alchohal might have numbed the taste and made for easy absorbtion.
Within 20 min I felt something, but I couldn't pin point it. I had no nasuea during the trip, which was mild and only about 7 hrs long. I had mild trails, color enhancement, and minor patterning. I ate 4-aco-det the night before so I probally exhausted my tolerance. I will wait a week and try 5 drops. I am currently storing the solution in my freezer, and it hasn't froze. I am still nervous about freezing it, but I figure it should preserve it for a long time considering 500 mgs of 5-meo-amt is not something you can use up in a week.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


--- layout: blog title: Help & Support redirect_to: "http://makerlog.org" ---
Need assistance with a Learn.js purchase?
Email us at hi@learnjs.io


What Every Programmer Absolutely, Positively Needs To Know About Encodings And Character Sets To Work With Text
- Encoding vs. Unicode “Code Points”: > “Unicode first and foremost defines a table of code points for characters. That’s a fancy way of saying”65 stands for A, 66 stands for B and 9,731 stands for ☃" (seriously, it does). How these code points are actually encoded into bits is a different topic." … “Characters are referred to by their”Unicode code point“. Unicode code points are written in hexadecimal (to keep the numbers shorter), preceded by a”U+" (that’s just what they do, it has no other meaning than “this is a Unicode code point”)."


{{item.desc}}
You are ordering {{amount}} pc's of {{item.name}} Price is {{item.price*amount}} €, with current rate it makes {{((item.price/rate)*amount) | round(6,'floor')}}


Toggle navigation
Niharika Creations
Logout
Dashboard
Enquiry
Purchase Order
Weaver Order
Purchase Orders
Purchase Order Number
Purchase Order Date
Company Name
Quality of Fabric
Quantity of Fabric
Price
Email
Submit
Reset
List of Purchase Orders
PO_Number
PO_Date
Company Name
Quality
Quantity
Price
Email


Linear regression for assessing and predicting the market value of used cars
1. Introduction
The purpose of this blog post is to explore the possibility of applying linear regression to describe, analyze and predict the listing price of used cars. In this regard, linear regression is introduced more loosely without having to define concepts in a strict mathematical sense. The data used in this post is scrapped from major used car listing websites. For more on the data and the subsequent analysis see this Jupyter Notebook or see the ‘Data’ section below. A serverless API of the final model is available here. You can also checkout my Github page if you are interested in the python code used for scrapping or if you want to download the data in csv format.
To make like-for-like comparisons and analysis, the following mid-sized sedans are considered.
| Manufacturer | Model |
|---|---|
| Toyota | Camry |
| Honda | Accord |
| Nissan | Altima |
| Ford | Fusion |
| Hyundai | Sonata |
| Chevrolet | Malibu |
| Volkswagen | Passat |
The goal is to be able to address questions like:
- How much would a model X car that is driven Y miles cost?
- What is the average price of model X cars after Y miles of usage?
- How much does depriciation (w.r.t. mileage, release year) affect model A cars compared to model B?
That said, everything stated in this blog post is solely based on curiosity and the desire to apply regression to the used car market. Obviously, anyone seriously considering to buy a car should seek expert advice.
2. The theory
Linear regression inherently assumes that there is a linear relationship between a random variable (the dependent variable) and another set of random variable(s) (the independent variables), i.e,
,
where is called the intercept and is the coefficient for . Often, the independent variable and the coefficients are expressed as -dimensional vectors, i.e., and
Linear regression acknowledges the relationship between the dependent and independent random variables can be non-deterministic. That is, there can be some uncertainity involved in determining the value of Y evenif we have a perfect knowledge of the values of the s. This uncertainity is represented by the error term e in the regression equation. All the uncertainity we cannot (or don’t want to) explain about Y is absorbed by this term.
In order to build reliable models we make the following assumptions on the error term:
-
The error should be independent of . For example, let our linear regression model represent the power consumption of an electronic device as a function of the load, and let us assume the model is ( and representing the and random variables, respectively). The independence assumption dictates that the probabilistic nature of should remain unaffected whether the load is 10%, 95%, or any other value.
-
The spread of e remains constant across all values of X. Going back to the previous example, e should not be more (or less) spread for the range of load values under study.
-
If statistical tests are required, we further need to assume that e has a normal distribution centered at 0. For further details on related matter check the assumptions and best practices of linear regression.
The coefficients in a linear regression model can be solved directly by matrix inversion or more iteratively by gradient descent or one of its variants.
Here it is important to note that the ‘linear’ in linear regression does not necessarily mean the relationship between X and Y is expressed as a straight line. For example,
is also considered a linear model as long as the expression remains linear in the coefficients.
Clearly, there is a plethora of models to choose from. we, therefore, need to have metrics that quantify how well a model performs in capturing the relationship between X & Y to be able to select the best model. Two of such metrics are:
-
R2: Also refered to as the coefficient of determination indicates how much of the variability of Y is explained by X (the independent variable). R2 of 1 tells us X perfectly (100%) explains the variability in Y, i.e., there is no uncertainty left in Y once the values of X are known. By contrast, R2 of 0 suggests X does not explain any of the variability in Y at all. Other values between 0 and 1 lie on the spectrum accordingly.
-
Predicted R2 and Adjusted R2: One weakness of R2 is that it is susiptible to overfitting. Predicted R2 and Adjusted R2 are aimed at mitigating this issue. Read this post for more detail.
-
RMSE: The Root Mean Squared Error is the expected magnitude of prediction error. RMSE = 0 represents a perfect model, and model performance decreases as RMSE increases. RMSE can also be nicely decomposed into bias and variance terms of the model.
We will also apply confidence and prediction intervals. This video elegantly shows what their difference is and how to calculate them.
3. The data
The data, as already mentioned in the introduction, is scrapped from car listing websites. The scrapped data is parsed and cleaned and the resulting data is stored in a csv file, which has the following format:
| Year | Year of release, e.g. 2010, 2019 |
|---|---|
| Make | Manufacturer of the car: Honda, Toyota, Nissan, Ford, Hyundai, Chevrolet and Volkswagen |
| Model | Accord, Camry, Altima, Fusion, Sonata, Malibu or Passat |
| Model detail | Trim level, e.g. for Honda LX, Sport, EX, EX-L and Touring |
| Price | Listing price of the car |
| Mileage | Mileage (in miles) posted by dealer |
| Website | A two letter abbreviation to identify the source website |
The following table provides valuable summary statistics of the quantitative columns
The CSV file contains listing details of 11,018 cars. However, dealers may list the same car more than once to improve its chance of being discovered among other cars. Duplicate entries may lead to inaccurate analysis and prediction. We, therefore, need to remove duplicates and run the summary statistics again. Doing so reveals that about half of the listings are duplicate entries as shown below.
Now we know that there are 6396 unique cars. Going one level deeper, we can see the number of cars, the average price, average mileage and average release year per manufacturer (model) below
Out of the 6396 unique cars listed, 1540 are Nissan Altima, 1317 are Toyota Camry, 1058 are Honda Accord and so on.
4. Analysis
Here, the goal is to build a multi-linear regression model that predicts (summarizes) the Listing Price of a used mid-size sedan car based on its Mileage, Release (Model) Year, and Trim level. We’ll build separate regression models for each of the cars listed above, excluding VW Passat and Chevrolet Malibu.
Before jumping into building the regression models, let us examine how Price tends to change with respect to Mileage and Year by taking the Honda Accord data set as an example. The following plots reveal the strong negative relationship between mileage and price and the strong positive relationship between release year and price.
The correlation matrix shown below quantifies this relationship. It also shows the strong negative relationship between Mileage and Year. Intuitively, it is highly unlikely for a 2019 model to rack up 100,000 miles as it is equally unlikely for a 2008 model to have a mileage of 10,000 miles.
For more on this and other analysis related to regression model building see this python notebook.
4.1 Regression models
After considering a number of features and feature transforms the following regression function that better expresses the relationship between the independent variables (Mileage, Year, Trim level)and dependent variable (Listing Price)is chosen:
,
where are the Price, Mileage, Year, and Trim of car , respectively. are the intercept, coefficient w.r.t Mileage, and coefficient w.r.t. Year. Since trim level is a categorical variable, we need to dummy-encode it before it can be used in a regression model. Assuming there are trim levels of a car model dummy variables are created using the summation of the indicators in the last term of the above equation. This results in one dummy variable for each trim level except the base trim-level. Coefficeint , therefore, represents the price difference between the base trim level and the trim level.
Note that Mileage and Year are transformed using functions and . The log transformation of Mileage not only yields better model performance it can also be motivated by the fact that the sharpest decline in Price happens during the first few (thousand) miles. Once a car makes it into tens of thousands of miles, the rate at which the Price decreases should slow down. Logarithmic functions are one of several functions that could capture this nonlinear relationship between Mileage and Price. Since base 2 logarithm is used, $a_1$ represents the depreciation with respect to mileage every time mileage doubles.
When it comes to the Year, what affects the Price of a car is how old the model is relative to the newest model, which is why the transformation is used. For example, a Toyota Camry is years old and should have a lower price than a ( years old) Toyota Camry if everything else is kept constant.
Five elastic net regularised models are trained for Ford Fusion, Honda Accord, Hyundai Sonata, Nissan Altima, and Toyota Camry. The coefficients and performance metrics of the resulting models are shown below.
| Car Model | Count* | Coefficients() | * | RMSE($) |
|---|---|---|---|---|
| Ford Fusion | 743 | (-1180, -920) | 81.2% | 1543 |
| Honda Accord | 1015 | (-1350, -1050) | 87.2% | 1888 |
| Hyundai Sonata | 687 | (-1200, -770) | 80.3% | 1302 |
| Nissan Altima | 1434 | (-1250, -780) | 70.9% | 1217 |
| Toyota Camry | 1172 | (-770, -1010) | 77.2% | 1510 |
- score is calculated on a test set after outlier removal using Cook’s distance. The number of cars used to train each model after outlier removal is presented in the ‘Count’ column.
According to the regression models, Toyota Camry has the smallest (in magnitude) coefficient w.r.t Mileage at . Take, for example, the price of a given Toyota Camry is at 500 miles. The model predicts that the average price drop is $19,230$ at 1000 miles, $18,460 at 2000 miles, so on.
Note that coefficient represents the depreciation with respect to mileage, which makes Toyota Camry the best one among the five models considered for retaining much of its original value as mileage increases. By contrast, Nissan Altima and Hyundai Sonata exhibit the least depreciation with respect to Year, with every passing year reducing the value of the car by about $800.
The following plots show the fitted regression models for all car models along with the data used to fit the regression models. In order to simplify the plots into 2D, cars (points in the scatter plot) are assumed to rack up 12000 miles per year, allowing us to represent Year in terms of Mileage as .
The bottom right plot shows all five regression curves in one plot. This plot, once more, gives the visual confirmation that Toyota Camry loses the least amount of value to depreciation.
Without the 12000 miles/year assumption, the resulting plots are 3-dimensional. The next figure shows such a plot for Honda Accord. It is easy to see that Price decreases linearly in the Year axis and logarithmically in the Mileage axis.
4.2 Prediction and comparison
The regression models we built can be used to predict the value of a car as well as making inference. Typcial questions we are interested in prediction are “What is the average price of used cars from model X, Year Y, trim T with mileage M?” or “What is the price range for a particular used car from model X, Year Y, trim T with mileage M?”. The former question is answered using the the regression line and calculating a confidence interval around it, while the latter is addressed by calculating a prediction interval along the regression line.
For example, the predicted average price of the base trim-level (LE) 2016 Toyota Camry cars at 40000 miles is
with a narrow 95% confidence interval of while the 95% prediction interval is . Roughly speaking, this means there is a 95% chance that a 2016 Toyota Camry LE car will have a listing price between and at miles.
If we compare these numbers to a 2016 Hyundai Sonata car at 40000 miles, we get
with confidence and prediction intervals of and , respectively.
In some cases, the prediction intervals can be too wide to be useful, specially compared to the narrow confidence intervals for the average listing price. However, considering the long list of factors that can affect the price of a car, this should not be surprising since the regression model only uses mileage, year, and trim level to predict price. The intervals could be narrowed down by obtaining more data and including additional features such as engine type, repair history and accident history.
5. Conclusion
This post illustrated how a simple approach such as linear regression can be applied to infere and predict the listing price of used mid-sized sedans. While regression can be a valuable tool to predict a continuous valued dependent variable, it also sets some assumptions about the predicted and predicting variables that need to be checked before the resulting regression model can be deemed acceptable.
Once the assumptions are checked, regression models can easily be trained with a relatively small amount of data, and in addtion to it’s predictive power, the coefficients of the model also give some insight on the magnitude and direction of the relationship between the dependent and independent variables.


"""
Sparse Matrix Utils
-------------------
Functions for computing corpus-wide term- or document-based values, like
term frequency, document frequency, and document length, and filtering terms
from a matrix by their document frequency.
"""
import numpy as np
import scipy.sparse as sp
[docs]def get_term_freqs(doc_term_matrix, *, type_="linear"):
"""
Compute frequencies for all terms in a document-term matrix, with optional
sub-linear scaling.
Args:
doc_term_matrix (:class:`scipy.sparse.csr_matrix`): M x N sparse matrix,
where M is the # of docs and N is the # of unique terms. Values must be
the linear, un-scaled counts of term n per doc m.
type_ ({'linear', 'sqrt', 'log'}): Scaling applied to absolute term counts.
If 'linear', term counts are left as-is, since the sums are already
linear; if 'sqrt', tf => sqrt(tf); if 'log', tf => log(tf) + 1.
Returns:
:class:`numpy.ndarray`: Array of term frequencies, with length equal to
the # of unique terms (# of columns) in ``doc_term_matrix``.
Raises:
ValueError: if ``doc_term_matrix`` doesn't have any non-zero entries, or
if ``type_`` isn't one of {"linear", "sqrt", "log"}.
"""
if doc_term_matrix.nnz == 0:
raise ValueError("`doc_term_matrix` must have at least 1 non-zero entry")
tfs = np.asarray(doc_term_matrix.sum(axis=0)).ravel()
if type_ == "linear":
return tfs # tfs is already linear
elif type_ == "sqrt":
return np.sqrt(tfs)
elif type_ == "log":
return np.log(tfs) + 1.0
else:
raise ValueError(
"type_ = {} is invalid; value must be one of {}".format(
type_, {"linear", "sqrt", "log"}
)
)
[docs]def get_doc_freqs(doc_term_matrix):
"""
Compute document frequencies for all terms in a document-term matrix.
Args:
doc_term_matrix (:class:`scipy.sparse.csr_matrix`): M x N sparse matrix,
where M is the # of docs and N is the # of unique terms.
.. note:: Weighting on the terms doesn't matter! Could be binary or
tf or tfidf, a term's doc freq will be the same.
Returns:
:class:`numpy.ndarray`: Array of document frequencies, with length equal to
the # of unique terms (# of columns) in ``doc_term_matrix``.
Raises:
ValueError: if ``doc_term_matrix`` doesn't have any non-zero entries.
"""
if doc_term_matrix.nnz == 0:
raise ValueError("`doc_term_matrix` must have at least 1 non-zero entry")
_, n_terms = doc_term_matrix.shape
return np.bincount(doc_term_matrix.indices, minlength=n_terms)
[docs]def get_inverse_doc_freqs(doc_term_matrix, *, type_="smooth"):
"""
Compute inverse document frequencies for all terms in a document-term matrix,
using one of several IDF formulations.
Args:
doc_term_matrix (:class:`scipy.sparse.csr_matrix`): M x N sparse matrix,
where M is the # of docs and N is the # of unique terms.
The particular weighting of matrix values doesn't matter.
type_ ({'standard', 'smooth', 'bm25'}): Type of IDF formulation to use.
If 'standard', idfs => log(n_docs / dfs) + 1.0;
if 'smooth', idfs => log(n_docs + 1 / dfs + 1) + 1.0, i.e. 1 is added
to all document frequencies, equivalent to adding a single document
to the corpus containing every unique term;
if 'bm25', idfs => log((n_docs - dfs + 0.5) / (dfs + 0.5)), which is
a form commonly used in BM25 ranking that allows for extremely common
terms to have negative idf weights.
Returns:
:class:`numpy.ndarray`: Array of inverse document frequencies, with length
equal to the # of unique terms (# of columns) in ``doc_term_matrix``.
Raises:
ValueError: if ``type_`` isn't one of {"standard", "smooth", "bm25"}.
"""
dfs = get_doc_freqs(doc_term_matrix)
n_docs, _ = doc_term_matrix.shape
if type_ == "standard":
return np.log(n_docs / dfs) + 1.0
elif type_ == "smooth":
n_docs += 1
dfs += 1
return np.log(n_docs / dfs) + 1.0
elif type_ == "bm25":
return np.log((n_docs - dfs + 0.5) / (dfs + 0.5))
else:
raise ValueError(
"type_ = {} is invalid; value must be one of {}".format(
type_, {"standard", "smooth", "bm25"}
)
)
[docs]def get_doc_lengths(doc_term_matrix, *, type_="linear"):
"""
Compute the lengths (i.e. number of terms) for all documents in a
document-term matrix.
Args:
doc_term_matrix (:class:`scipy.sparse.csr_matrix`): M x N sparse matrix,
where M is the # of docs, N is the # of unique terms, and values are
the absolute counts of term n per doc m.
type_ ({'linear', 'sqrt', 'log'}): Scaling applied to absolute doc lengths.
If 'linear', lengths are left as-is, since the sums are already
linear; if 'sqrt', dl => sqrt(dl); if 'log', dl => log(dl) + 1.
Returns:
:class:`numpy.ndarray`: Array of document lengths, with length equal to
the # of documents (# of rows) in ``doc_term_matrix``.
Raises:
ValueError: if ``type_`` isn't one of {"linear", "sqrt", "log"}.
"""
dls = np.asarray(doc_term_matrix.sum(axis=1)).ravel()
if type_ == "linear":
return dls # dls is already linear
elif type_ == "sqrt":
return np.sqrt(dls)
elif type_ == "log":
return np.log(dls) + 1.0
else:
raise ValueError(
"`type_` = {} invalid; must be one of {}".format(
type_, {"linear", "sqrt", "log"}
)
)
[docs]def get_information_content(doc_term_matrix):
"""
Compute information content for all terms in a document-term matrix. IC is a
float in [0.0, 1.0], defined as ``-df * log2(df) - (1 - df) * log2(1 - df)``,
where df is a term's normalized document frequency.
Args:
doc_term_matrix (:class:`scipy.sparse.csr_matrix`): M x N sparse matrix,
where M is the # of docs and N is the # of unique terms.
.. note:: Weighting on the terms doesn't matter! Could be binary or
tf or tfidf, a term's information content will be the same.
Returns:
:class:`numpy.ndarray`: Array of term information content values, with
length equal to the # of unique terms (# of columns) in ``doc_term_matrix``.
Raises:
ValueError: if ``doc_term_matrix`` doesn't have any non-zero entries.
"""
dfs = get_doc_freqs(doc_term_matrix)
# normalize doc freqs by total number of docs
# TODO: is this *really* what we want to do?
dfs = dfs / doc_term_matrix.shape[0]
ics = -dfs * np.log2(dfs) - (1 - dfs) * np.log2(1 - dfs)
ics[np.isnan(ics)] = 0.0 # NaN values not permitted!
return ics
[docs]def apply_idf_weighting(doc_term_matrix, *, type_="smooth"):
"""
Apply inverse document frequency (idf) weighting to a term-frequency (tf)
weighted document-term matrix, using one of several IDF formulations.
Args:
doc_term_matrix (:class:`scipy.sparse.csr_matrix`): M x N sparse matrix,
where M is the # of docs and N is the # of unique terms.
type_ ({'standard', 'smooth', 'bm25'}): Type of IDF formulation to use.
Returns:
:class:`scipy.sparse.csr_matrix`: Sparse matrix of shape M x N,
where value (i, j) is the tfidf weight of term j in doc i.
See Also:
:func:`get_inverse_doc_freqs()`
"""
idfs = get_inverse_doc_freqs(doc_term_matrix, type_=type_)
return doc_term_matrix.dot(sp.diags(idfs, 0))
[docs]def filter_terms_by_df(
doc_term_matrix, term_to_id, *, max_df=1.0, min_df=1, max_n_terms=None,
):
"""
Filter out terms that are too common and/or too rare (by document frequency),
and compactify the top ``max_n_terms`` in the ``id_to_term`` mapping accordingly.
Borrows heavily from the ``sklearn.feature_extraction.text`` module.
Args:
doc_term_matrix (:class:`scipy.sparse.csr_matrix`): M X N matrix, where
M is the # of docs and N is the # of unique terms.
term_to_id (Dict[str, int]): Mapping of term string to unique term id,
e.g. :attr:`Vectorizer.vocabulary_terms`.
min_df (float or int): if float, value is the fractional proportion of
the total number of documents and must be in [0.0, 1.0]; if int,
value is the absolute number; filter terms whose document frequency
is less than ``min_df``
max_df (float or int): if float, value is the fractional proportion of
the total number of documents and must be in [0.0, 1.0]; if int,
value is the absolute number; filter terms whose document frequency
is greater than ``max_df``
max_n_terms (int): only include terms whose *term* frequency is within
the top `max_n_terms`
Returns:
:class:`scipy.sparse.csr_matrix`: Sparse matrix of shape (# docs, # unique filtered terms),
where value (i, j) is the weight of term j in doc i.
Dict[str, int]: Term to id mapping, where keys are unique *filtered* terms
as strings and values are their corresponding integer ids.
Raises:
ValueError: if ``max_df`` or ``min_df`` or ``max_n_terms`` < 0.
"""
if max_df == 1.0 and min_df == 1 and max_n_terms is None:
return doc_term_matrix, term_to_id
if max_df < 0 or min_df < 0 or (max_n_terms is not None and max_n_terms < 0):
raise ValueError("max_df, min_df, and max_n_terms may not be negative")
n_docs, n_terms = doc_term_matrix.shape
max_doc_count = max_df if isinstance(max_df, int) else int(max_df * n_docs)
min_doc_count = min_df if isinstance(min_df, int) else int(min_df * n_docs)
if max_doc_count < min_doc_count:
raise ValueError("max_df corresponds to fewer documents than min_df")
# calculate a mask based on document frequencies
dfs = get_doc_freqs(doc_term_matrix)
mask = np.ones(n_terms, dtype=bool)
if max_doc_count < n_docs:
mask &= dfs <= max_doc_count
if min_doc_count > 1:
mask &= dfs >= min_doc_count
if max_n_terms is not None and mask.sum() > max_n_terms:
tfs = get_term_freqs(doc_term_matrix, type_="linear")
top_mask_inds = (-tfs[mask]).argsort()[:max_n_terms]
new_mask = np.zeros(n_terms, dtype=bool)
new_mask[np.where(mask)[0][top_mask_inds]] = True
mask = new_mask
# map old term indices to new ones
new_indices = np.cumsum(mask) - 1
term_to_id = {
term: new_indices[old_index]
for term, old_index in term_to_id.items()
if mask[old_index]
}
kept_indices = np.where(mask)[0]
if len(kept_indices) == 0:
raise ValueError(
"After filtering, no terms remain; "
"try a lower `min_df` or higher `max_df`"
)
return (doc_term_matrix[:, kept_indices], term_to_id)
[docs]def filter_terms_by_ic(doc_term_matrix, term_to_id, *, min_ic=0.0, max_n_terms=None):
"""
Filter out terms that are too common and/or too rare (by information content),
and compactify the top ``max_n_terms`` in the ``id_to_term`` mapping accordingly.
Borrows heavily from the ``sklearn.feature_extraction.text`` module.
Args:
doc_term_matrix (:class:`scipy.sparse.csr_matrix`): M X N sparse matrix,
where M is the # of docs and N is the # of unique terms.
term_to_id (Dict[str, int]): Mapping of term string to unique term id,
e.g. :attr:`Vectorizer.vocabulary_terms`.
min_ic (float): filter terms whose information content is less than this
value; must be in [0.0, 1.0]
max_n_terms (int): only include terms whose information content is within
the top ``max_n_terms``
Returns:
:class:`scipy.sparse.csr_matrix`: Sparse matrix of shape (# docs, # unique filtered terms),
where value (i, j) is the weight of term j in doc i.
Dict[str, int]: Term to id mapping, where keys are unique *filtered* terms
as strings and values are their corresponding integer ids.
Raises:
ValueError: if ``min_ic`` not in [0.0, 1.0] or ``max_n_terms`` < 0.
"""
if min_ic == 0.0 and max_n_terms is None:
return doc_term_matrix, term_to_id
if min_ic < 0.0 or min_ic > 1.0:
raise ValueError("min_ic must be a float in [0.0, 1.0]")
if max_n_terms is not None and max_n_terms < 0:
raise ValueError("max_n_terms may not be negative")
_, n_terms = doc_term_matrix.shape
# calculate a mask based on document frequencies
ics = get_information_content(doc_term_matrix)
mask = np.ones(n_terms, dtype=bool)
if min_ic > 0.0:
mask &= ics >= min_ic
if max_n_terms is not None and mask.sum() > max_n_terms:
top_mask_inds = (-ics[mask]).argsort()[:max_n_terms]
new_mask = np.zeros(n_terms, dtype=bool)
new_mask[np.where(mask)[0][top_mask_inds]] = True
mask = new_mask
# map old term indices to new ones
new_indices = np.cumsum(mask) - 1
term_to_id = {
term: new_indices[old_index]
for term, old_index in term_to_id.items()
if mask[old_index]
}
kept_indices = np.where(mask)[0]
if len(kept_indices) == 0:
raise ValueError("After filtering, no terms remain; try a lower `min_ic`")
return (doc_term_matrix[:, kept_indices], term_to_id)


oh.. there is something wrong
Can't access admin page bud..
Username: {{ form.username }}
Password: {{ form.password }}


Apple Developer Program
Tags: Apple
Type: Auxiliary Info
Developers must generally join the Apple Developer Program in order to build and sign and distribute their applications.
Link: Apple Developer Site
Contributed by on
Tips for App Development using Swift
Tags: Apple
Type: Auxiliary Info
Developers must generally join the Apple Developer Program in order to build and sign and distribute their applications.
Link: Apple Developer Site
Contributed by on


1/12/2015:
Concepts: Optionals
- Optionals are just enums
- Enumerate
- Range: a psuedo-representation of Range:
struct Range<T> {
var startIndex: T
var endIndex: T
} // note an array's range would be Range<Int>
- Special syntax for range:
let array = ["a","b","c","d","e"]
let subArray1 = array[2...3] // ["c", "d"]
let subArray1 = array[2...3] // ["c"]
for i in [27...104] { } //range is enumerable
- NSobject is the base class for all Objective-C classes (what about best practices in Swift?)
- It seems that Swift classes are inherently linked to these NSObject classes.
- NSNumber - generic number-holding class
- NSDate - used to find out date and time; be sure to check localization ramifications here...
- NSData - a "bag o' bits" used to save/restore/transmit raw data
Classes, Structures and Enumerations
- Similarities: declaration syntaxes, properties and functions, initliazers.
- Only classes have inheritance
- Introspection and casting are classes only
- Structs and Enums are passed by value but Classes are passed by reference
- Mark a function that can mutate a struct/enum with the keyword mutating
- Reference (stored in the heap). Note that you can still use
let
to mutate class properties with methods - You can override methods/properties in superclass with keyword
override
- Both types and instances can have methods/properties:
var d: Double = ...
if d.isSignMinus {
d = Double.abs(d)
}
- See above:
- here, isSignMinus is an instance property of a Double (you send it to particular Double)
- abs is a type method of a Double (sent to the type itself not a particular Double).
- You have to declare a type method/roerty with a
static
prefix or withclass
in a class:static func abs(d: Double) -> Double
- Paramters to all functions have an internal and external name
- internal name : name of local variable used inside method
- external name is what callers use to call the method
- Use
_
if no callers should use external name for given parameter
- Property Observers:
willSet
anddidSet
will be called before and after setting a property withnewValue
andoldValue
as their respective parmaters Lazy initialization: initialized only when someone acceses it
- can be used when there are cyclized dependencies between parent and child classes
When is
init
method needed?- You can set any property's value ...few asleep for 10 minutes
- Casting works with the
as
keyword.
1/12/2015:
Continuation of Calculator Demo - Assignment #2 will be based on the demo today
Concepts: Operand/operator stack
- Conventions: camelcase convention for names of files (e.g.
CalculatorBrain.swift
) - We're defining an Op object to refer to an operand or an operator: should it be a class or function or an enum
- We can create an empty array of objects with:
var opStack = Array<Op>()
, but the preferred syntax isvar opStack = [Op]()
- Functions are just types in Swift (no different from strings)
- Creating an enum (used to enumerate different possibilities): In swift, we can associate data with any of the cases in this enum
enum Op {
case Operand(Double)
case UnaryOperation(String, Double -> Double)
case BinaryOperation(String, (Double, Double) -> Double)
}
- An initializer is called by invoking a class with parentheses: (e.g.
var knownOps = [String:Op]()
). - We can also intiialize it with the
init()
method - Looking up something in a dictionary will always return an optional
- To make variables private to a class, add
private
- Sometimes you can't return an actual return value, you can make it an optional return value:
func evaluate() -> Double? {
}
- Swift passes structs by value and clases by references: Arrays, Dictionaries are structs
- There's an implicit
let
in from of all structs as parameters (read-only!) so the struct in this case is immutable - Hacky way of making a mutable copy for use inside a function (see the var that replaces the implicit let in the parameter):
func evaluate(var ops: [Op]) {
}
- Swift is actually smart enough to not actually copy a struct until a change is made. Swift might even make just a partial copy or just kept track of the actual changes made.
- We use
switch
to pull associated values out of enums - Underbars
_
are used when we don't care about the variable and don't intend on using it
1/7/2015:
Continuation of Calculator Demo
Concepts: Typed Functions, Arrays, Sets
Review
- Optionals are automatically assigned to be nil (not set)
- Note it's not necessary to declare the type of a variable:
var operandStack: Array<Double> = Array<Double>()
is equivalent tovar operandStack = Array<Double>()
- Creating arrays are just like:
- Computed properties : you can define properties that are computed and updated anywhere it is used
- Switch statement is much more powerful in Swift. You have to cover every possibility (make sure to include a Default case)
- Closures allow you to define functions as parameters:
performOperation({(op1,op2) in op1 * op2)
is equivalent toperformOperation {$0 * $1}
MVC - 3 camps
- Model - what your application (i.e. what is a program?)
- The model is completely UI independent, should never talk to the view
- Controller - how your model is presented to the user
- Controllers can always talk directly to their Model
- Controllers can also talk directly to the view (outlet)
- View - what the user sees
- Comunicates with the contorller through actions
- Sometimes the view needs to be synchronized with the controller (i.e. should I allow the user to scroll?
shouldScroll
willScroll
didScroll
- we solve this with delegations
- delegate is set via a protocol ("blind" to class)
- controllers provide a data source to the view
1/5/2015: Introduction to Swift
Introduction to the course and the start of the calculator demo to build basic intuition about programming in Swift
Concepts: Creating a project, Tying/connecting button components to their corresponding methods in the controller, Swift basics, Types in Swift (Optional types)
Logistics:
- Each class will feature a Demo
- Enrollment survey deadline is Tuesday
- Paul will likely have a "second start" to the class for the iTunesU taping (2 week delay)
Overview + Prerequisites:
- Real life object-oriented programming
- Databases, graphics, multimedia, animation in a real-world application
- Prior coursework assumes object-oriented programming
Four Layers
- Core OS:
- UNIX-based system
- Sockets, Kernel, Permissions, near hardware level
- Core Services
- Accessing lower level services through object-oriented interfaces
- Media (little time spent in this area)
- Capturing, editing media
- Audio mixing, recording
- Cocoa Touch (Vast majority of time spent here, 70%+)
- Buttons, sliders, multi-touch
- Build the interactivity with the application here
Platform Components:
- Xcode 6 is the code editor, compiler, debugger
- Language(s): We'll learn Swift in this class
- Frameworks - core motion, map kit, gyroscope
- Design Strategy - MVC
Demo:
- We're building a calculator from scratch
- Topics include:
- Creating a project in Xcode
- Building a UI
- iOS Simulator
- println
- defining a class in Swift
- Connecting method interactions to their components (CTRL + Drag method dots to their corresponding components in the view)


Who should start this process?
You can start adding the details of your apprenticeships to this commitment or you ask ask your provider to start it for you.
You can start adding the details of your apprenticeships to this commitment or you ask ask your provider to start it for you.


| is_callable {rlang} | R Documentation |
A callable object is an object that can appear in the function position of a call (as opposed to argument position). This includes symbolic objects that evaluate to a function or literal functions embedded in the call.
is_callable(x)
x |
An object to test. |
Note that strings may look like callable objects because
expressions of the form "list"()
are valid R code. However,
that's only because the R parser transforms strings to symbols. It
is not legal to manually set language heads to strings.
# Symbolic objects and functions are callable: is_callable(quote(foo)) is_callable(base::identity) # node_poke_car() lets you modify calls without any checking: lang <- quote(foo(10)) node_poke_car(lang, current_env()) # Use is_callable() to check an input object is safe to put as CAR: obj <- base::identity if (is_callable(obj)) { lang <- node_poke_car(lang, obj) } else { abort("`obj` must be callable") } eval_bare(lang)


ColorCAL
¶psychopy.hardware.crs.colorcal.
ColorCAL
(port=None, maxAttempts=2)¶A class to handle the CRS Ltd ColorCAL device
Open serial port connection with Colorcal II device
Usage: cc = ColorCAL(port, maxAttempts)
calibrateZero
()¶Perform a calibration to zero light.
For early versions of the ColorCAL this had to be called after connecting to the device. For later versions the dark calibration was performed at the factory and stored in non-volatile memory.
You can check if you need to run a calibration with:
ColorCAL.getNeedsCalibrateZero()
driverFor
= ['colorcal']¶getCalibMatrix
()¶Get the calibration matrix from the device, needed for transforming measurements into real-world values.
This is normally retrieved during __init__ and stored as ColorCal.calibMatrix so most users don’t need to call this function.
getInfo
()¶Queries the device for information
ok will be True/False Other values will be a string or None.
getLum
()¶Conducts a measurement and returns the measured luminance
Note
The luminance is always also stored as .lastLum
getNeedsCalibrateZero
()¶Check whether the device needs a dark calibration
In initial versions of CRS ColorCAL mkII the device stored its zero calibration in volatile memory and needed to be calibrated in darkness each time you connected it to the USB
This function will check whether your device requires that (based on firmware build number and whether you’ve already done it since python connected to the device).
| Returns: | True or False |
|---|
longName
= 'CRS ColorCAL'¶measure
()¶Conduct a measurement and return the X,Y,Z values
Usage:
ok, X, Y, Z = colorCal.measure()
Following a call to measure, the values ColorCAL.lastLum will also be populated with, for compatibility with other devices used by PsychoPy (notably the PR650/PR655)
readline
(size=None, eol='\n\r')¶This should be used in place of the standard serial.Serial.readline() because that doesn’t allow us to set the eol character
sendMessage
(message, timeout=0.1)¶Send a command to the photometer and wait an alloted timeout for a response.


---
layout: post
title: Cher - Shoop shoop song (it's in his kiss)
date: '2010-03-14T15:40:00.003+02:00'
author: Liliana
tags:
- pop
- Liliana
modified_time: '2010-05-06T03:23:38.051+03:00'
blogger_id: tag:blogger.com,1999:blog-551549162106413340.post-7235674743690750257
blogger_orig_url: http://pentrumuzica.blogspot.com/2010/03/cher-shoop-shoop-song-its-in-his-kiss.html
---
o melodie draguta pentru fetele putine ale blogului...:)
omniprezenta in reprezentatiile artistice din liceu...eeeh