wall follower
`Prev `__
W
`Next `__
--------------
**wall follower**: n.
A person or algorithm that compensates for lack of sophistication or
native stupidity by efficiently following some simple procedure shown to
have been effective in the past. Used of an algorithm, this is not
necessarily pejorative; it recalls ‘Harvey Wallbanger’, the winning
robot in an early AI contest (named, of course, after the cocktail).
Harvey successfully solved mazes by keeping a ‘finger’ on one wall and
running till it came out the other end. This was inelegant, but it was
mathematically guaranteed to work on simply-connected mazes — and, in
fact, Harvey outperformed more sophisticated robots that tried to
‘learn’ each maze by building an internal representation of it. Used of
humans, the term *is* pejorative and implies an uncreative,
bureaucratic, by-the-book mentality. See also `*code
grinder* <../C/code-grinder.html>`__; compare
`*droid* <../D/droid.html>`__.
--------------
+-------------------------+----------------------------+------------------------------+
| `Prev `__ | `Up <../W.html>`__ | `Next `__ |
+-------------------------+----------------------------+------------------------------+
| wall | `Home <../index.html>`__ | wall time |
+-------------------------+----------------------------+------------------------------+


| 限定符和类型 | 字段和说明 |
|---|---|
protected Map<String,SimulationEventHandler> |
SimpleSimulationRunFactory.customEventHandlerMap |
protected HashMap<String,SimulationEventHandler> |
SimpleSimulationRunFactory.eventHandlerMap |
protected Map<String,SimulationEventHandler> |
AbstractSimulationRun.eventHandlerMap
Map for eventType -> event handlers to execute events on simulation engine
|
| 限定符和类型 | 方法和说明 |
|---|---|
SimpleSimulationRun.Builder |
SimpleSimulationRun.Builder.eventHandlers(Map<String,SimulationEventHandler> eventHandlersMap) |
void |
SimpleSimulationRunFactory.setCustomEventHandlerMap(Map<String,SimulationEventHandler> customEventHandlerMap) |
void |
SimpleSimulationRunFactory.setEventHandlerMap(HashMap<String,SimulationEventHandler> eventHandlerMap) |
| 构造器和说明 |
|---|
AbstractSimulationRun(Map<String,SimulationEventHandler> eventHandlers) |
ReplaySimulationRun(ProcessEngine processEngine,
EventCalendar eventCalendar,
Map<String,SimulationEventHandler> customEventHandlerMap) |
ReplaySimulationRun(ProcessEngine processEngine,
Map<String,SimulationEventHandler> customEventHandlerMap) |
| 限定符和类型 | 类和说明 |
|---|---|
class |
AcquireJobNotificationEventHandler
Notify AcquireJobsRunnable to continue in execution
|
class |
DeployClasspathResourcesEventHandler
This class deploys resources from classpath
|
class |
DeployResourcesEventHandler
Start new process event handler for playback purposes
|
class |
NoopEventHandler
No operation event handler
|
class |
ScriptEventHandler
This class drives simulation event handling by script.
|
class |
StartProcessByIdEventHandler
Start new process event handler for playback purposes
|
class |
StartProcessByKeyEventHandler
Start new process event handler for playback purposes
|
class |
StartReplayLogEventHandler
This class schedules replay start simulation event and takes care about process start and
next event schedule
|
class |
StartReplayProcessEventHandler
This class schedules replay start simulation event and takes care about process start and
next event schedule
|
| 限定符和类型 | 类和说明 |
|---|---|
class |
PlaybackUserTaskCompleteEventHandler
complete user task handler for playback purposes
|
| 限定符和类型 | 类和说明 |
|---|---|
class |
ReplayUserTaskCompleteEventHandler
complete user task handler for replay purposes
|
Copyright © 2017 Alfresco. All rights reserved.


Allows influencing how the build results are reported back to Gerrit when the build finishes. All input values are optional. If the step occurs multiple times in a workflow, the last value set for each parameter is used.
If the build is not triggered by Gerrit Trigger, or if the trigger is configured to not report back to Gerrit when the build finishes, this step does nothing.


--- layout: page title: About header-img: "img/about-bg.png" ---
Hello, everyone!
Welcome to my Blog! I’m new at this but I wanted to create a space for me to share with the world my journey pursuing a career path in Web development and also just share a bit about some of my other journeys. This blog will mainly be about my experience learning programming languages and my interest in the tech industry. I will also blog about more personal things that I have interests in like music and health and fitness.
My reason for creating this blog is because I, as a woman of color first and foremost who is interested in Tech have found that I never found a blog that spoke to me. I do have an interest in many things besides tech but, I wanted a place where all of my interests come together.
I hope you’ll follow me on my journey!! 🙂


