A big part of the interview process for many data science positions is a data science task or assignment. Companies usually choose a data set that is typical for them, while only in rare cases a sample of their actual production data. Here, I am exploring such a data set, sent out by a leading UK retailer.
Your task is to read all data into your preferred software environment, get an understanding of the various variables that are included, and clean the dataset. Subsequently, proceed to build a model of your choice to predict store sales in the test dataset. You can choose as many methods of evaluating the model.
We’ll start by reading the data into R and having a look at the basic structure and variables available. Three tables are supplied: stores, train, and test. Since train and test are in the same format, we will combine the two tables in one (called ‘days’) to make reformatting a little easier.
```R # Any good R-script should use these ;) library(plyr) library(dplyr) library(tidyr) library(magrittr)
library(ggplot2) library(gridExtra) library(ggthemes)
library(caret) library(glmnet) library(doMC)
set.seed(1234)
stores <- read.csv(file = ‘original/store.csv’) train <- read.csv(file = ‘original/train.csv’) test <- read.csv(file = ‘original/test.csv’) days <- rbind( cbind(train, set = ‘train’), cbind(test, set = ‘test’))
head(stores) head(days) ``` Put tables here
Apparently, some of the categorical columns were interpreted as integers by R. We’ll fix that and reformat the data to make sure we use columns in an appropriate fashion. We also combine the data on days and shops are combined in one table via a left-hand join.
```R # Reformatting ‘stores’ stores %<>% mutate( # Stores number as character Store = as.character(Store), # And CompetitionStart as combination of month and year CompetitionStart = ifelse( # Where CompetitionOpenSince values are NA # we assume competition has been around for a while is.na(CompetitionOpenSinceYear), ‘2000-01-01’, # Otherwise we paste in month and year and make it a date (assuming 1st) paste0(‘01-‘, CompetitionOpenSinceMonth,’-‘, CompetitionOpenSinceYear)) %>% as.Date(format = ‘%d-%m-%Y’))
# Then we combine it with the shop data days %<>% mutate( # Again, Stores as character Store = as.character(Store), # And date into a proper time stamp Date = as.Date(Date, format = ‘%d/%m/%Y’)) %>% # Let’s convert categorical information into factors # mutate_each(funs(as.factor), DayOfWeek) %>% # Bring in the shop data left_join(stores, by = ‘Store’) %>% # Any entries of ‘CompetitionDistance’ for days that predate # ‘CompetitionOpenSince…’ are probably invalid. We’ll replace them with # the mean value of ‘CompetitionDistance’ across all stores mutate(CompetitionDistance = ifelse( Date < CompetitionStart, mean(stores$CompetitionDistance, na.rm = TRUE), CompetitionDistance)) %>% # Drop the old CompetitionOpenSince fields select(-one_of(‘CompetitionOpenSinceMonth’, ‘CompetitionOpenSinceYear’)) ```
Now we can take an initial look at the data to better understand what we’ve got and how we can best put it to use in the modelling exercise. I will use a couple of basic questions to guide my exploration of the data set. Since there is no sales data for the hold-out partition of the data I excluded it from most of the plots in this section.
We can look at the data on a sales-by-store level. Simply aggregate sales and other metrics from all days by store and plot them to visualise the relationship of metrics to one another. First, let’s try to understand what kind of shops are in our datasets. The shops are divided by their store type, and the range of products they offer (basic, medium, or full). The relationship between these factors is shown in the plot below.
```R # Make a data frame that aggregates the Sales data by Store # (Sales by Store, SbS) SbS <- days %>% # Use only the train data filter(set == ‘train’) %>% group_by(Store) %>% # Aggregate data by Store summarise( meanSales = mean(Sales, na.rm = TRUE), meanCustomers = mean(Customers, na.rm = TRUE), totalSales = sum(Sales, na.rm = TRUE), totalCustomers = sum(Customers, na.rm = TRUE), daysOpen = sum(Open, na.rm = TRUE), daysPromo = sum(Promo, na.rm = TRUE), daysHoliday = sum(ifelse(StateHoliday != 0, 1, 0), na.rm = TRUE), daysSchoolHoliday = sum(SchoolHoliday, na.rm = TRUE), dailySales = totalSales / daysOpen, dailyCustomers = totalCustomers / daysOpen, storeType = first(StoreType), range = first(Range), competitionDistance = mean(CompetitionDistance, na.rm = TRUE)) %>% # Change the factor levels for nice labels mutate( range = factor(range, labels = c(‘basic’,’medium’,’full’)), storeType = factor(storeType, labels = c(‘small’,’medium’,’big’,’huge’)))
mosaicplot( storeType ~ range, data = SbS, main = ‘Figure 1: Store type and range of products’, xlab = ‘Store type’, ylab = ‘Range of Products’) ```
We can see that there is a large number of small shops but only very few medium ones. Another noticeable factor is that barely any shops offer the medium product range. All of those that do fall in the medium size shop type. Furthermore, small shops are more likely to only offer the basic product range, while big and huge shops are more likely to offer the full range of products. However, a number of big and huge shops restrict their product range to the basic selection, which seems surprising. Perhaps the store type does not represent an ordinal scale of shop size as initially assumed?
Next we will look at some of the continuous variables available for our shops. We can plot number of customers against daily sales and differentiate by store type:
R
SbS %>%
ggplot(aes(
x = dailyCustomers,
y = dailySales,
size = storeType,
colour = range)) +
geom_point(alpha = 0.5) +
ggtitle('Figure 2: Relationship of daily customers with daily sales') +
xlab('Mean Daily Number of Customers') + ylab('Mean Daily Sales')
Somewhat unsurprisingly, there seems to be a strong relationship between number of customers and sales. Interestingly tough, when splitting this data up by store inventory, both ‘basic range’ stores and ‘maximum range’ stores seem to be doing well (i.e. high sales per customer) while ‘medium range’ stores have lower sales per customer. Additionally, small shops seem to have more customers than big and huge shops. Another indicator that my assumption about the nature of the store type was wrong.
Now I will go back to the data by day. Let’s first look at the sales data by day of the week (Figure 3). We can see that sales are highest on Monday, drop a bit during the middle of the week, pick up slightly on Friday, are lower on Saturday and basically nonexistent on Sunday (most shops are closed). This suggests that the day of the week should be included as a predictor in our final model. We can also use the dates to create time series for shops and look at the variation of sales over time. To take out weekly variability I also included a rolling mean of sales for a 7-day window (SalesOfWeek). The resulting plot (Figure 4) shows us the sales of the 2 years from the beginning of 2013 till the end of 2014. We can see patterns of regular variation in sales over the year. Here is what stands out to me: * Sales are low on Sundays (most shops are closed!) * Promotions tend to be every other week * Sales are higher in week with promotion * Sales are slightly higher in the time before Easter and distinctly higher before Christmas
```R # Sales by WeekDay SbWD <- days %>% filter(set == ‘train’) %>% mutate( DateType = paste0(StoreType, ‘-‘, Date)) %>% group_by(DateType) %>% summarise( Sales = mean(Sales), DayOfWeek = max(DayOfWeek), StateHoliday = max(ifelse(as.numeric(StateHoliday) > 1, 1, 0)), SchoolHoliday = max(SchoolHoliday), Promo = sum(Promo), StoreType = first(StoreType)) # Plot sales per day of the week SbWD %>% mutate( DayOfWeek = factor( DayOfWeek, labels = c(‘Mon’,’Tue’,’Wed’,’Thu’,’Fri’,’Sat’,’Sun’))) %>% ggplot(aes(DayOfWeek, Sales, fill = StoreType)) + geom_boxplot() + ggtitle(‘Figure 3: Mean Sales per Day of the Week’) + xlab(‘Day of the Week’) + ylab(‘Mean Sales’)
# (Sales by Day, SbD) SbD <- days %>% filter(set == ‘train’) %>% group_by(Date) %>% summarise( Sales = mean(Sales), DayOfWeek = max(as.numeric(DayOfWeek)-1), StateHoliday = max(ifelse(as.numeric(StateHoliday) > 1, 1, 0)), SchoolHoliday = max(SchoolHoliday), Promo = sum(Promo)) # Get a rolling mean of Sales library(RcppRoll) SbD$SalesOfWeek <- roll_mean( SbD$Sales, n = 7, align = ‘center’, fill = mean(SbD$Sales), na.rm = TRUE) # Timeline plot of sales data SbD %>% mutate( # Rescale some of the variables Sales = Sales / 10000, SalesOfWeek = SalesOfWeek / 10000, Promo = Promo / 1000, DayOfWeek = DayOfWeek / 7) %>% gather( # Get data into long format for ggplot key = category, value = measurement, Sales, SalesOfWeek, DayOfWeek, StateHoliday, SchoolHoliday, Promo) %>% mutate( # Change the order they will be plotted by category = factor( category, levels = c(‘Sales’, ‘SalesOfWeek’, ‘Promo’, ‘DayOfWeek’, ‘SchoolHoliday’, ‘StateHoliday’))) %>% # Make the plot ggplot(aes(Date, measurement, colour = category)) + geom_line() + facet_grid(category ~ .) + ggtitle(‘Figure 4: Time Series Representation of the Data’) + ylab(‘Rescaled Variable Value’) ```
For benchmarking I will create a very simple model: No data cleaning, no feature engineering, just the raw (reformatted) data in a GLMNET and GBM. I am using dummy variables for categorical variables and raw values for continuous variables. The model is evaluated with ten-fold cross-validation, repeated 5 times.
```R # Transforming factors into dummy variables daysdummy <- days %>% filter(set == ‘train’) %>% select(one_of(‘DayOfWeek’, ‘Promo’, ‘StateHoliday’, ‘SchoolHoliday’, ‘StoreType’, ‘Range’, ‘Sales’)) %>% # Create dummy variables model.matrix(Sales ~ ., data = .) %>% # Get the Sales data back cbind(select(days, -one_of(‘(Intercept)’, ‘DayOfWeek’, ‘Promo’, ‘StateHoliday’, ‘SchoolHoliday’, ‘StoreType’, ‘Range’)) %>% filter(set == ‘train’)) %>% mutate( # If CompetitionDistance is NA, use max Competition distance CompetitionDistance = ifelse( is.na(CompetitionDistance), max(days$CompetitionDistance, na.rm = TRUE), CompetitionDistance)) %>% # Create simple training set treating each day as independent observation, # ignoring factors Store and Date for now select(-Store, -Date, -Open, -set, -CompetitionStart)
head(daysdummy) ```
```R tuneControl <- trainControl( method = “repeatedcv”, number = 10, repeats = 5) model1 <- train( Sales ~ ., data = daysdummy, method = ‘glmnet’, metric = ‘RMSE’, trControl = tuneControl)
model1 ```
glmnet
780829 samples 19 predictor
No pre-processing Resampling: Cross-Validated (10 fold, repeated 5 times) Summary of sample sizes: 702746, 702747, 702746, 702747, 702746, 702747, … Resampling results across tuning parameters:
alpha lambda RMSE Rsquared 0.10 6.91422 1210.331 0.9013087 0.10 69.14220 1214.036 0.9009795 0.10 691.42198 1386.398 0.8870391 0.55 6.91422 1210.402 0.9012853 0.55 69.14220 1228.537 0.8988403 0.55 691.42198 1611.039 0.8521414 1.00 6.91422 1211.024 0.9011885 1.00 69.14220 1245.152 0.8963104 1.00 691.42198 1754.444 0.8288464
RMSE was used to select the optimal model using the smallest value. The final values used for the model were alpha = 0.1 and lambda = 6.91422.
R
fitControl <- trainControl(
method = "repeatedcv",
number = 10,
repeats = 5)
model2 <- train(
Sales ~ .,
data = daysdummy,
method = "gbm",
trControl = fitControl)
save(model2, file = 'saved/basic.gbm.rda')
Stochastic Gradient Boosting
780829 samples 19 predictor
No pre-processing Resampling: Cross-Validated (10 fold, repeated 5 times) Summary of sample sizes: 702746, 702746, 702745, 702746, 702747, 702747, … Resampling results across tuning parameters:
interaction.depth n.trees RMSE Rsquared 1 50 1502.452 0.8639662 1 100 1296.930 0.8922199 1 150 1225.590 0.9011660 2 50 1287.706 0.8954673 2 100 1138.885 0.9137963 2 150 1101.484 0.9186211 3 50 1193.371 0.9078775 3 100 1090.395 0.9202973 3 150 1063.971 0.9238807
Tuning parameter ‘shrinkage’ was held constant at a value of 0.1 Tuning parameter ‘n.minobsinnode’ was held constant at a value of 10 RMSE was used to select the optimal model using the smallest value. The final values used for the model were n.trees = 150, interaction.depth = 3, shrinkage = 0.1 and n.minobsinnode = 10.
Now, let’s see how we can improve the above predictions. I feel like I have a better understanding now of how sales behave between stores and over time, so I will try creating some features from what we have learned in the data exploration. I create a variable indicating days before Christmas and Easter, to incorporate the lag between the holiday and the impact on people’s shopping behaviour. I also calculate mean sales per store and include this values into the set of predictors, which acts as a proxy for the population density, infrastructure availability, and similar factors related to the location of each individual store. Finally, I exclude closed days here. Predicting closed days as 0 would decrease the error metric, but that feels like cheating! Instead, let’s only look at days that the shops are open.
```R # Include mean sales by store as predictor meanSbS <- days %>% left_join( select(SbS, one_of(‘Store’, ‘meanSales’)), by = ‘Store’) %>% group_by(Store) %>% summarise( meanSales = mean(Sales, na.rm = TRUE))
daysBH <- days %>% mutate( Easter = ifelse(StateHoliday == ‘b’, 1, 0), Christmas = ifelse(StateHoliday == ‘c’, 1, 0), StateHoliday = ifelse(StateHoliday == ‘0’, 0, 1)) %>% group_by(Date) %>% summarise( StateHoliday = max(StateHoliday), Christmas = max(Christmas), Easter = max(Easter)) %>% mutate( BH = lead(StateHoliday, n = 1) * 3 + lead(StateHoliday, n = 2) * 2 + lead(StateHoliday, n = 3), BC = lead(Christmas, n = 1) * 3 + lead(Christmas, n = 2) * 2 + lead(Christmas, n = 3), BE = lead(Easter, n = 1) * 3 + lead(Easter, n = 2) * 2 + lead(Easter, n = 3)) %>% select(Date, BH, BC, BE)
modeldata <- days %>% left_join( meanSbS, by = ‘Store’) %>% left_join( daysBH, by = ‘Date’) %>% mutate( # If CompetitionDistance is NA, use max Competition distance CompetitionDistance = ifelse( is.na(CompetitionDistance), max(days$CompetitionDistance, na.rm = TRUE), CompetitionDistance), # If any holiday lag is NA, use zero BH = ifelse(is.na(BH), 0, BH), BC = ifelse(is.na(BH), 0, BC), BE = ifelse(is.na(BE), 0, BE)) %>% select(-CompetitionStart)
modeldata %<>% select(one_of(‘DayOfWeek’, ‘StoreType’, ‘Range’, ‘Sales’)) %>% mutate( # Dummy value to include test set in transformation Sales = ifelse(is.na(Sales), -999, Sales), DayOfWeek = as.factor(DayOfWeek)) %>% # Create dummy variables model.matrix(Sales ~ ., data = .) %>% # Get the Sales data back cbind(modeldata) %>% mutate( StateHoliday = ifelse(StateHoliday == 0, 1, 0)) %>% select( -one_of(‘(Intercept)’, ‘Store’, ‘Date’, ‘DayOfWeek’, ‘Promo’, ‘StoreType’, ‘Range’))
trainset <- filter(modeldata, set == ‘train’ & Open == 1) %>% select(-Open, set) testset <- filter(modeldata, set == ‘test’ & Open == 1) %>% select(-Open, set) ```
From the previous quick tuning runs, we know that the GBM did much better than the GLM. I suspect that this is due to the interaction between variables which the GBM is able to capture while the GLM (with the formula I use) only looks at variables by themselves. We’ll, therefore, use the GBM model. Predictions from this model improved with higher interaction and a higher number of trees, so I will choose some higher values here. I would have liked to do more parameter tuning on this, but the model takes quite a while to compute so I’ll do with these ad-hoc values (if you are rerunning the code, avoid rerunning this bit and load the saved model object instead).
```R registerDoMC(cores = 4)
fitControl <- trainControl( method = “repeatedcv”, number = 4, repeats = 1, allowParallel = TRUE, verboseIter = TRUE) gbmGrid <- expand.grid( interaction.depth = 10, n.trees = 500, shrinkage = 0.2, n.minobsinnode = 10) model4 <- train( Sales ~ ., data = trainset, method = “gbm”, tuneGrid = gbmGrid, trControl = fitControl)
is.prediction <- predict(model4, newdata = trainset) os.prediction <- predict(model4, newdata = testset)
fs.prediction <- predict(model4, newdata = modeldata, na.action = na.pass) %>% # Create data frame with predictions # Use prediction for both train and test set cbind(‘Prediction’ = ., days) %>% # Set closed days to zero mutate(Prediction = ifelse(Open == 0, 0, Prediction)) %>% # Set negative values to zero mutate(Prediction = ifelse(Prediction < 0, 0, Prediction)) ```
We have a set of predictions now, but I don’t have the Sales values for 2015 so I can’t evaluate on the blind holdout sample. Instead, I will plot the results for visual inspection.
R
# Simple scatterplot to see the results
fs.prediction %>%
ggplot(aes(Sales, Prediction)) +
geom_point() + ylab('Predicted Sales') +
ggtitle('Simple Scatterplot of observed and predicted sales')
The scatterplot reveals that for the training set there is a very good agreement between the observed and predicted sales, indicated by the long, linear shape of the point cloud. For some values, the model underestimates the values of sales, so it seems that my model is missing out on a part of the signal here. Further research could go into what distinguishes these points from the rest of the data set. When plotting the time series again, it seems that the general trend in the sales data is well captured. The range of variation in the weekly sales data, however, also seems to be slightly underestimated by the model.
Let’s plot the time series again, this time including both the train and the test period.
```R ts.prediction <- fs.prediction %>% group_by(Date) %>% summarise( Sales = mean(Sales), Prediction = mean(Prediction))
ts.prediction$SalesOfWeek <- roll_mean( ts.prediction$Sales, n = 7, align = ‘center’, fill = mean(ts.prediction$Sales), na.rm = TRUE) ts.prediction$PredictionOfWeek <- roll_mean( ts.prediction$Prediction, n = 7, align = ‘center’, fill = mean(ts.prediction$Sales), na.rm = TRUE) # Timeline plot of sales data ts.prediction %>% gather( # Get data into long format for ggplot key = category, value = measurement, Sales, SalesOfWeek, Prediction, PredictionOfWeek) %>% mutate( # Change the order they will be plotted by category = factor( category, levels = c(‘Sales’, ‘SalesOfWeek’, ‘Prediction’, ‘PredictionOfWeek’))) %>% # Make the plot ggplot(aes(Date, measurement, colour = category)) + geom_line() + facet_grid(category ~ .) + ggtitle(‘Figure 6: Time Series Representation of the Data’) + ylab(‘Variable Value’) ```
And that’s all for now. As always, hope it is interesting. Please leave a comment below!


