|
| def | __init__ (self, raw_dict, coin_in, coin_out, date, trans_type=TransactionType.TRADING, successful=True, commission=None) |
| |
| def | get_attrs (self) |
| |
| def | has (self, item) |
| |
| def | is_trade (self) |
| |
| def | is_deposit (self) |
| |
| def | is_fee (self) |
| |
| def | is_withdrawal (self) |
| |
| def | get_amount_buy_sell (self, coin) |
| |
| def | get_amount_traded (self, coin) |
| |
| def | get_amount_commission (self, coin) |
| |
| def | get_amount_moved (self, coin) |
| |
| def | get_amount (self, coin) |
| |
| def | get_coins (self) |
| |
| def | __getitem__ (self, key) |
| |
| def | __str__ (self) |
| |
| def pyhodl.core.models.transactions.Transaction.__init__ |
( |
|
self, |
|
|
|
raw_dict, |
|
|
|
coin_in, |
|
|
|
coin_out, |
|
|
|
date, |
|
|
|
trans_type = TransactionType.TRADING , |
|
|
|
successful = True , |
|
|
|
commission = None |
|
) |
| |
:param raw_dict: {}
Dict containing raw data
:param trans_type: TransactionType
Type of transactions
:param date: date
Date info
:param successful: bool
True iff transaction has actually taken place
:param commission: Transaction
Commission of transaction (if any)
| def pyhodl.core.models.transactions.Transaction.__getitem__ |
( |
|
self, |
|
|
|
key |
|
) |
| |
| def pyhodl.core.models.transactions.Transaction.__str__ |
( |
|
self | ) |
|
| def pyhodl.core.models.transactions.Transaction.get_amount |
( |
|
self, |
|
|
|
coin |
|
) |
| |
:param coin: Coin
Coin to get
:return: float
Amount of coin in transaction
| def pyhodl.core.models.transactions.Transaction.get_amount_buy_sell |
( |
|
self, |
|
|
|
coin |
|
) |
| |
:param coin: Coin
Coin to get
:return: float
Amount of coin trade
| def pyhodl.core.models.transactions.Transaction.get_amount_commission |
( |
|
self, |
|
|
|
coin |
|
) |
| |
:param coin: Coin
Coin to get
:return: float
Amount of coin fee
| def pyhodl.core.models.transactions.Transaction.get_amount_moved |
( |
|
self, |
|
|
|
coin |
|
) |
| |
:param coin: Coin
Coin to get
:return: float
Amount of coin moved (withdrawn/deposited)
| def pyhodl.core.models.transactions.Transaction.get_amount_traded |
( |
|
self, |
|
|
|
coin |
|
) |
| |
:param coin: Coin
Coin to get
:return: float
Amount of coin trade
| def pyhodl.core.models.transactions.Transaction.get_attrs |
( |
|
self | ) |
|
:return: []
Keys of internal dict
| def pyhodl.core.models.transactions.Transaction.get_coins |
( |
|
self | ) |
|
:return: tuple (str, str, str)
Coin buy, coin sell and coin fee
| def pyhodl.core.models.transactions.Transaction.has |
( |
|
self, |
|
|
|
item |
|
) |
| |
:param item: str
Item to look for
:return: bool
True iff item is in any of the data
| def pyhodl.core.models.transactions.Transaction.is_deposit |
( |
|
self | ) |
|
:return: bool
True iff data is a deposit
| def pyhodl.core.models.transactions.Transaction.is_fee |
( |
|
self | ) |
|
:return: bool
True iff data is a fee
| def pyhodl.core.models.transactions.Transaction.is_trade |
( |
|
self | ) |
|
:return: bool
True iff data is a trading
| def pyhodl.core.models.transactions.Transaction.is_withdrawal |
( |
|
self | ) |
|
:return: bool
True iff data is a withdrawal
| pyhodl.core.models.transactions.Transaction.coin_buy |
| pyhodl.core.models.transactions.Transaction.coin_sell |
| pyhodl.core.models.transactions.Transaction.commission |
| pyhodl.core.models.transactions.Transaction.date |
| pyhodl.core.models.transactions.Transaction.raw |
| pyhodl.core.models.transactions.Transaction.successful |
| pyhodl.core.models.transactions.Transaction.transaction_type |
The documentation for this class was generated from the following file:
- /home/stefano/Coding/Python/projects/pyhodl/pyhodl/core/models/transactions.py


Please check to make sure you’ve typed the URL correctly. Maybe try a search?
All Rights Reserved © Techno Store 2017


This web application is provided in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.


Location: X Y
Energy
Supplies %
Credits
Health
MOVE
90
180 0
270
COMMANDS
Saved Games
Celestial Object Positions:


An easier way to organize your grocery list without the mental math. Input your items that you wish to purchase and the website will do the rest for you.
Navigate to your closest grocery store with your organized grocery list. We also let you know where your closets grocery store is to you.
No more wasted paper! Take your list on your phone with you on the go.


The Torque Flite 727 is a heavy duty Chrysler 3 speed automatic
transmissions. They have an aluminum case and a 23 spline
output shaft.
Usage
The TF 727 was used in full sized Jeeps (SJs and J series pickups)
from 1980-1983. From 1984-1992, the 727 was standard in trucks with the
AMC 360 V8 and optional in trucks with the AMC 258. It uses
the standard AMC bolt pattern. The case is 16" long and 14 bolts
hold in the pan.
| Transmission | 1st | 2nd | 3rd | 4th | 5th | Rev |
| TF 727 | 2.45 | 1.45 | 1.00 | | | NA |