Font Awesome Icon Picker is a fully customizable plugin for Twitter Bootstrap,
with a powerful base API,
based on
Bootstrap Popover Picker
You can use Font Awesome or another font icon set of your choice (icon options and items are customizable).
{ //... title: 'With custom options', icons: ['github', 'heart', 'html5', 'css3'], selectedCustomClass: 'label label-success', mustAccept:true, placement:'bottomRight', showFooter:true, //... (see the source code of this page) }
Note: In dropdowns the placement is controlled by the Bootstrap dropdown plugin
{ //... icons:['home', 'repeat', 'search', 'arrow-left', 'arrow-right', 'star'], iconBaseClass:'glyphicon', iconComponentBaseClass:'glyphicon', iconClassPrefix:'glyphicon-' //... }


ASVideoPlayerNodeDelegate Protocol Reference
| Conforms to | NSObject |
|---|---|
| Declared in | ASVideoPlayerNode.h |
– videoPlayerNodeNeededDefaultControls:
Delegate method invoked before creating controlbar controls @param videoPlayer
- (NSArray *)videoPlayerNodeNeededDefaultControls:(ASVideoPlayerNode *)videoPlayer
Declared In
ASVideoPlayerNode.h
– videoPlayerNodeCustomControls:
Delegate method invoked before creating default controls, asks delegate for custom controls dictionary. This dictionary must constain only ASDisplayNode subclass objects. @param videoPlayer
- (NSDictionary *)videoPlayerNodeCustomControls:(ASVideoPlayerNode *)videoPlayer
Discussion
- This method is invoked only when developer implements videoPlayerNodeLayoutSpec:forControls:forMaximumSize: and gives ability to add custom constrols to ASVideoPlayerNode, for example mute button.
Declared In
ASVideoPlayerNode.h
– videoPlayerNodeLayoutSpec:forControls:forMaximumSize:
Delegate method invoked in layoutSpecThatFits: @param videoPlayer
- (ASLayoutSpec *)videoPlayerNodeLayoutSpec:(ASVideoPlayerNode *)videoPlayer forControls:(NSDictionary *)controls forMaximumSize:(CGSize)maxSize
Parameters
controls |
|
|---|---|
maxSize |
|
Discussion
- Developer can layout whole ASVideoPlayerNode as he wants. ASVideoNode is locked and it can’t be changed
Declared In
ASVideoPlayerNode.h
– videoPlayerNodeTimeLabelAttributes:timeLabelType:
Delegate method invoked before creating ASVideoPlayerNodeControlTypeElapsedText and ASVideoPlayerNodeControlTypeDurationText @param videoPlayer @param timeLabelType
- (NSDictionary *)videoPlayerNodeTimeLabelAttributes:(ASVideoPlayerNode *)videoPlayerNode timeLabelType:(ASVideoPlayerNodeControlType)timeLabelType
Declared In
ASVideoPlayerNode.h
– didTapVideoPlayerNode:
Delegate method invoked when ASVideoPlayerNode is taped.
- (void)didTapVideoPlayerNode:(ASVideoPlayerNode *)videoPlayer
Parameters
videoPlayerNode |
The ASVideoPlayerNode that was tapped. |
|---|
Declared In
ASVideoPlayerNode.h
– videoPlayerNode:didPlayToTime:
Delegate method invoked when ASVideoNode playback time is updated.
- (void)videoPlayerNode:(ASVideoPlayerNode *)videoPlayer didPlayToTime:(CMTime)time
Parameters
second |
current playback time. |
|---|---|
videoPlayerNode |
The video player node |
Declared In
ASVideoPlayerNode.h
– videoPlayerNode:willChangeVideoNodeState:toVideoNodeState:
Delegate method invoked when ASVideoNode changes state.
- (void)videoPlayerNode:(ASVideoPlayerNode *)videoPlayer willChangeVideoNodeState:(ASVideoNodePlayerState)state toVideoNodeState:(ASVideoNodePlayerState)toState
Parameters
state |
ASVideoNode state before this change. |
|---|---|
videoPlayerNode |
The ASVideoPlayerNode whose ASVideoNode is changing state. |
toSate |
ASVideoNode new state. |
Discussion
This method is called after each state change
Declared In
ASVideoPlayerNode.h
– videoPlayerNode:shouldChangeVideoNodeStateTo:
Delegate method is invoked when ASVideoNode decides to change state.
- (BOOL)videoPlayerNode:(ASVideoPlayerNode *)videoPlayer shouldChangeVideoNodeStateTo:(ASVideoNodePlayerState)state
Parameters
state |
ASVideoNode that is going to be set. |
|---|---|
videoPlayerNode |
The ASVideoPlayerNode whose ASVideoNode is changing state. |
Discussion
Delegate method invoked when player changes it’s state to ASVideoNodePlayerStatePlaying or ASVideoNodePlayerStatePaused and asks delegate if state change is valid
Declared In
ASVideoPlayerNode.h
– videoPlayerNodeDidPlayToEnd:
Delegate method invoked when the ASVideoNode has played to its end time.
- (void)videoPlayerNodeDidPlayToEnd:(ASVideoPlayerNode *)videoPlayer
Parameters
videoPlayer |
The video node has played to its end time. |
|---|
Declared In
ASVideoPlayerNode.h
– videoPlayerNode:didSetCurrentItem:
Delegate method invoked when the ASVideoNode has constructed its AVPlayerItem for the asset.
- (void)videoPlayerNode:(ASVideoPlayerNode *)videoPlayer didSetCurrentItem:(AVPlayerItem *)currentItem
Parameters
videoPlayer |
The video player node. |
|---|---|
currentItem |
The AVPlayerItem that was constructed from the asset. |
Declared In
ASVideoPlayerNode.h
– videoPlayerNode:didStallAtTimeInterval:
Delegate method invoked when the ASVideoNode stalls.
- (void)videoPlayerNode:(ASVideoPlayerNode *)videoPlayer didStallAtTimeInterval:(NSTimeInterval)timeInterval
Parameters
videoPlayer |
The video player node that has experienced the stall |
|---|---|
second |
Current playback time when the stall happens |
Declared In
ASVideoPlayerNode.h
– videoPlayerNodeDidStartInitialLoading:
Delegate method invoked when the ASVideoNode starts the inital asset loading
- (void)videoPlayerNodeDidStartInitialLoading:(ASVideoPlayerNode *)videoPlayer
Parameters
videoPlayer |
The videoPlayer |
|---|
Declared In
ASVideoPlayerNode.h
– videoPlayerNodeDidFinishInitialLoading:
Delegate method invoked when the ASVideoNode is done loading the asset and can start the playback
- (void)videoPlayerNodeDidFinishInitialLoading:(ASVideoPlayerNode *)videoPlayer
Parameters
videoPlayer |
The videoPlayer |
|---|
Declared In
ASVideoPlayerNode.h
– videoPlayerNodeDidRecoverFromStall:
Delegate method invoked when the ASVideoNode has recovered from the stall
- (void)videoPlayerNodeDidRecoverFromStall:(ASVideoPlayerNode *)videoPlayer
Parameters
videoPlayer |
The videoplayer |
|---|
Declared In
ASVideoPlayerNode.h


This tests the usage of the <video> tag as a texture source. The image below should be the video above after applying the feColorMatrix filter.
<video>


Welcome to the 2020 Unofficial AP Exam Simulator! This is based off of the AP Demo released by Collegeboard, and should emulate (fairly well) the examination process for any questions that you desire to test on. Upload one or two questions as an Image and begin the exam. The timer will immediately start going. When it is complete, if there is a second question, you will be transitioned to it automatically. The submission process is identical to that of the AP Exam, with the caveat that the system does not manage file sizes, unlike on the official AP Exam. It should also be noted that this page is only built to run on computers using Chrome, however using this system to prep for exams where you will upload an image (through a phone) is fine (But uploading documents or pasting on mobile is buggy). The system does not retain questions or exam responses past your session (refresh), so ensure that you have a copy of everything you need on your system (IE: Don't delete your response if you need to turn it in to a teacher, and don't delete the question off of your computer until you are done responding to it).
Upload Image for Question 1 (REQUIRED)
Upload Image for Question 2


FitModeldData file main parameters¶
Model Definition¶
The first line of the file states which model will be used by the fitting program
1 fitModel: AzzEPG
The model chosen must come from the eight fit models defined in lines 24 to 32. For each model there is a corresponding parameter file defined. These lines in the file, together with lines 34 to 42 should not be altered.
24 paramsModelName:
25 AzzEPG: fitModelParameterJsonFiles/azz_fatmuscle_epg_model_params.json
26 fatEPG2: fitModelParameterJsonFiles/two_fat_epg2_model_params.json
27 fatEPG1: fitModelParameterJsonFiles/one_fat_epg1_model_params.json
28 muscleEPG1: fitModelParameterJsonFiles/one_fatmuscle_epg1_model_params.json
29 muscleEPG2 : fitModelParameterJsonFiles/two_fatmuscle_epg2_model_params.json
30 phantomEPG1: fitModelParameterJsonFiles/oneParamEPGphantom_model_params.json
31 phantomEPG2: fitModelParameterJsonFiles/twoParamEPGphantom_model_params.json
32 Azzabou: fitModelParameterJsonFiles/azz_params.json
Study Data Directory Structure Used or Not.¶
It was stated earlier that this file can be used to work on data found in a study directory structure or directly on files in a single directory. This is achieved by either putting a list of participants in the fitSubject list or setting it to empty.
44 fitSubject: [HC-001]
In this configuration we will use data found in study directory structure. If the line had been set in the following manner
44 fitSubject: []
then the program would work on named files within the fitModeldata file defined in lines 54 to 59
54 #roisIndividual: simpleModelData/DMD_001_FOREARM_RoiSet.zip
55
56 roiOutline: simpleModelData/EH_DMDT_001_1_foreArm_outline.zip
57
58 analyzeHdr: simpleModelData/WIP_Forearm_T2_CLEAR.hdr
59 analyzeImg: simpleModelData/WIP_Forearm_T2_CLEAR.img
Defining sessions, imaged regions and slices¶
If the fitting program is taking data from the Data Directory Structure then the sessions and imaged regions to be used are defined as lists in lines 45 and 47. If defined data is used then the fitSession and fitImagedRegions fields are ignored.
45 fitSession: [sess-1]
46 fitImagedRegions: [forearm]
47 fitSlices: [1,2,3]
The slices to be used in the fitting are defined in line 47. The slices defined in this list are also used when the program works on defined data.
Updating the values in the LMFIT parameter structures.¶
Initial starting values for parameters can be set within the file by updating the fields starting at lines 18 to 22
14 # EPGAZZ model parameters to update
15 # Always include the echo value
16
17 ParamVals:
18 echo:
19 value: 8
20 min: 0
21 max: 10
22 vary: False
As shown in the example the echo spacing time must always be set in the file. Further parameters within the fitting model can be set in a similar manner. Parameters that might want to be changed could be the the T2 values of the fat in the model, or the initial guess of the muscle T2.
As an example, further items may be added to the file in the following manner to set the long and short T2 components of the fat.
ParamVals:
echo:
value: 8.0
t2_l:
value: 250.0
min: 0.0
max: 300.0
vary: False
t2_s:
value: 80.0
min: 0.0
max: 300.0
vary: False
In this example all the attributes of the two T2 fat parameters are set, i.e. value,minimum, maximum and is it varied in the model. The minimum and maximum are set so that they cover the new value for the parameter. If the value is beyond the range present in the original parameter file then it will be incorrectly set. The vary attribute could be omitted from the definition. If is is changed from its original setting within the original parameter file then the model will be changed as more or less parameters are varied during the fit. It is best not to change the vary attribute from its original setting.
The parameters that can be altered are listed below:
A_f
A_m
B1
T1_f
T1_m
c_l
c_s
echo
t2_fl
t2_fs
t2_m
The flag setParamValsIndividually is set to True in the file in this example. In this case, then fat values are calculated from previous model data in the study directory structure for each participant in the fitSubject list. This flag can only be set to True when data is being fit from a study directory structure. When this is the case the path to the fat data should be indicated using the fatResultsDir flag
11 fatResultsDir: T2/results/fat/fatEPG2
When the flag setParamValsIndividually is set to False then all the fat parameters for certain models are set from within the file if they are present, for all participants.
ROI Author Preferences :: roiAuthorPreference¶
The field roiAuthorPreferences at line 51 gives a list of author initials that are used to choose which ROI files are used.
51 roiAuthorPreference: [EH]
The order of the list gives the priority, if a certain author cannot be found, then the next author initials will be used to choose the correct ROI files. This option is only acted upon when the fitting scripts are used within a study dierctory structure.
Use Roi Outline :: useRoiOutline¶
This option is set to True when an outline ROI is used to define which part of the image is to be fit.
38 useRoiOutline: False
Outline ROI filenames must include the word outline in their name for the programs to function correctly
Image Data Format :: imageDataFormat¶
The fitting progams can now read in both analyze and nifti data formats. This must be indicated in the file
52 imageDataFormat: Analyze
For Analyze format the program expects to find the image data as a file, therefore when the fitting program is fitting individual data then a file name with a relative or complete path should be given.
58 analyzeHdr: simpleModelData/WIP_Forearm_T2_CLEAR.hdr
59 analyzeImg: simpleModelData/WIP_Forearm_T2_CLEAR.img
Nifti data can come in the form of a single file, either zipped or not, or as a series of files, perhaps corresponding to individual echo times for the T2 data. If this is the case then the directory where the data can be found must be entered.
imageDataFormat: nifti
# when individual files
niftiData: C:\Users\NEH69\Dropbox\projects\programming\2019\MRIstudyDescription\simpleModelData\WIP_Forearm_T2_CLEAR.nii.gz
# when a series of nifti files
niftiData: C:\Users\NEH69\Dropbox\projects\programming\2019\MRIstudyDescription\simpleModelData\niffti


Summer Focus
Posted: Fri May 26, 2006 11:16 am
We need to decide what we'll be doing this summer, for those that are interested. I'd really like to finish something this summer--but we need to focus on something that will use the resources and capabilities we have in such a way that we all don't get sick of the project and not want to work on it.
We should have a meeting soon. Next tuesday or wednesday?
We should have a meeting soon. Next tuesday or wednesday?


Index
ERDColumn (81)
attachmentId
attachmentId
attachmentId
attachmentType
blogAttachmentContentId
blogContentType
blogGroupId
blogGroupId
blogGroupOwnerId
blogId
blogId
blogOwnerId
blogOwnerId
blogOwnerId
blogPreviewContentId
blogTextContentId
content
contentType
contentType
description
description
description
description
description
description
edit
edit
email
extension
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
name
password
path
pozition
projectId
projectId
projectOwnerId
projectTeamId
projectTeamOwnerId
projectTeamOwnerId
projectTeamOwnerId
projectTeamOwnerId
projectTeamOwnerId
projectTeamOwnerId
role
roleId
share
title
title
title
title
title
title
userId
userId
userId
userOwnerId
userOwnerId
userOwnerId
userOwnerId
userOwnerId
userOwnerId
userOwnerId
userOwnerId
userOwnerId
username
ERDDataModel (1)
DB Model
ERDDiagram (4)
Blog Relations
Full
Project Relations
User Relations
ERDEntity (17)
Attachment
Blog
BlogAttachmentContent
BlogContentPozition
BlogGroup
BlogPreviewContent
BlogTextContent
Project
ProjectAttachment
ProjectTeam
ProjectTeamAttachment
ProjectTeamBlogGroup
ProjectTeamUser
ProjectUser
Role
User
UserRole
ERDRelationship (39)
at this pozition has attachment (BlogContentPozition—BlogAttachmentContent)
at this pozition has preview (BlogContentPozition—BlogPreviewContent)
at this pozition has text (BlogContentPozition—BlogTextContent)
contains blogs (BlogGroup—Blog)
contains contents (Blog—BlogContentPozition)
contains projects (ProjectTeam—Project)
contains shared project attachments (ProjectTeam—ProjectAttachment)
contains shared project team attachments (ProjectTeam—ProjectTeamAttachment)
contains shared project team blog groups (ProjectTeam—ProjectTeamBlogGroup)
has an owner (User—BlogAttachmentContent)
has an owner who has delegated rights (ProjectTeam—BlogAttachmentContent)
has an owner who has delegated rights (User—ProjectTeamBlogGroup)
has an owner who has delegated rights (User—ProjectTeamAttachment)
has an owner who has delegated rights (User—ProjectAttachment)
has attachment content (Blog—BlogAttachmentContent)
has attachments (User—Attachment)
has attachments (Project—ProjectAttachment)
has blog (User—Blog)
has blog group (User—BlogGroup)
has preview content (Blog—BlogPreviewContent)
has project team users (ProjectTeam—ProjectTeamUser)
has projects (User—Project)
has roles (User—UserRole)
has roles (Role—UserRole)
has teams (User—ProjectTeam)
has text content (Blog—BlogTextContent)
has users (Project—ProjectUser)
link to attachment (Attachment—BlogAttachmentContent)
link to blog (Blog—BlogPreviewContent)
link to blog group (BlogGroup—BlogPreviewContent)
link to project (Project—BlogPreviewContent)
link to project team (ProjectTeam—BlogPreviewContent)
link to shared attachment (Attachment—ProjectTeamAttachment)
link to shared attachment (Attachment—ProjectAttachment)
link to shared blog groups (BlogGroup—ProjectTeamBlogGroup)
link to user (User—ProjectTeamUser)
link to user (User—ProjectUser)
the project has only the attachments of the project team to which they are delegated (ProjectTeamAttachment—ProjectAttachment)
the project has only the users of the project team (ProjectUser—ProjectTeamUser)
ERDRelationshipEnd (78)
BlogGroupId
attachmentId
attachmentId
attachmentId
attachmentId
attachmentId
blogAttachmentContentId
blogGroupId
blogGroupOwnerId
blogId
blogId
blogOwnerId
blogOwnerId
blogOwnerId
blogPreviewContentId
blogTextContentId
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
id
projectId
projectOwnerId
projectTeamId
projectTeamOwnerId
projectTeamOwnerId
projectTeamOwnerId
projectTeamOwnerId
projectTeamOwnerId
projectTeamOwnerId
projectid
roleId
userId
userId
userId
userId
userId
userOwnerId
userOwnerId
userOwnerId
userOwnerId
userOwnerId
userOwnerId
userOwnerId
userOwnerId
userOwnerId
Project (1)
My Blog


SipChat
Home
(current)
Menu
Reservations
Register/Login
Blog
Search
Register
Name
Email address
please give ur email correctly.
Password
Remember me
Sign Up
-->
Thank you for becoming a member!
×
Wohoo, your account is created.
Happy Shopping.
Now Login from the Login/SignUp page.
Login
Email
Password
Remember me
Login
Follow us on:


{% extends "base.html" %} {% import "bootstrap/wtf.html" as wtf %} {% import "_macros.html" as macros %} {% block title %}Row-Bot{% endblock %} {% block page_content %}
Please login if you want to see your current posts or register as a new user.


Class Doctorant
Doctorant
- DT\DoctoramaBundle\Entity\Personne
- DT\DoctoramaBundle\Entity\Doctorant
public
DT\SecurityBundle\Entity\Compte
|
|
public
DT\SecurityBundle\Entity\Compte
|
|
public
|
|
public
|
|
public
integer
|
|
public
|
|
public
integer
|
|
public
|
|
public
integer
|
|
public
|
|
public
string
|
|
public
|
|
public
string
|
|
public
|
|
public
string
|
|
public
|
|
public
string
|
|
public
|
|
public
string
|
|
public
|
|
public
string
|
|
public
|
|
public
string
|
|
public
|
|
public
string
|
|
public
|
|
public
string
|
|
public
|
|
public
string
|
|
public
|
|
public
string
|
|
public
|
|
public
string
|
protected
integer
|
$id |
|
|
protected
mixed
|
$compte |
|
|
protected
mixed
|
$these |
|
$adresse,
$civilite,
$dateDeNaissance,
$depDeNaissance,
$mail,
$nom,
$nomUsage,
$paysDeNaissance,
$prenom,
$reunions,
$villeDeNaissance
|


{%extends "layout.html"%} {%block searchform%} {%endblock%} {%block soga%}
Sorry. The page you are looking for does not exist. Try Search.


This library is a set of interface tools that we use everyday in our Angular projects. They are designed as single blocks, easily customizable with CSS, opinionated components or directives.
We keep this library up-to-date with the latest Angular capabilities. Therefore, we can use any of its component in your AOT ready projects.
We develop this library with the user experience in mind. Therefore, interactions must be easy to understand and none of the components should affect the performance. When working with other libraries, we often face the problem that, in huge tables, a simple tooltip on each cell could greatly impact the snappiness of the application.


Welcome to the BusMall survey! Select your favorite product from each set of some of our finest products we have to offer.
You will be presented with 25 sets of products and be rewarded with a fine graph for all your effort.
The green bar represents the product/s you picked the most


--- layout: post title: Compressible Navier-Stokes equations tags: maths author: HvZ Engineering scripts: mathjax ---
The model equations associated with compressible flow are given by: ``ρ'+(ρu_i)_{,i} = 0`` ``(ρu_j)' + (ρu_iu_j)_{,i} - P_{ij,i} = 0`` ``E' + (u_iE)_{,i} - (u_jP_{ij})_{,i} + q_{i,i} = 0`` referring to the continuity, momentum and energy equation, respectively, where `P_{ij}` denotes the stress tensor and `E` the energy density: ``P_{ij} = -nk_BTδ_{ij} - \tfrac{2}{3}μu_{k,k}δ_{ij} + μ(u_{i,j}+u_{j,i})`` ``E = \tfrac{3}{2}nk_BT+\tfrac{1}{2}ρu^2`` The heat flux `q` is usually approximated by Fourier's law: ``q=-k∇T``
Since `ρ` and `u` are dependent variables in the compressible case, the continuity equation becomes non linear. Therefore, we will apply a Newton linearization on (1). Expressing the density and velocity as a sum of approximate and disturbance, i.e., `ρ=\bar{ρ} + δρ` and `u=\bar{u}+δu`, we present the linearized continuity equation after substitution and neglecting higher-order terms as: ``δρ' + (ρδu_i)_{,i} + (u_iδρ)_{,i} = -ρ' - (ρu_i)_{,i}`` where, for author's convenience and reader's confusion, we have removed the bar referring to the approximate density and velocity.
To determine the linearized momentum equation we follow similar steps as was done for the continuity equation. The linearized momentum equation is given by: ``(ρδu_j+u_jδρ)' + (ρ(u_iδu_j+u_jδu_i)+u_iu_jρ)_{,i} - P_{ij,i} = -(ρu_j)' - (ρu_iu_j)_{,i}`` Note that the stress tensor is linear in `u` and therefore does not need linearization. Beware that the velocity in `P` is `\bar{u}+δu`.
To linearize the energy equation we first linearize the energy density: `E = \bar{E} + δE`, where `\bar{E} = \tfrac{3}{2} nk_BT + \tfrac{1}{2}ρu^2` and `δE = \tfrac{3}{2}nk_BδT + ρu_kδu_k + \tfrac{1}{2}u^2δρ` Note that the velocity squared is given by `u^2=u_ku_k`. Furthermore, we require the linearized stress tensor. Since the stress tensor is linear it suffices to replace the approximate `\bar{(\cdot)}` and perturbation `δ(\cdot)` accordingly. The linearized energy equation is given by: ``δE' + (u_iδE + Eδu_i)_{,i} - (u_jδP_{ij}+P_{ij}δu_j)_{,i} - (kδT_i)_{,i} = -E' - (u_iE-u_jP_{ij}-kT_{,i})_{,i}``
To summarize we can formulate the three linearized coupled equations that form the linearized Navier-Stokes equations for compressible flow: ``δρ' + (ρδu_i + u_iδρ)_{,i} = -(ρ' + (ρu_i)_{,i})`` ``(ρδu_j+u_jδρ)' + (ρ(u_iδu_j+u_jδu_i)+u_iu_jρ - P_{ij})_{,i} = -( (ρu_j)' + (ρu_iu_j)_{,i} )`` ``δE' + (u_iδE + Eδu_i - u_jδP_{ij}-P_{ij}δu_j - kδT_i)_{,i} = -(E' + (u_iE-u_jP_{ij}-kT_{,i})_{,i})`` Since ρ is the only variable that couples the continuity and momentum equation to the energy equation, the incompressible case (constant density) will decouple the system. This can be seen from the expression for the energy density `E`. In the constant-density case, the flow is described by the continuity and momentum equation, and the temperature is given by the energy equation.