a function tells id the node should be deleted, set undefined if want to delete all
insert a set of nodes, if some nodes exists, ignore the errors
nodes to be inserted
new node ids (without which exist already)
load graph data and show network in current format
delete matched nodes


Class: Cymru::ASNumber
Constant Summary
- ASN =
".asn.cymru.com"
Instance Attribute Summary (collapse)
-
- (Object) allocdate
readonly
Returns the value of attribute allocdate.
-
- (Object) asname
readonly
Returns the value of attribute asname.
-
- (Object) country
readonly
Returns the value of attribute country.
-
- (Object) registry
readonly
Returns the value of attribute registry.
Instance Method Summary (collapse)
-
- (ASNumber) initialize
constructor
A new instance of ASNumber.
- - (Object) whois(asn) (also: #lookup)
Constructor Details
- (ASNumber) initialize
A new instance of ASNumber
67 68 |
# File 'lib/cymruwhois.rb', line 67 def initialize end |
Instance Attribute Details
- (Object) allocdate (readonly)
Returns the value of attribute allocdate
63 64 65 |
# File 'lib/cymruwhois.rb', line 63 def allocdate @allocdate end |
- (Object) asname (readonly)
Returns the value of attribute asname
63 64 65 |
# File 'lib/cymruwhois.rb', line 63 def asname @asname end |
- (Object) country (readonly)
Returns the value of attribute country
63 64 65 |
# File 'lib/cymruwhois.rb', line 63 def country @country end |
- (Object) registry (readonly)
Returns the value of attribute registry
63 64 65 |
# File 'lib/cymruwhois.rb', line 63 def registry @registry end |
Instance Method Details
- (Object) whois(asn) Also known as: lookup
70 71 72 73 74 75 76 77 78 79 80 |
# File 'lib/cymruwhois.rb', line 70 def whois(asn) @asn = "AS" + asn + ASN ans = intxt(@asn) @country = ans[1] @registry = ans[2] @allocdate = ans[3] @asname = ans[4] return ans end |


AgilePDX Vision:
We see Portland as a world-class leader in software development and the broader creative economy. By "World Class" we mean profitable, sustainable, and joyful.
AgilePDX Mission:
Create a vibrant and successful Agile community of practice in the greater Portland metropolitan area by sharing real-world experience, distilled wisdom, and innovative ideas for Agile done well.
Recurring Meetings
In addition to our website, social media contributions and sponsorship of local events, we host three monthly meetings:
Downtown Pub Lunch - 12:00 noon to 1:30 PM on the first Friday of the month.
Westside Breakfast - 7:30 AM to 9:00 AM on the second Tuesday of the month.
Downtown Evening - 6-30 PM to 8:30 PM on the third Wednesday of the month.
You can find all the details on
calagator.org, the technology event calendar.
Coordinating Committee contact
Contact us at
<EMAIL_ADDRESS>Upcoming Events
- Event foo
- Event bar
- Event baz
2015 Corporate Sponsors
-
PNSQC - huge sponsors of AgilePDX - providing the pizza for our sessions all year round.
The Pacific Northwest Software Quality Conferences are highly respected platforms for software professionals to interact and exchange ideas. Secure your place early!
-
Puppet Labs - generously host us every month, and on top of that an employee stays with us all evening.
Puppet Labs is based on an open source product and are always looking to hire top notch Rubyists and sysadmins.
Improve This Site
AgilePDX is entirely volunteer run.
Fork us on GitHub and share your improvements with us!


674
|
|
Oracle Performance Tuning and Optimization
by Edward Whalen
Sams, Macmillan Computer Publishing
ISBN: 067230886x Pub Date: 04/01/96
|
22
1000
Chapter 12 Operating System-Specific Tuning
This chapter looks at the tunable parameters in specific operating systems. In this chapter, you see how to tune the operating system parameters discussed in the last chapter (there is an overview of the parameters and areas in the OS you can modify).
Many factors should lead you to choose a particular operating system to run in your installation. I have no intention of influencing that decision. Usually, your choice of operating system depends on how it fits into your installation in terms of connectivity and the administrative expertise you already have.
Each operating system has advantages and disadvantages, both in terms of ease of use and configurability. Sometimes, there is a tradeoff between the two. In this chapter, I try to represent the advantages and disadvantages of each operating system along with the tuning methodologies.
NOTE: Several popular operating systems are described in alphabetical order in this chapter. I have tried to pick the OSes that are typically used in the client/server market. I apologize if your particular OS is not included here. The chapter looks at NetWare first, then at Windows NT and OS/2, and finishes up with the UNIX operating system.
The goals of this chapter are to provide you with a basic understanding of what is available in the server operating system arena. Each operating system is unique, both in how the system operates and in the level of configuration available. By understanding something about the architecture of the OS, you may gain some insight into how you can best configure your system for Oracle.
NetWare
NetWare is the most popular file and print server operating system on the market. NetWare has grown in popularity over the last few years and is now seen as both a file-and-print server as well as a stable and robust application server. Recently, Novell has release an SMP version of NetWare. NetWare itself has always had very good performance as a single-processor operating system, but with the introduction of NetWare SMP, you can take advantage of scaleable performance increases by adding additional CPUs.
NetWare operates in a client/server configuration only. There is no facility within NetWare to provide login functionality from terminals. From the very beginning, NetWare was designed to support clients through network connections. NetWare is designed to be a lean-running operating system; the overhead associated with it is very small.
Architectural Overview
NetWare runs on Intel PC servers and provides file and print services to clients over network connections. The Novell network protocol of choice is SPX/IPX, but TCP/IP is also supported (the choice of network protocol usually depends on the protocol used by the PC clients).
Unlike the other operating systems described in this chapter, NetWare is not a virtual memory operating system. With NetWare, all the memory needed by Oracle and the server processes must fit into physical memory. The obvious disadvantage is that you must be careful not to exceed the bounds of the memory available. The advantage is that the system is guaranteed not to page and that all the overhead necessary to manage virtual memory is eliminated.
b08
With NetWare SMP, the basic server functionality of the NetWare services is still done on the primary CPU. Certain applications, such as Oracle, have to be modified to take advantage of the additional CPUs. NetWare SMP operates in a master/slave mode.
The term master/slave refers to the way in which the multiprocessing architecture works. The base processor is the master and is responsible for dispatching work to the other CPUs, which operate as slave processors.
The result of having a master/slave architecture is that the additional CPUs are not burdened by the overhead processing such as network connections and hardware interrupts that must be done by the master. The slave processors devote all their time to Oracle processing.
The slave processors run the Oracle background processes as well as the Oracle server processes. In this manner, an additional CPU is very scaleable. By adding a second CPU to your server, you may come close to doubling the performance of your system (if there is available I/O bandwidth).
|


Hi there! We are a friendly group of people dedicated to learning and teaching Python. Follow us on Meetup.com for upcoming events. Join us on Facebook and team up with our members outside of our meeting. Learn or join in on our projects on our Github account.


Early life
Christoph Vogelsang (born 26 July 1985) is a German professional poker player from Sassenberg, Münster. Vogelsang was raised in Sassenberg, Münster. He studied economics at Witten/Herdecke University and the London School of Economics. Vogelsang currently resides in London and is a Christian.
Poker career
| Year | Result |
| 2020, March | Vogelsang's live tournament earnings exceed $25,000,000 |
| 2017, June | Won the 2017 Super High Roller Bowl and earned $6,000,000 |
| 2014 | Participated in $1,000,000 Big One for One Drop finishing 3rd for $4,480,001 |
| 2013, October | Cashed in his first major tournament, the EPT London £50,000 Super High Roller where he finished 3rd for £383,200 ($621,321) |
| 2010 | Made several $10 deposits into online poker. Within 4 weeks he was playing $5000 No Limit Hold'em online cash games |
Online poker
Vogelsang played under the alias Tight-Man1 on Full Tilt Poker where he earned over $1,900,000 and under the alias 26071985 on PokerStars where he has earned over $600,000
External links
Christoph Vogelsang Hendon Mob profile http://pokerdb.thehendonmob.com/player.php?a=r&n=294789
References
- "Vogelsang: "I Think I Got Luckier Than 99% of All Poker Players" http://www.pokerlistings.com/vogelsang-i-think-i-got-luckier-than-99-of-all-poker-players-20008
- "£50,000 Super High Roller" https://www.pokernews.com/tours/ept/2013-ept-london/super-high-roller/
- "Daniel Colman wins One Drop for $15 million" http://www.espn.com/poker/story/_/id/11169110/2014-wsop-daniel-colman-wins-big-one-one-drop
- https://www.pokercentral.com/articles/christoph-vogelsang-wins-2017-super-high-roller-bowl
- http://pokerdb.thehendonmob.com/player.php?a=r&n=294789
- "Poker Player Tight-Man1" https://www.highstakesdb.com/profiles/Tight-Man1.aspx
- "Poker Player 26071985" https://www.highstakesdb.com/profiles/pokerstars/26071985.aspx


0.15.2 (02/10/2020)
Twenty-fourth alpha release.
Build changes, fix and refactorings
- Moved compatibility up to IDEA 2020.3
-
Fixed automatic insertion/overwrite of colon and parenthesis
in case trailing spaces are present in the line
-
Fixed an exception while getting footer values in certain cases.
See issue 32.
-
Fixed an exception while using the Conventional Commit commit's inspections enhancements.
See issue 33.
- Done a minor code clean-up


--- layout: post authors: ["Greg Wilson"] title: A Bunch of Bootcamps date: 2013-02-01 time: "09:00:00" tags: ["Bootcamps"] ---
We've had a busy month: we've run bootcamps at the Max Planck Institute in Tübingen, the Technische Universiteit München, Mozilla's office in Toronto, McGill University, Columbia University (a double-header that's still running today), and the universities of Waterloo, Chicago, and British Columbia. We've also booked a bunch more, some of which are now open for registration:
| Site | Dates | Registration |
|---|---|---|
| University of British Columbia | February 4-5 | Open |
| Macquarie University | February 7-8 | Full |
| AMOS Conference (Melbourne) | February 14-15 | Full |
| University of Washington | February 25-26 | Full |
| Lawrence Berkeley National Laboratory | March 4-5 & 6-7 | For LBL staff |
| University of Virginia | March 7-8 | Coming soon |
| Utah State University | March 23-24 | Open |
| University of Arizona | April 4-5 | Open |
| University of Manchester | April 18-19 | Open |
| Telecom ParisTech | April 20-21 | Open |
| Vrije Universiteit (Amsterdam) | May 2-3 | Coming soon |
| GEOMAR (Kiel) | May 6-7 | For members of ISOS, IMAP and the SFB754 |
| Howard Hughes Medical Institute (Virginia) | May 6-7 | For HHMI staff |
| Stanford University | May 6-7 | Coming soon |
| University of California Berkeley | May 6-7 | Coming soon (in R!) |
| Lawrence Berkeley National Laboratory | May 9-10 | For LBL staff |
| University of California Davis | May 13-14 | Coming soon |
| University of Oslo | July 3-4 | Open |
| University of Bath | July 15-16 | Coming soon |
And we're hoping to finalize arrangements with the following sites real soon now:
|
|
We'd love to add even more pins to our map, especially in countries we haven't visited yet. If you'd like to help make that happen, please get in touch. And many thanks once again to everyone who has hosted a bootcamp, taught one, shown up to help, or come to learn—installation headaches be damned, we're making a difference :-)