Toggle navigation Udacity Logo
* Logout
*
Logout
×
Return to "Self-Driving Car Engineer" in the classroom
Student Hub chat icon Discuss on Student Hub
Advanced Lane Finding
* Review
* History
* Review
* Code Review
* History
Unable to review
Your project could not be reviewed. Please resubmit after you address
the issue noted below by the reviewer.
Key parts of your submission were the same as another student's
submission or an online source. Please resubmit after you address the
issue noted below by the reviewer.
Potential Source URL:
Download project files
Review #1 (this review)
Reviewed 18h ago
student notes
Nothing Specific
Review #1 (this review)
Reviewed 18h ago
student notes
Nothing Specific
*CarND-Advanced-Lane-Lines/output_images/save_output_here.txt*
*CarND-Advanced-Lane-Lines/examples/example.py*
*CarND-Advanced-Lane-Lines/writeup.md*
-
x
1
# ADVANCE LANE FINDING
2
3
In this project, your goal is to write a software pipeline to identify the lane boundaries in a video.
4
5
6
# PROJECT GOALS
7
---
8
9
The goals / steps of this project are the following:
10
11
* [x] Compute the camera calibration matrix and distortion coefficients given a set of chessboard images.
12
* [x] Apply a distortion correction to raw images.
13
* [x] Use color transforms, gradients, etc., to create a thresholded binary image.
14
* [x] Apply a perspective transform to rectify binary image ("birds-eye view").
15
* [x] Detect lane pixels and fit to find the lane boundary.
16
* [x] Determine the curvature of the lane and vehicle position with respect to center.
17
* [x] Warp the detected lane boundaries back onto the original image.
18
* [x] Output visual display of the lane boundaries and numerical estimation of lane curvature and vehicle position.
19
20
---
21
22
> The images for camera calibration are stored in the folder called `camera_cal`. The images in `test_images` are for testing my pipeline on single frames. To extract more test images from the videos, one can simply use an image writing method like `cv2.imwrite()`, i.e., one can then read the video in frame by frame as usual, and for frames if he/she want to save for later one can write to an image file.
23
24
25
> To help the reviewer examine my work, I saved examples of the output from each stage of my pipeline in the folder called `output_images`, and include a description of what each image shows. The video called `project_video.mp4` is the video your pipeline should work well on.
26
27
28
29
30
## [I.] COMPUTING CAMERA MATRIC AND DISTORTION COEFFICIENT
31
32
The code for this step is contained in the first few code cell of the IPython notebook located in "./Advance Lane Finding.ipynb".
33
34
Camera calibration measures the distortion inherent in cameras that utilize lenses so that the images taken with the camera can be corrected by removing the distortion. The measure distortion function takes a Python sequence of checkerboard image filenames taken at different distances, center-offsets, and orientations. Checkerboard patterns are useful for this tasks because of their high contrast, known geometry, and regular pattern.
35
36
![Sample_Chessboard_Calibration_Image](camera_cal/calibration2.jpg)
37
38
![Calibrated_Camera_Images](artifacts/Mapping_Corner_calibration2.png)
39
40
I start by preparing "object points", which will be the (x, y, z) coordinates of the chessboard corners in the world. Here I am assuming the chessboard is fixed on the (x, y) plane at z=0, such that the object points are the same for each calibration image. Thus, `objp` is just a replicated array of coordinates, and `objpoints` will be appended with a copy of it every time I successfully detect all chessboard corners in a test image. `imgpoints` will be appended with the (x, y) pixel position of each of the corners in the image plane with each successful chessboard detection.
41
42
I then used the output `objpoints` and `imgpoints` to compute the camera calibration and distortion coefficients using the `cv2.calibrateCamera()` function. I applied this distortion correction to the test image using the `cv2.undistort()` function and obtained this result:
43
44
![Corner_Mapped_Images](artifacts/Corner_Mapping_After_Camera_Calibration.png)
45
46
47
48
49
## [II.] IMAGE PROCESSING PIPELINE (Road Model Images)
50
51
52
#### STEP 1. TRANSFORMING ROAD MODEL IMAGES TO DISTORTION-CORRECTED IMAGES
53
54
To demonstrate this step, I will describe how I apply the distortion correction to one of the test images like this one:
55
56
![Distortion_Corrected_Calibration_Image_1](artifacts/Undistortion_Calibration_Image 12.png)
57
58
![Distortion_Corrected_Calibration_Image_2](artifacts/Undistortion_Calibration_Image 4.png)
59
60
![Distortion_Corrected_Calibration_Image_3](artifacts/Undistortion_Calibration_Image 17.png)
61
62
![Distortion_Corrected_Calibration_Image_4](artifacts/Undistortion_Calibration_Image 1.png)
63
64
![Distortion_Corrected_Calibration_Image_5](artifacts/Undistortion_Calibration_Image 8.png)
65
66
![Distortion_Corrected_Road_Model_Image](artifacts/Undistorted_Road_Model_Image.png)
67
68
69
70
#### STEP 2. GENERATING BINARY-THRESHOLD IMAGES FOR LANE PIXELS (POINTS) DETECTION
71
72
Here we apply color and edge thresholding in this section to better detect the lines, and make it easier to find the lane points to fit a polynomial that best describes our left and right lanes later. Continuous experimentation by the task of the gradient thresholding and facilitating it with the changing color spaces we should adopt to increase our chances of detecting near perfect lanes-lines. Few Experiments that were carried out in this stage:
73
74
75
**A. GRADIENT THRESHOLDING**
76
77
* We use the Sobel operator to identify gradients, that is change in color intensity in the image. Higher values would denote strong gradients, and therefore sharp changes in color
78
79
* We experimented with many parameters and across different Sobel operations and came up with this final result shown below.
80
81
![Gradient_Thresholding_Road_Model_Image_1](artifacts/Gradient_Thresholding_Road_Model_Image_1.png)
82
83
![Gradient_Thresholding_Road_Model_Image_2](artifacts/Gradient_Thresholding_Road_Model_Image_2.png)
84
85
86
87
**B. COLOUR THRESHOLDING**
88
89
* We experiment with different color spaces to see which color space and channel(s) we should use for the most effective separation of lane lines.
90
91
* On the RGB components, we see that the blue channel is worst at identifying yellow lines, while the red channel seems to give best results.
92
93
* For HLS and HSV, the hue channel produces an extremely noisy output, while the saturation channel of HLS seems to give the strong results; better than HSV’s saturation channel. conversely, HSV’s value channel is giving a very clear grayscale-ish image, especially on the yellow line, much better than HLS’ lightness channel.
94
95
> At this stage, we are faced with various choices that have pros and cons. Our goal here is to find the right thresholds on a given color channel to highlight yellow and white lines of the lane. There are actually many ways we could achieve this result, but we choose to use HLS because we already know how to set thresholds for yellow and white lane lines from Project 1: Simple Lane Detection.
96
97
98
**C. COMBINED THRESHOLDING PIPELINE**
99
100
* I used a combination of color and gradient thresholds to generate a binary image (thresholding steps were carried out using function `thresholding_pipeline()` and `plot_combined_thresholding()`). Here's an example of my output for this step.
101
102
* On the left image, all green pixels were retained by our Sobel thresholding, while the blue pixels were identified by our HLS color thresholding. The results are very encouraging and it seems we have found the right parameters to detect lanes in a robust manner. We turn next to applying a perspective transform to our image and produce a bird’s eye view of the lane.
103
104
![Combined_Thresholding_Road_Model_Image_1](artifacts/grad_colour_thresholding_image1.jpg)
105
106
![Combined_Thresholding_Road_Model_Image_2](artifacts/grad_colour_thresholding_image2.jpg)
107
108
109
#### STEP 3. PERSPECTIVE TRANSFORMATION TO ACCURATELY FINDING LANE LINE'S AND IT'S CURVATURE
110
111
The code for my perspective transform includes a function called `warp()` and `plot_perspective_tranformed_img()`. The `warp()` function takes as inputs an image (`img`), as well as source (`src`) and destination (`dst`) points. I chose the hardcode the source and destination points in the following manner:
112
113
```python
114
# Four source coordinates manually coded
115
src = np.float32(
116
[[577, 450],
117
[720, 450],
118
[200, 650],
119
[1200, 650]])
120
121
# Four desired coordinates manually coded
122
dst = np.float32(
123
[[100, 100],
124
[1200, 100],
125
[100, 710],
126
[1200, 710]])
127
```
128
129
* We now need to define a trapezoidal region in the 2D image using the above `src` points that will go through a perspective transformation procedures to convert the image to a bird’s eye view, like in the below:
130
131
![Perspective_Transformed_Road_Model_Image_1](perspective_tranformed_test_image1.jpg)
132
133
![Perspective_Transformed_Road_Model_Image_2](perspective_tranformed_test_image2.jpg)
134
135
* This resulted in the following source and destination points:
136
137
| Source | Destination |
138
|:-------------:|:-------------:|
139
| 577, 450 | 100, 100 |
140
| 720, 450 | 1200, 100 |
141
| 200, 650 | 100, 710 |
142
| 1200, 650 | 1200, 710 |
143
144
* I verified that my perspective transform was working as expected by drawing the `src` and `dst` points onto a test image and its warped counterpart to verify that the lines appear parallel in the warped image.
145
146
![Perspective_Tranformed_Image_1](artifacts/perspective_tranformed_image1.jpg)
147
148
![Perspective_Tranformed_Image_2](artifacts/perspective_tranformed_image2.jpg)
149
150
151
152
#### STEP 4. LANE BIFURCATION, DRIVABLE AREA MAPPING AND RADIUS OF CURVATURE
153
154
**A. PLOTTING OF HISTOGRAM TO CHECK FOR BINARY ACTIVATIONS**
155
156
* To decide explicitly which pixels are part of the lines and which belong to the left line and which belong to the right line. Plotting a histogram of where the binary activations occur across the image is one potential solution for this.
157
158
* With this histogram we are adding up the pixel values along each column in the image. In our thresholded binary image, pixels are either 0 or 1, so the two most prominent peaks in this histogram will be good indicators of the x-position of the base of the lane lines.
159
160
![Histogram_Road_Model_Image_1](artifacts/Histogram_Road_Model_Image_1.png)
161
162
![Histogram_Road_Model_Image_2](artifacts/Histogram_Road_Model_Image_2.png)
163
164
165
**B. SLIDING WINDOW TO FIND PIXELS IN THE LANE**
166
167
* We can use that as a starting point for where to search for the lines. From that point, we can use a sliding window, placed around the line centers, to find and follow the lines up to the top of the frame.
168
169
* For better details about how exactly we did it, read line by line commented code inside the function `find_lane_pixels()`.
170
171
![Lane_Pixels_Road_Model_Image_1](artifacts/Lane_Pixels_Road_Model_Image_1.png)
172
173
![Lane_Pixels_Road_Model_Image_2](artifacts/Lane_Pixels_Road_Model_Image_2.png)
174
175
176
**C. FITTING A POLYNOMIAL 'N-degree'**
177
178
* Here we fit a polynomial for the detected left lane line points and right lane line points. We use fucntions namely `fit_polynomial()` to fit the appropriate degree polynomial and bifurcate the left and the right lane lines.
179
180
* Futher to visualize the detected lane lines and mark the drivable path on the bird eye view road, the area between the detected lane lines is then mapped with green colour and is mapped on to the original Image.
181
182
![Drivable_Area_Road_Model_Image_1](artifacts/Drivable_Area_Road_Model_Image_1.png)
183
184
![Drivable_Area_Road_Model_Image_2](artifacts/Drivable_Area_Road_Model_Image_2.png)
185
186
187
**D. COMBININIG PROCESSED IMAGE WITH THRESHED IMAGE**
188
189
* Here I reverse the perspective transformation applied previously and then I try to map the drivable area detected in the previous steps on the threshed image
190
191
* Futher to visualize the detected mapping as the drivable path down the road, the path map image and the gradient and colour threshed images are combined. Details in the function `reverse_warp()`
192
193
![Masked_Combined_Road_Model_Image_1](artifacts/Masked_Combined_Road_Model_Image_1.png)
194
195
![Masked_Combined_Road_Model_Image_2](artifacts/Masked_Combined_Road_Model_Image_2.png)
196
197
198
**E. FINDING RADIUS OF CURVATURE OF LANE LINES AND VEHICLE ALIGNMENT
199
200
* At this step I calculate the curvature of polynomial functions in the pixels i.e. the right and the left lane lines. Refer fucntion `measure_curvature_pixels()` for more details.
201
202
* Next the calculate the Relative vehicle alignment from the lane's center -- positive means rightwards deviation from lane's center and similarly negative means leftward deviation from lane's center.
203
204
![Final_lane_Mapping_Road_Model_Image_1](artifacts/Final_lane_Mapping_Road_Model_Image_1.png)
205
206
![Final_lane_Mapping_Road_Model_Image_2](artifacts/Final_lane_Mapping_Road_Model_Image_2.png)
207
208
209
210
211
### [III.] VIDEO PROCESSING PIPELINE (Road Model Videos)
212
213
#### A. FINAL OUTPUT VIDEO FOR THE TEST VIDEO
214
215
* For the test video the best fit happened with the three degree polynomial fit. Second degree polynomial fit was able to perfectly detect the lane lines near to the ego vehicle but as the distance from the vehicle increases it starts to fluctuate and sometimes was not able to map the lane lines properly.
216
217
* The above software created is robust to shadows from the sides of the roads, changing light conditions was also not able to bring about any significant change while mapping the lane lines.
218
219
Here's a [link to my test video result](test_output_videos/project_video_3rd_degree_output.mp4)
220
221
Here's a [link to my test video result](test_output_videos/project_video_2nd_degree_output.mp4)
222
223
224
#### B. FINAL OUTPUT VIDEO FOR THE CHALLENGE TEST VIDEO
225
226
* The software developed above is robust to shadows on the roads, changing colour or features of the road. The above software is still not robust to the glare due to the Sunny condition.
227
228
* The above software is still not able to distinguish between the actual lane line and a cracked line on the road and is most likely to fail in such scenario. Also beacuse of the threshing mechanism used here the cracks in the lane gets higher activation peak and hence is detected as one of the lane line.
229
230
Here's a [link to my challenege_test video result](test_output_videos/challenge_video_3rd_degree_output.mp4)
231
232
233
#### C. FINAL OUTPUT VIDEO FOR THE HARDER CHALLENGE TEST VIDEO
234
235
* For harder challenge video a three degree polynomial fit was successfully able to map the lane lines in various parts of the video sequence. But a lot of parts gives a better fit with second degree polynomial fit. A code needs to be added which can help the software to smoothly switch between the degree of the polynomial fit.
236
237
* Because of the fixed attention window is used here, so the algorithm fails to detect lanes if parts of the lane go beyond that pre-fixed attention region. According to the smooth variation in degree mechanism, we can also move the two sides of the attention window accordingly. Doing this can help the software to focus it's attention to the region where the probability of finding the next lane line points is maximum.
238
239
Here's a [link to my harder_challenge_test video result](test_output_videos/harder_challenge_video_3rd_degree_output.mp4)
240
241
---
242
243
### [IV.] DISCUSSIONS MOVING AHEAD
244
245
#### PROBLEMS AND ISSUES WITH THE EXUSTING PIPELINE AND HOW TO MAKE IT MORE ROBUST
246
247
This was an exciting, but rather difficult project, which felt very different from our previous projects. The long range of continuous experimentaion really took efforts and understanding of the concepts learned. We’ve covered how to perform camera calibration, color and gradient thresholds, as well as perspective transform and sliding windows to identify lane lines! The sliding windows code was particularly hard to understand initially but after long time debugging it and making comments (all available on my notebook) I finally understood every line!
248
249
**We believe there are many improvements that could be made to this project, such as:**
250
251
* Experiments with LAB and YUV color spaces to determine whether we can produce better color thresholding.
252
253
* Use convolutions instead of sliding windows to identify hot pixels. Convolutions will be faster and also computationally efficient.
254
255
* Implementing outlier rejection and use a low-pass filter to smooth the lane detection over frames, meaning add each new detection to a weighted mean of the position of the lines to avoid jitter.
256
257
* Formulate a way so as to pass the lane information from previous frame to present frame such that our software know in advance or can calculate a fair expectation of where to look for the drivable lane area.
258
259
* Use of deep learning based techniques like semantic segmentation to map out the free space or the drivale area and hence providing flexiblility to the software or removing the fixated trapezoidal area approach to search for drivable area.
260
261
* With the semantic segmentation based approach any disturbance in the lane line detection because of the objects in the environment can also be avoided using this appraoch.
262
263
* Moreover, we need to build a much more robust pipeline to succeed on the two challenge videos that are part of this project.
*CarND-Advanced-Lane-Lines/README.md*
Your reviewer has provided annotations for your project
Download annotations
Meets Specifications
Well Done! :clap: :clap: Congratulations on completing this project.
:muscle: :fire: :fire:
You have done a good job on this project! You understand all the parts
of this project very well.
*Keep up the great work and stay Udacious :udacious:*
PS: Please rate my review. Five :star: would be appreciated. If
you have any feedback, please add a comment to your rating.
Writeup / README
The writeup / README should include a statement and supporting figures /
images that explain how each rubric item was addressed, and specifically
where in the code each step was handled.
✅Well done :clap: :clap: The implementation process is presented in the
writeup and example images for each stage of the implemented pipeline
are provided.
Screen Shot 2020-01-29 at 8.57.07 PM.png
Camera Calibration
OpenCV functions or other methods were used to calculate the correct
camera matrix and distortion coefficients using the calibration
chessboard images provided in the repository *(note these are 9x6
chessboard images, unlike the 8x6 images used in the lesson)*. The
distortion matrix should be used to un-distort one of the calibration
images provided as a demonstration that the calibration is correct.
Example of undistorted calibration image is Included in the writeup (or
saved to a folder).
✅Well done :clap: :clap: The process of camera calibration has been
successfully applied to un-distort the test image.
Screen Shot 2020-01-29 at 9.01.04 PM.png
Pipeline (test images)
Distortion correction that was calculated via camera calibration has
been correctly applied to each image. An example of a distortion
corrected image should be included in the writeup (or saved to a folder)
and submitted with the project.
✅Well done :clap: :clap: The distortion correction has been correctly
applied to real-world images.
A method or combination of methods (i.e., color transforms, gradients)
has been used to create a binary image containing likely lane pixels.
There is no "ground truth" here, just visual verification that the
pixels identified as part of the lane lines are, in fact, part of the
lines. Example binary images should be included in the writeup (or saved
to a folder) and submitted with the project.
✅Well done :clap: :clap: The input image was converted into the HLS
color space, and binary thresholds were applied on each output.
Screen Shot 2020-01-29 at 9.02.45 PM.png
OpenCV function or other method has been used to correctly rectify each
image to a "birds-eye view". Transformed images should be included in
the writeup (or saved to a folder) and submitted with the project.
✅Well done :clap: :clap:
Screen Shot 2020-01-29 at 9.04.12 PM.png
Methods have been used to identify lane line pixels in the rectified
binary image. The left and right line have been identified and fit with
a curved functional form (e.g., spine or polynomial). Example images
with line pixels identified and a fit overplotted should be included in
the writeup (or saved to a folder) and submitted with the project.
✅Well done :clap: :clap: The data points found with the sliding window
method were fit with a polynomial and both lane lines have been
correctly identified.
Screen Shot 2020-01-29 at 9.06.04 PM.png
Here the idea is to take the measurements of where the lane lines are
and estimate how much the road is curving and where the vehicle is
located with respect to the center of the lane. The radius of curvature
may be given in meters assuming the curve of the road follows a circle.
For the position of the vehicle, you may assume the camera is mounted at
the center of the car and the deviation of the midpoint of the lane from
the center of the image is the offset you're looking for. As with the
polynomial fitting, convert from pixels to meters.
✅Well done :clap: :clap: The required parameters were computed providing
users with information on the estimated radius of curvature and the
position of the vehicle with respect to the center of the road. These
measurements are printed on the video frame.
Screen Shot 2020-01-29 at 9.06.43 PM.png
The fit from the rectified image has been warped back onto the original
image and plotted to identify the lane boundaries. This should
demonstrate that the lane boundaries were correctly identified. An
example image with lanes, curvature, and position from center should be
included in the writeup (or saved to a folder) and submitted with the
project.
✅Well done :clap: :clap:
Pipeline (video)
The image processing pipeline that was established to find the lane
lines in images successfully processes the video. The output here should
be a new video where the lanes are identified in every frame, and
outputs are generated regarding the radius of curvature of the lane and
vehicle position within the lane. The pipeline should correctly map out
curved lines and not fail when shadows or pavement color changes are
present. The output video should be linked to in the writeup and/or
saved and submitted with the project.
✅Awesome :fire: :rocket:
Screen Shot 2020-01-29 at 9.09.37 PM.png
Discussion
Discussion includes some consideration of problems/issues faced, what
could be improved about their algorithm/pipeline, and what hypothetical
cases would cause their pipeline to fail.
✅Well done :clap: :clap: You provided a reflection on the implemented
algorithm, identified its limitations, and suggested possible improvements.
Download Project
Return to Path
Rate this review
( ) //( ) //( ) //( ) //( ) //