megamenu.js-响应式jQuery大菜单插件
Last responsive megamenu you'll ever need
jQuery之家
返回下载页
Home
About
School
Lidership
History
Locations
Careers
Study
Undergraduate
Masters
International
Online
Research
Undergraduate research
Masters research
Funding
Something
Sub something
Sub something
Sub something
Sub something
News
Today
Calendar
Sport
Contact
School
Lidership
History
Locations
Careers
Study
Undergraduate
Masters
International
Online
Study
Undergraduate
Masters
International
Online
Empty sub
megamenu.js - Last responsive megamenu you'll ever need


The main window is the "desktop" of RTeasy where you can manage the functions and windows of RTeasy. The menu bar contains the menus:
| Section <IP_ADDRESS>: Filemenu;) | (
| Section <IP_ADDRESS>: Edit Menu;) | (
| Section <IP_ADDRESS>: Simulator Menu;) | (
| Section 3.1.3.: Design) | (
| Section 3.1.4: Help Menu;) | (
RTeasy has two different states. The edit mode (Section 3.1.1: edit mode) offers functions to work on programs. The simulation mode (Section 3.1.2: Simulation Mode) is only available for completely compilable programs. For further processing you have to switch back to the edit mode.
This mode is set default after starting an new project or loading an existing project. To switch from the simulation mode back to the edit mode, use the button
.These functions switch from the simulation mode to the edit mode. |
. closes the current project an creates a new one.
. loads an existing project from your file system.
. saves the current project at a predefined location.
. saves the project at the location that is chosen in the appearing dialog box.
. terminates RTeasy.
These functions are only enabled in the edit mode. |
. cancel the last change
. copy selected area
. cut selected area
. insert from clipboard
Section 9: Message Log Window).
. tries to compile the program and prints a structured code at success. Otherwise errors and warnings are shown in the message log window (. opens a dialog box with the current settings.
| Language / Sprache: - sets the language of menu titles, buttons, errors and warnings. |
| Plug & Feel - sets the window design |
| verbose Warnings - shows all warnings. |
In the simulation mode you can simulate the predefined and compilable program. You start the simulation mode by using the button Section 3.1: Edit/Simulation Mode )
. (The following functions are only available in the simulation mode. |
. sets the simulator to its initial values.
. executes the statements in the next cycle.
. executes the next statement within a cycle.
. executes the program until you stop it or it reaches an end state.
Section 8: Breakpoint Window to manage breakpoints.
. opens the breakpoint window. sets the simulator to its initial values.
. executes the statements in the next cycle.
. executes the next statement within a cycle.
. executes the program until you stop it or it reaches an end state.
Section 8: Breakpoint Window to manage breakpoints.
. opens the breakpoint window. sets all declared memories to its initial values . clears all window contents. (
The function "Show Control Signals" generates all control signals of the current program and shows them in the signal window. The Button
closes the window.This function derives the low level model of the current program. That implies that all parallel statements will be separated to several single statements.
This menufunction generates a VHDL-Code from your RTeasy-program. For this it is necessary to check your RTeasy-program for errors. The logwindow will display the errors, that must be repaired. Please notice, that the generated VHDL-Code can have redundant parts and smaller errors. We recommend to look through the generated code and repair and report the errors.
| Pervious Page |


Yantramattan is an acupressure mat. It’s is simply a mat with stimulation points, where you lay on. It has its origin in the ancient Chinese medicine. It has been of big help to me with my neck pain. I have many times experienced intense muscle pain, not being able to move my head to one side. These conditions where occurring often to me, and lasted from 4 to 7 days. When I started using the Yantramattan my neck was pain free within 2-3 days! It can also be used for pain or tension relief on your back or shoulders, as a headache relief, stress relief, energy booster and sleep improvement.
There are many ways of using the Yantramattan.
The most popular is laying on your back. You can also lay on
your belly,
on your side or
even stand on it.
You can find this image on https://pixabay.com/static/uploads/photo/2015/10/31/12/30/massage-1015571_960_720.jpg.


LAFD crews encounter heavy smoke when responding to blaze at medical clinic in East Hollywood
EAST HOLLYWOOD, Calif. (KABC) -- Fire crews encountered heave smoke when they responded to a structure fire in East Hollywood Friday evening.
Over 100 firefighters were assigned to the blaze in the 1200 block of N. Vermont Avenue at a single story medical center. The location was the site of a previous burn and arson investigators were called in to investigate.
No other structures were threatened and there were no reports of injuries.


| Ccadmin.pm: Administration Functions | 69 KB | 07/01/2007 | 16:40:17 |
| Cccookie.pm: Cookie Handling | 18 KB | 07/01/2007 | 16:40:18 |
| Ccdirectory.pm: Open Office Directory | 29 KB | 07/01/2007 | 16:40:19 |
| Cchooks.pm: Hooks for Transactions and Users | 6 KB | 07/01/2007 | 16:40:19 |
| Cclite.pm: Transaction and Central Functions | 224 KB | 07/01/2007 | 16:40:34 |
| Cclitedb.pm: Database Functions | 106 KB | 07/01/2007 | 16:40:26 |
| Ccrss.pm: Rss Functions | 18 KB | 07/01/2007 | 16:40:35 |
| Ccsecure.pm: Security and Hashing Functions | 19 KB | 07/01/2007 | 16:40:36 |
| Ccu.pm: Utility Functions | 60 KB | 07/01/2007 | 16:40:38 |
| Ccvalidate.pm: Validation Functions | 61 KB | 07/01/2007 | 16:40:40 |
| ccadmin.cgi: Main Administration Script | 44 KB | 07/01/2007 | 16:40:10 |
| ccdirectory.cgi: Printed Directory Script | 27 KB | 07/01/2007 | 16:40:11 |
| ccinstall.cgi: Install and New Registry Script | 31 KB | 07/01/2007 | 16:40:12 |
| cclite.cgi: Main Controller Script | 59 KB | 07/01/2007 | 16:40:06 |
| ccupload.cgi: Batch Transaction Upload Script | 17 KB | 07/01/2007 | 16:40:13 |


GroupLayout
layout manager combined with a builder tool to lay out your GUI. One such builder tool is the
NetBeans IDE. Otherwise, if you want to code by hand and do not want to use GroupLayout
, then GridBagLayout
is recommended as the next most flexible and powerful layout manager.
If a container holds components whose size is not affected by the container's size or by font, look-and-feel, or language changes, then absolute positioning might make sense. Desktop panes, which contain internal frames, are in this category. The size and position of internal frames does not depend directly on the desktop pane's size. The programmer determines the initial size and placement of internal frames within the desktop pane, and then the user can move or resize the frames. A layout manager is unnecessary in this situation.
Another situation in which absolute positioning might make sense is that of a custom container that performs size and position calculations that are particular to the container, and perhaps require knowledge of the container's specialized state. This is the situation with split panes.
Creating a container without a layout manager involves the following steps.
setLayout(null)
.Component
class's setbounds
method for each of the container's children.Component
class's repaint
method.However, creating containers with absolutely positioned containers can cause problems if the window containing the container is resized.
Here is a snapshot of a frame whose content pane uses absolute positioning.
Click the Launch button to run AbsoluteLayoutDemo using Java™ Web Start (download JDK 6). Alternatively, to compile and run the example yourself, consult the example index.
Its code is in
AbsoluteLayoutDemo.java
.
The following code snippet
shows how the components in the content pane
are created and laid out.
pane.setLayout(null); JButton b1 = new JButton("one"); JButton b2 = new JButton("two"); JButton b3 = new JButton("three"); pane.add(b1); pane.add(b2); pane.add(b3); Insets insets = pane.getInsets(); Dimension size = b1.getPreferredSize(); b1.setBounds(25 + insets.left, 5 + insets.top, size.width, size.height); size = b2.getPreferredSize(); b2.setBounds(55 + insets.left, 40 + insets.top, size.width, size.height); size = b3.getPreferredSize(); b3.setBounds(150 + insets.left, 15 + insets.top, size.width + 50, size.height + 20); ...//In the main method: Insets insets = frame.getInsets(); frame.setSize(300 + insets.left + insets.right, 125 + insets.top + insets.bottom);


There's no need to logout because the server isn't stateful (no sessions). Just destroy the auth token and you're done.


Instructions for Discount Total:
1) Copy the code example into a new web page e.g. mals.html
2) Download and save the mals-scripts.js file into the same folder (note: can be in another)
3) Change the product information in the form to your product
e.g.
4) Change the discountpr value to your product discount
e.g.
The above example means:
if they order 2 or less the price is 9.99
if they order 3 to 4 (i.e. 2 + 2 = 4), the price is 8.99
if they order 5 to 8 (i.e. 4 + 4 = 8), the price is 7.99
if they order more than 8 (ignore the 0) the price is 6.99
For more info on discountpr visit https://www.mals-e.com/tpv.php?tp=2
5) Ensure your wwX and userid are the same as Mals (TIP! enter your details at the top before copying example)
6) Open the web page in a browser e.g. Chrome and test it
--- Customize ---
The script looks for an element with id called malsDiscountTotal to display the total. Put this wherever you like within the form and style using CSS.
Total: $0.00
--- Calling Script ---
The script is very versatile. You can activate it on one or more forms (or links) easily. Note: if you don't know jQuery selectors visit https://www.w3schools.com/jquery/jquery_selectors.asp
- Example 1 = specific form by id
MalsScripts.discountTotal('#form1');
This will activate the script on the form with id="form1"
- Example 2 = specific forms by id
MalsScripts.discountTotal('#form1,#form2');
This will activate the script on two forms with id="form1" and id="form2"
- Example 3 = all forms by class
MalsScripts.discountTotal('.myform');
This will activate the script on all forms with class="myform"
- Example 4 = callback function
MalsScripts.discountTotal('#form1',function(){
// Called when script is called;
});
- Example 5 = callback click function
discountTotal(element,,function(){
// Called when qty field changed/clicked
})
--- General Notes ---
- Add class .mals-ignore to any forms you don't want transformed e.g.