This documentation explains how to use the functions provided by the rfret
package to analyze FRET titration experiments and determine a macromolecular interaction’s binding constant (Kd). Examples using real-life datasets are presented and discussed.
Analysis of FRET data can be broken down into the following steps, each of which rfret
provides functions for:
inspect_raw_data
);average_technical_replicates
);correct_fret_signal
);kd
, fret_min
and fret_max
; function guess_quadratic_parameters
);fit_binding_model
).All these functions are designed to work independently, therefore you can skip some of these steps (for example, you might not have technical replicates to average, or you might perform your own signal correction using a different method and software). However, they are also designed to produce outputs that can be directly used as input for the next function, making the whole analysis free of any need for more data reformatting.
rfret
is designed such that the user doesn’t have to manually do any calculation or any edit to the numbers: such manipulations in spreadsheet programs are not only time-consuming, they are also error-prone and encourage the bad habit of doing calculations in the same file that contains the raw data (which should remain unaltered, to ensure reproducibility of the analysis).
The raw data must be formatted like the following example (first 6 rows of a real-life dataset):
| Well.Row | Well.Col | Content | fret_channel | acceptor_channel | donor_channel | concentration |
|---|---|---|---|---|---|---|
| E | 1 | blank_1 | 27507 | 180706 | 1527 | 1000.00 |
| E | 2 | blank_1 | 12797 | 81296 | 1118 | 500.00 |
| E | 3 | blank_1 | 7095 | 45215 | 1103 | 250.00 |
| E | 4 | blank_1 | 4161 | 23985 | 951 | 125.00 |
| E | 5 | blank_1 | 2743 | 15361 | 899 | 62.50 |
| E | 6 | blank_1 | 1755 | 9282 | 984 | 31.25 |
Most (if not all) plate readers have an “export to CSV” feature, which is best suited to save raw data in a format usable by rfret
. If offered a choice between “plate layout” and “table view”, choose “table view”: this will export the data in a format similar to the previous table.
The Well.Row
and Well.Col
columns present in this example dataset were created by the plate reader software used to produce this dataset, but rfret
will simply ignore them and any other columns except the following ones (these can come in any order, but must have the exact following case sensitive names):
Content
fret_channel
acceptor_channel
donor_channel
concentration
Therefore, you will need to either edit these column names manually when you save your data, or set up your plate reader software to write these column names automatically for you. You might need to add the concentration
column manually, if your plate reader software is not aware of your titration series.
This data preparation step is the only one for which you will need to use a spreadsheet program (you can also edit the CSV file in a simple text editor, but a spreadsheet displays this sort of data in a way that is much easier to navigate).
By its very nature, a FRET experiment provides built-in controls for the correct preparation of the titration samples. In a typical experiment, the donor-labeled molecule is kept constant at a low concentration, and the acceptor-labeled molecule is titrated across a wide concentration series prepared by serial dilutions. In these conditions, inspecting the fluorescence intensities in the donor and acceptor channels provides an easy way to check that these concentrations meet the expected ones.
To use rfret
, we first need to load the package:
library(rfret)
The function inspect_raw_data
takes a raw dataset and outputs, for each one of the donor, acceptor and FRET channels, a plot of the fluorescence intensity across the titration series. Warnings will appear, because two of these plots have a logarithmic scale on the x
axis, and some datapoints have zero as x
coordinate (samples with no acceptor-labeled molecule).
Let’s look at an example:
ttn <- c("titration_1", "titration_2")
plots_1 <- inspect_raw_data(raw_data = fret_good, titrations = ttn)
plots_1$donor
## Warning: Transformation introduced infinite values in continuous x-axis
## Warning: Transformation introduced infinite values in continuous x-axis
In the donor channel plot, all fluorescence intensities should be equal, since the donor-labeled molecule is present at the same concentration in all samples. Fluorescence detection is sensitive enough to detect very small pipetting errors, therefore this plot is a good way to detect such errors. The line represents the mean of all fluorescence intensities in the donor channel, and the shaded area represents +/- 10 % of the mean. If all data points fall into this shaded area, as in this example (except one slightly outside), then the pipetting of the donor-labeled molecule achieved a good precision.
The blank experiment doesn’t contain the donor-labeled molecule, and has near-zero fluorescence intensities across the entire titration series, as expected.
Let’s look at the acceptor channel plot:
plots_1$acceptor
If the serial dilution was performed with good precision, all data points should cluster around a straight line, as in this example.
The FRET channel plot quickly tells if the data contains useful signal, and if it is worth completing the analysis:
plots_1$fret
## Warning: Transformation introduced infinite values in continuous x-axis
The titration and blank experiments should have visible differences in fluorescence intensity at some point in the titration series. If their data points perfectly overlap, it means the data doesn’t contain any useful signal (as we will see in a later example).
The function average_technical_replicates
takes a raw dataset, and the names of the replicates associated to the titration and blank experiments (column Content
in the raw dataset). These names are chosen by the user at the data saving stage right after the experiment. In our example dataset, these names are blank_1
, blank_2
, titration_1
and titration_2
, and each one has 24 data points:
summary(fret_good$Content)
## blank_1 blank_2 titration_1 titration_2
## 24 24 24 24
We already set the names of the titration experiments above, so we can reuse them and only need to define the blank names. We will store the resulting reduced dataset in a variable to use it in subsequent steps of the analysis.
blk <- c("blank_1", "blank_2")
reduced_dataset <- average_technical_replicates(raw_data = fret_good,
titrations = ttn,
blanks = blk)
The reduced datasets now have only two names, with 24 data points each:
summary(reduced_dataset$Content)
## blank titration
## 24 24
The function correct_fret_signal
applies the correction described in the following references:
It takes a reduced dataset from average_technical_replicates
(or any similarly formatted dataset) and outputs the corrected FRET signal.
final_dataset <- correct_fret_signal(reduced_dataset)
final_dataset
## concentration fret_corrected
## 1 1.000000e+03 4187.65301
## 2 5.000000e+02 4079.15319
## 3 2.500000e+02 3968.91208
## 4 1.250000e+02 2837.45927
## 5 6.250000e+01 2531.60067
## 6 3.125000e+01 1513.43434
## 7 1.562500e+01 1308.37658
## 8 7.812500e+00 763.51358
## 9 3.906250e+00 431.15523
## 10 1.953125e+00 371.52433
## 11 9.765625e-01 0.00000
## 12 4.882812e-01 358.93902
## 13 2.441406e-01 35.97851
## 14 1.220703e-01 74.38332
## 15 6.103516e-02 102.68790
## 16 3.051758e-02 74.76773
## 17 1.525879e-02 104.05945
## 18 7.629395e-03 152.99099
## 19 3.814697e-03 65.84552
## 20 1.907349e-03 14.26907
The two previous functions, average_technical_replicates
and correct_fret_signal
, can not only be used independently on individual datasets: they can also be applied in a batch processing mode on all raw data files present in one folder. This involves a wrapper function called batch_process
. Here is an example of the use of this function:
setwd("/path/to/raw/data/files")
batch_process(input = ".",
titrations = c("titration_1", "titration_2"),
blanks = c("blank_1", "blank_2"),
skip_lines = 4,
output = "/save/processed/data/here")
If no output directory is specified, the function returns all corrected datasets as a list of dataframes, which can then be accessd and manipulated programmatically.
The function guess_parameters
takes a corrected dataset from correct_fret_signal
(or any similarly formatted dataset) and outputs initial values for kd
, fret_min
and fret_max
.
These values are based on very naive guesses: fret_min
and fret_max
are simply the minimum and maximum fluorescence intensities present in the final corrected dataset, and kd
is the value of concentration
of the datapoint that has the closest FRET value to (fret_max - fret_min) / 2
(fluorescence intensity at half-maximum).
These naive guesses are most of the time close enough to the actual value to make the fit converge properly. If the fitting procedure fails using these initial values, one can visually find a better approximation of kd
by plotting the corrected FRET data as a function of the titration series. Alternatively, failure to fit the data can reveal data quality problems.
Let’s try that on our example dataset:
guessed_params <- guess_parameters(final_dataset)
guessed_params
## $kd
## [1] 62.5
##
## $fret_min
## [1] 0
##
## $fret_max
## [1] 4187.653
The last step involves the function fit_binding_model
, which is simply a wrapper around R’s stats::nls
function. It takes a corrected dataset (output of correct_fret_signal
), a binding model (currently available models are: hyperbola
, quadratic
and quadratic_homodimer
), a list of initial values for kd
, fret_min
and fret_max
(either provided by the user, or directly the output of guess_parameters
), and the fixed concentration of donor-labeled molecule. It returns an nls
object that can be further examined with standard functions (like summary
) or used as input for make_figure
.
The function make_figure
takes an nls
object and the associated corrected fret data, and returns a result table, a plot of the binding curve, a residual plot, and a figure with those two plots combined.
Let’s finish analyzing our example dataset, display the result table and the final figure:
my_fit <- fit_binding_model(corrected_data = final_dataset,
binding_model = quadratic,
parameters = guessed_params,
donor_concentration = 10)
my_results <- make_figure(final_dataset, my_fit)
my_results$results
## term estimate std.error
## 1 kd 48.41484 6.294323
## 2 fret_min 116.84493 46.089282
## 3 fret_max 4437.96247 130.070102
my_results$final_figure
The previous example featured a good dataset, making the analysis straightforward. The following examples show how the function inspect_raw_data
can be used to detect outliers.
All fluorescence detection instruments have a defined dynamic range, and will not report any fluorescence intensity higher than a certain arbitrary number when reading an intensity that exceeds this threshold. In these situations, the instrument should warn the user right away, but the resulting dataset can still be saved and meaningless results can be obtained if these outliers go unnoticed.
The function inspect_raw_data
can optionnaly detect the presence of such reads in a raw dataset and report it to the user. For this, it needs the value of a saturated fluorescence read. All datasets discussed in this document were collected using an instrument that saturates at a fluorescence intensity value of 260000. Let’s inspect another dataset that contains such values:
inspection <- inspect_raw_data(fret_saturated_reads,
highest_signal = 260000)
## Warning: Acceptor channel contains saturated reads. Measure again with a
## lower gain for this channel.
The function gives a warning indicating which channel contains saturated reads. The user then has the opportunity to inspect the numbers and possibly exclude outliers from the subsequent analysis, or even repeat the measurement with a lower gain. Collecting new data avoiding saturation of the fluorescence detector is indeed necessary to get meaningful results.
The function also returns saturated_reads = TRUE
, which can be used to programmatically test for the presence of saturated reads in a raw dataset:
inspection$saturated_reads
## [1] TRUE
No further checks are performed on the number provided for highest_signal
, and the function will return meaningless information if this number does not match the actual saturation value of the instrument. As every instrument will have a different arbitrary saturation value, the user is responsible for finding and using the correct number.
Let’s inspect another different dataset:
plots_2 <- inspect_raw_data(fret_donor_outliers, ttn)
plots_2$donor
## Warning: Transformation introduced infinite values in continuous x-axis
## Warning: Transformation introduced infinite values in continuous x-axis
The donor channel plot clearly shows four obvious outliers in the titration_1
series. They are at the 5th, 13th, 21st and 24th positions in the titration series. We can easily find them in the raw data:
fret_donor_outliers$donor_channel[fret_donor_outliers$Content == "titration_1"][c(5, 13, 21, 24)]
## [1]<PHONE_NUMBER>05<PHONE_NUMBER>25
These outliers come from pipetting errors: the three wells that have a higher fluorescence intensity received too much donor-labeled molecule, whereas the one that has a lower fluorescence intensity did not receive enough donor-labeled molecule. Knowing that, one can decide on a rationale basis to exclude these data points from the subsequent analysis.
Let’s inspect a third dataset:
plots_3 <- inspect_raw_data(fret_acceptor_outliers)
plots_3$acceptor
This acceptor channel plot shows that the highest acceptor-labeled molecule concentration is very different between the titration and blank experiments, and between technical replicates. Again, one can decide to exclude data points from the analysis based on this observation.
The previous two datasets are not ideal, because they contain outliers in either the donor channel or the acceptor channel. Yet, they contain useful FRET signal and can yield binding curves and binding constants. You now know how to analyze them to find out what these binding curves look like, and what the associated binding constants are.
In this last example, we will see how the function inspect_raw_data
can help quickly detecting usable signal in a FRET dataset. Let’s inspect a last dataset:
plots_4 <- inspect_raw_data(fret_bad)
plots_4$fret
## Warning: Transformation introduced infinite values in continuous x-axis
Something looks wrong here: there is very little visible difference in fluorescence intensity in the FRET channel between the titration and blank experiments.
For comparison, this is how this same plot looked for the first dataset we inspected:
plots_1$fret
## Warning: Transformation introduced infinite values in continuous x-axis
The last example dataset doesn’t look like it contains any signal. We can verify that by plotting the corrected data and see if we get anything that looks like a binding curve:
bad_data <- average_technical_replicates(fret_bad, ttn, blk)
bad_data_corr <- correct_fret_signal(bad_data)
library(ggplot2)
qplot(concentration, fret_corrected, data = bad_data_corr, log = "x") + theme_bw()
This dataset doesn’t yield any binding curve, and trying to fit this data would either fail or give a completely meaningless value for Kd.
Used in combination with R Markdown, rfret
makes the process of data analysis fully integrated with the lab notebook record keeping process.