1 write to _symbolResolver
System.Management.Automation (1)
engine\parser\SymbolResolver.cs (1)
325
_symbolResolvePostActionVisitor = new SymbolResolvePostActionVisitor {
_symbolResolver
= this };
4 references to _symbolResolver
System.Management.Automation (4)
engine\parser\SymbolResolver.cs (4)
742
_symbolResolver
._symbolTable.LeaveScope();
750
_symbolResolver
._symbolTable.LeaveScope();
756
_symbolResolver
._symbolTable.LeaveScope();
762
_symbolResolver
._symbolTable.LeaveScope();


Before Change
print("Killed")
else:
print("Terminating Process...")
try:
self.process.terminate()
self.process.wait(timeout=10)
print("Terminated")
except TimeoutExpired:
print("Termination timed out. Killing Process...")
self.process.kill()
print("Killed")
def set_final_status(self, returncode):
Set the status bar output based on subprocess return code
if returncode == 0 or returncode ==<PHONE_NUMBER>:
status = "Ready"
After Change
print("Killed")
else:
print("Terminating Process...")
children = psutil.Process().children(recursive=True)
for child in children:
child.terminate()
_, alive = psutil.wait_procs(children, timeout=10)


 No, just a regular mistake.
 No, just a regular mistake.
The spirit is willing, but the flesh is spongy and bruised. Does anybody else feel jealous and aroused and worried?
I'm sorry, guys. I never meant to hurt you. Just to destroy everything you ever believed in.
These old Doomsday Devices are dangerously unstable. I'll rest easier not knowing where they are.
Bender! Ship! Stop bickering or I'm going to come back there and change your opinions manually!
If we can hit that bullseye, the rest of the dominoes will fall like a house of cards. Checkmate.
Hey, tell me something. You've got all this money.


References
1
Lescuyer, G. (2012). Sustainable Forest Management at the Local Scale: A Comparative Analysis of Community Forests and Domestic Forests in Cameroon. Small-Scale Forestry, 12(1), 51–66. doi:10.1007/s11842-012-9199-x
Download


EUR/USD Technical Analysis: Bounces off 8-week-old rising trendline amid bearish MACD
by Anil Panchal- EUR/USD recovers from near-term key support lines.
- 100-day SMA, the three-week-old rising trend line will challenge buyers.
EUR/USD takes the bids to 1.1025 during the Asian session on Monday. The pair recently recovered from an upward sloping trend line since October 01.
As a result, buyers will target 50% Fibonacci retracement of the previous month upside, at 1.1030, as immediate resistance ahead of confronting 38.2% Fibonacci retracement level near 1.1065.
Though, 1.1080/85 area including 100-day Simple Moving Average (SMA) and a falling trend line since November 04 could keep pair’s further upside in check.
Alternatively, pair’s declines below 1.1015 support line will shift the market’s focus to 61.8% Fibonacci retracement level of 1.0994 and October 08 low near 1.0940.
If bears dominate past-1.0940, the October month’s bottom close to 1.0880 will become their favorite.
Traders should observe that the 12-bar Moving Average Convergence and Divergence (MACD) indicator keeps flashing bearish signals and raise doubts on any recovery.
EUR/USD daily chart
Trend: Pullback expected
additional important levels
| Overview | |
|---|---|
| Today last price | 1.1022 |
| Today Daily Change | -1 pip |
| Today Daily Change % | -0.01% |
| Today daily open | 1.1023 |
| Trends | |
|---|---|
| Daily SMA20 | 1.1073 |
| Daily SMA50 | 1.1043 |
| Daily SMA100 | 1.1087 |
| Daily SMA200 | 1.1174 |
| Levels | |
|---|---|
| Previous Daily High | 1.1088 |
| Previous Daily Low | 1.1014 |
| Previous Weekly High | 1.1098 |
| Previous Weekly Low | 1.1014 |
| Previous Monthly High | 1.118 |
| Previous Monthly Low | 1.0879 |
| Daily Fibonacci 38.2% | 1.1043 |
| Daily Fibonacci 61.8% | 1.106 |
| Daily Pivot Point S1 | 1.0995 |
| Daily Pivot Point S2 | 1.0968 |
| Daily Pivot Point S3 | 1.0921 |
| Daily Pivot Point R1 | 1.1069 |
| Daily Pivot Point R2 | 1.1116 |
| Daily Pivot Point R3 | 1.1143 |


.box { width:400px; padding: 1em; border-radius: .5em; border: 5px solid rebeccapurple; background-color: lightblue; } .box::after { content: "This is a string. I know because it is quoted in the CSS." }


Sep 26, 2020
Animation with Dragon Bones —
There are many variants to create a skeletal animation but almost all of them are paid and so not available for educational purposes. In this article we’ll work with Dragon Bones, that’s a free, but a bit weird tool.
The Dragon Bones has decent functionality and it’s free. To be presise the editor itself is free as in beer (closed sources) but the code for integrating models into cocos2d-x is distributed under MIT license.
…
Sep 25, 2020
Animation —
There are two kinds of animation:
- frame (spreadsheet) animation: the graphical designers create a series of frames and Cocos2d draws them one by one using Animation and Animate classes. The Animate is a subclass of Action, so it will be easy to use.
- Skeletal animation: a model of the character is created with some special programs and then gets imported to Cocos2d. There is another post about it.
…
Sep 25, 2020
How to remove objects —
Since we already know about actions and other basic things, now we can think about correct memory usage.
To illustrate it we’ll create a simple scene with one sprite and one button. After pressing the button the sprite will out of the scene and then it should be removed somehow.
…
Sep 25, 2020
Advanced usage of CC_CALLBACK —
In the previous article about callbacks I’ve said that the number in the CC_CALLBACK_*
macro means the amount of parameters need for called function. That wasn’t exactly true because the C++ magic allows to do a one more trick here.
…
Sep 25, 2020
Advanced actions —
The previous article described how to use Action to move the objects. Now we’ll learn how to do more complicated stuff.
…


AKimage(.js) is a JavaScript image processing library. It is still in alpha stage.
You can fork me at github here.


Note: Delimiters ('{$ ctrl.model.DELIMETER $}') are allowed in the folder name to create deep folders.