Hello, {{first_name}}.
We would like to welcome you on board, but first we need to confirm your identity.
Without your email confirmation we cannot protect your account, so the following button is what's gonna make you a champion.
If you haven't requested an account, please click here.


| Trees | Indices | Toggle frames |
|---|
Abstract font class able to produce glyphs.
To construct a font, use pyglet.font.load, which will instantiate the platform-specific font class.
Internally, this class is used by the platform classes to manage the set of textures into which glyphs are written.
|
glyph_renderer_class
Abstract class for creating glyph images.
|
|
|
texture_class
A texture within which glyphs can be drawn.
|
| __init__(self) | |
|
add_font_data(cls,
data)
Add font data to the font loader.
|
|
| bool |
have_font(cls,
name)
Determine if a font with the given name is installed.
|
| Glyph |
create_glyph(self,
image)
Create a glyph using the given image.
|
| list of Glyph |
get_glyphs(self,
text)
Create and return a list of Glyphs for text.
|
| list of Glyph |
get_glyphs_for_width(self,
text,
width)
Return a list of glyphs for text that fit within the given width.
|
| int |
ascent = 0
Maximum ascent above the baseline, in pixels.
|
| int |
descent = 0
Maximum descent below the baseline, in pixels.
|
texture_width = 256
|
|
texture_height = 256
|
|
texture_internalformat = 6406
|
Add font data to the font loader.
This is a class method and affects all fonts loaded. Data must be some byte string of data, for example, the contents of a TrueType font file. Subclasses can override this method to add the font data into the font registry.
There is no way to instantiate a font given the data directly, you must use pyglet.font.load specifying the font name.
Create a glyph using the given image.
This is used internally by Font subclasses to add glyph data to the font. Glyphs are packed within large textures maintained by Font. This method inserts the image into a font texture and returns a glyph reference; it is up to the subclass to add metadata to the glyph.
Applications should not use this method directly.
Create and return a list of Glyphs for text.
If any characters do not have a known glyph representation in this font, a substitution will be made.
Return a list of glyphs for text that fit within the given width.
If the entire text is larger than 'width', as much as possible will be
used while breaking after a space or zero-width space character. If a
newline is enountered in text, only text up to that newline will be
used. If no break opportunities (newlines or spaces) occur within
width
, the text up to the first break opportunity will be used (this
will exceed width
). If there are no break opportunities, the entire
text will be used.
You can assume that each character of the text is represented by exactly one glyph; so the amount of text "used up" can be determined by examining the length of the returned glyph list.
See Also: GlyphString
0 |
| Trees | Indices | Toggle frames |
|---|
| Generated by Epydoc 3.0beta1 on Sun Mar 22 20:15:39 2009 | http://epydoc.sourceforge.net |