It is so rare that a big scale film that is predicated on something as fantastic as alien life would take the first twenty minutes of the film to build its characters rather than rush us into sensory overload, that at first I thought this movie was going to be a classic miscaculation on the part of the filmmakers. Filmmakers in the "instant gratification, I have a very short attention-span, give me something big and easy and give it to me now" culture that we have become.
But once I adjusted to the fact that this film was really going to be about a person and not a pheonomenon, I sat back and watched one of the truly greatest experiences of the summer. CONTACT is an exciting, intelligent and incredibly moving experience about the unknown. It proves that a woman, if talented and interesting enough, can pick up an adventure film and carry it as well as any of the fellahs.
Jody Foster has some truly beautiful and transporting moments in this film and my hat is off to her for sharing so much. At the heart of every really strong performance there is sharing and she doesn't hold back.
I think I have now seen Zemeckis' finest work. Certainly a far cry from the silly, feeble stuff of Gump. The moments of Contact in this film would certainly make Stanley Kubrick proud, though the filmmakers decide to take an infinitely more personal and intimate road vereing from their 2001 style journey that may seen derivative but it is demanded by this story and really unavoidable. Where we end up is quite a different take than the Arthur C. Clarke version of such a journey and depending on your cup of tea, you will either love or vehemently dislike the choice the film makes.
It has one or two false notes in its epic running time. But it is amazing how negligible false notes are in a film where you are enjoying the ride. A little less talk from the actual CONTACT sequence would've been great. But there is really no way to pay off this incredible premise and make everyone happy. I thought ultimately it was a wonderful way to spend an evening.
If more films were as smart as this one and as brave, I shudder to think where the movies might be headed. Its been a long time since a film got me so excited about the human race...
For that, I'm moved and grateful. Hats off to the filmmakers!
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Cards (tinpo_cards v0.1.0)
Provides methods for creating and handling a deck of Cards.
Link to this section Summary
Functions
This confirms with either Tue or False if a particular card is present or not in the deck.
Returns a list of strings representing a deck of playing cards.
Divides a deck into a hand and the remainder of the deck. The hand_size argument indicate how many cards should be in the hand.
You should ignore this as it has nothing to do with the project, but rather the result of failure to resist the urge to delete it.
Please ignore as it has no effect with the project. it is only a representation of wish to practice testing at the onset of this project.
Link to this section Functions
confirm(deck, card)
This confirms with either Tue or False if a particular card is present or not in the deck.
Examples
iex(1)> deck = Cards.create_deck
iex(2)> Cards.confirm(deck, "Ace")
false
iex(3)> Cards.confirm(deck, "Ace of Spades")
true
create_deck()
Returns a list of strings representing a deck of playing cards.
create_hand(hand_size)
handle(deck, hand_size)
Divides a deck into a hand and the remainder of the deck. The hand_size argument indicate how many cards should be in the hand.
Examples
iex(1)> deck = Cards.create_deck
iex(2)> Cards.handle(deck, 5)
iex(3)> {hand, deck} = Cards.handle(deck, 5)
iex(4)> hand
["Ace of Spades", "Two of Spades", "Three of Spades", "Four of Spades",
"Five of Spades"]
hello()
You should ignore this as it has nothing to do with the project, but rather the result of failure to resist the urge to delete it.
load(filename)
location(x, y)
Please ignore as it has no effect with the project. it is only a representation of wish to practice testing at the onset of this project.