Professional events need to be inclusive, by representing a diverse range of speakers. That way everybody can be involved with and inspired by the cutting edge of their field.
Too many events though don't represent any diversity at all.
We want to take concrete steps to fix this from the bottom up.
We want to end totally homogeneous events,
and we need your help.
By signing a pledge above, you're committing to avoid supporting or creating paid events that don't feature any diverse representation whatsoever. (This is a low bar for a reason — see the FAQ.)
Just promising to avoid that isn't a huge step though, on its own. If you're reading this, you're probably not going to fall foul of this intentionally anyway. The magic comes when you start actively ensuring that commitment:
When confirming your slot at an event, include a note like:
Hopefully this won't be an issue, but just to let you know I've signed the Minimum Viable Diversity pledge. I won't be able to speak [at this event/on this panel] if every other speaker you pick is a [man/cis woman/white person] like me. Let me know if that's going to be a problem — I'm happy to help you find speakers from underrepresented groups.
In most cases this will be enough (and many events will be surprised you even think that this is a risk). If events get back to you asking for help and tips, show them the "Organizing an Event?" section under resources.
Before booking tickets to an event, include a note like:
I'm interested in buying tickets to [event name], but I've signed the Minimum Viable Diversity pledge, so I won't be able to attend if you pick a lineup without any diversity at all. Can you confirm that that's not going to happen?
In most cases this will be enough (and many events will be surprised you even think that's a risk). If events get back to you asking for help and tips, show them the "Organizing an Event?" section under resources.
Firstly, include the Minimum Diversity Pledge logo on your site, and tweet and spread the word about your commitment to show people you care.
Secondly, when introducing speakers, attendees or others to your event, include some text like the below:
In case you're not aware, we've signed the Minimum Viable Diversity pledge. We're committed to ensuring our lineup and all of our panels include at least some degree of diversity. We are putting lots of work into bringing you a wide range of speakers and we're hoping to go far beyond this, but you can treat this as a minimum guarantee: this won't be another event filled with the same homogenous voices — we promise!
If you're organising paid events, see the 'As an event' section. If you're sponsoring events, check the event will have some diversity first:
We're potentially interested in sponsoring [event name], but we've signed the Minimum Viable Diversity pledge, so we won't be able to if you might have a lineup with no diversity at all. Can you confirm that that's not going to happen?
When your employees ask about attending or speaking at an event, include some text along the lines of:
Have you checked that this event has some diversity in its lineup? As you may know we've signed the Minimum Viable Diversity pledge. Hopefully this doesn't fall below that fairly low bar, but if it does I'd strongly encourage you to look around for other options.
If you're not sure, send them an email and check. There are some quick and easy template emails for that on the pledge site itself. Let me know if you'd like us to talk to the event for you, or help you find other options.
In many cases events will already have lineups including some diversity, so should just need a quick check in practice. Most events that don't will be surprised you even think that this is a risk, but just a last few won't even be thinking about this at all, and won't have a plan.
These are the events we're trying to improve. Try and nudge them in the right direction, and if they need any help and tips, show them the "Organizing an Event?" section under resources.
Each step here builds a culture that makes it unacceptable for an event to ignore diversity, as too many do (some illustrative examples). Remember, of course, that not all diversity is visible: give events a chance to explain where they stand and what they're doing before you reject them.
When organizers have big groups of speakers warn them they'll have to drop out if they don't have any speaker diversity, and whole batches of attendees asking them to confirm that in advance, it stops being possible to ignore the issue. With an embarassingly low bar it's hard to argue it's ok.

Sign the pledge.
Spread the word! Share the pledge around, tell conferences and your employer and your friends about it, and help us get as many people involved as possible, so we can make maximum impact.
As well as helping and inspiring individual people from underrepresented groups, increasing speaker diversity is important because diverse groups solve problems better. We've done studies, it's measurably true, and aiming for a diverse mix of genders, races, religions, sexualities & more everywhere makes us all more successful, and the world a better place.
This is important in communities generally, but especially for people in leading role-model positions, such as speakers at industry events. More diverse groups of speakers will give us conference talks and discussion with a wider range of ideas, but more importantly will also include & inspire more diverse audiences in turn.
It's this multiplier effect that's key. More diverse lineups let everybody get involved in the cutting-edge of the field, help spread diversity in the community as a whole, and hopefully inspire more diverse groups of people to share their ideas on stage too.
By focusing on the minimum level, we hope to get as many people as possible involved. If it becomes a common sight for organizers everywhere, nobody can run events that totally ignore diversity. The pledge can't rule out the majority of existing events, or it simply wouldn't be practical. We need to focus first on the clear worst offenders, and build up from there.
The hope here is that this will cause big problems for those below the minimum bar, and the steady pressure from many pledge signers mentioning it when accepting speaking slots and buying tickets will highlight diversity further, even among events already reaching this line. This builds awareness and momentum across the board to improve diversity even further, everywhere.
This is just the start though. You personally don't need to limit yourself to this minimal bar, and we'd definitely encourage you to go even further. (See resources for some suggestions). In future we also hope to extend beyond this, to steadily raise the bar and improve diversity more and more. For now though this pledge is focused on taking a pragmatic and immediate step forward, with a long road ahead.
Diversity is important, and every event should have a diverse lineup. Many free events are tiny meetups organized by volunteers though, with tiny lineups, and barely enough time or resources to actively find any speakers, let alone go further and encourage diverse speakers. (See resources for some tips on doing this.) These events do need to be more inclusive too, but outright boycotts across the board would rule out many events that can't easily invest more effort to go further. Including these events in this pledge would make it impossible for many people to sign up.
Events that charge for entry are a different matter: any event large & successful enough to charge for tickets has the power to provide an inclusive environment, and a responsibility to do so. These events need to be investing some of their revenue and time back into their speaker selection to guarantee at least a minimum level of diversity, and many aren't. This is where we're focusing.
You personally don't have to limit this to only paid events though. This is the minimum general bar, but do feel free to go further and push for more! (See resources if you'd like some ideas for ways to do that.)
The short answer: it depends, but the key is to highlight a range of voices from a variety of backgrounds, especially those who aren't normally heard.
Diversity is a complicated topic, and it's going to depend on the context. You may have to make your own call on this. Not all diversity is visible: many disabilities have no physical manifestation and you cannot tell if a person is LGBT just from appearance. However, a lack of visible diversity is a very clear indicator that an event is not considering diversity at all. It is the clearly failing cases that this pledge is most concerned with. When your whole lineup is white men, there's a clear problem. If you have a lineup that instead includes some women, people of color, LGBT people, and people with disabilities, you've gained some level of diversity.
Existing represention of the groups in question is key. The groups to focus on are those who are otherwise frequently discriminated against, and are different to the typical speakers you'd see at your event. Adding somebody British to a lineup of Americans typically doesn't add any meaningful diversity. Adding somebody from Latin America often would.
For white male speakers, the speaker pledge is often relevant and actionable. It's less relevant as a speaker from an underrepresented group though, as bringing your own voice to an event often increases the diversity of speakers automatically. (That's not always the case! There are occasional instances of problematic lineups including only the voices of cis white women, for example, but it's a much less frequent issue than the classic all-white-male panel.)
For some of us who are ourselves underrepresented, it may feel like we'll never be a member of a homogeneous group of speakers, and this pledge won't matter. These pledges exist though because never seeing people like yourself up on stage sucks, and without the support of the people we're trying to help, they're meaningless. If you're from an underrepresented group, we need your help to create better events:
There are quite a few other related pledges. Many of these are more narrowly focused aimed at a specific field or part of world. Some commit you to general rather than concrete action, or look only at panel lineups, rather than whole conferences. Many focus only on including female speakers, rather than encouraging diversity as a whole (an easy way to leave many other underrepresented groups excluded). Those other pledges have value, but they're not doing exactly what we want to do here.
The goal of this pledge is to help people take specific concrete action to solve the diversity problem that appears in professional events of all sorts of fields, all around the world, for everybody. As far as we're aware, this is the only pledge doing that.
Mainly just publish how many of them we get, so everybody can see how many people think this is important.
The pledges also ask you for your name (or your company/event's name and logo). We're planning to eventually publish a list of the people who've signed up, and include a selection of event and company logos on the site. There is an option in the pledge to sign it but opt out of having your name published, if you'd prefer.
Finally, we also collect email addresses (again, optionally). We'll never share these or spam them. They're only going to be used for very occasional later updates closely related to this pledge.
There's a lot of content out there on diversity. Read some of the many articles outlining approaches to solving exactly this problem, like Ashe Dryden's incredibly detailed posts (one, two), Anna Shipman's great guide or the Hopper Fund's exhaustive walkthrough.
Actively encourage submissions from relevant communities. Tweet at groups like @CallbackWomen and @DevChix for exposure to women looking for speaking events. Meri Williams also has a useful guide on broadening the responses to your call for papers, filled with tips for making this process more effective.
Approach speakers from underrepresented backgrounds. Talk to organizations representing underrepresented groups in your industry and see if they can suggest speakers, and look for speakers from varied backgrounds in the lineups of other conferences in your field. If you get stuck, here's some pre-compiled lists of great speakers from a diverse range of backgrounds you could talk to:
Have another list or resource people should see? Suggest it.
Sign the Diversity Charter and promise to encourage and help event organizers commit to improving diversity more generally. They've also got their own fantastic set of resources on all this too, which are well worth a read.
If you're in tech, join Project Include, a community working to provide materials, support and guidance for teams and companies in tech to improve diversity.
Donate to, sponsor and support organizations like CallbackWomen, Model View Culture, AlterConf, Codebar and Stemettes.
Want to extend or change this pledge? This whole site is fully open-source, available on Github, and MIT licensed. If you spot a typo, have concerns, or think there's another resource that should be included open an issue or create a pull request, and help us do better.


Welcome to My Blog
Hello and Welcome to My new Personal Blog Page where I will be covering topics either on my family and faith, household projects or something related to coding which will mostly be Python.
 Stephen is six and Seth is three.
Here's a quick list of some of Our Favorite Things.
| categories | Bryce | Tyna | Stephen | Seth |
|---|---|---|---|---|
| tv-show | The Flash | Poirot | Daniel Tiger's Neighborhood | Paw Patrol |
| movie | Star Trek: First Contact | Young Frankenstein | Big Hero 6 | Cars |
| food | Pizza | Anything Chocolate | Anything Chocolate | Anything Chocolate |


|
Screen Name |
Parameter
|
Type |
Description |
|
Layer |
pp_layer
|
layer |
Defines the layers to be processed. Its value may be a
single layer name or an expression. The paste layer or the signal/ mixed
layers that are defined as top or bottom layers will be used. |
|
Width Mode |
pp_w_mode
|
menu |
Distance, Factor, Value |
|
Factor (Width Mode) |
pp_w_fact
|
double |
Range: 0.3 <-> 0.99 When the Width Mode parameter is set to Factor, this field
contains the factor by which the SMD pad's width will be divided. |
|
Value (Width Mode) |
pp_w_val
|
p_mil |
Range: 2 <-> 500 |
|
Height Mode |
pp_h_mode
|
menu |
Distance, Factor, Value |
|
Factor |
pp_h_fact
|
double |
Range:0.3 <-> 0.99 When the Height Mode parameter is set to Factor, this field
contains the factor by which the SMD pad's height will be divided. |
|
Value |
pp_h_val
|
p_mil |
Range: 2 <-> 500 When the Height Mode parameter is set to Value, this
parameter is the absolute value by which the SMD pad height will be changed. |
|
Symmetric |
pp_s_mode
|
menu |
Distance, Factor, Value Defines how symmetric SMD pads will be shrunk: distance, factor
or value |
|
Factor (Symmetric) |
pp_s_fact
|
double |
Range: 0.3 <-> 0.99 When the Symmetric mode parameter is set to Factor, this
field contains the factor by which the SMD pad will be divided. |
|
Value (Symmetric) |
pp_s_val
|
p_mil |
Range: 2 <-> 500 When the Symmetric mode parameter is set to Distance, this
parameter is the distance by which the SMD pad will be shrunk. When the
Symmetric parameter is set to Value, this parameter is the absolute value by
which the SMD pad will be shrunk. |
|
SMD Ranges |
pp_w_min
|
p_mil |
Range 2 <-> 500 |
|
SMD Ranges |
pp_w_max
|
p_mil |
Range: 2 <-> 500 |
|
SMD Ranges |
pp_h_min
|
p_mil |
Range: 2 <-> 500 Only SMD pads in the ranges of this parameter will be
processed. |
|
SMD Ranges |
pp_h_max
|
p_mil |
Range: 2 <-> 500 Only SMD pads in the ranges of this parameter will be processed. |
|
Test Via Mode |
pp_test_mode
|
menu |
Distance, Factor, Value Defines how Test point pads will be shrunk: distance,
factor or value. |
|
Factor |
pp_test_fact
|
double |
Range 0.3 <-> 0.99 When the Test Via Mode parameter is set to Factor, this
field contains the factor by which the Test Point size will be divided. |
|
Value |
pp_test_val
|
p_mil |
Range: 2 <-> 500 When the Test Via Mode parameter is set to Distance, this
parameter is the distance by which the Test point pad will be shrunk. When the Test Via Mode parameter is set to Value, this
parameter is the absolute value by which the Test point size will be changed. |
|
Affect selected |
pp_sel_mode
|
radio |
Range: No, Yes Yes - specifies that the SPO DFM action will apply only to
user-selected features. No - applies to all features in the layer. The features
must be selected from the Work layer. |
|
Ground Pads recognition by |
pp_gnd_recognize
|
radio |
Range: None, Diameter, Selection Defines how to identify Ground pads. None - completely ignored. Diameter - identified by diameter (for pads that do not
have the .smd or .test_point
attributes). Selection - selected pads (without .smd or .test_point
attributes), and the Affect Selected parameter (above) is forced to No. |
|
Ground Pad Diam |
pp_gnd_size1,
pp_gnd_size2, pp_gnd_size3 |
p_mil |
Range: 0 <-> 200 These are the diameters defining Ground pads when Diameter mode
is specified in Ground Pads Recognition By. To use only one or two of the fields, set all other fields
of the parameters to 0 (zero). Either way, the Ground pads must be round and
must not have .smd or .test_point
attributes. |
|
Ground Pad AR |
pp_gnd_ar
|
p_mil |
Range: 2 <-> 50 The distance of the Ground pad paste from the edge of the
pad. |
|
Paste Width |
pp_gnd_width
|
p_mil |
Range: 2 <-> 50 The width of the pastes (shaped like a thermal pad) on a
Ground Pad |
|
Num |
pp_gnd_num
|
int |
Range: 2 <-> 8 The number of paste sections that make up the thermal pad
shape on the Ground pad. |
|
Gap |
pp_gnd_gap
|
p_mil |
Range: 2 <-> 50 The size of the gap between the paste sections (the
distance between them). |


--- layout: post title: 'Likeable: Love your Objects with Redis' date: '2011-11-03T11:00:00-05:00' tags: - ruby - redis - likeable - performance permalink: /post/12284687281/likeable-love-your-objects-with-redis ---
This is a re-post of an article I wrote for Gowalla’s Engineering Blog. You can view the original article here.
Likeable is a new open-source Ruby library that we built here at Gowalla to power all of the “loves” on stories, comments, highlights and photos that you see. It’s built on top of Redis to be extremely simple, isolated and fast. Likeable plays well with ActiveRecord objects, but can be used with any Ruby object that implements an #id
method.
To see it in action, head over to my Gowalla profile and love the first thing you see. Immediately you’ll see the heart change colors and the love count increase by one. If you click on that number you’ll see everyone who has loved that object.
This might seem trivial at first glance. But consider that dozens of elements on the page must pull this information: how many people have loved it, whether the viewer has loved it, and (on some pages) which of your friends have loved it. Using Redis allows us to stay simple, flexible and fast.
Let’s say we’ve got a comment made on a recent Gowalla story.
@comment = Comment.last
@comment.like_count #=> 0
If our user wants to like this comment, he can do so with ease:
@user = User.find_by_username('schneems')
@user.like! @comment
And that’s it. The comment now reports the details of the like.
@comment.like_count #=> 1
@comment.likes #=> [#<Likeable::Like ... >]
@comment.likes.last.user #=> #<User username: "schneems" ...>
For Rails apps, Likeable is extremely simple to set up.
First, add Likeable to your Gemfile
:
gem 'likeable'
Set up your Redis connection in (e.g.) config/initializers/likeable.rb
:
Likeable.setup do |likeable|
likeable.redis = Redis.new
end
Next, add the Likeable::UserMethods
module to your User
model:
class User < ActiveRecord::Base
include Likeable::UserMethods
end
Finally, add the Likeable
module to any model you want to be likeable:
class Comment < ActiveRecord::Base
include Likeable
end
To learn more, check out the Likeable source, look at the example Rails app or watch the Likeable screencast.
We’d love to get contributions to Likeable. If you want it to do something it doesn’t already, open an issue on GitHub. Or, if you feel so inclined, create a patch and submit a pull request.


HOME |
BUS |
CAB |
RAILWAY |
AIR-PLANE |
WATER FREIGHT |
BODA-BODA |
Databse |
Hotel |
NEWS |
About us |
Contact us |
Sign-In |
Sign-Up
YOU ARE BOOKED FOR SAFE JOURNEY WITH ROLIVES TRAVELS
Booking details


Bootstrap's pagination is highly customized in Material Admin to match the overall look and feel of the template thus most of it's Bootstrap customization such as sizing, custom texts would not work here.
Complete
Boundary links disabled
Direction links disabled
Number only
The selected page no: {{paginCurrentPage}}/{{paginNumPages}}


RC. These macros define a family of log priority levels:
-
LOG_LEVEL_FATAL
: indicates an error which is wholly unrecoverable, a sign of a major bug in the program. Logging one of these crashes the program to prevent further damage. -
LOG_LEVEL_DFATAL
: indicates an error which is technically recoverable but is nonetheless a sign of a major bug in the program. In debug mode, logging one of these crashes the program to prevent further damage (and to allow easier debugging withgdb
). -
LOG_LEVEL_ERROR
: indicates a serious problem that prevents the program from accomplishing something. -
LOG_LEVEL_WARN
: indicates a problem that the program can work around. -
LOG_LEVEL_INFO
: indicates a situation which is not a problem, but unusual enough to be worth commenting on. -
VLOG_LEVEL(num)
: indicates a debugging or other high-verbosity message. The valid range fornum
is0..127
; each increment marks a higher level of verbosity.
Logging Macros
LOG()
VLOG()
#define LOG(name) ::base::Logger(__FILE__, __LINE__, 1, LOG_LEVEL(name)) #define VLOG(num) ::base::Logger(__FILE__, __LINE__, 1, VLOG_LEVEL(num))
RC. These are the standard logging macros.
Example:
const int x = 42; LOG(INFO) << "Hello world!"; VLOG(0) << "x=[" << x << "]";
LOG_EVERY_N()
VLOG_EVERY_N()
#define LOG_EVERY_N(name, n) \ ::base::Logger(__FILE__, __LINE__, (n), LOG_LEVEL(name)) #define VLOG_EVERY_N(num, n) \ ::base::Logger(__FILE__, __LINE__, (n), VLOG_LEVEL(num))
RC. These logging macros log only 1 message out of every
n
, discarding the rest.
LOG_EXCEPTION()
#define LOG_EXCEPTION(e) ...
RC. This logging macro logs a caught exception.
Example:
try { ...; // may throw } catch(...) { LOG_EXCEPTION(std::current_exception()); }
CHECK Macros
CHECK()
#define CHECK(cond) ...
RC. Asserts that the given condition holds true, logging a
LOG_LEVEL_DFATAL
message if it does not.
Example:
struct Foo {...}; Foo foo; bool predicate(const Foo& value); CHECK(predicate(foo)) << ": extra message";
This is shorthand for:
struct Foo {...}; Foo foo; bool predicate(const Foo& value); if (!predicate(foo)) { LOG(DFATAL) << "CHECK FAILED: predicate(foo)" << ": extra message"; }
CHECK_OK()
#define CHECK_OK(result) ...
RC. Similar to CHECK(result)
, where result
is a base::Result
, but
this macro provides better log messages.
CHECK_EQ()
CHECK_NE()
CHECK_LT()
CHECK_LE()
CHECK_GT()
CHECK_GE()
#define CHECK_EQ(x, y) ... #define CHECK_NE(x, y) ... #define CHECK_LT(x, y) ... #define CHECK_LE(x, y) ... #define CHECK_GT(x, y) ... #define CHECK_GE(x, y) ...
RC. Similar to CHECK(x == y)
,
CHECK(x != y)
, etc., but these macros provide better log
messages.
CHECK_NOTNULL()
#define CHECK_NOTNULL(ptr) ...
RC. Asserts that the given pointer is non-null, logging a
LOG_LEVEL_FATAL
message if it is null. ptr
may be a T*
, a
std::shared_ptr
or a
std::unique_ptr.
Returns the pointer.
NOTE: Unlike the other macros in the
CHECK
family, this macro logs at
LOG_LEVEL_FATAL
, i.e. it will crash production code if it
fails. This is because an unexpected null pointer is an unrecoverable
error, and a controlled crash is better than undefined behavior.
NOTE: Unlike the other macros in the
CHECK
family, this macro does not
allow the caller to add to the log message. This is because it returns a
pointer, not a base::Logger
.
Foo* ptr1 = CHECK_NOTNULL(func1(...)); Foo* ptr2 = CHECK_NOTNULL(var2); std::shared_ptr<Foo> ptr3 = CHECK_NOTNULL(func3(...)); std::shared_ptr<Foo> ptr4 = CHECK_NOTNULL(std::move(var4)); std::unique_ptr<Foo> ptr5 = CHECK_NOTNULL(func5(...)); std::unique_ptr<Foo> ptr6 = CHECK_NOTNULL(std::move(var6));
This is shorthand for:
Foo* ptr1 = func1(...); if (!ptr1) LOG(FATAL) << "CHECK FAILED: func1(...) != nullptr"; Foo* ptr2 = var2; if (!ptr2) LOG(FATAL) << "CHECK FAILED: var2 != nullptr"; std::shared_ptr<Foo> ptr3 = func3(...); if (!ptr3) LOG(FATAL) << "CHECK FAILED: func3(...) != nullptr"; std::shared_ptr<Foo> ptr4 = std::move(var4); if (!ptr4) LOG(FATAL) << "CHECK FAILED: std::move(var4) != nullptr"; std::unique_ptr<Foo> ptr5 = func5(...); if (!ptr5) LOG(FATAL) << "CHECK FAILED: func5(...) != nullptr"; std::unique_ptr<Foo> ptr6 = std::move(var6); if (!ptr6) LOG(FATAL) << "CHECK FAILED: std::move(var6) != nullptr";
Debug-only Macros
DLOG()
DVLOG()
DLOG_EVERY_N()
DVLOG_EVERY_N()
DCHECK()
DCHECK_OK()
DCHECK_EQ()
DCHECK_NE()
DCHECK_LT()
DCHECK_LE()
DCHECK_GT()
DCHECK_GE()
#define DLOG(name) ... #define DVLOG(vlevel) ... #define DLOG_EVERY_N(name, n) ... #define DVLOG_EVERY_N(vlevel, n) ... #define DCHECK(x) ... #define DCHECK_OK(x) ... #define DCHECK_EQ(x, y) ... #define DCHECK_NE(x, y) ... #define DCHECK_LT(x, y) ... #define DCHECK_GT(x, y) ... #define DCHECK_LE(x, y) ... #define DCHECK_GE(x, y) ...
BETA. These macros are variants of their namesakes without the "D"
prefix. When NDEBUG
is defined, these macros evaluate to a
null base::Logger
. Otherwise, they
are exactly equivalent to their namesakes.
NOTE: These should be used sparingly. Prefer the non-"D" versions of these macros unless profiling shows that they are impacting your performance.
DCHECK_NOTNULL()
#define DCHECK_NOTNULL(ptr) ...
BETA. This macro is a variant of
CHECK_NOTNULL
. When
NDEBUG
is defined, it becomes a pass-through no-op.
Otherwise it is exactly equivalent to its namesake.
NOTE: This should be used sparingly. Prefer the non-"D" version of this macro unless profiling shows that it is impacting your performance.
Top-level Functions
want()
namespace base { bool want(const char* file, unsigned int line, unsigned int every_n, level_t level); }
BETA. Returns true if at least one logging target would be interested in a log with the given metadata.
This is also the function responsible for maintaining log moduli. For
example, if want()
is called three times with the same
values for file
and line
and with
every_n == 3
, then it will return true once and false
twice.
log()
namespace base { void log(const LogEntry& entry); }
BETA. Sends the given LogEntry to all interested logging targets.
This is also the function responsible for automatic log flushing and for terminating the program upon fatal errors.
log_single_threaded()
namespace base { void log_single_threaded(); }
RC. Forces the use of single-threaded logging. This is mostly useful for GoogleTest death tests.
NOTE: this function throws std::logic_error
if
the logging thread has already been started.
log_flush()
namespace base { void log_flush(); }
RC. Blocks until all logs written before the flush have been committed.
log_flush_set_level()
namespace base { void log_flush_set_level(level_t level); }
RC. Sets the threshold for automatic log flushing. Messages with the
given priority or higher will call
flush()
on all logging targets.
log_stderr_set_level()
namespace base { void log_stderr_set_level(level_t level); }
BETA. Sets the threshold for stderr
logging. Messages
with the given priority or higher are logged; messages with lower
priority are discarded.
log_target_add()
namespace beta { void log_target_add(LogTarget* target); }
BETA. Registers a LogTarget implementation to receive log messages.
log_target_remove()
namespace beta { void log_target_remove(LogTarget* target); }
BETA. Unregisters a LogTarget implementation from receiving new log messages. This call implies a flush.
log_set_gettid()
namespace beta { void log_set_gettid(pid_t (*func)()); }
BETA. Replaces the
gettid(2)
syscall with a fake for testing.
log_set_gettimeofday()
namespace beta { void log_set_gettimeofday(int (*func)(struct timeval*, struct timezone*)); }
BETA. Replaces the
gettimeofday(2)
syscall with a fake for testing.
level_t
namespace base { class level_t { public: constexpr level_t() noexcept; constexpr explicit level_t(signed char value) noexcept; constexpr level_t(const level_t&) noexcept; constexpr level_t(level_t&&) noexcept; level_t& operator=(const level_t&) noexcept; level_t& operator=(level_t&&) noexcept; constexpr explicit operator signed char() const noexcept; }; constexpr bool operator==(level_t a, level_t b) noexcept; constexpr bool operator!=(level_t a, level_t b) noexcept; constexpr bool operator<(level_t a, level_t b) noexcept; constexpr bool operator<=(level_t a, level_t b) noexcept; constexpr bool operator>(level_t a, level_t b) noexcept; constexpr bool operator>=(level_t a, level_t b) noexcept; }
RC. A value type indicating the priority level of a log message.
Higher priority levels compare greater than lower priority levels;
for example, LOG_LEVEL_ERROR > LOG_LEVEL_WARN
.
NOTE: The integer values are NOT part of the stable API!
level_t::level_t()
Constructs a level_t
value.
-
The default constructor is equivalent to
VLOG_LEVEL(0)
. -
The explicit 1-arg
signed char
constructor creates a priority level with the given underlying representation.
Reminder: the integer values are NOT part of the stable API! - The copy constructor does the obvious thing.
- The move constructor is equivalent to the copy constructor.
level_t::operator=()
Assigns a level_t
value. The copy and move assignment
operators work analogously to the copy constructor.
level_t::operator signed char()
Returns the underlying representation.
Reminder: the integer values are NOT part of the stable API!
level_t::operator==()
level_t::operator!=()
level_t::operator<()
level_t::operator<=()
level_t::operator>()
level_t::operator>=()
Compares two level_t
values.
LogEntry
namespace base { struct LogEntry { struct timeval time; pid_t tid; const char* file; unsigned int line; level_t level; std::string message; LogEntry(); LogEntry(const char* file, unsigned int line, level_t level, std::string message) noexcept; LogEntry(const LogEntry& other); LogEntry(LogEntry&& other); LogEntry& operator=(const LogEntry& other); LogEntry& operator=(LogEntry&& other); void clear() noexcept; explicit operator bool() const noexcept; void append_to(std::string* out) const; std::string as_string() const; }; }
BETA. Represents a log message and the various metadata fields associated with it.
LogEntry::time
Stores the time at which this LogEntry was constructed.
LogEntry::tid
Stores the TID of the thread which constructed this LogEntry.
LogEntry::file
Identifies the source filename from where the log is coming.
LogEntry::line
Identifies the source line number from where the log is coming.
LogEntry::level
Identifies the priority level of the LogEntry.
LogEntry::message
Stores the message of the LogEntry.
LogEntry::LogEntry()
Constructs a LogEntry.
- The default constructor creates an empty LogEntry.
- The 4-arg constructor populates the specified fields. In addition, it captures the current time and the calling thread's TID.
- The copy constructor does the obvious thing.
- The move constructor creates this LogEntry to hold the fields of the moved-from LogEntry, leaving the moved-from LogEntry in the default-constructed state.
LogEntry::operator=()
Assigns a LogEntry. The copy and move assignment operators work analogously to their respective constructors.
LogEntry::clear()
Sets the LogEntry to the default-constructed state.
LogEntry::operator bool()
Returns true iff this LogEntry is non-empty.
LogEntry::append_to()
Stringifies this LogEntry and appends it to the given string.
See also:
base::append_to()
.
LogEntry::as_string()
Stringifies this LogEntry and returns it.
Logger
namespace base { class Logger { public: Logger(); Logger(const char* file, unsigned int line, unsigned int every_n, level_t level); Logger(Logger&&) noexcept; ~Logger() noexcept(false); Logger& operator=(Logger&&) noexcept; void clear() noexcept; const char* file() const noexcept; unsigned int line() const noexcept; unsigned int every_n() const noexcept; level_t level() const noexcept; explicit operator bool() const noexcept; std::ostringstream* stream() noexcept; const std::ostringstream* stream() const noexcept; std::string message() const; template <typename T> Logger& operator<<(const T& obj); Logger& operator<<(std::ostream& (*obj)(std::ostream&)); LogEntry entry() const;Logger(const Logger&) = delete;Logger& operator=(const Logger&) = delete;} }
BETA. Collects the data for a log message, then logs it when the destructor runs.
The base::Logger
class is rarely used directly. It is
normally used internally by the LOG
macro and family.
Logger::Logger()
Constructs a Logger.
- The default constructor results in a null Logger, which discards everything written to it and does nothing in the destructor.
- The 4-arg constructor results in a non-null Logger, which initializes the metadata for a new LogEntry, appends message data to the log, and logs the entry in the destructor.
- The move constructor creates this Logger in the state that the moved-from Logger originally had, and converts the moved-from Logger into a null Logger.
For the 4-arg constructor, file
must be non-null,
line
and every_n
must be 1
or
greater, and level
must be a valid level as defined by a
LOG_LEVEL_*
, LOG_LEVEL(name)
, or
VLOG_LEVEL(num)
macro.
Logger::~Logger()
Destroys the Logger. If this Logger is non-null, the accumulated LogEntry will be written to the log.
Logger::operator=()
Assigns to the Logger. The move assignment operator works analogously to the move constructor, converting the moved-from Logger into a null Logger.
Logger::clear()
Sets the Logger to the default-constructed state.
Logger::file()
Accesses the filename with which this Logger was constructed.
Returns nullptr
iff this is a null Logger.
Logger::line()
Accesses the line number with which this Logger was constructed.
Returns 0
iff this is a null Logger.
Logger::every_n()
Accesses the count modulus with which this Logger was constructed.
Returns 0
iff this is a null Logger.
Logger::level()
Accesses the priority level with which this Logger was constructed.
Returns VLOG_LEVEL(0)
if this is a null Logger.
Logger::operator bool()
Returns true iff this Logger is a non-null Logger.
Logger::stream()
Returns a pointer to the std::ostringstream
into which
this Logger is accumulating its message. Returns nullptr
if
this is a null Logger.
Logger::message()
Returns the log message as accumulated so far, or the empty string if this is a null Logger.
Logger::operator<<()
These operators append to or manipulate the
std::ostringstream
of a non-null Logger, or discard their
arguments when performed on a null Logger.
Logger::entry()
Returns a LogEntry
which
represents the Logger's message as accumulated so far.
LogTarget
namespace base { class LogTarget { public: virtual ~LogTarget() noexcept = default; virtual bool want(const char* file, unsigned int line, level_t level) const = 0; virtual void log(const LogEntry& entry) = 0; virtual void flush() = 0; }; }
BETA. Abstract base class for logging backend implementations.
LogTarget::want()
Returns true iff this LogTarget is interested in recording a LogEntry with the given metadata. If no LogTarget expresses interest, then the entry will not be logged at all.
This method will be called from multiple threads.
LogTarget::log()
Observes the given LogEntry.
LogTarget::flush()
Requests that the LogTarget flush all written log entries to disk,
using fdatasync(2)
or equivalent.


We're sorry but xd-meal doesn't work properly without JavaScript enabled. Please enable it to continue.


Routine repairs to Grill at Bisee junction
by Ministry of Infrastructure, Ports, Energy and labour(PRESS RELEASE) – The Department of Infrastructure, Ports and Energy wishes to inform the motoring public that a section of roadway at the Bisee intersection along the Castries Gros Islet Highway will be reduced to one lane traffic from Saturday November 23rd to Monday November 25th and again on Saturday November 30th to Monday December 2to facilitate repairs to the grilles at this intersection.
During the works, traffic will only be allowed to exit the Bisee Junction and motorists wishing to gain access to Bisee and nearby communities, via the Highway, must do so utlising the Summersdale entrance near Wayne`s Garage.
All commuters are asked to be guided by road signs which will be placed for their information and guidance, abide by the instructions given by flaggers who will be on location and extend full cooperation.
The Department of Infrastructure, Ports and Energy wishes to apologies for any inconveniences which may be caused as a result of the road works but assures the public that these interventions are important for general Road Safety.
More Development Stories
-
Final phase of Sandals to Choc Road Widening Project November 21, 2019
-
Soufriere Police Station renovations complete November 21, 2019
-
Stephenson King reveals Castries North development projects May 5, 2019
-
Castries Vision 2030 consultations end April 26, 2019
-
EC$79.8 million allocated for ongoing roads, bridges and maintenance/rehabilitation projects April 17, 2019
-
Cul De Sac Bridge project’s official financial bid opening, contract negotiation and signing all set February 4, 2019
-
Taiwan to lend Saint Lucia US$100 million for airport redevelopment project November 19, 2018
-
Gov’t shuts down section of La Ressource Road November 14, 2018
-
Pearl of the Caribbean developer to give update on the project November 14, 2018


Web Beep
Text to (kinda musical) tones and back again.
Try it out! [Alpha]
Make Beeps
Decode Beeps
[upload]
Documentation
Creative Commons Attribution 3.0 Unported License.
(c) Danny Ayers 2011
archived activities of Danny Ayers
Text to (kinda musical) tones and back again.
[upload]
Creative Commons Attribution 3.0 Unported License.
(c) Danny Ayers 2011


Oct 1, 2013 1:20 PM
This seminar will explore the role of arts in education and how they can be used to engage students across all subjects. The arts have historically been a common ground for connection and expression. Integration across academic disciplines can strengthen a child's learning. However, with the growing cuts to arts programming in public schools, a significant number of students are denied these valuable tools for connection, expression, and advancement. An understanding of how learning takes place in and through the arts, while considering the issues of access and quality, is key to approaching the challenges the arts face in education and how those challenges can be addressed. Hadi Eldebek is a musician, composer, entrepreneur, and educator. In 2009, he joined Yo-Yo Ma's Silk Road Project as a teaching artist. He was a part of the development of Silk Road Connect, an approach to teaching that targets upper elementary and middle school students in low-resourced communities, where students are least likely to have access to the transformative power of the arts. Hadi is currently working on his startup "instruMeet", a platform for music and arts collaboration and education. Hadi has a B.S. in Chemistry and Mathematics from City University of New York, and currently is pursuing his masters in Operations research and Industrial Engineering at Columbia University.


The following examples illustrate some basic ways to identify inputs that users are required to complete.
Providing a text description in the input label
Text descriptions can appear in the form label of required inputs, for example, using “(required)” along with the input label, as in “Email (required)”.
Email (required)
<input type="text" id="email" required>
Providing instructions on the page
Text descriptions can appear before the form, for example, including instructions that indicate that all inputs are required, as in “Note: All inputs required”, before the form on the page or view.

Note: All inputs are required

Name
<input type="text" id="name" aria-required="true">
Email
<input type="text" id="email" aria-required="true">
Providing a non-text indicator and text instructions
Non-text descriptions can appear in the form as the indicator along with descriptive text, for example, an asterisk in the input label, as in “Email *”.
Using a character non-text indicator

Note: An asterisk (*) denotes a required field

Email *
<input type="text" id="email" required>
Using an image non-text indicator

Note:  denotes a required field

Email
<input type="text" id="email" required>


Fallout games are a must have for any apocalypse fans!
Fallout one ,featured in 1997, gives a nice hybrid gameplay of a fresh new combat system intertwined with a nice comic book natsalgic feel. Although this game is well overdated I recommend getting it before playing any of the others. Bethesda does a wonderful job, even back in the day, of creating a boundless world and tons of gameplay: With humor included!
Fallout two was made pretty much the same as the first but in a diffrent area and with a couple improvements. Combat remains turn based but it certainly doesnt fail to deliver, dailogues develop in to talking avatars, inventory access is made easier, and if you work hard enough you can even have a fully functioning car in the game.
Fallout Tactics brought a new system to the series with it's spin off. The game actually included a squad you could command and action was set in real time. Although this game was a little bit underrated I personally still count it among the series because it's just as amusing as the first two, and brought life to Fallout 3!
In 2008 Fallout 3 was released on Xbox 360. This game revolutionized the combat system in the finalized form of V.A.T.S.; not to mention it put the fallout series on the map for all gamers. For those who enjoy modern mechanics, and don't wish to dig through the web for the older games I suggest starting with this one as an introduction.
Fallout:New Vegas had a rough release. The makers decided to tweak the combat system a little with armor piercing bullets.. and well it didn't turn out as planned. The game added a survival feature where you actually had to eat, drink, and stay rested in the game. They also introduced using campfires to cook meals and improved the crafting system by a mile. All setbacks aside it is not a bad game, and has just as much flair as the rest.
Fallout 4 released on Xbox One last year. This added a base building concept to the game which players really enjoyed. They also upgraded how power armor works and turned it into a literal mechsuit the players can climb in and walk around in. Although I haven't gotten much play time with this game I know they did not fail to deliver with this one.
Fallout releases by year:
| Released in | |||||
|---|---|---|---|---|---|
| Fallout 1 | Fallout 2 | Fallout: Tactics | Fallout 3 | Fallout: New Vegas | Fallout 4 |
| 1997 | 1998 | 2001 | 2008 | 2010 | 2015 |


-
A Watch Guy's Thoughts On The Apple Watch After Seeing It In The Metal ...
www.hodinkee.com
I'm not even sure we can call it a watch. Okay, it goes on the wrist, and it happens to tell the time, but that's about where the similarities ...
-
ALS Ice Bucket Challenge
www.youtube.com
Apple CEO Tim Cook and recording artist Michael Franti take the Ice Bucket Challenge to benefit ALS research.
-
Apple - Privacy - Government Information Requests
www.apple.com
Our commitment to customer privacy doesn’t stop because of a government information request.
-
App store set records in July: Apple
www.cnbc.com
Apple said that its app store set records for revenue and customers in July.
-
What Coke Contains
medium.com
The Vons grocery store two miles from my home in Los Angeles, California sells 12 cans of Coca-Cola for $6.59 — 54 cents…
-
Eric Robinson sur Twitter : "brb gonna stare at this Apple Watch ...
twitter.com
Mot de passe oublié ? Vous utilisez déjà Twitter via SMS ?
-
Stripe: Apple Pay
stripe.com
Stripe is a suite of APIs that powers commerce for businesses of all sizes.
-
1Password - Password Manager and Secure Wallet
itunes.apple.com
Get 1Password - Password Manager and Secure Wallet on the App Store. See screenshots and ratings, and read customer reviews.
-
Israel’s N.S.A. Scandal - NYTimes.com
www.nytimes.com
WASHINGTON — IN Moscow this summer, while reporting a story for Wired magazine , I had the rare opportunity to hang out for three days with Edward J. ...
-
Scott Hurff
scotthurff.com
I'm Scott Hurff, and I love to help you build better products. I'm on the founding team of a Kleiner Perkins-backed mobile startup, created a course ...
-
Microsoft Near Deal to Buy Minecraft Maker Mojang
online.wsj.com
Microsoft is in serious discussions to buy Mojang, the Swedish company behind the popular "Minecraft" videogame, according to a person with knowledge ...
-
Apple (United Kingdom) - Job Creation
www.apple.com
Read how our focus on innovation has resulted in hundreds of thousands of European jobs at Apple and at developers and businesses supported by Apple.
-
iTunes Session by OneRepublic
itunes.apple.com
Preview and download iTunes Session on iTunes. See ratings and read customer reviews.
-
IPPAWARDS | 8th Annual iPhone Photography Awards™ 2014 Winners - IPPAWARDS ...
www.ippawards.com
2014 PHOTOGRAPHERS POTY & CATEGORY WINNERS ANIMALS ARCHITECTURE CHILDREN FLOWERS FOOD LANDSCAPE LIFESTYLE NATURE NEWS/EVENTS OTHERS PANORAMA PEOPLE ...
-
Omotesando, Tokyo - Grand opening 6.13.2014
www.youtube.com
Introducing the newest Apple Store in Tokyo. Take a peek behind the scenes and see how it all comes together.
-
Beats by Dre | The Game Before The Game
www.youtube.com
Beats by Dr. Dre presents "The Game Before The Game": http://www.thegamebeforethegame.com "Jungle" Jay Z Remix: http://beats.is/JayZrmx Before the ...
-
Charitybuzz | Lunch with Apple CEO Tim Cook at Apple Headquarters in ...
www.charitybuzz.com
Auction Proceeds Benefit RFK Center for Justice and Human Rights
-
Apple - iPhone 5s - You’re more powerful than you think
www.apple.com
With iPhone 5s you have the power to do everyday things in extraordinary ways, and extraordinary things every day.
-
Jimmy Fallon and Billy Joel take an iPad app for an incredible ride
www.loopinsight.com
Last night's Tonight Show was one for the ages. Jimmy Fallon introduced Billy Joel to a beatboxing iPad app called Loopy HD. Watch the video. Magic.
-
Gus Malzahn: Auburn would welcome gay player
www.al.com
Malzahn, asked about Missouri defensive end Michael Sam's decision to reveal he is gay, said a gay player would be welcome on Auburn's football team.
-
Apple - Supplier Responsibility
www.apple.com
All over the world, we're expanding opportunities for workers and ensuring that they're treated with respect and dignity.
-
HRC's 2014 Corporate Equalty Index
www.hrc.org
Human Rights Campaign Foundation’s 2014 Corporate Equality Index is the national benchmarking tool on corporate policies and practices pertinent to ...
-
The Auburn Plainsman sur Twitter : "FINAL: Auburn 59, Missouri 42. After a ...
twitter.com
Mot de passe oublié ? Vous utilisez déjà Twitter via SMS ?
-
Duke football upends Wake Forest to clinch share of Coastal Division title ...
www.dukechronicle.com
With a 28-21 win against Wake Forest, the Blue Devils won their ninth game of the season and have clinched at least a share of the ACC's Coastal ...
-
Senate Approves Ban On Gay Bias at Work
online.wsj.com
The Senate passed legislation banning workplace discrimination against gay, lesbian, bisexual and transgender employees, capping a 17-year effort to ...


Fireworks are back; first song in five years, “Demitasse,” out now (listen)
by Andrew SacherMichigan emo/pop punk band Fireworks went on hiatus in 2015 after releasing their third album, Oh, Common Life (on Triple Crown), and today they re-appeared with a tweet pointing to the website higherlonelypower.com, where they’re streaming a new song, “Demitasse.” It’s very different from anything they’ve done before; it’s a soaring, post-rocky song fueled by somber piano, ambient textures, sputtering percussion, and choir-like vocal harmonies. It isn’t even remotely any offshoot of “punk” until about five minutes in, and even at that point, it’s a much more majestic thing than your average emo/pop punk band. If Fireworks are planning a full reunion and more music like this, then they found a very, very good reason to come back. Listen here.


--- tags: - 基础算法-模拟 grammar_cjkRuby: true catalog: true layout: post header-img: "img/header/P29.jpg" preview-img: "/img/preview/P29.jpg" ---
标签：模拟
Rock... Paper!
After Karen have found the deterministicwinning (losing?) strategy for rock-paper-scissors, her brother, Koyomi, comesup with a new game as a substitute. The game works as follows.
A positive integer n is decided first.Both Koyomi and Karen independently choose n distinct positive integers,denoted byx1, x2, ..., xn and y1, y2, ..., yn respectively. They reveal their sequences, and repeat until all of 2nintegers become distinct, which is the only final state to be kept andconsidered.
Then they count the number of ordered pairs(i, j) (1 ≤ i, j ≤ n) such that the valuexixor yj equals to one of the 2n integers. Here xormeans thebitwiseexclusive or operation on two integers, and is denoted by operators ^and/or xor in most programming languages.
Karen claims a win if the number of suchpairs is even, and Koyomi does otherwise. And you're here to help determine thewinner of their latest game.
Input
The first line of input contains a positiveintegern (1 ≤ n ≤ 2 000) — the length of both sequences.
The second line containsnspace-separated integers x1, x2, ..., xn (1 ≤ xi ≤ 2·106) —the integers finally chosen by Koyomi.
The third line containsnspace-separated integers y1, y2, ..., yn (1 ≤ yi ≤ 2·106) —the integers finally chosen by Karen.
Input guarantees that the given 2nintegers are pairwise distinct, that is, no pair (i, j) (1 ≤ i, j ≤ n) exists such that one of the following holds: xi = yj; i ≠ j andxi = xj; i ≠ j and yi = yj.
Output
Output one line — the name of the winner,that is, "Koyomi" or "Karen" (without quotes). Please beaware of the capitalization.
Examples
Input
3
1 2 3
4 5 6
Output
Karen
Input
5
2 4 6 8 10
9 7 5 3 1
Output
Karen
Note
In the first example, there are 6 pairssatisfying the constraint: (1, 1), (1, 2), (2, 1), (2, 3), (3, 2) and (3, 3). Thus, Karen wins since 6 is an evennumber.
In the second example, there are 16 suchpairs, and Karen wins again.
Code
#include<bits/stdc++.h> #define rep(i,a,b) for(int i=a;i<=b;i++) #define dep(i,a,b) for(int i=a;i>=b;i--) #define LL long long using namespace std; const int maxn=2006,maxm=2000006; int a[maxn],b[maxn]; bool num[maxm]; int n,cnt=0; int main() { scanf("%d",&n); rep(i,1,n)scanf("%d",&a[i]),num[a[i]]=true; rep(i,1,n)scanf("%d",&b[i]),num[b[i]]=true; rep(i,1,n) rep(j,1,n){ if((a[i]^b[j])>=maxm)continue; if(num[a[i]^b[j]])cnt++; } if(cnt%2==0)cout<<"Karen\n"; else cout<<"Koyomi\n"; return 0; }


--- layout: post title: The Thomson Reuters Logo... categories: [] tags: [] status: publish type: post published: true meta: _original_post_id: '' _original_import_author: John Duprey author: ---
My wife found this on PostSecret. I chuckled. True or not I'll never look at the Thomson Reuters logo the same. Branding is a fickle thing, no?


# -*- coding: utf-8 -*-
"""
Methods related to Hertz contact theory
"""
from math import sqrt, pi, log
def __rred(r_1, r_2):
"""
Calculate the reduced (effective) radius of two radii according to Hertzian
contact theory.
Parameters
----------
r_1: scalar
The first radius.
r_2: scalar
The second radius.
Returns
-------
r_red: scalar
The reduced (effective) radius.
"""
if (r_1 == 0 or abs(r_1) == float('inf')) and r_2 != 0:
r_red = r_2
elif (r_2 == 0 or abs(r_2) == float('inf')) and r_1 != 0:
r_red = r_1
elif (r_1 == 0 or abs(r_1) == float('inf')) and \
(r_2 == 0 or abs(r_2) == float('inf')):
r_red = 0
elif r_1 == -r_2:
r_red = 0
else:
r_red = 1 / (1 / r_1 + 1 / r_2)
return r_red
[docs]def reff(r_x_1, r_y_1, r_x_2, r_y_2, ):
"""
Calculate the effective radii for two bodies according to Hertzian contact
theory. It is assumed that the two major axis of each body (x- and y-axis)
are perpendicular to each other and that the x and y axes of both bodies are
aligned.
Parameters
----------
r_x_1: scalar
The radius of body 1 in direction 1 (x).
r_y_1: scalar
The radius of body 1 in direction 2 (y).
r_x_2: scalar
The radius of body 2 in direction 1 (x).
r_y_2: scalar
The radius of body 2 in direction 2 (y).
Returns
-------
r_eff: scalar
The effective radius.
r_eff_x: scalar
The effective radius in x-direction.
r_eff_y: scalar
The effective radius in y-direction.
"""
recip_radius = []
for radius in [r_x_1, r_y_1, r_x_2, r_y_2]:
if radius == 0:
recip_radius.append(float('inf'))
else:
recip_radius.append(1 / radius)
r_eff_x = __rred(r_x_1, r_x_2)
r_eff_y = __rred(r_y_1, r_y_2)
r_eff = __rred(r_eff_x, r_eff_y)
return r_eff, r_eff_x, r_eff_y
[docs]def eeff(e_1, nu_1, e_2, nu_2):
"""
Calculate the effective (Young's) modulus of two contact bodies according
to Hertzian contact theory.
Parameters
----------
e_1: ndarray, scalar
The Young's modulus of contact body 1.
nu_1: ndarray, scalar
The Poisson ratio of contact body 1.
e_2: ndarray, scalar
The Young's modulus of contact body 2.
nu_2: ndarray, scalar
The Poisson ratio of contact body 1.
Returns
-------
e_eff: scalar
The effective modulus.
"""
e_eff = 1 / ((1 - nu_1 ** 2) / (2 * e_1) + (1 - nu_2 ** 2) / (2 * e_2))
return e_eff
def __auxparamshertz(r_eff_x, r_eff_y):
"""
Calculate a set of parameters required for Hertz contact area/pressure
calculations.
Parameters
----------
r_eff_x: scalar
The effective redius of the contact problem in x-direction.
r_eff_y: scalar
The effective redius of the contact problem in x-direction.
Returns
-------
a_ast: scalar
A parameter often referred to as a*.
b_ast: scalar
A parameter often referred to as b*.
kappa: scalar
A parameter often referred to as kappa.
param_lambda: scalar
A parameter often referred to as lambda.
"""
if r_eff_x == 0 or r_eff_y == 0:
param_lambda = 0
else:
param_lambda = min(r_eff_x / r_eff_y, r_eff_y / r_eff_x)
kappa = 1 / (1 + sqrt(log(16 / param_lambda) / (2 * param_lambda)) -
sqrt(log(4)) + 0.16 * log(param_lambda))
a_ast = kappa * (1 + (2 * (1 - kappa ** 2)) / (pi * kappa ** 2) -
0.25 * log(kappa)) ** (1 / 3)
b_ast = a_ast / kappa
return a_ast, b_ast, kappa, param_lambda
[docs]def dhertz(e_eff, r_x_1, r_y_1, r_x_2, r_y_2, force):
"""
Calculate the elastic normal displacement of a contact problem according
to Hertzian contact theory.
Parameters
----------
e_eff: scalar
The effective modulus of the contact problem.
r_x_1: scalar
The radius of body 1 in direction 1 (x).
r_y_1: scalar
The radius of body 1 in direction 2 (y).
r_x_2: scalar
The radius of body 2 in direction 1 (x).
r_y_2: scalar
The radius of body 2 in direction 2 (y).
force: scalar
The normal force in the contact.
Returns
-------
norm_disp: scalar
The elastic normal displacement of the contact problem.
"""
apb = 0.5 * (1 / r_x_1 + 1 / r_y_1 + 1 / r_x_2 + 1 / r_y_2)
bma = 0.5 * sqrt((1 / r_x_1 - 1 / r_y_1) ** 2 +
(1 / r_x_2 - 1 / r_y_2) ** 2)
r_a = 1 / (apb - bma)
r_b = 1 / (apb + bma)
r_c = sqrt(r_a * r_b)
f_1 = 1 - pow(pow(r_a / r_b, 0.0602) - 1, 1.456)
f_2 = 1 - pow(pow(r_a / r_b, 0.0684) - 1, 1.531)
param_c = pow(3 * force * r_c / (4 * e_eff), 1 / 3) * f_1
param_e = 1 - pow(r_b / r_a, 4 / 3)
param_a = param_c * pow(1 - param_e ** 2, 1 / 4)
param_b = param_c * pow(1 - param_e ** 2, 1 / 4)
norm_disp = param_a * param_b / r_c * (f_2 / f_1)
return norm_disp
[docs]def ahertz(r_eff, r_eff_x, r_eff_y, e_eff, force):
"""
Calculate the contact area according to Hertzian contact theory.
Parameters
----------
r_eff: scalar
The effective radius of the contact problem.
r_eff_x: scalar
The effective radius of the contact problem in x-direction.
r_eff_y: scalar
The effective radius of the contact problem in y-direction.
e_eff: scalar
The effective modulus of the contact problem.
force: scalar
The normal force in the contact.
Returns
-------
half_axis_a: scalar
The contact area half axis in x-direction.
half_axis_b: scalar
The contact area half axis in y-direction.
a_hertz: scalar
The contact area.
"""
a_ast, b_ast, _, _ = __auxparamshertz(r_eff_x, r_eff_y)
half_axis_a = a_ast * (3 * force * r_eff / e_eff) ** (1 / 3)
half_axis_b = b_ast * (3 * force * r_eff / e_eff) ** (1 / 3)
a_hertz = pi * half_axis_a * half_axis_b
return half_axis_a, half_axis_b, a_hertz
[docs]def fhertz(r_eff, r_eff_x, r_eff_y, e_eff, p_critical):
"""
Calculate the load carrying capacity of a Hertzian contact.
Parameters
----------
r_eff: scalar
The effective radius of the contact problem.
r_eff_x: scalar
The effective radius of the contact problem in x-direction.
r_eff_y: scalar
The effective radius of the contact problem in y-direction.
e_eff: scalar
The effective modulus of the contact problem.
p_critical: scalar
The critical mean Hertzian contact pressure that the contact can sustain
without plastic deformation.
Returns
-------
f_crit: scalar
The load carrying capacity of the Hertzian contact.
"""
a_ast, b_ast, _, _ = __auxparamshertz(r_eff_x, r_eff_y)
f_crit = (pi * a_ast * b_ast * p_critical) ** 3 * (3 * r_eff / e_eff) ** 2
return f_crit
[docs]def phertz(r_eff, r_eff_x, r_eff_y, e_eff, force):
"""
Calculate the mean contact pressure in a Hertzian contact.
Parameters
----------
r_eff: scalar
The effective radius of the contact problem.
r_eff_x: scalar
The effective radius of the contact problem in x-direction.
r_eff_y: scalar
The effective radius of the contact problem in y-direction.
e_eff: scalar
The effective modulus of the contact problem.
force: scalar
The normal force in the contact.
Returns
-------
p_hertz: scalar
The mean Hertzian contact pressure in the contact.
"""
_, _, area = ahertz(r_eff, r_eff_x, r_eff_y, e_eff, force)
p_hertz = force / area
return p_hertz


Hotness Alert! Esha Gupta scorches in this sultry pose as she flaunts a plunging neckline
by TIMESOFINDIA.COMEsha Gupta has started her weekend on a sizzling note as she took to Instagram to share another drool-worthy picture of herself. An avid social media user, Esha never shies away from flaunting her well-toned body on social media.
Read Also: Smoking Hot! Esha Gupta looks ravishing in a sexy red bikini and fans can't get over her hotness
Taking to Instagram, where she enjoys millions of followers, the mesmerising diva shared a scintillating picture of herself donning a plunging neckline outfit while she enjoys the sun rays while posing for the lens. She captioned the post as "When the sun shines 🌞"
This isn't the first time that Esha has set the mercury levels rising as she has even flaunted her envious body in a bikini on the picture-sharing platform. Here's a look at few of her earlier posts.
Meanwhile, on the professional front, Esha, who was last seen in 'Total Dhamaal' is also rumoured to play a part in Ameesha Patel produced 'Desi Magic' and had reportedly bagged a role in 'Hera Pheri 3'.
Read Also: Esha Gupta looks hotter than ever in this throwback picture
Facebook Twitter Pintrest


Jonathan Sharman
About
Games
Projects
Research
Questless
(github)
Work-in-progress roguelike RPG written in C++ using
SFML
and
entt
.
Gynjo
(github)
Simple interpreted language with an emphasis on being a good CLI calculator. Originally written in C++, then ported to Rust. Pronounced /'dʒɪndʒoʊ/.
Tempus
(twoclickclock.com)
(github)
Simple two-click browser-based alarm clock.
64-bit Image Editor
(github.io)
A monochrome 8x8 image editor that allows conversion to/from a 64-bit integer.
<EMAIL_ADDRESS>·
GitHub
·
LinkedIn