Hello World 3.0
ps of TPOLM on the keys yet again
attention Lisbon demoscene:
you should drop by the Artica HQ
in FCT / Monte da Caparica
on the 2nd of August 2014
at around 14:30
you are summoned
to attend ScenePT Demoilta#3
to watch some demos with us
last one got cancelled last minute
fuckings to east-side hurricanes
but we're gonna make up with #3
it's gonna rock like a boozetuga
as usual we have:
projector
sound system
internet
crappy cooler
and more!
entrance fee:
one superbock
partyplace located at:
Artica's headquarters
Madan Park / FCT
Edificio 6
Monte da Caparica
Credits:
code & text - ps / TPOLM
music - Frame / Enough Records
Greetings to:
ScenePT AllStars
Nothing
GlenZ
Napalm Core
Volumetric Illusions
Airbag
Radioactive Design
alien)(dream
Spontz
Madwizards
Satori
Rift
MFX
Kewlers
flo
Traction
Accession
Cocoon
Inque
xplsv
ate bit
Conspiracy
Andromeda Software Development
Farbrausch
Kosmoplovci
TPOLM
Enough Records
and you...


"These boys are amazingly talented and always smartly dressed! Their music makes me smile and want to dance."
-Jackson's Mom
A group of classy, eccentric guys coming together to gift the world of their music.
The Feds. are a high energy indie-rock band originating from Northern California. They recently transplanted down to San Diego for school and work reasons. Not unlike Derek Zoolander, being really really ridiculously good looking is a way of life, especially if you throw in a good suit. But, really, in all seriousness they like having a good time just like everyone else. They have a new yet to be named EP coming out in late March and are playing at the SDSU Open Air Theater for this years’ GreenFest.


OS//OS will be bringing together global leaders and local champions, we're building a stage for world-leading practitioners and the brightest local minds across business, technology and democracy.
Audrey Tang, a civic hacker who grew up among Tiananmen exiles, is known for revitalizing the computer languages Perl and Haskell, as well as building the online spreadsheet system EtherCalc in collaboration with Dan Bricklin.
In the public sector, Audrey serves on Taiwan national development council’s open data committee and K-12 curriculum committee; and led the country’s first e-Rulemaking project.
In the private sector, Audrey works as a consultant with Apple on computational linguistics, with Oxford University Press on crowd lexicography, and with Socialtext on social interaction design.
In the third sector, Audrey actively contributes to Taiwan’s g0v (“gov-zero”), a vibrant community focusing on creating tools for the civil society, with the call to “fork the government”.
Photo Credit: CC BY 4.0 Camille McOuat @ Liberation.fr
Alanna has a passion for Open Business meets Open Tech meets Open Collaboration. She loves innovating new tools and processes to help people work in radically transparent and participatory ways.
Alanna is an anarchist management hacker, internet geek, feminist, and community builder - and can't wait to get amongst it with the OS//OS community!
Via video link
Named one of the top ten "Most Influential Thinkers in the World" by MIT, Douglas Rushkoff is the author of Throwing Rocks at the Google Bus: How Growth Became the Enemy of Prosperity. He is a technology commentator for CNN, and a prominent advocate for open source solutions to social problems. As a media theorist, he is the originator of the terms "viral media”, "digital natives," and "social currency."
Douglas has written a dozen bestselling books on media, technology, and culture, including Present Shock, Program or Be Programmed, Media Virus, Life Inc and the novel Ecstasy Club, and is Professor of Media Theory and Digital Economics at CUNY/Queens. He wrote the graphic novels Testament and A.D.D., and made the television documentaries Generation Like, Merchants of Cool, The Persuaders, and Digital Nation. He lives in New York, and lectures about media, society, and economics around the world.
Rushkoff's latest work, Throwing Rocks at the Google Bus, looks at how the digital economy went wrong and what we can do to reclaim its promise.
Photo Credit: Johannes Kroemer
Kāi Tahu, Kāti Mamoe
Christopher Cormack has a BSc in Computer Science and a BA in Mathematics and Māori Studies.
While working for Katipo Communications he was the lead developer of the original version of Koha, which went live at Horowhenua Library Trust on January 5, 2000. Since then he has served various roles in the community: Release manager, QA manager and Translation manager.
Christopher works for Catalyst IT in Wellington and believes in Free Software and allowing users the freedom to innovate
Joshua is a programmer and entrepreneur.
In 2010 he launched Enspiral and turned his personal consulting company into a collective vehicle to help more people work on stuff that matters.
In 2013 he helped launch Enspiral Dev Academy which is an intensive 9 week programming course and has been exploring the intersection of tech, startups and education.
Joshua now splits his time between core Enspiral and the Academy and has promised not to start anything new for a while. The number 2016 is proving to be quite tempting however...
Marianne Elliott is National Director for ActionStation - a movement to reignite participation in our democracy and restore 'people power' by building a community of active citizens, and facilitating collective social action for progressive change.
Trained as a human rights lawyer, Marianne worked in Timor-Leste, the Gaza Strip and Afghanistan before returning to New Zealand. She believes in the power of open democracy to help solve the wicked problems of our age.
Laura O'Connell-Rapira is the Director of Campaigns at ActionStation - a community campaigning organisation representing over 140,000 members that combines digital tools and people power to drive a fairer, more just and sustainable Aotearoa. She is the Co-founder of RockEnrol - a volunteer-run organisation dedicated to building and activating political power for young people and is the Events Director at Our Place Events.
Laura is passionate about unleashing the power of the crowd through digital and community organising, effective collaboration and values-based campaigning. She is a Live The Dream 2014 Alumni with Inspiring Stories Trust.
Hiria is a prolific doer with a driving need to give back and MAD love for tech. So when she realised that beta data.govt would end up using open source software to surface open govt data, to make finding data easier, quicker and nicer to use, she did the dance of joy and gave high-fives over the cubicle wall.
 She comes in to figure out what people need, what the base functionality should be and then work with a team to fix or get another "thing" built. All the while asking people "Hey what do you think of this? It's ok if you think it sucks, but can you be more specific?"
In her spare time, she likes to hatch plans to get more maori and pacifica youth into tech and is currently working on Diversify.nz a photostock website that only features New Zealand and her diverse peoples.
If you're wondering, yes, both of these things came about because she saw the data on diversity in Tech and decided to do something about it.
Lillian Grace is CEO and Founder of Figure.NZ, the first organisation globally to designate everyone as a user of data and to build the systems, software, language and trust required to deliver to this standard. Lillian is also on the recently established Data Futures Partnership Working Group, as well as on the board of the NZ Innovation Partnership and of Te Pūnaha Matatini, New Zealand’s Centre of Research Excellence developing methods and approaches for transforming complex data about NZ into knowledge, tools, and insight. Previously Lillian was at Academy Award-Winning Massive Software, at think tank The New Zealand Institute.


Akan names come from a traditional naming system for people from Ghana. A child’s name is determined by factors surrounding his or her birth. For example, the day of their birth or the manner in which they were born may determine which name they get irrespective of their gender. These Akan names signify the day one is born. According to Akan tradition, each child is born with a name associated to their soul. The day the child is born is therefore determined by the soul. The well thought and organized naming system of the Akan’s was initiated by the ancestors and has attracted so many people’s attention as they desire to know more about these names. As a matter of fact, it is possible to tell what led to someone’s birth, the day they were born and their rank among the siblings just by their names.In this website, you can be able to know you Akan name and the day of the week you were born just from your date of birth. To find out moreClick here


The most common way to include HeadJS on your site will be to include it in the <head>
{% highlight html %} {% endhighlight %}But sometimes you might want it to load up a bunch of code right away, without having to declare that code in a new <script> tag. This can be very useful when using code-generation, or even if you just want to stick all your code in a centralized place.
{% highlight html %} {% endhighlight %}In the above example you would put your code in init.js, which would be called automagically
{% highlight js %} // init.js head.load("file1.js", "file2.js"); {% endhighlight %}Note: Only the first detected instance of data-headjs-load will be used, so make sure there is only one on the page.


Home
Travel Support
Packages
Resources
Contact
Our Packages
First Time?
........
Learn More
Winter Wonderland
........
Learn More
Culture and Unity
........
Learn More


With this SCSS mixin you'll be able to horizontally AND vertically center blocks of text dynamically, with ease
To use it, just @include centerEl
You can set some properties through parameters too, like the left
position, width
and text-align
.
Defaults: $left: 50%, $width: 50%, $align: center
But you don't have to horizontally align if you don't want to. Just include the mixin like this...
@include centerEl($left: 95%, $align: left);
Or you can include the mixin like this...
@include centerEl($left: 5%, $width: auto, $align: left);
Forked and adapted from a Fiddle by @jeffgolenski


"""Qubits for quantum computing.
Todo:
* Finish implementing measurement logic. This should include POVM.
* Update docstrings.
* Update tests.
"""
from __future__ import print_function, division
import math
from sympy import Integer, log, Mul, Add, Pow, conjugate
from sympy.core.basic import sympify
from sympy.core.compatibility import string_types, range
from sympy.matrices import Matrix, zeros
from sympy.printing.pretty.stringpict import prettyForm
from sympy.physics.quantum.hilbert import ComplexSpace
from sympy.physics.quantum.state import Ket, Bra, State
from sympy.physics.quantum.qexpr import QuantumError
from sympy.physics.quantum.represent import represent
from sympy.physics.quantum.matrixutils import (
numpy_ndarray, scipy_sparse_matrix
)
from mpmath.libmp.libintmath import bitcount
__all__ = [
'Qubit',
'QubitBra',
'IntQubit',
'IntQubitBra',
'qubit_to_matrix',
'matrix_to_qubit',
'matrix_to_density',
'measure_all',
'measure_partial',
'measure_partial_oneshot',
'measure_all_oneshot'
]
#-----------------------------------------------------------------------------
# Qubit Classes
#-----------------------------------------------------------------------------
class QubitState(State):
"""Base class for Qubit and QubitBra."""
#-------------------------------------------------------------------------
# Initialization/creation
#-------------------------------------------------------------------------
@classmethod
def _eval_args(cls, args):
# If we are passed a QubitState or subclass, we just take its qubit
# values directly.
if len(args) == 1 and isinstance(args[0], QubitState):
return args[0].qubit_values
# Turn strings into tuple of strings
if len(args) == 1 and isinstance(args[0], string_types):
args = tuple(args[0])
args = sympify(args)
# Validate input (must have 0 or 1 input)
for element in args:
if not (element == 1 or element == 0):
raise ValueError(
"Qubit values must be 0 or 1, got: %r" % element)
return args
@classmethod
def _eval_hilbert_space(cls, args):
return ComplexSpace(2)**len(args)
#-------------------------------------------------------------------------
# Properties
#-------------------------------------------------------------------------
@property
def dimension(self):
"""The number of Qubits in the state."""
return len(self.qubit_values)
@property
def nqubits(self):
return self.dimension
@property
def qubit_values(self):
"""Returns the values of the qubits as a tuple."""
return self.label
#-------------------------------------------------------------------------
# Special methods
#-------------------------------------------------------------------------
def __len__(self):
return self.dimension
def __getitem__(self, bit):
return self.qubit_values[int(self.dimension - bit - 1)]
#-------------------------------------------------------------------------
# Utility methods
#-------------------------------------------------------------------------
def flip(self, *bits):
"""Flip the bit(s) given."""
newargs = list(self.qubit_values)
for i in bits:
bit = int(self.dimension - i - 1)
if newargs[bit] == 1:
newargs[bit] = 0
else:
newargs[bit] = 1
return self.__class__(*tuple(newargs))
[docs]class Qubit(QubitState, Ket):
"""A multi-qubit ket in the computational (z) basis.
We use the normal convention that the least significant qubit is on the
right, so ``|00001>`` has a 1 in the least significant qubit.
Parameters
==========
values : list, str
The qubit values as a list of ints ([0,0,0,1,1,]) or a string ('011').
Examples
========
Create a qubit in a couple of different ways and look at their attributes:
>>> from sympy.physics.quantum.qubit import Qubit
>>> Qubit(0,0,0)
|000>
>>> q = Qubit('0101')
>>> q
|0101>
>>> q.nqubits
4
>>> len(q)
4
>>> q.dimension
4
>>> q.qubit_values
(0, 1, 0, 1)
We can flip the value of an individual qubit:
>>> q.flip(1)
|0111>
We can take the dagger of a Qubit to get a bra:
>>> from sympy.physics.quantum.dagger import Dagger
>>> Dagger(q)
<0101|
>>> type(Dagger(q))
<class 'sympy.physics.quantum.qubit.QubitBra'>
Inner products work as expected:
>>> ip = Dagger(q)*q
>>> ip
<0101|0101>
>>> ip.doit()
1
"""
@classmethod
def dual_class(self):
return QubitBra
def _eval_innerproduct_QubitBra(self, bra, **hints):
if self.label == bra.label:
return Integer(1)
else:
return Integer(0)
def _represent_default_basis(self, **options):
return self._represent_ZGate(None, **options)
def _represent_ZGate(self, basis, **options):
"""Represent this qubits in the computational basis (ZGate).
"""
format = options.get('format', 'sympy')
n = 1
definite_state = 0
for it in reversed(self.qubit_values):
definite_state += n*it
n = n*2
result = [0]*(2**self.dimension)
result[int(definite_state)] = 1
if format == 'sympy':
return Matrix(result)
elif format == 'numpy':
import numpy as np
return np.matrix(result, dtype='complex').transpose()
elif format == 'scipy.sparse':
from scipy import sparse
return sparse.csr_matrix(result, dtype='complex').transpose()
def _eval_trace(self, bra, **kwargs):
indices = kwargs.get('indices', [])
#sort index list to begin trace from most-significant
#qubit
sorted_idx = list(indices)
if len(sorted_idx) == 0:
sorted_idx = list(range(0, self.nqubits))
sorted_idx.sort()
#trace out for each of index
new_mat = self*bra
for i in range(len(sorted_idx) - 1, -1, -1):
# start from tracing out from leftmost qubit
new_mat = self._reduced_density(new_mat, int(sorted_idx[i]))
if (len(sorted_idx) == self.nqubits):
#in case full trace was requested
return new_mat[0]
else:
return matrix_to_density(new_mat)
def _reduced_density(self, matrix, qubit, **options):
"""Compute the reduced density matrix by tracing out one qubit.
The qubit argument should be of type python int, since it is used
in bit operations
"""
def find_index_that_is_projected(j, k, qubit):
bit_mask = 2**qubit - 1
return ((j >> qubit) << (1 + qubit)) + (j & bit_mask) + (k << qubit)
old_matrix = represent(matrix, **options)
old_size = old_matrix.cols
#we expect the old_size to be even
new_size = old_size//2
new_matrix = Matrix().zeros(new_size)
for i in range(new_size):
for j in range(new_size):
for k in range(2):
col = find_index_that_is_projected(j, k, qubit)
row = find_index_that_is_projected(i, k, qubit)
new_matrix[i, j] += old_matrix[row, col]
return new_matrix
[docs]class QubitBra(QubitState, Bra):
"""A multi-qubit bra in the computational (z) basis.
We use the normal convention that the least significant qubit is on the
right, so ``|00001>`` has a 1 in the least significant qubit.
Parameters
==========
values : list, str
The qubit values as a list of ints ([0,0,0,1,1,]) or a string ('011').
See also
========
Qubit: Examples using qubits
"""
@classmethod
def dual_class(self):
return Qubit
class IntQubitState(QubitState):
"""A base class for qubits that work with binary representations."""
@classmethod
def _eval_args(cls, args):
# The case of a QubitState instance
if len(args) == 1 and isinstance(args[0], QubitState):
return QubitState._eval_args(args)
# For a single argument, we construct the binary representation of
# that integer with the minimal number of bits.
if len(args) == 1 and args[0] > 1:
#rvalues is the minimum number of bits needed to express the number
rvalues = reversed(range(bitcount(abs(args[0]))))
qubit_values = [(args[0] >> i) & 1 for i in rvalues]
return QubitState._eval_args(qubit_values)
# For two numbers, the second number is the number of bits
# on which it is expressed, so IntQubit(0,5) == |00000>.
elif len(args) == 2 and args[1] > 1:
need = bitcount(abs(args[0]))
if args[1] < need:
raise ValueError(
'cannot represent %s with %s bits' % (args[0], args[1]))
qubit_values = [(args[0] >> i) & 1 for i in reversed(range(args[1]))]
return QubitState._eval_args(qubit_values)
else:
return QubitState._eval_args(args)
def as_int(self):
"""Return the numerical value of the qubit."""
number = 0
n = 1
for i in reversed(self.qubit_values):
number += n*i
n = n << 1
return number
def _print_label(self, printer, *args):
return str(self.as_int())
def _print_label_pretty(self, printer, *args):
label = self._print_label(printer, *args)
return prettyForm(label)
_print_label_repr = _print_label
_print_label_latex = _print_label
[docs]class IntQubit(IntQubitState, Qubit):
"""A qubit ket that store integers as binary numbers in qubit values.
The differences between this class and ``Qubit`` are:
* The form of the constructor.
* The qubit values are printed as their corresponding integer, rather
than the raw qubit values. The internal storage format of the qubit
values in the same as ``Qubit``.
Parameters
==========
values : int, tuple
If a single argument, the integer we want to represent in the qubit
values. This integer will be represented using the fewest possible
number of qubits. If a pair of integers, the first integer gives the
integer to represent in binary form and the second integer gives
the number of qubits to use.
Examples
========
Create a qubit for the integer 5:
>>> from sympy.physics.quantum.qubit import IntQubit
>>> from sympy.physics.quantum.qubit import Qubit
>>> q = IntQubit(5)
>>> q
|5>
We can also create an ``IntQubit`` by passing a ``Qubit`` instance.
>>> q = IntQubit(Qubit('101'))
>>> q
|5>
>>> q.as_int()
5
>>> q.nqubits
3
>>> q.qubit_values
(1, 0, 1)
We can go back to the regular qubit form.
>>> Qubit(q)
|101>
"""
@classmethod
def dual_class(self):
return IntQubitBra
def _eval_innerproduct_IntQubitBra(self, bra, **hints):
return Qubit._eval_innerproduct_QubitBra(self, bra)
[docs]class IntQubitBra(IntQubitState, QubitBra):
"""A qubit bra that store integers as binary numbers in qubit values."""
@classmethod
def dual_class(self):
return IntQubit
#-----------------------------------------------------------------------------
# Qubit <---> Matrix conversion functions
#-----------------------------------------------------------------------------
[docs]def matrix_to_qubit(matrix):
"""Convert from the matrix repr. to a sum of Qubit objects.
Parameters
----------
matrix : Matrix, numpy.matrix, scipy.sparse
The matrix to build the Qubit representation of. This works with
sympy matrices, numpy matrices and scipy.sparse sparse matrices.
Examples
========
Represent a state and then go back to its qubit form:
>>> from sympy.physics.quantum.qubit import matrix_to_qubit, Qubit
>>> from sympy.physics.quantum.gate import Z
>>> from sympy.physics.quantum.represent import represent
>>> q = Qubit('01')
>>> matrix_to_qubit(represent(q))
|01>
"""
# Determine the format based on the type of the input matrix
format = 'sympy'
if isinstance(matrix, numpy_ndarray):
format = 'numpy'
if isinstance(matrix, scipy_sparse_matrix):
format = 'scipy.sparse'
# Make sure it is of correct dimensions for a Qubit-matrix representation.
# This logic should work with sympy, numpy or scipy.sparse matrices.
if matrix.shape[0] == 1:
mlistlen = matrix.shape[1]
nqubits = log(mlistlen, 2)
ket = False
cls = QubitBra
elif matrix.shape[1] == 1:
mlistlen = matrix.shape[0]
nqubits = log(mlistlen, 2)
ket = True
cls = Qubit
else:
raise QuantumError(
'Matrix must be a row/column vector, got %r' % matrix
)
if not isinstance(nqubits, Integer):
raise QuantumError('Matrix must be a row/column vector of size '
'2**nqubits, got: %r' % matrix)
# Go through each item in matrix, if element is non-zero, make it into a
# Qubit item times the element.
result = 0
for i in range(mlistlen):
if ket:
element = matrix[i, 0]
else:
element = matrix[0, i]
if format == 'numpy' or format == 'scipy.sparse':
element = complex(element)
if element != 0.0:
# Form Qubit array; 0 in bit-locations where i is 0, 1 in
# bit-locations where i is 1
qubit_array = [int(i & (1 << x) != 0) for x in range(nqubits)]
qubit_array.reverse()
result = result + element*cls(*qubit_array)
# If sympy simplified by pulling out a constant coefficient, undo that.
if isinstance(result, (Mul, Add, Pow)):
result = result.expand()
return result
[docs]def matrix_to_density(mat):
"""
Works by finding the eigenvectors and eigenvalues of the matrix.
We know we can decompose rho by doing:
sum(EigenVal*|Eigenvect><Eigenvect|)
"""
from sympy.physics.quantum.density import Density
eigen = mat.eigenvects()
args = [[matrix_to_qubit(Matrix(
[vector, ])), x[0]] for x in eigen for vector in x[2] if x[0] != 0]
if (len(args) == 0):
return 0
else:
return Density(*args)
[docs]def qubit_to_matrix(qubit, format='sympy'):
"""Converts an Add/Mul of Qubit objects into it's matrix representation
This function is the inverse of ``matrix_to_qubit`` and is a shorthand
for ``represent(qubit)``.
"""
return represent(qubit, format=format)
#-----------------------------------------------------------------------------
# Measurement
#-----------------------------------------------------------------------------
[docs]def measure_all(qubit, format='sympy', normalize=True):
"""Perform an ensemble measurement of all qubits.
Parameters
==========
qubit : Qubit, Add
The qubit to measure. This can be any Qubit or a linear combination
of them.
format : str
The format of the intermediate matrices to use. Possible values are
('sympy','numpy','scipy.sparse'). Currently only 'sympy' is
implemented.
Returns
=======
result : list
A list that consists of primitive states and their probabilities.
Examples
========
>>> from sympy.physics.quantum.qubit import Qubit, measure_all
>>> from sympy.physics.quantum.gate import H, X, Y, Z
>>> from sympy.physics.quantum.qapply import qapply
>>> c = H(0)*H(1)*Qubit('00')
>>> c
H(0)*H(1)*|00>
>>> q = qapply(c)
>>> measure_all(q)
[(|00>, 1/4), (|01>, 1/4), (|10>, 1/4), (|11>, 1/4)]
"""
m = qubit_to_matrix(qubit, format)
if format == 'sympy':
results = []
if normalize:
m = m.normalized()
size = max(m.shape) # Max of shape to account for bra or ket
nqubits = int(math.log(size)/math.log(2))
for i in range(size):
if m[i] != 0.0:
results.append(
(Qubit(IntQubit(i, nqubits)), m[i]*conjugate(m[i]))
)
return results
else:
raise NotImplementedError(
"This function can't handle non-sympy matrix formats yet"
)
[docs]def measure_partial(qubit, bits, format='sympy', normalize=True):
"""Perform a partial ensemble measure on the specifed qubits.
Parameters
==========
qubits : Qubit
The qubit to measure. This can be any Qubit or a linear combination
of them.
bits : tuple
The qubits to measure.
format : str
The format of the intermediate matrices to use. Possible values are
('sympy','numpy','scipy.sparse'). Currently only 'sympy' is
implemented.
Returns
=======
result : list
A list that consists of primitive states and their probabilities.
Examples
========
>>> from sympy.physics.quantum.qubit import Qubit, measure_partial
>>> from sympy.physics.quantum.gate import H, X, Y, Z
>>> from sympy.physics.quantum.qapply import qapply
>>> c = H(0)*H(1)*Qubit('00')
>>> c
H(0)*H(1)*|00>
>>> q = qapply(c)
>>> measure_partial(q, (0,))
[(sqrt(2)*|00>/2 + sqrt(2)*|10>/2, 1/2), (sqrt(2)*|01>/2 + sqrt(2)*|11>/2, 1/2)]
"""
m = qubit_to_matrix(qubit, format)
if isinstance(bits, (int, Integer)):
bits = (int(bits),)
if format == 'sympy':
if normalize:
m = m.normalized()
possible_outcomes = _get_possible_outcomes(m, bits)
# Form output from function.
output = []
for outcome in possible_outcomes:
# Calculate probability of finding the specified bits with
# given values.
prob_of_outcome = 0
prob_of_outcome += (outcome.H*outcome)[0]
# If the output has a chance, append it to output with found
# probability.
if prob_of_outcome != 0:
if normalize:
next_matrix = matrix_to_qubit(outcome.normalized())
else:
next_matrix = matrix_to_qubit(outcome)
output.append((
next_matrix,
prob_of_outcome
))
return output
else:
raise NotImplementedError(
"This function can't handle non-sympy matrix formats yet"
)
[docs]def measure_partial_oneshot(qubit, bits, format='sympy'):
"""Perform a partial oneshot measurement on the specified qubits.
A oneshot measurement is equivalent to performing a measurement on a
quantum system. This type of measurement does not return the probabilities
like an ensemble measurement does, but rather returns *one* of the
possible resulting states. The exact state that is returned is determined
by picking a state randomly according to the ensemble probabilities.
Parameters
----------
qubits : Qubit
The qubit to measure. This can be any Qubit or a linear combination
of them.
bits : tuple
The qubits to measure.
format : str
The format of the intermediate matrices to use. Possible values are
('sympy','numpy','scipy.sparse'). Currently only 'sympy' is
implemented.
Returns
-------
result : Qubit
The qubit that the system collapsed to upon measurement.
"""
import random
m = qubit_to_matrix(qubit, format)
if format == 'sympy':
m = m.normalized()
possible_outcomes = _get_possible_outcomes(m, bits)
# Form output from function
random_number = random.random()
total_prob = 0
for outcome in possible_outcomes:
# Calculate probability of finding the specified bits
# with given values
total_prob += (outcome.H*outcome)[0]
if total_prob >= random_number:
return matrix_to_qubit(outcome.normalized())
else:
raise NotImplementedError(
"This function can't handle non-sympy matrix formats yet"
)
def _get_possible_outcomes(m, bits):
"""Get the possible states that can be produced in a measurement.
Parameters
----------
m : Matrix
The matrix representing the state of the system.
bits : tuple, list
Which bits will be measured.
Returns
-------
result : list
The list of possible states which can occur given this measurement.
These are un-normalized so we can derive the probability of finding
this state by taking the inner product with itself
"""
# This is filled with loads of dirty binary tricks...You have been warned
size = max(m.shape) # Max of shape to account for bra or ket
nqubits = int(math.log(size, 2) + .1) # Number of qubits possible
# Make the output states and put in output_matrices, nothing in them now.
# Each state will represent a possible outcome of the measurement
# Thus, output_matrices[0] is the matrix which we get when all measured
# bits return 0. and output_matrices[1] is the matrix for only the 0th
# bit being true
output_matrices = []
for i in range(1 << len(bits)):
output_matrices.append(zeros(2**nqubits, 1))
# Bitmasks will help sort how to determine possible outcomes.
# When the bit mask is and-ed with a matrix-index,
# it will determine which state that index belongs to
bit_masks = []
for bit in bits:
bit_masks.append(1 << bit)
# Make possible outcome states
for i in range(2**nqubits):
trueness = 0 # This tells us to which output_matrix this value belongs
# Find trueness
for j in range(len(bit_masks)):
if i & bit_masks[j]:
trueness += j + 1
# Put the value in the correct output matrix
output_matrices[trueness][i] = m[i]
return output_matrices
[docs]def measure_all_oneshot(qubit, format='sympy'):
"""Perform a oneshot ensemble measurement on all qubits.
A oneshot measurement is equivalent to performing a measurement on a
quantum system. This type of measurement does not return the probabilities
like an ensemble measurement does, but rather returns *one* of the
possible resulting states. The exact state that is returned is determined
by picking a state randomly according to the ensemble probabilities.
Parameters
----------
qubits : Qubit
The qubit to measure. This can be any Qubit or a linear combination
of them.
format : str
The format of the intermediate matrices to use. Possible values are
('sympy','numpy','scipy.sparse'). Currently only 'sympy' is
implemented.
Returns
-------
result : Qubit
The qubit that the system collapsed to upon measurement.
"""
import random
m = qubit_to_matrix(qubit)
if format == 'sympy':
m = m.normalized()
random_number = random.random()
total = 0
result = 0
for i in m:
total += i*i.conjugate()
if total > random_number:
break
result += 1
return Qubit(IntQubit(result, int(math.log(max(m.shape), 2) + .1)))
else:
raise NotImplementedError(
"This function can't handle non-sympy matrix formats yet"
)


Provides classes that create a {@link java.util.jar.Manifest} given a
{@link java.lang.Class} that is defined within a currently loaded jar.
This is used to provide properties information (particularly version
information) from the manifest included within the jar file.


Upload your image
Image
Upload style image
Styles
{% extends "base.html" %} {% block topNavbar %}
Upload a picture you would like to combine with the style.
In style swap method, you can upload any image you like.
As you submit, our model will combine the stylish image for you. Typically, the image will be displayed on the bottom of the website in a minute.


Disney+ will fix its 'Simpsons' widescreen problem in 2020
Viewers will be able to choose between 4x3 or cropped widescreen versions.
by Richard LawlerAs soon as Disney+ launched, fans of The Simpsons noticed a big problem. In a repeat of an issue that occurred when FXX started playing old episodes a few years ago, someone made the decision to crop and zoom older 4x3 aspect ratio episodes to fill out an HD widescreen frame. It was eventually corrected, and it turns out that new owner Disney will also fix things up -- eventually.
In a statement, a Disney spokesperson said that "in early 2020" it will offer a toggle for the first 19 seasons of episodes so people can choose to view them in their original format -- important for many visual gags that extend to the top or bottom of the frame -- or widescreen-adjusted.
Disney:
We presented "The Simpsons" in 16:9 aspect ratio at launch in order to guarantee visual quality and consistency across all 30 seasons. Over time, Disney+ will roll out new features and additional viewing options. As part of this, in early 2020, Disney+ will make the first 19 seasons (and some episodes from Season 20) of "The Simpsons" available in their original 4:3 aspect ratio, giving subscribers a choice of how they prefer to view the popular series.


Letter of Motivation
Agreement
Candidate Data
Skills
Document Upload
Letter of Motivation
Submit Application
Motivational Letter
Submit
Submit
Submit


Ensure you have the sample project topseed-helloworld open in VS Code and Prepros running on it. Per Lab 1, make sure the home page is running in a browser.
Visit and browse these sites: http://materialpalette.com, https://design.google, https://material.io and https://material.io/guidelines/#. We follow Material Design guidelines, put forward by Google, to make our sites and mobile apps look better.
Find '/_sass/main.css'
in the home page source, and inspect it. Other than fonts, all CSS used on the site is in this one CSS.
Visit https://www.muicss.com. Read 'Getting Started/Introduction', then browse the section 'CSS/JS'. We use the MUI CSS libraries in our project. Inspect /public/_sass/_base.scss
. SCSS is CSS with some added features, such as $variables
and @import
. You can turn any CSS file into SCSS just by changing the ending to .scss
.
Inspect /public/_sass/_colors.scss
. See a color scheme we generated with materialpalette.com. Use /* */ to comment it out. Go back to http://materialpalette.com, pick two colors, download your own palette in CSS format and paste it after the section you commented out. Save, refresh the browser; you should see your new color scheme applied to the site. Revert to the palette you had commented out.
Inspect /public/_sass/main.sass
. SASS uses a special syntax without the curly braces or ';'
at the end of a line that are used in CSS (and SCSS). SASS can also use SCSS imports such as @import '_base'
. Prepros compiles the .sass
and its dependent .scss
imports into the single main.css
used in the browser. In Prepros Files select _main.sass, check 'Minify CSS', and click Process File. Open /_sass/main.css
and see that it is now minified.
Inspect /page/two/_buttons.html
. Copy the entire HTML. Go to http://html2jade.org (Pug used to be called Jade) and paste this html. In the right pane you see Pug markup, a way to write html without having to worry about closing tags. We write Pug.
Inspect the code snippet at /page/two/_buttons.pug
. It should match the output of html2jade. Every .pug
file in the project has a corresponding .html
used by the browser, with the exception of include's within another .pug
file. Inspect /page/two/index.pug
to find the 'include _buttons'
. Inspect /page/two/index.html
to find the generated buttons HTML.
Watch the video 'Do you Even JADE bro' at https://www.youtube.com/watch?v=wzAWI9h3q18. Once you know how to write Pug, you can generate beautiful HTML quickly.


Stan Wiggers
Profile
Hi there! My name is Stan Wiggers, I am 25 years old and live in Deventer. I would describe myself as a calm go-getter who likes to look at things analytically. I am a sports enthusiast, I love hanging out with friends and every now and then I like to turn on my DJ Controller to mix music or turn on my PlayStation to play videogames.
Experience
Bol.com
Utrecht
Business Intelligence Specialist
Mar 2021 - Present
- Being a BI Specialist at bol.com means providing the correct data insights for our colleagues
- Extra focus on Data Literacy
- Data Literacy
- Tableau
- Google BigQuery
- SQL
Business Intelligence Intern
Sep 2020 - Feb 2021
- Support of the BI Autonomous Insights team
- Wrote my Master Thesis with the title; Is Data Literacy Related To Data Usage?
- Master Thesis
Content Specialist
Apr 2019 - Sep 2019
- As a Content Specialist I was responsible for the content at the cluster Electronics
- Provide products with creative content and optimize findability
- Creative Content
- Findability
- Customer Journey
Bijverkoop Specialist
Aug 2018 - Dec 2018
- Responsible for the additional 'shopping card' sales at the cluster Electronics
- Improving the additional sales strategy by testing and analyzing data
- Experiments
- Data Analysis
- Strategy
Product Specialist Intern
Feb 2018 - Jul 2018
- As an intern I supported the product & brand specialists in their daily work, but I also had my own tasks
- Wrote my Bachelor Thesis with the title; Het sales-uplift Uplift-plan
- Bachelor Thesis
Haverkamp Deventer
Deventer
Digital Marketer
Mar 2017 - Jan 2018 & Oct 2019 - Feb 2021
- Digital Marketer, consisting of optimization of 4 webshops and building 1 new webshop
- Google Analytics
- Google Adwords
- Customer Journey
- Social Media
- HTML
Digital Marketing Intern
Mar 2017 - Jan 2018
- Support of the Digital Marketing team
- Formulation of a marketing plan
Plus Supermarkets
Schalkhaar
Teamlead
Oct 2011 - Aug 2016
- Together with a team of stock fillers, we made sure that the supermarket was stocked every evening
- Responsible for the stock, counting the money and closing the shop correctly
- Retail
- Leadership
Education
MSc Marketing Analytics
Tilburg University
Feb 2020 - Present
Specialised in Data Analytics
Bachelor Commercial Economics
Hogeschool Saxion Deventer
Feb 2020 - Present
Specialised in Digital Marketing
- +316 53121505
-<EMAIL_ADDRESS>- linkedin.com/in/stan-wiggers-765a3ba2/
- Netherlands
Skills
-
-
Data Analysis
- Tableau
- Google BigQuery (SQL)
- Google Analytics
-
Programming
- Python
- Jupyter Notebook
- R Studio
- HTML
-
Developer Tools
- Git
- Github
Languages
-
DutchNative
-
EnglishProfessional
-
GermanBasic
Interests
- Mountain biking & cycling
- Soccer
- Fitness & Bootcamp
- Friends
- Music
- Sneakers
- Gaming