Education
is key to Development.
True purpose of education is to make great minds, not careers.
Prevailing System
Sit
Listen
Learn
Exam
Grades
Reasons to Worry
Disinterest
Study for grades only
Self thinking and analyzing
Maker Education
Hands-on teaching
Build and Learn
Pratical, then Theory
What happens in Maker Education?
Use of tools
Construct
Research
Analyze
Learn
How and Why
Interactive - Engaging
Relevancy - Understanding
Construtivism - Skills
Analyze - Solving
What do we want from
our kids' education?
Understands
Grades
Jobs and Skills
Living and Reputation
Samantha
Global Compitition
Technological Revolution
What are the chances?
Karkhana
Curriculum
Tools and Kits
Collaborate with Schools
Karkhana
3 Schools
200 Students
Thousand Dreams
Our children should not be left out.
Nhasala Joshi
Engineer
Karkhana Pvt. Ltd.
nhasala.joshi@gmail.com


Weather Dashboard
Desired City
Recent Searches
Please click on the city name or type new search
New City Search
Temp:
°F
Wind:
mph
Humidity:
Future Weather


|
|
| |
|
| Each 'Zone' is made-to-order using our dough recipe, and stuffed to your satisfaction with the freshest ingredients. |
| |
|
| Check out our menu! Select from our categories above. |
| |
| Need a menu?
Download and print our
latest menu
Includes promo coupons |
|
|
Quid Pro Quo:
Minimum $7.00 Order For Delivery
Prices Subject to Change without Notice
Tax applies to all items
$1 Delivery Charge added for deliveries 3-5 Miles |
|
|
| |
© 2011 DP Dough Troy | Sitemap |
|


Elon Musk unveils Tesla's new Cybertruck
by Ben BoltonTesla has released various electric car and even semi-truck models over the last few years. During an event on Thursday in Los Angeles, the company shared its vision for the future of pickup trucks.
Elon Musk and his team showed off the Cybertruck, a large metallic vehicle with a trapezoid shape. It's designed to have the utility of a truck and the performance of a sports car.
The Cybertruck is set to go into production in late 2021 and will start at $39,900. Other base models will cost $49,900 or $69,900 with a $7,000 upgrade for the self-driving "autopilot" mode.
The Cybertruck is Tesla's sixth vehicle since the company was founded in 2003. Musk said previously that the design would be inspired by films like "Blade Runner" and "The Spy Who Loved Me."
Some models of the Cybertruck will have a range of 500 miles and can go from 0 to 60 mph in less than 2.9 seconds. It will have a towing capacity of more than 14,000 pounds and can seat six people.
The payload has a 3,500 pound capacity and 100 cubic feet of storage space. The body of the truck is made of ultra-hard 30X cold-rolled stainless steel.
Not all parts of the unveiling went as planned. While demonstrating the Cybertruck's breakproof glass with a sledgehammer and metal ball, the window glass ended up shattering.
The end of the presentation also showed off a potential all-terrain vehicle that could charge in the bed of the Cybertruck, though Musk did not detail if it would go on sale.
For those who wish to be early adopters, the Cybertruck is available now for pre-order.


{% extends "tpl.layout.html" %} {% block content %}
The renowned Art Gallery of Ontario (AGO) occupies a unique looking modern building on the west side of the city center. A whole series of temporary exhibitions are mounted throughout the year by this exceptionally well endowed gallery. Highlights include the collections of Canadian, African and Oceanic, and European art. The museum also holds a particularly impressive collection of Canadian paintings.


| 360° camera | |
| 180° camera | |
| mobile camera |
Please select the camera types which should be visible:
This application was designed in order to help you protect your right to privacy in public spaces. It is our belief that open access to the location of cameras will help you make more informed decisions about how you consent to surveillance in public spaces. This application relies on the wisdom of the crowd, in order to create consensus about where cameras are located and what they might be able to see.
It was originally conceived as part of a collaborative graduate school seminar between the University of Minnesota and the University of Münster. Original funding for this project was secured through the University of Minnesota and the German Academic Exchange Organization (DAAD). This project was supervised by Dr. Francis Harvey and Dr. Chris Kray, and implemented by a collaborative team of graduate students:
René Unrau is the Senior Programmer. René has a Bachelor of Science in Geoinformatics from the University of Muenster and is pursuing a Master of Geoinformatics also at the University of Muenster. René speaks four languages, is an avid tennis player, and can type at 150 words per minute.
Bryan Runck is the Chief Monitoring Officer in charge of evaluation of the application and the oversight of human resources. Bryan has a B.A. in English from St. Olaf College and a M.S. in applied plant sciences from the University of Minnesota. He is currently a second year geography PhD student at the University of Minnesota researching GIS and Agent-Based Modeling. Bryan is a semi-professional wrestler.
Ding Fei is the Senior Researcher. She oversees the strategic implementation of research-oriented developments in the application. Ding has a B.A. in English Language & Literature and a B.S. in Resource Science & Engineering from Beijing Normal University. She recently completed a M.A. in geography and is now pursuing a PhD in geography at the University of Minnesota conducting research in the role of China in development projects in Ethiopia. Ding likes chocolate.
Alex Ding is the Senior Database Manager. He is in charge of overseeing the database and making sure that the application is always up and running. Alex is an avid ukulele player and loves a good american barbeques.
Eric DeLuca is the Chief Creative Officer in charge of future developments and design. Eric has a B.A. in Peace Studies and Environmental Studies from St. John's University and is pursuing a M.A. in geography at the University of Minnesota. Eric is obsessed with penguins and loves using power tools.
We take your right to technological privacy seriously. We will never ask for your name, credit card details, or any unique identifiers. Unlike many mapping applications, we will not access your location data when the app is not in use or is in the background. We will never use your personal information to focus our advertising efforts (mostly because we don’t know anything about you), but also because we think that hyper-personalized marketing is intrusive and annoying. Ultimately, we don’t believe that you should have to sacrifice your privacy for performance or quality, and we are constantly striving to keep your privacy at the center of the application. If there’s anything you feel like we need to work on, feel free to contact us.
It is a crowd-sourced application, meaning the map gets better and more reliable as more people use it and provide feedback. Anonymous users can add surveillance cameras to the map using a web or mobile browser. Confidence scores are awarded to each camera as users can assign each one a ‘thumbs up’ or a ‘thumbs down’ rating. High-confidence will lead to a more reliable map, and low-confidence can lead to the camera being removed.
There are three options under the “add a camera” menu (360 degree, 180 degree, or mobile cameras). 360 degree and mobile cameras will both assign a complete circle polygon, while the 180 degree cameras will default to a half-circle polygon. The height of the camera is estimated based on floor height, and the polygon size is adjusted based on how high the camera is mounted (higher cameras mean larger fields of view and larger polygons). The user then has the option to manually adjust the polygon based on surrounding obstructions.
There are a variety of people who will find this application useful. Some users feel that surveillance cameras are an unwanted invasion of privacy. This application will allow those users to make an informed choice to avoid surveillance cameras in public spaces. Some users, such as runners or people travel alone at night, claim to feel safer in areas of high surveillance. They will find value in being able to choose routes that are under higher surveillance.
Crowd-sourcing makes it so individual doesn’t have the power to remove a camera on their own. You can simply give the camera a “thumbs-down” rating. If that camera receives enough thumbs-down ratings that it will be removed.
There is no need to add it twice. Instead, simply give the camera a “thumbs-up” rating to confirm the camera and increase its confidence rating.
Copyright (c) 2014 Eric DeLuca, Alex Ding, Ding Fei, Bryan Runck, René Unrau
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
We want to hear from you. Feel free to send us an email<EMAIL_ADDRESS>if you have any questions, concerns, or ideas for improvements. Or, fill out this anonymous form with your feedback: Link to formular
Please choose one of the three camera types provided below. In the following the step you will be asked to enter some parameters, based on your decision or draw the polygon by yourself.
Often found at the top of a street or traffic light. These are unobstructed. Please enter a description text for your camera and confirm this page. On the following map, you can choose the location.
Often fixed to walls or buildings and pointed in a particular direction. The direction can typically be changed (either manually or remotely), but they remain obstructed on at least one side. After confirming your settings, you are asked to choose the origin-location of your camera by clicking on the map. After that you have to orient your camera by clicking on the map again. We will compute a polygon based the line between the two locations which can still be edited.
Often found attached to mobile generators or trailers so they can be easily repositioned. They typically have a dome style, 360 degree camera on the top. Please enter a description text for your camera and confirm this page. On the following map, you can choose the location.
Please choose the location of your camera
Orientate your camera by choosing another location
Your camera has been registered
Your comment has been registered
Your vote has been registered
The area your polygon is covering is too big, please make it smaller
Your polygon has too many vertices, please draw it again
No comments yet...


Base type: System.Entity
Summary: This entity presents component. Used in alerting.
| Name | Type | Notes |
|---|---|---|
| ApplicationID | System.Int32 | The unique integer representation of parent application. |
| ComponentID | System.Int64 | The unique integer representation of component. |
| ApplicationAvailability | System.String | The string value that contains the application availability. |
| ComponentName | System.String | The string value that contains the name of component. |
| ComponentType | System.Int32 | The integer value that contains the component type. |
| ComponentAvailability | System.String | The availability of a component. |
| ResponseTime | System.Int64 | The long value that contains the component response time. |
| StatisticData | System.Double | The double value that contains the component statistic data. |
| ProcessName | System.String | The string value that contains the name of process. |
| ProcessInstanceCount | System.Int32 | The integer value that contains the process instance count. |
| PercentCPU | System.Int32 | The integer value that contains CPU usage in percent. |
| PercentMemory | System.Int32 | The double value that contains memory usage in percent. |
| MemoryUsed | System.Int64 | The double value that contains memory usage. |
| PercentVirtualMemory | System.Int32 | The double value that contains virtual memory usage in percent. |
| VirtualMemoryUsed | System.Int64 | The double value that contains virtual memory used. |
| ComponentMessage | System.String | The string value that contains component message. |
| UserDescription | System.String | The string value that contains the component user description. |
| UserNotes | System.String | The string value that contains the component user notes. |
| IOReadOperationsPerSec | System.Double | The integer value that contains IO read operations per second for process. |
| IOWriteOperationsPerSec | System.Double | The integer value that contains IO write operations per second for process. |
| IOTotalOperationsPerSec | System.Double | The integer value that contains IO read/write operations per second for process. |
| StatusOrErrorDescription | System.String | The string value that contains the component status or status description. |
| DisplayType | System.String | Provides the display type, for example, Windows Service, for the specific monitor. |
| LastTimeUp | System.DateTime | Provides the date and time a component was last seen in the Up state. |
| MultiValueMessages | System.String | Message sent when alerting on Multiple Value Chart. |
| MultiValueStatistics | System.String | Statistics sent when alerting on Multiple Value Chart. |
| PercentApplicationAvailability | System.Int32 | Provides the availability of an application as a percentage. |
| PercentComponentAvailability | System.Int32 | Provides the availability of a component as a percentage. |
| WindowsEventMessages | System.String | Full details of the corresponding event. |
| DisplayName | System.String | |
| Description | System.String | |
| InstanceType | System.Type | |
| Uri | System.String | |
| InstanceSiteId | System.Int32 | Default='0'. |
| Component | Orion.APM.Component | Defined by relationship Orion.APM.ComponentAlertReferencesComponent (System.Reference) |


Python has a rich ecosystem of modules including plotting with Matplotlib, data structure and analysis with Pandas, Machine Learning or Natural Language Processing. However, data scientists working with Spark may occasionaly need to call out one of the hundreds of libraries available on spark-packages.org which are written in Scala or Java. Unfortunately, Jupyter Python notebooks do not currently provide a way to call out scala code. As a result, a typical workaround is to first use a Scala notebook to run the Scala code, persist the output somewhere like a Hadoop Distributed File System, create another Python notebook, and re-load the data. This is obviously inefficent and awkward.
PixieDust provides a solution to this problem by letting users directly write and run scala code in its own cell. It also lets variables be shared between Python and Scala and vice-versa.
After importing the PixieDust module, users can simply use the %%scala magic to write Scala code and run the cell as any other normal cell. Any compilation error will be reported in the cell output. The following example shows how to run the Watson sentiment sample app written in Scala:
First install the jar into the Python kernel:
import pixiedust pixiedust.installPackage("https://github.com/ibm-cds-labs/spark.samples/raw/master/dist/streaming-twitter-assembly-1.6.jar")
You can now run the Scala code that uses Spark Streaming to fetch tweets:
%%scala val demo = com.ibm.cds.spark.samples.StreamingTwitter demo.setConfig("twitter4j.oauth.consumerKey","XXXX") demo.setConfig("twitter4j.oauth.consumerSecret","XXXX") demo.setConfig("twitter4j.oauth.accessToken","XXXX") demo.setConfig("twitter4j.oauth.accessTokenSecret","XXXX") demo.setConfig("watson.tone.url","https://gateway.watsonplatform.net/tone-analyzer/api") demo.setConfig("watson.tone.password","XXXX") demo.setConfig("watson.tone.username","XXXX") import org.apache.spark.streaming._ demo.startTwitterStreaming(sc, Seconds(30))
Every variable defined within Python are accessible in Scala. For example:
#define variables in python var1="Hello" var2=200
You can then access these variables in Scala
println(var1) println(var2 + 10)
Likewise, you can transfer variables defined in Scala by prefixing them with __ (2 underscores). The following example shows how to access the tweets into a dataframe and transfer them into the python shell namespace:
%%scala val demo = com.ibm.cds.spark.samples.StreamingTwitter val (__sqlContext, __df) = demo.createTwitterDataFrames(sc)
Then use the __df variable in Python
print(__df.count())


|
MSP DSP Library
|
Data Structures | |
| struct | MSP_LEA_ADDMATRIX_PARAMS |
| Parameter structure for LEACMD__ADDMATRIX command. More... | |
| struct | MSP_LEA_ADDLONGMATRIX_PARAMS |
| Parameter structure for LEAMD__ADDLONGMATRIX command. More... | |
| struct | MSP_LEA_SUBMATRIX_PARAMS |
| Parameter structure for LEACMD__SUBMATRIX command. More... | |
| struct | MSP_LEA_SUBLONGMATRIX_PARAMS |
| Parameter structure for LEACMD__SUBLONGMATRIX command. More... | |
| struct | MSP_LEA_MPYMATRIX_PARAMS |
| Parameter structure for LEACMD__MPYMATRIX command. More... | |
| struct | MSP_LEA_MPYLONGMATRIX_PARAMS |
| Parameter structure for LEACMD__MPYLONGMATRIX command. More... | |
| struct | MSP_LEA_MAC_PARAMS |
| Parameter structure for LEACMD__MAC command. More... | |
| struct | MSP_LEA_MACLONG_PARAMS |
| Parameter structure for LEACMD__MACLONGMATRIX command. More... | |
| struct | MSP_LEA_POLY_PARAMS |
| Parameter structure for LEACMD__POLYNOMIAL command. More... | |
| struct | MSP_LEA_MAX_PARAMS |
| Parameter structure for LEACMD__MAX command. More... | |
| struct | MSP_LEA_MAXLONG_PARAMS |
| Parameter structure for LEACMD__MAXLONGMATRIX command. More... | |
| struct | MSP_LEA_MAXUNSIGNED_PARAMS |
| Parameter structure for LEACMD__MAXUNSIGNED command. More... | |
| struct | MSP_LEA_MAXLONGUNSIGNED_PARAMS |
| Parameter structure for LEACMD__MAXUNSIGNEDMATRIX command. More... | |
| struct | MSP_LEA_MIN_PARAMS |
| Parameter structure for LEACMD__MIN command. More... | |
| struct | MSP_LEA_MINLONG_PARAMS |
| Parameter structure for LEACMD__MINLONGMATRIX command. More... | |
| struct | MSP_LEA_MINUNSIGNED_PARAMS |
| Parameter structure for LEACMD__MINUNSIGNEDMATRIX command. More... | |
| struct | MSP_LEA_MINLONGUNSIGNED_PARAMS |
| Parameter structure for LEACMD__MINLONGUNSIGNED command. More... | |
| struct | MSP_LEA_MPYCOMPLEXMATRIX_PARAMS |
| Parameter structure for LEACMD__MPYCOMPLEXMATRIX command. More... | |
| struct | MSP_LEA_MACCOMPLEXMATRIX_PARAMS |
| Parameter structure for LEACMD__MACCOMPLEXMATRIX command. More... | |
| struct | MSP_LEA_MPYMATRIXROW_PARAMS |
| Parameter structure for LEACMD__MPYMATRIXROW command. More... | |
| struct | MSP_LEA_FIR_PARAMS |
| Parameter structure for LEACMD__FIR command. More... | |
| struct | MSP_LEA_FIRLONG_PARAMS |
| Parameter structure for LEACMD__FIRLONG command. More... | |
| struct | MSP_LEA_FIRCOMPLEX_PARAMS |
| Parameter structure for LEACMD__FIRCOMPLEX command. More... | |
| struct | MSP_LEA_FIRLONGCOMPLEX_PARAMS |
| Parameter structure for LEACMD__FIRLONGCOMPLEX command. More... | |
| struct | MSP_LEA_IIRBQ1_PARAMS |
| Parameter structure for LEACMD__IIRBQ1 command. More... | |
| struct | MSP_LEA_IIRBQ2_PARAMS |
| Parameter structure for LEACMD__IIRBQ2 and LEACMD__IIRBQ2EXTENDED commands. More... | |
| struct | MSP_LEA_BITREVERSECOMPLEX_PARAMS |
| Parameter structure for LEACMD__BITREVERSECOMPLEXEVEN or LEACMD__BITREVERSECOMPLEXODD commands. More... | |
| struct | MSP_LEA_BITREVERSECOMPLEXLONG_PARAMS |
| Parameter structure for LEACMD__BITREVERSECOMPLEXLONGEVEN or LEACMD__BITREVERSECOMPLEXLONGODD commands. More... | |
| struct | MSP_LEA_FFTCOMPLEXAUTOSCALING_PARAMS |
| Parameter structure for LEACMD__FFTCOMPLEXAUTOSCALING command. More... | |
| struct | MSP_LEA_FFTCOMPLEXFIXEDSCALING_PARAMS |
| Parameter structure for LEACMD__FFTCOMPLEXFIXEDSCALING command. More... | |
| struct | MSP_LEA_FFTCOMPLEXLONG_PARAMS |
| Parameter structure for LEACMD__FFTCOMPLEXLONG command. More... | |
| struct | MSP_LEA_FFT_PARAMS |
| Parameter structure for LEACMD__FFT command. More... | |
| struct | MSP_LEA_FFTLONG_PARAMS |
| Parameter structure for LEACMD__FFTLONG command. More... | |
| struct | MSP_LEA_INTERLEAVE_PARAMS |
| Parameter structure for LEACMD__INTERLEAVEEVENEVEN, LEACMD__INTERLEAVEEVENODD, LEACMD__INTERLEAVEODDEVEN and LEACMD__INTERLEAVEODDODD commands. More... | |
| struct | MSP_LEA_DEINTERLEAVE_PARAMS |
| Parameter structure for LEACMD__DEINTERLEAVEEVENEVEN, LEACMD__DEINTERLEAVEEVENODD, LEACMD__DEINTERLEAVEODDEVEN and LEACMD__DEINTERLEAVEODDODD commands. More... | |
| struct | MSP_LEA_DEINTERLEAVELONG_PARAMS |
| Parameter structure for LEACMD__DEINTERLEAVELONG command. More... | |
Macros | |
| #define | MSP_USE_LEA 1 |
| Enable the LEA accelerator for DSPLib functions. The default is to use LEA when available, to disable LEA define MSP_DISABLE_LEA in the compiler settings. More... | |
| #define | MSP_LEA_REVISION MSP_LEA_REVISION_B |
| If a LEA revision is not specified default to revision B. | |
| #define | MSP_LEA_CONVERT_ADDRESS(x) ((uint16_t)(((uintptr_t)(x) >> 2) & 0xffff)) |
| Convert MSP430 address to internal LEA address mapping. | |
| #define | MSP_LEA_REVERT_ADDRESS(x) ((uintptr_t)(((uint32_t)(x) << 2))) |
| Convert LEA address to MSP430 address mapping. | |
| #define | MSP_LEA_RANGE(x) |
| Check that the address is aligned correctly. More... | |
| #define | MSP_LEA_ALIGNED(x, n) (!((uint32_t)(x) & ((n)-1))) |
| Check that the address is within the LEA RAM. | |
| #define | MSP_LEA_VALID_ADDRESS(x, n) (MSP_LEA_RANGE(x) & MSP_LEA_ALIGNED(x,n)) |
| Check that the address aligment is valid and within the LEA RAM. | |
| #define | MSP_LEA_CONST_ZERO 0xA000 |
| LEA constant memory address for 0x0000 coefficients. | |
| #define | MSP_LEA_CONST_ONE 0xAC00 |
| LEA constant memory address for 0x7fff coefficients. | |
| #define | MSP_LEA_Q15_CONST_NEG_ONE 0xB000 |
| LEA constant memory address for 0x8000 coefficients. | |
| #define | MSP_LEA_IQ31_CONST_NEG_ONE 0xE000 |
| LEA constant memory address for 0x80000000 coefficients. | |
| #define | LEACMD__INTERLEAVEEVENEVEN (0x0000f000) |
| LEA command ID for interleave even even command. | |
| #define | LEACMD__INTERLEAVEEVENODD (0x0000f001) |
| LEA command ID for interleave even odd command. | |
| #define | LEACMD__INTERLEAVEODDEVEN (0x0000f002) |
| LEA command ID for interleave odd even command. | |
| #define | LEACMD__INTERLEAVEODDODD (0x0000f003) |
| LEA command ID for interleave odd odd command. | |
Functions | |
| void | msp_lea_init (void) |
| DSPLib initialization routine for LEA. More... | |
| static void | msp_lea_invokeCommand (uint16_t cmdId) |
| Invoke a command with interrupts enabled and enter low-power mode or poll the interrupt flag. More... | |
| static void * | msp_lea_allocMemory (uint16_t length) |
| Allocate LEA-SC memory from stack. More... | |
| static void | msp_lea_freeMemory (uint16_t length) |
| Free LEA-SC memory from stack. More... | |
| static bool | msp_lea_acquireLock (void) |
| Acquire LEA-SC module if available. More... | |
| static void | msp_lea_freeLock (void) |
| Free LEA-SC module. More... | |
| void | msp_lea_initCommandTable (void) |
| Initialize the table used for loading commands. More... | |
| uint16_t | msp_lea_getRevision (void) |
| Return the revision of LEA code ROM. More... | |
| uint16_t | msp_lea_loadCommand (uint16_t commandId, const void *command, uint16_t length) |
| Load a LEA command into code memory. More... | |
Variables | |
| const uint32_t | MSP_LEA_MIN [23] |
| LEA patch for the LEA__MIN command. | |
| const uint32_t | MSP_LEA_MINUNSIGNED [23] |
| LEA patch for the LEA__MINUNSIGNED command. | |
| const uint32_t | MSP_LEA_MINLONGMATRIX [20] |
| LEA patch for the LEA__MINLONGMATRIX command. | |
| const uint32_t | MSP_LEA_MINUNSIGNEDLONGMATRIX [20] |
| LEA patch for the LEA__MINUNSIGNEDLONGMATRIX command. | |
| const uint32_t | MSP_LEA_MAX [23] |
| LEA patch for the LEA__MAX command. | |
| const uint32_t | MSP_LEA_MAXUNSIGNED [23] |
| LEA patch for the LEA__MAXUNSIGNED command. | |
| const uint32_t | MSP_LEA_MAXLONGMATRIX [20] |
| LEA patch for the LEA__MAXLONGMATRIX command. | |
| const uint32_t | MSP_LEA_MAXUNSIGNEDLONGMATRIX [20] |
| LEA patch for the LEA__MAXUNSIGNEDLONGMATRIX command. | |
| const uint32_t | MSP_LEA_MACLONGMATRIX [18] |
| LEA patch for the LEA__MACLONGMATRIX command. | |
| const uint32_t | MSP_LEA_FFTCOMPLEXAUTOSCALING [58] |
| LEA patch for the LEACMD__FFTCOMPLEXAUTOSCALING command. | |
| const uint32_t | MSP_LEA_FFTCOMPLEXLONG [64] |
| LEA patch for the LEA__FFTCOMPLEXLONG command. | |
| const uint32_t | MSP_LEA_MPYLONGMATRIX [17] |
| LEA patch for the LEA__MPYLONGMATRIX command. | |
| const uint32_t | MSP_LEA_IIRBQ1 [31] |
| LEA patch for the LEA__IIRBQ1 command. | |
| const uint32_t | MSP_LEA_IIRBQ2 [32] |
| LEA patch for the LEA__IIRBQ2 command. | |
| const uint32_t | MSP_LEA_IIRBQ2EXTENDED [47] |
| LEA patch for the LEA__IIRBQ2EXTENDED command. | |
| const uint32_t | MSP_LEA_FIRLONG [30] |
| LEA patch for the LEA__FIRLONG command. | |
| const uint32_t | MSP_LEA_FIRCOMPLEXLONG [43] |
| LEA patch for the LEA__FIRCOMPLEXLONG command. | |
| const uint32_t | MSP_LEA_INTERLEAVEEVENEVEN [22] |
| LEA function for the LEACMD__INTERLEAVEEVENEVEN command. | |
| const uint32_t | MSP_LEA_INTERLEAVEEVENODD [24] |
| LEA function for the LEACMD__INTERLEAVEEVENODD command. | |
| const uint32_t | MSP_LEA_INTERLEAVEODDEVEN [22] |
| LEA function for the LEACMD__INTERLEAVEODDEVEN command. | |
| const uint32_t | MSP_LEA_INTERLEAVEODDODD [24] |
| LEA function for the LEACMD__INTERLEAVEODDODD command. | |
| volatile uint16_t | msp_lea_ifg |
| DSPLib interrupt flags. | |
| volatile uint16_t | msp_lea_locked |
| DSPLib LEA-SC locked flag. | |
Definitions required to support the use of LEA.
| #define MSP_LEA_RANGE | ( | x | ) |
Check that the address is aligned correctly.
| #define MSP_USE_LEA 1 |
Enable the LEA accelerator for DSPLib functions. The default is to use LEA when available, to disable LEA define MSP_DISABLE_LEA in the compiler settings.
It is always recommended to use LEA for lowest power and best performance. Disabling LEA is only intended to be used for benchmarking LEA performance against the CPU and hardware multiplier or by users who would like to dedicate the LEA peripheral to a specific function and run the remainder on the CPU.
|
inlinestatic |
Acquire LEA-SC module if available.
|
inlinestatic |
Allocate LEA-SC memory from stack.
| length | Length of memory to allocate in 32-bit words. |
|
inlinestatic |
Free LEA-SC module.
|
inlinestatic |
Free LEA-SC memory from stack.
| length | Length of memory to allocate in 32-bit words. |
| uint16_t msp_lea_getRevision | ( | void | ) |
Return the revision of LEA code ROM.
| void msp_lea_init | ( | void | ) |
DSPLib initialization routine for LEA.
| void msp_lea_initCommandTable | ( | void | ) |
Initialize the table used for loading commands.
|
inlinestatic |
Invoke a command with interrupts enabled and enter low-power mode or poll the interrupt flag.
| uint16_t msp_lea_loadCommand | ( | uint16_t | commandId, |
| const void * | command, | ||
| uint16_t | length | ||
| ) |
Load a LEA command into code memory.


System Architect Definitions, Encyclopedia:"D:\DATA\SYSARCH\HCM\GEN_DATA\SUBJECT\V01\CURRENT\"
Duplicates allowed (Class Attribute)
- Class Name:
"Ordered Classification Element"
- Derived:
F
- &Value Type:
Boolean
- Optional:
F
- Unique:
F
- Const:
F
- Description:
If "True", duplicate values of "Order" in the associated "Ordered Species Relations" are allowed.


Icon made from
Icon Fonts
is licensed by CC BY 3.0
Lock in color selections by clicking a color square
<<<
Projects
Choose a project to see saved palettes
Generate New Colors
Save Palette


Press release
65 per cent of education and training in prisons not good enough
Today, Ofsted is at Wormwood Scrubs prison for its Further Education and Skills Annual Lecture.
In his
lecture
, the National Director for Further Education and Skills, Matthew Coffey, is highlighting recent findings that show no prison was rated outstanding for its education and training provision in the last 4 years. Only 35 per cent were judged to be good.
Matthew Coffey, National Director of Further Education and Skills said:
This year’s Annual Lecture aims to focus on how we can reduce the stubbornly high reoffending rates that are nearly 50% for adult prisoners and 72% for juveniles. It is unacceptable that Ofsted judged only 35% of prisons good for their education and training provision. If these figures related to our schools there would be a national outcry. The aim is to reduce the number of reoffenders by focusing on rehabilitation in prisons through better employer engagement and better teaching and training.
Far too many prisoners leave prison without employability skills, meaning they are less likely to find a job. Research shows that being in employment is one of the key factors that can reduce the risk of reoffending by between 30-50%. However, examples of good training provision in prisons were all too scarce. In fact, we haven’t judged a single prison to be outstanding for their education and training provision in the last four years.
Clearly, reducing the number of those reoffending is in everyone’s interests. Every prisoner costs the taxpayer the same as sending a child to Eton, around £34,000 per year. We must now focus on improvement of prisoners’ vocational and employability skills to ensure we support them on their journey out of prison and into employment to break the cycle of re-offending.
The lecture is discussing the fine balance between punishment and the need to focus on rehabilitation to reduce the likelihood of reoffending.
It is exploring solutions to these difficult issues by making recommendations, including the following:
-
a review of the rules on disclosing a criminal offence after completion of a sentence
-
ensuring that prison governors are held accountable for the quality of education and training
-
for the new resettlement prisons to develop a daily routine that fits around the working day whilst collaborating with employers to ensure they give training that suits employers’ needs
Inspections of education and training in prisons will continue to focus on the importance of supporting prisoners into sustained employment on release. In a recent small-scale research project , almost 50% of the prisoners sampled had previously been excluded from school and 63% had been in some form of care as a child. We will continue to ensure our school inspections focus on what school leaders can do to encourage young people to reach their potential and not drop out of education.
Notes to editors
-
You can find the
speech in full
on the website.
-
Panel members will include:
-
Sally Morgan, Chair of Ofsted
-
Matthew Coffey HMI, Ofsted National Director of FE and Skills
-
Nick Hardwick, Her Majesty’s Inspector of Prisons
-
Phil Taylor, Governor of Wormwood Scrubs
-
John Hoskison, author of ‘Inside – One Man’s Experience of Prison’
-
John Timpson CBE, Chief Executive Officer of Timpson Ltd
-
Nicola Padfield, Lecturer at the University of Cambridge - Criminal and Penal Justice


|
|
| CSolid_Phase (int n=3) |
| |
|
| CSolid_Phase (const CSolid_Phase &BB) |
| |
|
| CSolid_Phase (string model) |
| |
|
CSolid_Phase & | operator= (const CSolid_Phase &BB) |
| |
|
void | set_val (int i, double val) |
| |
|
double | get_val (int i) |
| |
|
void | set_val (string SS, double val) |
| |
|
void | set_settling_model (string _settling_model) |
| |
|
int | lookup_phase (string S) |
| |
|
|
int | n_phases |
| |
|
vector< vector< CStringOP > > | f |
| |
|
vector< vector< CStringOP > > | K |
| |
|
vector< CStringOP > | capacity |
| |
|
vector< CStringOP > | capacity_c |
| |
|
vector< double > | mobility_factor |
| |
|
CStringOP | dispersion |
| |
|
vector< double > | c_params |
| |
|
int | indicator |
| |
|
string | model |
| |
|
string | name |
| |
|
vector< string > | phase_names |
| |
|
double | vs |
| |
|
double | diffusion |
| |
|
CStringOP | vs_coefficient |
| |
|
string | settling_model |
| |
|
vector< double > | settling_parameters |
| |
Definition at line 14 of file Solid_Phase.h.
The documentation for this class was generated from the following files:


Awesome looks so good
Awesome is the landing page you wish you had when you started
awesome is an amazing landing page brought to you on everyone's favorite learning platform, Udemy. Imagine what is next.
Mobile First, Always
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Praesent ultrices at massa nec imperdiet. Ut tempor augue tincidunt odio luctus, non tempor sem cursus. Proin.
HTML5 & CSS3
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Praesent ultrices at massa nec imperdiet. Ut tempor augue tincidunt odio luctus, non tempor sem cursus. Proin.
Socially Social
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Praesent ultrices at massa nec imperdiet. Ut tempor augue tincidunt odio luctus, non tempor sem cursus. Proin.
Yes, it even looks good on an iPhone
It is important to make sure that you are coding for responsive design. We want all of our work to function properly on all devices. This is the awesome way
How about an iPad? Yup that too!
It doesn't matter what device you are on. Awesome will always look awesome. Its in the name after all.
Hear what our fans have to say about awesome
"I learned how to build this website in an amazing online course on Udemy. I couldn't be happier!"
John Smith


Behind the Scenes: Ship in Rough Sea
Background
My name is Novak Miler and I got into visual effects as a compositor in 2008/2009 working primarily in After Effects for Sinister Studio in South Africa, after completing my degree in Fine Arts at Rhodes University.
I took an interest in some 3D packages but found that Blender suited me best when I started learning about it in 2015. YouTube has been my primary source of education in Blender and when I had any spare time, I would find myself watching tutorials. As time went on, I started implementing Blender more and more into my jobs.
Now I would probably refer to myself as a generalist, working directly with agencies and directors on-set for VFX supervision, generating the 3D assets, and working on the final compositing with most jobs that I am involved in.
Inspiration
Many years ago, my father bought a model of a ship, which was always displayed in the sitting room while I was growing up. Soon after my father’s passing, my mother asked that I take the model, and it now sits in my own sitting room.
A few years back, I took a keen interest in photography but was especially influenced by the works of Felix Hernandez, who is truly a master of his craft. I wanted to simulate what Hernandez does, but enhance it in a slightly different way by using Blender.
I was also always impressed by classic paintings of old ships in rough seas...the depth and mood these skilled painters evoked would fill me with awe and fear of nature's power.
Ivan Aivazovsky 1866
Process
I had the real model, a keen interest in photography, and Blender. I now had to put it all together.
Photography
The first step was to photograph the ship in a way that I could extract it and light it in a real environment to create some mood.
I didn't have any sort of chroma screen at home so I simply mounted the ship up against a wall in my living room. I knew that extracting the ship was going to be long and painful, but with the use of Photoshop and its background erase tool, things went quicker than expected.
Modeling/Texturing
With the ship extracted, I now had an image on an alpha matte that I could bring into Blender. The rest of the process was the fun bit. The hard parts were now out of the way.
I saved a second image of the extracted ship as a black and white image which I could use to drive displacement in Blender. I didn’t want a flat image in the scene. Small amounts of displacement allow for the 3D model to react to lighting in the scene more realistically when compared to a flat image that has to be matched to in Blender.
To get detailed displacement, I had to subdivide the image of the ship to quite a high level. I made around 10 subdivisions before I was happy with the level of detail being displayed.
I added a color ramp node to the black and white image to crush/remove any errors I had made in removing the ship from the background of the original photo.
I then added a plane with the ocean modifier to generate an ocean.
The ocean plane was textured with an image of foamy water, and I added a second plane behind the ship that was textured with some dark and moody clouds.
Lighting
The final steps in Blender involved adding one spot light above the ship to match the direction of the light, and changing the world material to act as a volume so that I could get a light streak in the scene.
This allowed the one spot light to isolate the ship in the scene compositionally.
I rendered the scene out in Cycles and brought it into Photoshop for any final clean-ups and grading, as well as adding a splash at the bow of the ship to make it look like a wave had just impacted the hull.
Final Image
About the Author
Novak Miler, VFX artist at SinisterStudio


Welcome to Building Re-frame Components. You can find this course online. You need to install Leiningen. You should then run Figwheel in this project's directory like this:
lein fig-dev
That will begin watching changes to the code files in the
src/
directory. As you save changes to the files, you can
watch them change in your browser. Click on one of the lessons below.
Teacher is the completed version of the code, Student is incomplete
and waiting for you to edit it. Then open the cljs
file
in the editor of your choice, make some changes, and watch them change
in the browser.
If you have any questions or you find a bug, I am more than welcome to help you. Please contact me directly at<EMAIL_ADDRESS>Rock on!
Eric


--- layout: page title: Consulting published: true ---
I'm a freelance programmer, and I'm available for hire.
Here's my resume
I'm always interested in hearing about new opportunities, so let me know what you are building.


CODEFORCES BIO-DATA
Get bio-data
Handle
Name
Rating
Title
Max Rating
Number of Contest participated
Best rank in contest
Best rating gain
Number of Problems Accepted
Number of Submissions
-
-
-
-
-
-
-
-
-
-


Derek Eder
@derekeder
Well, it was fun while it lasted. Goodbye @WBEZafternoon & good luck @NialaBoodhoo https://twitter.com/chicagotribune/status/606262522686152705
6/4/2015, 9:18:38 AM
Favs: 2
Retweets: 0
link← @derekeder Twitter archive
Derek Eder
@derekeder
Well, it was fun while it lasted. Goodbye @WBEZafternoon & good luck @NialaBoodhoo https://twitter.com/chicagotribune/status/606262522686152705
6/4/2015, 9:18:38 AM
Favs: 2
Retweets: 0
link


Bypassing UAC
Exploiting UAC is a trivial process. There are two stages needed to be taken to achieve bypass to elevate from standard user rights to administrator user rights.
- Writing to a secure location (use iFileOperation COM Object or Windows Update Standalone Installer (wusa.exe))
- Exploiting DLL hijacking vulnerability
In order for our bypass to be successful to start off with we need
- A medium integrity process
- A standard user in an administrators group (required for COM / wusa)
- Windows executable must be signed by Microsoft code signing certificate
- Windows executable must be located in a secure directory
- Windows executable also must specify the auto Elevate property in their manifest
For auto-elevation the Windows executable must be signed, located in a secure directory such as C:\Windows\System32 and must specify the autoElevate property in their manifest.


|
The Association of Lisp UsersThe Association of Lisp Users (ALU) is a user group which aims to promote Lisp, help inform and educate Lisp users in general, and help represent Lisp users as a group to the vendors. The ALU holds an annual conference and supports the formation of inter-vendor standards. ALU has international membership and is incorporated in the US.What's New at This SiteThis entire site is new. It's development began in the summer of 1996.
The previous home page of the ALU was
NavigationThe hierarchy is divided into nine groups:
The navigation bar also has the ALU logo, . Clicking on this logo brings you back to the contents page. The Site Map lists each file that is maintained as part of this website. The files are listed by group. Repeatedly clicking on will take you on a "guided tour" moving through each page in the site. goes back to the previous page or grouping, while moves up within a grouping back towards the contents page. Comments and CopiesThis site is copyright 1997 by the Association of Lisp Users. Trademarks are the property of their owners. Don't use the information on this site to trash Lisp or Lispers (including vendors, publishers, etc.).The official home of the Association of Lisp Users is http:/www.lisp.org, which may or may not be installed yet. If you are examining this material from a different host, than you are looking at a mirror (i.e. a copy of the material). Any appearance within a different host hierarchy does not imply any connection with, or endorsement by, the Association of Lisp Users. A gnu compressed tar file containing a snapshot of the current contents of the entire site is available for download from the file ../admin/alu.tgz. If you make a mirror of this site (perhaps in a language other than English,) please let us know so that we can put a pointer to it on the initial welcome page. Also, any publicly available or commerically used mirrors should be complete and unedited copies. We are interested in your comments about this site. Contact us at<EMAIL_ADDRESS>(author<EMAIL_ADDRESS>are particularly interested in volunteers to help with our long list of planned improvements. CreditsThis site was constructed from information in a variety of other sites, including those by Brad Miller, Rainer Joswig, John Mallery, Mark Kantrowitz and Carnegie-Mellon Unversity, Franz, Inc., Harlequin, Inc., and Digitool, Inc..We are grateful to:
This particular site was compiled by Howard R. Stearns, who requests that you send him any comments you may have. |