Class ComponentRelationsRepairResultModel
This class represents the results of a component relation repair request.
Inheritance
System.Object
ComponentRelationsRepairResultModel
Inherited Members
System.Object.ToString()
System.Object.Equals(System.Object)
System.Object.Equals(System.Object, System.Object)
System.Object.ReferenceEquals(System.Object, System.Object)
System.Object.GetHashCode()
System.Object.GetType()
System.Object.MemberwiseClone()
Namespace: Vasont.Inspire.Models.Components
Assembly: Vasont.Inspire.Models.dll
Syntax
public class ComponentRelationsRepairResultModel
Properties
| Improve this Doc View SourceAllowedElements
Gets or sets the element names that are allowed to be picked in the repair dialog that is displayed upon an unsuccessful auto repair.
Declaration
public List<string> AllowedElements { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Collections.Generic.List<System.String> |
Components
Gets or sets the resulting components that matched the current relationship.
Declaration
public List<MinimalComponentModel> Components { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Collections.Generic.List<MinimalComponentModel> |
ElementBoxChecked
Gets or sets a value indicating whether the element check box should be initially checked in the repair dialog that is displayed after an unsuccessful auto repair.
Declaration
public bool ElementBoxChecked { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Boolean |
ElementRequired
Gets or sets a value indicating whether an element is required to be selected before allowing the target to be chosen.
Declaration
public bool ElementRequired { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Boolean |
IsRepairSuccessful
Gets or sets a value indicating whether the repair was successful.
Declaration
public bool IsRepairSuccessful { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Boolean |


Guidelines
Move the mouse pointer very near the upper edge of the document area and hold it steady for about 1.5 seconds - the ruler will appear. You can click on the ruler to add/remove vertical guidelines.
You can also right-click to the ruler to precisely define the guideline type you want to insert:
- Normal guideline - when clicked, a math box is created
- Text guideline - when clicked, a text box is created
- Text autowrap guideline - object do not stick to it, but forces line wrap when you type text
In addition, local automatic guidelines are displayed when your mouse pointer is vertically aligned with nerby math/text objects.


|
Walls And Holes
1
|
Go to the source code of this file.
Classes | |
| class | MapCellGraphicsItem |
| The MapCellGraphicsItem class Inherits from QGraphicsItem this class is used for painting and generating the cells in MapCell. More... | |
Enumerations | |
| enum | MapViewMode { NoView = 0, DefaultView = 1, HeightMapView = 2 } |
| enum MapViewMode |


Tim Stackhouse<EMAIL_ADDRESS>Philadelpha Area, USA
"We can only see a short distance ahead, but we can see plenty there that needs to be done." --Alan Turing, 1950


- getCategory(Integer) - Method in class task.SimplyTaskList
-
Gives the priority category of the task.
- getCategoryInfo() - Method in class task.SimplyTaskList
-
Gives information about the possible categories.
- getComment() - Method in class task.SimplyTask
-
Gives the stored information about the task.
- getFinishedTaskNames() - Method in class task.SimplyTaskList
-
It gives the names of the finished tasks.
- getFirstIndexOfCategory(String) - Method in class task.SimplyTaskList
-
Gives the first index of the category.
- getIsFinished() - Method in class task.SimplyTask
-
Gives information about task if it is finished.
- getIsFinished(Integer) - Method in class task.SimplyTaskList
-
Checks if the task is finished.
- getLastIndexOfCategory(String) - Method in class task.SimplyTaskList
-
Gives the last index of the category.
- getLastPriorityInCategory(String) - Method in class task.SimplyTaskList
-
Gives the last priority value of the given priority category.
- getListName() - Method in class task.SimplyTaskList
-
Gives the name of the task list.
- getNextCatIndex(String) - Method in class task.SimplyTaskList
-
Gives the index of the next category used from the possible category list.
- getPrevCatIndex(String) - Method in class task.SimplyTaskList
-
Gives the index of the previous category from the priorityCategories list.
- getPriority(Integer) - Method in class task.SimplyTaskList
-
Gives the priority of the task.
- getPriorityCategories() - Method in class task.SimplyTaskList
-
Gives the list of possible priority categories.
- getTaskCategory(Integer) - Method in class task.SimplyTaskList
-
Gives the category of the task.
- getTaskComment(Integer) - Method in class task.SimplyTaskList
-
Gives some information about the task.
- getTaskIndex(String) - Method in class task.SimplyTaskList
-
Adds the index of the task in the active task list.
- getTaskName() - Method in class task.SimplyTask
-
Gives the task's name.
- getTaskName(Integer) - Method in class task.SimplyTaskList
-
Gives the name of a task.
- getTasks() - Method in class task.SimplyTaskList
-
Gives the list of the tasks.


2 Basic visualization of radar scans
2.1 The structure of polar volumes
# Let's first download the NEXRAD polar volume files for the KHGX radar (Houston)
# for a 15 minute period in 2017:
download_pvolfiles(date_min=as.POSIXct("2017-05-04 01:25:00"), date_max=as.POSIXct("2017-05-04 01:40:00"), radar="KHGX", directory="./data_pvol")
# store the filenames in my_pvolfiles
<- list.files("./data_pvol", recursive = TRUE, full.names = TRUE, pattern="KHGX")
my_pvolfiles # print to console our files:
my_pvolfiles# let's load the first of our downloaded files:
<- read_pvolfile(my_pvolfiles[1]) my_pvol
Exercise 1: What is the minimum and maximum scan elevation contained in the volume? And which scan parameters are available? (See manual page of the read_pvolfile()
function for the nomenclature of various available quantities).
2.2 Plotting radar scans
# let's extract the scan collected at 1.5 degree elevation from our polar volume:
<- get_scan(my_pvol, 0.5)
my_scan # print some information about this scan:
my_scan# let's plot the reflectivity factor parameter of the scan in a range - azimuth coordinate system:
plot(my_scan, param = "DBZH")
Usually it is easier to visually explore radar scans as a PPI (plan position indicator), which is a projection of the scan on a Cartesian (X,Y) or (lat,lon) grid:
# before we can plot the scan, we need to project it on a Cartesian grid,
# i.e. we need to make a Plan Position Indicator (PPI)
<- project_as_ppi(my_scan)
my_ppi # print some information about this ppi:
my_ppi# you can see we projected it on a 500 meter grid
# (check the manual of the project_as_ppi function to see how you can
# change the grid size (argument grid_size) and the maximum distance
# from the radar up to where to plot data (argument range_max))
#
# Now we are ready to plot the ppi, for example let's plot reflectivity factor DBZH:
plot(my_ppi, param = "DBZH")
Exercise 2: This case shows an incoming precipitation front, characterized by localized but intense thunderstorms, as well as biological scattering. Make also a ppi plot of the correlation coefficient (RHOHV) and radial velocity (VRADH). Verify which regions are precipitation, and the approximate direction of movement of biology and precipitation.
Exercise 3: Based on the radial velocity image, are the biological scatterers birds or insects? Why?
2.3 Overlaying radar scans on maps
# It is often informative to plot radar data on a base layer.
# first download the background image:
<- download_basemap(my_ppi)
basemap # plot the basemap:
plot(basemap)
# then overlay the PPI on the basemap, restricting the color scale from -20 to 40 dBZ:
map(my_ppi, map = basemap, param = "DBZH", zlim = c(-20, 40))


A red flare silhouetted the jagged edge of a wing.A red flare silhouetted the jagged edge of a wing.A red flare silhouetted the jagged edge of a wing.A red flare silhouetted the jagged edge of a wing.
It was going to be a lonely trip back.It was going to be a lonely trip back.A red flare silhouetted the jagged edge of a wing.A red flare silhouetted the jagged edge of a wing.
A red flare silhouetted the jagged edge of a wing.A red flare silhouetted the jagged edge of a wing.A red flare silhouetted the jagged edge of a wing.A red flare silhouetted the jagged edge of a wing.

A red flare silhouetted the jagged edge of a wing.A red flare silhouetted the jagged edge of a wing.A red flare silhouetted the jagged edge of a wing.A red flare silhouetted the jagged edge of a wing.


| :: [FilePath] | path (list of directories to search) |
| -> [ChaseName] | todo (list of modules still to find) |
| -> [ChaseName] | done (list of modules already found) |
| -> accu | initial (start value of accumulator) |
| -> ([FilePath] -> ChaseName -> IO (Either cu String)) | parse (function that attempt to find and parse a module) |
| -> (cu -> [ChaseName]) | imports (function that extracts imports from
a parse result) |
| -> (ChaseName -> [ChaseName] -> cu -> accu -> IO accu) | on module (function that computes a new
accumulator from a parse result) |
| -> (ChaseName -> accu -> IO accu) | on missing (function that computes a new
accumulator value when parsing failed) |
| -> IO accu | result (accumulated value) |
| A generic import chasing function. The type of the final result is a
parameter, which will usually be instantiated to a list of parsed
modules. |


@@include('inc/top.html', {"id": "home-page", "title": "David, a dependency management tool for Node.js projects"})
David gets you an overview of your project dependencies, the version you use and the latest available, so you can quickly see what's drifting. Then it's all boiled down into a badge showing the current status, which you can embed on your site.
Got a Node.js project? Get a badge. David is free for public projects on Github.
Declare your dependencies in a package.json file and you're good.  Click on the examples above for a preview.
Type your username / repo name in below and get yours...
@@hostname/username/repo.svg
David is currently BETA, which means it may be unreliable, unavailable or not working. That said, it's already useful and we're working to make it rock solid. It's all in Github so feel free to help.
These are the most used NPM dependencies based on open source GitHub projects that are using them.


Ensure that the website is https://honest.cash with a valid security certificate. Your email and password is used to decrypt your wallet and get access to your bitcoin.
https://honest.cash


Introduction
The objective of this project is to start familiarizing ourselves with programming real time systems using a time-based architecture, and to become comfortable interfacing with peripherals using an arduino microcontroller. Some of the peripherals used in this project include photo transistors, servo motors, light emitting diodes (LED), an lcd display, and bluetooth modules.
The goal for this project was to use bluetooth communications to control two servo motors and a laser connected to one microcontroller, from a joystick connected to a separate microcontroller, using a real time scheduler.
Although a relatively basic task, this project offers insights into the types of problems that arise when interfacing time-sensitive software with hardware components.
Hardware Overview
The hardware components used for this project are as follows:
- 2 Arduino Mega 2560
- 2 Tower Pro MG90S Servo Motors
- 1 Pan and Tilt Kit
- 1 PS2 Joystick
- 1 Laser (LED)
- 1 LCD Display
- 1 3.3 / 5 V Power Supply
- 2 Breadboards
- 2 JY-MCU Bluetooth Modules (One HC-06, one HC-05)
- 1 Photocell
- 1 10K resistor
- 1 1K resistor
- Jumper wires
Arduino Mega 2560
The Arduino Mega is a multi-purpose microprocessor with an abundance of I/O pins, for the biggest and most demanding of projects [1]
- Operating Voltage 5V
- Input Voltage (recommended) 7-12V
- Input Voltage (limit) 6-20V
- Digital I/O Pins 54 (of which 15 provide PWM output)
- Analog Input Pins 16
- DC Current per I/O Pin 20 mA
- DC Current for 3.3V Pin 50 mA
Laser Diode
We used a noname laser diode with two leads, a Vin (red wire) and a Ground (blue wire). This laser draws ~15mA, so it can be driven directly by the microcontroller.
Pan and Tilt Kit
We used a 3D printed pan and tilt kit that houses two servo motors, one for each direction. There is also a shelf on the top to mount the laser module.
LCD Shield Display (DFR0009)
An LCD shield that plugs into the top of the Arduino Mega. Arduino has a library to interface with the display.
PS2 Joystick
A PS2 joystick is used to control the motion of the pan and tilt servo motors. The range of analog values read from the joystick is 0-1024, both in the x and y direction. The joystick has 5 pins:
- VCC (5V)
- Ground
- X-axis
- Y-axis
- SW (Click)
The X- and Y-axis pins output an analog value corresponding to the position of the joystick. The SW pin outputs a digital value corresponding to the state of the button built into the joystick.
Power Supply
The power supply has the option to output either 3.3 or 5 volts, depending on the position of the jumpers on the power supply. It has 4 power pins and 4 ground pins, and is powered via a port that connects to a wall adapter.
Breadboards
Given the temporary and iterative nature of this project, breadboards are an ideal candidate for connecting all these hardware components. We used two breadboards, one full sized (60) and one half sized (30 rows).
Jumper wires
Since we used breadboards to connect the hardware components of this project, we also needed to use jumper wires to actually make the connections. Two different kinds of jumper wires were used: male-to-male and male-to-female.
2 JY-MCU Bluetooth Modules (one HC-06, one HC-05)
These two bluetooth modules are very similar. They both have versions that come with either 4 or 6 pins. For this project, only 4 pins are used: VCC (5V), Ground, Rx, and Tx. The RX and TX are used for UART communication between the microcontroller and the bluetooth chip. The HC-06 module is able to be configured as either a master or a slave, whereas the HC-05 module does not support the master role and must be used as a slave. Both modules can have their names and PINs configured.
Photocell
A photocell is essentially a resistor whose resistance changes inversely proportional to the amount of light its surface it subjected to. In tandem with a pull-up resistor, the output of a photocell can be read in as an analog input.
Software Overview
Project 1 uses the core Arduino libraries to interface with the servo motors and avr ADCs, so for the sake of simplicity we used the Arduino IDE to develop and upload the code. The core Arduino libraries are written in C++, so the project implementation is also written in C++; however only C features were used. In addition, the Time Triggered Scheduler (TTS) from the UVic mechatronics lab website was incorporated into phase 2 [3].
Git was used to facilitate collaboration when implementing the software for Project 1.
The software sections of Phase 1 and Phase 2 go into more detail about the types of problems solved using software and the methods used to solve them, as well as some of the fundamental design decisions made throughout the implementation of Project 1.
Phase 1
Phase 1 of this project involved controlling hardware from a single base station, using wired connections and a single arduino. The arduino core libraries were used in combination with a single polling loop, without the use of any time-triggered scheduler. Phase 1 required that the pan and tilt motors be controlled by the movement of a joystick, and that the laser be controlled by the clicking of that joystick. It also requires that the photocell recognizes when it is being hit by a laser. The last piece of Phase 1 is displaying the state of the joystick and the photocell on an LCD display.
Hardware
The hardware for phase one consists of 3 sources of input: the joysticks analog movements along the X and Y axis, the analog value of the photocell, and the digital state of the joystick’s button.
It also consists of 3 outputs: the laser, the pair of servo motors used to drive the pan and tilt, and the LCD display.
Power Supply
Since we used an LCD shield that sits on top of the Arduino, we did not have access to the 5V power pin of the Arduino. To remedy this, we used an external power supply to provide power to all the components that would otherwise have been powered directly from the Arduino 5V pin.
The power supply plugs directly into the wall. The jumpers are configured such that the power supply will supply 5V. One of the power pins as well as one of the ground pins are each connected to a different row of the breadboard.
We also made a connection between the row with the power supply’s ground and one of the Arduino’s ground pins. This is to ensure that all components share the same ground reference.
Joystick
The joystick’s VCC and Ground pins connect to the rows of the breadboard that are connected to the 5V output and ground of the Arduino.
The X and Y pins of the joystick connect directly to analog input pins on the Arduino. These values can be read in directly without scaling, and show values from 0 - 1024 on each axis.
The digital SW pin, the pin detailing the state of the joystick’s button, is not as simple to read as the analog axis pins. It must be connected to a pull-down resistor. The SW pin should connect both a 1K resistor and a digital input pin on the Arduino. The other side of the resistor should connect to 5V.
When the button is not pressed in, the digital pin connected to the SW pin will be HIGH, since the path of least resistance is through the resistor and directly into the digital pin. When the button is pressed, the digital pin is connected to ground inside the joystick, pulling the pin reading down to LOW.
Photocell
Similar to the joystick, the photocell also requires a pull-down resistor. One side of the photocell is connected directly to the 5V pin of the Arduino. The other side is connected to a row of the breadboard that connects to both a 10K resistor, and an analog in pin on the Arduino. The other side of the 10K resistor is connected to ground.
The resistance of the photocell in the dark is high, and it decreases as it is subjected to more light. This means that as more light hits the photocell, the total resistance of the system decreases, allowing more current to pass through into the analog in pin used to read the value of the photocell.
 It only has two leads, a red and a black. The red lead connects to a digital out pin that will control the state of the laser, and the black lead connects to ground.
Servo Motors
Each servo motor has 3 wires: brown, red, and orange. The brown wire is Ground, red is power (5V), and orange is signal. The ground and power wires are connected to the breadboard in their corresponding ground and 5V rows, and the signal wires are connected directly to PWM pins on the Arduino.
LCD Shield
The LCD shield plugs directly into the top of the Arduino. A couple of the pins on the shield are labeled the same as the Arduino pins, so those go together and line the rest up.
Software
The code for phase 1 has 5 main tasks, two of which involve reading external values, while the other three use those values to update the state of the peripheral motors, laser, and lcd. These tasks are performed in sequence in the main Arduino loop, with a delay of 50 milliseconds at the end of each loop, to enforce a rough sampling rate of 20Hz.
While these tasks are performed in sequence in the phase 1 code, they are described in a modular nature here as the descriptions still apply to the phase 2 code. While theoretically fewer tasks could have been used as most operations are dependent on the sampling of the joystick values, the tasks were separated to adhere to the philosophy of the time-triggered scheduler used in phase 2.
An initial sampling rate of 20 Hz was decided on by considering the rate at which the values of any of the peripherals could reasonably change. Since the joystick is human controlled, we decided it could only change (including the joystick’s click) 10 times per second. To be safe we doubled that, settling on a sampling rate of 20Hz. This sampling rate is tested and justified in phase 2.
Reading Joystick
The analog voltage for the X and Y position of the joystick is read and passed through an exponential moving-average filter. In addition, the digital value of the joystick button was read. Because of the low sample rate, no de-bouncing was needed for the button. For the exponential filter on the joystick positions, a 90 percent weight is applied to the previous value, corresponding to a weight of 10 percent of the current value. This filter proportion is designed to maximize the smoothness of control over the motors. While no linearization was needed for project 1, some form of linearization will be necessary for project 3 to obtain more precise control of the laser attitude.
In addition to filtering, we discarded joystick readings that were near the center of either access, creating a deadzone of approximately ∓ 25 increments in either direction. This was necessary to ensure smooth servo control as the joystick readings were noisy in this range.
Photocell
The second task reads the analog value of the photocell. This value is then stored for later use in another task, where it will be written to the LCD screen. After some testing, it was observed that given the resistor used (described in the hardware section of phase 1), the photocell reads ~85 in a well lit room, ~12 when it is cupped by a hand, and ~600 when a laser shines directly on it. With this information, a “hit” threshold of 350 was used to determine whether or not the photocell was being hit by a laser.
Servo Control
The third task is responsible for controlling the pan and tilt servo motors. It scales the filtered values read from the joystick to incremental relative position commands added to the absolute position of the servos, which is measured in degrees in the range 0 to 180. Relative control of the servos allowed for much more precise movements than absolute control would have, as the joysticks are not precise enough to achieve a specific position. The arduino Servo library was used to achieve the correct pulse width modulation necessary for servo control.
Laser Control
The fourth task takes the button state, decides whether the laser should be on or off, and then writes the corresponding value to the laser. It sets the laser pin HIGH if the button is pressed, and LOW if it’s not.
LCD Display
The fifth and final task is writing the filtered X and Y values from task 1, and the photocell reading from task 2, to the LCD display. The absolute position of the joystick in both the X and Y directions are printed on the LCD, as well as whether or not the photocell reading is above the “hit” threshold. The arduino LiquidCrystal library was used to interface with the LCD shield display.
An issue that we encountered when programming the LCD shield was incorrect characters being rapidly printed to the screen. While this initially appeared related to the frequency of screen updates, in reality it was caused by an unnoticed buffer overflow when formating the joystick data to be printed. This bug highlights the difficulty in debugging embedded code.
Phase 2
The major change in the second phase of this project involved the addition of wireless communication of joystick information via bluetooth. This required that the single station from phase one be split into a separate base station and remote station that would interface with bluetooth.
The base station was required to have the joystick, LCD screen, photocell, and a bluetooth master module. The remote station contained the servo motors, laser, and a bluetooth slave module. The base station read in the values from the joystick X and Y axis and button, and the photocell, wrote them to the LCD screen, and sent the data to the remote station. With that data, the remote station controls the output peripherals (servos and laser) accordingly.
In addition, both the base and remote stations were required to schedule their tasks using a Time-Triggered Scheduler (TTS) instead of a polling loop. The frequency and periods of each tasks were considered carefully, with the objective of minimizing CPU utilization, while maintaining full functionality.
Hardware
The only hardware that had to change from phase one to phase two, with the exception of moving some of the peripherals over to another breadboard and Arduino, is the inclusion of the bluetooth modules.
The extra components for phase 2 are an extra Arduino, an extra breadboard, and two bluetooth HC-05/06 modules.
Wiring diagrams for the complete remote and base stations can be seen in figures 8 and 9 respectively.
Bluetooth HC-05/06 Modules
We configured our HC-06 to be the bluetooth master, and the 05 to be the slave. The configuration process involves setting the name, pin, and role of each module. The commands for each of these configuration steps were provided to us as a reference.
The PIN that is set on these two modules is what tells them to communicate with each other, as opposed to any of the other powered modules in the room at the time. With that in mind, it was important to pick a PIN that other groups would likely not use themselves.
The bluetooth module communicates over UART (serial). The VCC and ground pins connect to the 5V and ground pins of the Arduino. The Rx and Tx pins connect to the Tx1 and Rx1 pins on the Arduino, respectively. This configuration is known as a null-modem configuration, and it what most modern serial devices use.
Software
The tasks outlined in the software section for phase 1 were all re-used for phase 2, with the base station running the joystick, photocell and LCD tasks, and the remote station running the servo and laser tasks. The only additions were the integration of a time-triggered scheduler to reduce cpu utilization and increase performance, and bluetooth tasks on both stations to handle the transmission of packets. A shared packet format was developed so that the remote station could understand the order of the bytes it was receiving.
Bluetooth Packet
In order to account for data potentially being lost during bluetooth transmission, a 4-byte packet structure with an aligning “start” byte was developed to allow for basic error checking. In this way, any data received before the “start” byte will be discarded, as it doesn’t correspond to the agreed-upon packet structure. The below figure illustrates the structure of the bluetooth packet and the data contained by each byte. The scaling of the joystick values to servo angles from phase 1 was moved into the base station’s joystick task for phase 2. Because the commanded absolute position of the servo is only in the range 0-180, this allowed us to encode the servo position into a single byte.
| Byte 0 | Byte 1 | Byte 2 | Byte 3 |
|---|---|---|---|
| Start Byte = 'S' | Joystick Button Value = (0 or 1) | Pan Angle = (0 - 180) | Tilt Angle = (0 - 180) |
Initially, a separate “start” and “stop” byte was used for each packet, but we discovered that because the error-rate was so low, a single aligning byte was sufficient for the purposes of short-range bluetooth communication. Because the packets are almost always consecutive, the trailing “stop” byte would be immediately succeeded by a “start” byte and was therefore redundant.
Bluetooth Tasks
Both station’s bluetooth tasks used the Arduino Serial functions to communicate with the bluetooth chips via UART. The task on the base station simply copied the data produced by the other tasks into a packet format and set the entire 4-byte packet at once. However, the remote station task followed a more complicated procedure to ensure data integrity. It discards any data received before the agreed-upon starting byte then reads the packet only if at least a 4-bytes of data is available in the hardware UART buffers.
We initially considered reading the bluetooth data byte-by byte, with a lower task frequency, to avoid blocking in the bluetooth task to wait for a full packet of data. However, because there is a hardware buffer that automatically stores received UART data, we found that this was actually unnecessary. The Arduino serial library allows the user to check how many unread bytes have been received, meaning that the bluetooth task on our remote station will only read the data if at least 4-bytes (one packet worth) has been received. Otherwise it will immediately return without ever blocking. This greatly reduced CPU utilization.
Time Triggered Scheduler
The Time Triggered Scheduler required that the period and phase of each task be manually specified so that the system ran smoothly but CPU utilization was minimized. Because the software tasks for phase 2 required very little CPU time to execute, our first estimations for scheduler period and phase ended up meeting these requirements.
The below sections detail the logic behind the timing chosen for each station, as well as the analysis of the timing using a logic analyzer. Separate digital pins for each task were raised and lowered each time a task was scheduled and returned respectively, so that their runtime could be easily seen on the logic analyzer.
Base Station
The timing of the overall system was largely dependent on the sampling rate of the joystick, as the joystick was the primary input device that determined the action of the rest of the system. Because it is unrealistic for joystick inputs to happen faster than 10 times per second (Hz), a scheduling period of 20 Hz, corresponding to a period of 50 ms was chosen for the task that read the joystick values. Based on this, the bluetooth task period was set at half this, to ensure that each change in joystick value was captured appropriately. The other tasks were then set to multiples of the joystick period; the LCD had a longer period as it was not necessary to update the screen faster than can be perceived. The offsets were widely spaced to ensure that none of the tasks overlapped. Figure 12 shows the logic analyzer results for the base station while Table 1 indicates the corresponding channel mappings and periods/offsets for the logic analyzer screenshots.
Longer periods were experimented with to further reduce cpu utilization. However, we found that increasing the period of the LCD task beyond 100ms introduced undesirable latency in the position indications of the joysticks. Furthemore, decreasing the sampling rate of the joysticks caused the movement of the servos to be imprecise, as there was a larger amount of latency in the system.
| Base | ||||
|---|---|---|---|---|
| Channel | Task | Period (ms) | Offset (ms) | Average Execution Time (μs) |
| 0 | Write to LCD | 100 | 0 | 3500 |
| 1 | Read Light Sensor | 25 | 20 | 110 |
| 2 | Transmit over Bluetooth | 25 | 15 | 30 |
| 3 | Read Joystick Values | 50 | 10 | 32 |
The timing analysis clearly showed that there was no overlap or timing jitter, and that CPU utilization was very low, with each tasks execution time being a small fraction if its period. The LCD task by far took the most amount of time, but also had the longest period. The total CPU utilization for the base station can therefore be calculated with the following equation.
For the base station this yields a CPU utilization of approximately 4.1 %, which is extremely low, as desired.
Remote Station
Since the remote station only received data from the base station and did not transmit, the scheduling periods were chosen based on the decisions already made for the base station. The period of the bluetooth task was set to 25 ms to match that of the base station, and ensure that packets were read at the same rate they entered the buffer. The periods of the servo and laser tasks were set to match the period of the bluetooth task as it was not possible for their state to change any faster than the information in the bluetooth packets is received. Figure 14 and table 2 show similar logic analyzer results as for the base station.
| Remote | ||||
|---|---|---|---|---|
| Channel | Task | Period (ms) | Offset (ms) | Average Execution Time (μs) |
| 0 | Set Laser | 25 | 15 | 10 |
| 1 | Set Servose | 25 | 20 | 106 |
| 2 | Read from Bluetooth | 25 | 0 | 20 |
If CPU utilization is calculated using the same equation as above, we obtain a utilization of 0.54% for the remote station, which is an order of magnitude lower than that of the base station.
Conclusion
The timing analysis done in phase two shows that the time-triggered architecture used to control the devices in this project has the potential to be a simple and reliable basis for implementing an RTOS. Future iterations of the TTS implemented in project two will need mechanisms to handle urgent events and interrupts, start and stop dynamically created tasks and utilize the idle time between periodic tasks.
References
[1] "Arduino Mega 2560 Rev3", Store.arduino.cc, 2019. [Online]. Available: https://store.arduino.cc/usa/arduino-mega-2560-rev3. [Accessed: 03- Feb- 2019].
[2] "MG90S | Tower Pro", Towerpro.com.tw, 2019. [Online]. Available: https://www.towerpro.com.tw/product/mg90s-3/. [Accessed: 03- Feb- 2019].
[3] "Lab Guide: Time-Triggered Scheduling | Neil's Log Book", Nrqm.ca, 2019. [Online]. Available: https://nrqm.ca/mechatronics-lab-guide/lab-guide-time-triggered-scheduling/. [Accessed: 06- Feb- 2019].
[4] "Arduino PS2 Joystick Tutorial: Keyes KY-023 Deek Robot", Henry's Bench, 2019. [Online]. Available: http://henrysbench.capnfatz.com/henrys-bench/arduino-sensors-and-input/arduino-ps2-joystick-tutorial-keyes-ky-023-deek-robot/. [Accessed: 04- Feb- 2019].


Have you ever chosen to pass through the black door at some stage in your life?
Let me share with you the following story…
"Several generations ago, during one of the most turbulent desert wars in the Middle East, a spy was captured and sentenced to death by a general of the Persian army. The general, a man of intelligence and compassion, had adopted a strange and unusual custom in such cases. He permitted the condemned person to make a choice. The prisoner could either face the firing squad or pass through the black door.
As the moment of execution drew near, the general ordered the spy to be brought before him for a short, final interview, the primary purpose of which was to receive the answer of the doomed man to the query: " What shall it be - the firing squad or the Black Door?"
This was not an easy decision and the prisoner hesitated, but soon made it known that he much preferred the firing squad to the unknown horrors that might wait for him behind the ominous and mysterious door. Not long thereafter, a volley of shots in the courtyard announced that the grim sentence had been fulfilled.
The general, staring at his boots, turned to his aide and said, " You see how it is with men; they will always prefer the known way to the unknown. It is characteristic of people to be afraid of the undefined. Yet I gave him choice."
“What lies beyond the Black Door?" asked the aide.
"Freedom", replied the general. "And I've known only a few men brave enough to take it."
The Black Door - Author Unknown.


--- layout: post title: "Retiring old service versions" description: "A few ideas on how to retire old versions of a web service." date: 2020-06-01 9:36 UTC tags: [Services] image: "/content/binary/reverse-proxy-based-delay.png" image_alt: "Sequence diagram of a client, reverse proxy, and application server." --- {% include JB/setup %}
{{ page.description }}
I was recently listening to a .NET Rocks! episode on web APIs, and one of the topics that came up was how to retire old versions of a web service. It's not easy to do, but not necessarily impossible.
The best approach to API versioning is to never break compatibility. As long as there's no breaking changes, you don't have to version your API. It's rarely possible to completely avoid breaking changes, but the fewer of those that you introduce, the fewer API version you have to maintain. I've previously described how to version REST APIs, but this article doesn't assume any particular versioning strategy.
Sooner or later you'll have an old version that you'd like to retire. How do you do that?
First, take a minute to understand why some clients keep using old versions of your API. It may be obvious, but I meet enough programmers who never give incentives a thought that I find it worthwhile to point out.
When you introduce a breaking change, by definition this is a change that breaks clients. Thus, upgrading from an old version to a newer version of your API is likely to give client developers extra work. If what they have already works to their satisfaction, why should they upgrade their clients?
You might argue that your new version is 'better' because it has more features, or is faster, or whatever it is that makes it better. Still, if the old version is good enough for a particular purpose, some clients are going to stay there. The client maintainers have no incentives to upgrade. There's only cost, and no benefit, to upgrading.
Even if the developers who maintain those clients would like to upgrade, they may be prohibited from doing so by their managers. If there's no business reason to upgrade, efforts are better used somewhere else.
Web services exist in various contexts. Some are only available on an internal network, while others are publicly available on the internet. Some require an authentication token or API key, while others allow anonymous client access.
With some services, you have a way to contact every single client developer. With other services, you don't know who uses your service.
Regardless of the situation, when you wish to retire a version, you should first try to give clients advance warning. If you have an address list of all client developers, you can simply write them all, but you can't expect that everyone reads their mail. If you don't know the clients, you can publish the warning. If you have a blog or a marketing site, you can publish the warning there. If you run a mailing list, you can write about the upcoming change there. You can tweet it, post it on Facebook, or dance it on TikTok.
Depending on SLAs and contracts, there may even be a legally valid communications channel that you can use.
Give advance warning. That's the decent thing to do.
Even with advance warning, not everyone gets the message. Or, even if everyone got the message, some people deliberately decide to ignore it. Consider their incentives. They may gamble that as long as your logs show that they use the old version, you'll keep it online. What do you do then?
You can, of course, just take the version off line. That's going to break clients that still depend on that version. That's rarely the best course of action.
Another option is to degrade the performance of that version. Make it slower. You can simply add a constant delay when clients access that service, or you can gradually degrade performance.
Many HTTP client libraries have long timeouts. For example, the default HttpClient timeout is 100 seconds. Imagine that you want to introduce a gradual performance degradation that starts at no delay on June 1, 2020 and reaches 100 seconds after one year. You can use the formula d = 100 s * (t - t0) / 1 year
, where d
is the delay, t
is the current time, and t0
is the start time (e.g. June 1, 2020). This'll cause requests for resources to gradually slow down. After a year, clients still talking to the retiring version will begin to time out.
You can think of this as another way to give advance warning. With the gradual deterioration of performance, users will likely notice the long wait times well before calls actually time out.
When client developers contact you about the bad performance, you can tell them that the issue is fixed in more recent versions. You've just given the client organisation an incentive to upgrade.
Another option is to deliberately make the service err now and then. Randomly return a 500 Internal Server Error
from time to time, even if the service can handle the request.
Like deliberate performance degradation, you can gradually make the deprecated version more and more unreliable. Again, end users are likely to start complaining about the unreliability of the system long before it becomes entirely useless.
One of the many benefits of HTTP-based services is that you can put a reverse proxy in front of your application servers. I've no idea how to configure or operate NGINX or Varnish, but from talking to people who do know, I get the impression that they're quite scriptable.
Since the above ideas are independent of actual service implementation or behaviour, it's a generic problem that you should seek to address with general-purpose software.
Imagine having a general-purpose reverse proxy that detects whether incoming HTTP requests are for the version you'd like to retire (version 1 in the diagram) or another version. If the proxy detects that the request is for a retiring version, it inserts a delay before it forward the request to the application server. For all requests for current versions, it just forwards the request.
I could imagine doing something similar with failure injections.
All of the above are only ideas. If you can use them, great. Consider the implications, though. You may be legally obliged to keep an SLA. In that case, you can't degrade the performance or reliability below the SLA level.
In any case, I don't think you should do any of these things lightly. Involve relevant stakeholders before you engage in something like the above.
Legal specialists are as careful and conservative as traditional operations teams. Their default reaction to any change proposal is to say no. That's not a judgement on their character or morals, but simply another observation based on incentives. As long as everything works as it's supposed to work, any change represents a risk. Legal specialists, like operations teams, are typically embedded in incentive systems that punish risk-taking.
To counter other stakeholders' reluctance to engage in unorthodox behaviour, you'll have to explain why retiring an old version of the service is important. It works best if you can quantify the reason. If you can, measure how much extra time you waste on maintaining the old version. If the old version runs on separate hardware, or a separate cloud service, quantify the cost overhead.
If you can't produce a compelling argument to retire an old version, then perhaps it isn't that important after all.
Server logs can be useful. They can tell you how many requests the old version serves, which IP addresses they come from, at which times or dates you have most traffic, and whether the usage trend is increasing or decreasing.
These measures can be used to support your argument that a particular version should be retired.
Versioning web services is already a complex subject, but once you've figured it out, you'll sooner or later want to retire an old version of your API. If some clients still make good use of that version, you'll have to give them incentive to upgrade to a newer version.
It's best if you can proactively make clients migrate, so prioritise amiable solutions. Sometimes, however, you have no way to reach all client developers, or no obvious way to motivate them to upgrade. In those cases, gentle and gradual performance or reliability degradation of deprecated versions could be a way.
I present these ideas as nothing more than that: ideas. Use them if they make sense in your context, but think things through. The responsibility is yours.
Comments
Hi Mark. As always an excellent piece. A few comments if I may.
An assumption seems to be, that the client is able to update to a new version of the API, but is not inclined to do so for various reasons. I work with organisations where updating a client if nearly impossible. Not because of lack of will, but due to other factors such as government regulations, physical location of client, hardware version or capabilities of said client to name just a few.
We have a tendency in the software industry to see updates as a question of 'running Windows update' and then all is good. Most likely because that is the world we live in. If we wish to update a program or even an OS, it is fairly easy even your above considerations taken into account.
In the 'physical' world of manufacturing (or pharmacy or mining or ...) the situation is different. The lifetime of the 'thing' running the client is regularly measured in years or even decades and not weeks or months as it is for a piece of software.
Updates are often equal to bloating of resource requirements meaning you have to replace the hardware. This might not always be possible again for various reasons. Cost (company is pressed on margin or client is located in Outer Mongolia) or risk (client is located in Syria or some other hotspot) are some I've personally come across.
REST/HTTP is not used. I acknowledge that the original podcast from .NET Rocks! was about updating a web service. This does not change the premises of your arguments, but it potentially adds a layer of complication.


referenced
by Eliot Jordan at 2022-07-15 15:50:45.merged
by Eliot Jordan at 2022-07-15 15:50:45.closed
by Eliot Jordan at 2022-07-15 15:50:45.referenced
by Eliot Jordan at 2022-07-15 15:55:43.merged
by Eliot Jordan at 2022-07-15 15:55:43.closed
by Eliot Jordan at 2022-07-15 15:55:43.head_ref_deleted
by Eliot Jordan at 2022-07-15 15:55:46.assigned
by Eliot Jordan at 2022-07-15 21:24:30.renamed
by None at 2022-07-15 21:18:50.renamed
by None at 2022-07-15 21:19:17.assigned
by Eliot Jordan at 2022-07-15 21:24:41.referenced
by Trey Pendragon at 2022-07-14 22:34:05.merged
by Trey Pendragon at 2022-07-14 22:34:05.closed
by Trey Pendragon at 2022-07-14 22:34:05.head_ref_deleted
by Trey Pendragon at 2022-07-14 22:34:05.closed
by Trey Pendragon at 2022-07-14 22:34:10.referenced
by Trey Pendragon at 2022-07-14 22:34:23.merged
by Trey Pendragon at 2022-07-14 22:34:23.closed
by Trey Pendragon at 2022-07-14 22:34:23.head_ref_deleted
by Trey Pendragon at 2022-07-14 22:34:24.closed
by Trey Pendragon at 2022-07-14 22:34:28.referenced
by Trey Pendragon at 2022-07-14 22:34:42.merged
by Trey Pendragon at 2022-07-14 22:34:42.closed
by Trey Pendragon at 2022-07-14 22:34:42.head_ref_deleted
by Trey Pendragon at 2022-07-14 22:34:43.referenced
by Trey Pendragon at 2022-07-14 23:04:08.merged
by Trey Pendragon at 2022-07-14 23:04:08.closed
by Trey Pendragon at 2022-07-14 23:04:08.head_ref_deleted
by Trey Pendragon at 2022-07-14 23:04:09.closed
by None at 2022-07-15 13:26:26.A rough estimate of scanned resources from Alma:
figgy_production=# select COUNT(*) from orm_resources WHERE metadata @> '{"source_metadata_identifier": []}' AND metadata->'source_metadata_identifier'->>0 LIKE '99%';
count
-------
78688
I think that means we could do a full refresh every day and be fine - almost two.
referenced
by Eliot Jordan at 2022-07-15 17:13:58.merged
by Eliot Jordan at 2022-07-15 17:13:58.closed
by Eliot Jordan at 2022-07-15 17:13:59.head_ref_deleted
by Eliot Jordan at 2022-07-15 17:13:59.Here's the original BL issue about the search param deprecations (took some digging to find) https://github.com/projectblacklight/blacklight/issues/2683
referenced
by None at 2022-07-15 18:28:12.assigned
by None at 2022-07-15 18:30:39.referenced
by Eliot Jordan at 2022-07-15 21:10:02.merged
by Eliot Jordan at 2022-07-15 21:10:02.closed
by Eliot Jordan at 2022-07-15 21:10:02.head_ref_deleted
by Eliot Jordan at 2022-07-15 21:10:02.referenced
by Eliot Jordan at 2022-07-15 21:10:43.merged
by Eliot Jordan at 2022-07-15 21:10:43.closed
by Eliot Jordan at 2022-07-15 21:10:43.head_ref_deleted
by Eliot Jordan at 2022-07-15 21:10:44.head_ref_force_pushed
by Eliot Jordan at 2022-07-15 18:45:44.deployed
by None at 2022-07-15 19:46:19.labeled
by Eliot Jordan at 2022-07-15 17:15:24.assigned
by Eliot Jordan at 2022-07-15 17:15:25.closed
by Eliot Jordan at 2022-07-15 21:14:01.There's another one of these in the structure node view
Found another one in monograms/index.html.erb
@eliotjordan I can add to the open PR
@eliotjordan that one looks done already?
Ooops. Yep. I was on an old branch.
reopened
by None at 2022-07-15 13:24:16.assigned
by None at 2022-07-15 14:58:23.referenced
by None at 2022-07-15 15:28:42.mentioned
by Eliot Jordan at 2022-07-15 15:45:54.subscribed
by Eliot Jordan at 2022-07-15 15:45:55.mentioned
by Eliot Jordan at 2022-07-15 15:46:24.subscribed
by Eliot Jordan at 2022-07-15 15:46:24.closed
by Eliot Jordan at 2022-07-15 21:14:12.head_ref_force_pushed
by Eliot Jordan at 2022-07-15 21:09:04.head_ref_force_pushed
by Eliot Jordan at 2022-07-15 21:11:13.ready_for_review
by Eliot Jordan at 2022-07-15 21:11:23.head_ref_force_pushed
by Eliot Jordan at 2022-07-15 21:12:18.Thank you for your patience regarding my progress on this. Regarding my updates for this issue, I have the following:
The form has the ability to attach up to 20 files, of < 100Mb each
I need to ensure that this validation for up to 20 files is in place, however https://github.com/pulibrary/pdc_describe/pull/220 ensures that multiple files can be updated and replaced
Files that are submitted will be stored in the pre-curation S3 bucket for now. [...] AWS S3 Buckets should use environment variables for the staging and production environments
I am addressing this in the next pull request(s)
The files are visible and downloadable from the show screen There is a clear difference between pre-curated data and post-curated data Once pre-curated data has been submitted, it is visible in a pre-curated data section on the dataset show page
The files themselves are visible, however, there needs to be clearer disambiguation between pre-curated and curated data
It was clarified during a meeting held on 07/15/22 that the files stored on disk must be human-readable, and stored within a human- navigable directory tree.
renamed
by Bess Sadler at 2022-07-15 16:56:56.ready_for_review
by Bess Sadler at 2022-07-15 16:58:21.referenced
by Hector Correa at 2022-07-15 17:35:35.merged
by Hector Correa at 2022-07-15 17:35:35.closed
by Hector Correa at 2022-07-15 17:35:35.head_ref_deleted
by Hector Correa at 2022-07-15 17:35:36.This now addressing disambiguating uncurated
from curated file uploads in the UI. Please let me know should the phrasing for this need to be updated.
renamed
by James R. Griffin III at 2022-07-15 13:34:22.head_ref_force_pushed
by James R. Griffin III at 2022-07-15 13:35:38.head_ref_force_pushed
by James R. Griffin III at 2022-07-15 13:47:55.renamed
by James R. Griffin III at 2022-07-15 13:48:14.ready_for_review
by James R. Griffin III at 2022-07-15 13:48:20.assigned
by James R. Griffin III at 2022-07-15 13:48:31.referenced
by Hector Correa at 2022-07-15 17:42:36.merged
by Hector Correa at 2022-07-15 17:42:36.closed
by Hector Correa at 2022-07-15 17:42:36.head_ref_deleted
by Hector Correa at 2022-07-15 17:42:37.deployed
by None at 2022-07-15 18:12:13.referenced
by Bess Sadler at 2022-07-15 18:29:13.merged
by Bess Sadler at 2022-07-15 18:29:13.closed
by Bess Sadler at 2022-07-15 18:29:14.head_ref_deleted
by Bess Sadler at 2022-07-15 18:29:14.This was implemented via https://github.com/pulibrary/pdc_describe/pull/216
closed
by Hector Correa at 2022-07-15 18:55:57.I could not get the JSON schema working, so went with the XML, which means we are already using 4.4.
closed
by Bess Sadler at 2022-07-15 20:01:51.assigned
by James R. Griffin III at 2022-07-15 21:01:23.I saw the same parameters as everyone else. I do not think the VM is at risk of running out of disk space - it has plenty of available space.
The spreadsheet was generated out of vSphere, and according to John, the values for disk usage in vSphere/VMware relate to the space the entire VM occupies on the host. Even though the 40GB disk is thin-provisioned, the VM is currently "taking up" 37 of those 40GB.
closed
by Alicia Cozine at 2022-07-15 20:36:00.referenced
by Trey Pendragon at 2022-07-14 22:32:49.merged
by Trey Pendragon at 2022-07-14 22:32:49.closed
by Trey Pendragon at 2022-07-14 22:32:49.head_ref_deleted
by Trey Pendragon at 2022-07-14 22:32:50.labeled
by Kevin Reiss at 2022-07-15 21:40:40.labeled
by Kevin Reiss at 2022-07-15 21:40:40.referenced
by Christina Chortaria at 2022-07-15 12:00:09.merged
by Christina Chortaria at 2022-07-15 12:00:09.closed
by Christina Chortaria at 2022-07-15 12:00:09.head_ref_deleted
by Christina Chortaria at 2022-07-15 12:00:10.deployed
by None at 2022-07-14 22:46:19.head_ref_force_pushed
by Jane Sandberg at 2022-07-15 19:13:03.@eliotjordan correct -- this image didn't work on silicon macbooks when built with the previous instructions.
The current commands have worked for @christinach and me on Intel macbooks. I wonder if it could be a docker version issue?
labeled
by Eliot Jordan at 2022-07-15 18:16:00.mentioned
by Jane Sandberg at 2022-07-15 18:16:01.subscribed
by Jane Sandberg at 2022-07-15 18:16:01.mentioned
by Eliot Jordan at 2022-07-15 19:44:25.subscribed
by Eliot Jordan at 2022-07-15 19:44:25.mentioned
by Christina Chortaria at 2022-07-15 19:44:26.subscribed
by Christina Chortaria at 2022-07-15 19:44:26.I'm not the most qualified to review for technical accuracy but I think the draft looks nice!
labeled
by Kevin Reiss at 2022-07-15 18:29:51.


PIG DICE GAME
Welcome to the pig Dice
DICE RULES:-
- There must be players
- player rolls the dice and scores points untill he/she scores one.If score is one,the dice is passed to the next player
- when the score is one he looses all the scores except the ones that he/she had hold.
- when the scores on the hold exceeds or equal to 100,the player becomes the winner
- The game ends
Player one:-
rollDice:-
totalSum1:-
currentScore1:-
Player two:-
rollDice:-
totalSum2:-
currentScore2:-
BIG UP!
You won the game!!
Copyright© 2019


Toggle navigation
?
Home
(current)
Orbit view
Welcome to
AstroMine
.
Our project
Orbit Views
Technology
Future Prospects


This is a design company, and we are skilled in creating beautiful designs in our graphics and animations for use in entertainment, advertisement and TV commercials.
We pay attention to details to create a well crafted design for our customers to use and present their businesses to the public. Whether you are an existing business or a start-up, you can market your products and services digitally.
We offer comprehensive services designed to allow the company to do whatever it takes to satisfy our customers.
We are focused on a wide variety of design fields and we render the best quality design services to our customers.
Now is the age of computers and the internet has made this world a global village. Almost all sorts of information can be collected from millions of websites on internet and this is where we come in with our designers and developers who are skilled in creating interactive websites to showcase your business contents.
We design logos, banners, fliers etc
We design responsive websites to view accross the main platforms
We design and develop apps to improve your customer service
We design and draw graphic illustrations
We can create cartoons and animations for your business presentation
We model and create 3d animations for movie and commercials. We also create Architectural Visualizations
Noise reduction and vocal removal as well as creation of soundtracks
Captivating motion graphics and visual effects
Photoshop retouch and things like colour change in your photos
This is a sample business app for the digital design company called Dmt design tech
Version 1.0.1
Website is "www.dmtdesigntech.com.ng
© 2017 dmtdesigntech all rights reserved


|
Bullet Collision Detection & Physics Library
|
btSubsimplexConvexCast implements Gino van den Bergens' paper "Ray Casting against bteral Convex Objects with Application to Continuous Collision Detection" GJK based Ray Cast, optimized version Objects should not start in overlap, otherwise results are not defined. More...
#include <btSubSimplexConvexCast.h>
Public Member Functions | |
| btSubsimplexConvexCast (const btConvexShape *shapeA, const btConvexShape *shapeB, btSimplexSolverInterface *simplexSolver) | |
| virtual bool | calcTimeOfImpact (const btTransform &fromA, const btTransform &toA, const btTransform &fromB, const btTransform &toB, CastResult &result) |
| SimsimplexConvexCast calculateTimeOfImpact calculates the time of impact+normal for the linear cast (sweep) between two moving objects. More... | |
| Public Member Functions inherited from btConvexCast | |
| virtual | ~btConvexCast () |
Private Attributes | |
| btSimplexSolverInterface * | m_simplexSolver |
| const btConvexShape * | m_convexA |
| const btConvexShape * | m_convexB |
btSubsimplexConvexCast implements Gino van den Bergens' paper "Ray Casting against bteral Convex Objects with Application to Continuous Collision Detection" GJK based Ray Cast, optimized version Objects should not start in overlap, otherwise results are not defined.
Definition at line 27 of file btSubSimplexConvexCast.h.
| btSubsimplexConvexCast::btSubsimplexConvexCast | ( | const btConvexShape * | shapeA, |
| const btConvexShape * | shapeB, | ||
| btSimplexSolverInterface * | simplexSolver | ||
| ) |
Definition at line 24 of file btSubSimplexConvexCast.cpp.
|
virtual |
SimsimplexConvexCast calculateTimeOfImpact calculates the time of impact+normal for the linear cast (sweep) between two moving objects.
Precondition is that objects should not penetration/overlap at the start from the interval. Overlap can be tested using btGjkPairDetector.
take relative motion
Just like regular GJK only add the vertex if it isn't already (close) to current vertex, it would lead to divisions by zero and NaN etc.
Implements btConvexCast.
Definition at line 32 of file btSubSimplexConvexCast.cpp.
|
private |
Definition at line 30 of file btSubSimplexConvexCast.h.
|
private |
Definition at line 31 of file btSubSimplexConvexCast.h.
|
private |
Definition at line 29 of file btSubSimplexConvexCast.h.


I am looking for help with a casting build with at least 20 wiz/sorc lvls and the ac would have the help of items i already have on a persistant world that include +7 armor ac +7 natural ac +7 dodge and +7 deflection so thats 28 ac right there.. If the build has already been done, that's awesome just show me the way. Otherwise i'm looking for your ideas because i've been tinkering alot and just think i must be missing something... thanks so much in advance and I look foreward to your post!
Cheers, _________________ gwen'eth moonthistle
your only real chance is sorc/rdd/pm (since you have the tumble already). Usin imp expertise is 10.. so you have at least 48 ac. The only thing you did was make it impossible for everything else (as far as i can tell). Taking pm to 28 gives +16 ac.. so you have now 76 or so. BUt that leaves 12 lvls left. you need 3 sorc lvls to qual for rdd, leavin 9 for rdd.. so +3 ac.. 79?? with armor skin you can get 81. Using fp is 8, tower is 3, that gives 92... LOL
BUT! the build ISNT what you askd for, so what you want is impossible, from what i can tell (unless you can find +10 itms).
So, the question you have to ask yourself is, what is more important: ac or caster abilities? Havin a lv 3 sorc with 100 ac may be nice, but im not sure what for!


W.A.R.
Money:
Turn:
Next Turn
Toggle Labels
City Details
Army Details
Army Details
Name:
General:
Units:
Back
Battle
General:
Units:
General:
Units:
Back
Fight
Retreat
Victory
Loss
General:
Units:
Loss:
General:
Units:
Loss:
Back
⇑
⇓
Upgrade City Hall
City Hall level:
Population:
Back
Troops exchange window
Units:
General:
⇒
⇐
Units:
General:
Back


Experiments with watercolor, embroidery, 3d prints, installations and macrame. Some of my art is on society6.


- M. Chilukuri and S. Jung, “A Mixed-Mode Variable Gain Amplifier for Hearing Aid Devices,” IEEE Dallas Circuits
and Systems Conference, November, 2018.
- M. Chilukur, S. Jung, and K. Ryoo, “A Low Power and Low Noise Preamplifier Circuit for Hearing Aid Devices,”
IEEE Dallas Circuits and Systems Conference, October, 2016.
- U. Mahendran, S. Jung, K. Ryoo, and S. Pyo, “A Switched Capacitor based Transimpedance Amplifier for Detection
of HAB using an Optical Sensor,” IEEE Dallas Circuits and Systems Conference, October, 2016.
- M. Chilukuri, and S. Jung, “A High Frequency Memristor Emulator Circuit,” IEEE Dallas Circuits and Systems
Conference, pp. 1-4, October, 2015.
- H. Zamankhan, S. Jung, S.-Y. Cho, J.-M. Park, H. Choi, “Comparison between Various Observing Systems for
Monitoring Harmful Algal Blooms and Preliminary Concept of Innovative Sensing Network for In-Situ Monitoring of
Biological Toxins”, Special Symposium on Advances in Sensing Technologies for Real-Time and Remote Monitoring of
Water Quality, The 250th American Chemical Society (ACS) National Meeting, August, 2015.
- H. Zamankhan, S. Jung, H. Choi, “In Situ Monitoring of Biological Toxins in Harmful Algal Blooms: Sensing
Network Demonstration”, at Texas Water 2014, April, 2014, Dallas, TX.
- H. Z. Malayeri, S. Jung, and H. Choi, “In situ monitoring of microcystins for the evaluation of harmful algal
blooms,” 247th ACS National Meeting and Exposition, March, 2014.
- V. Shenoy, S. Jung, K. Ryoo, and H. Kim, “A 24 GHz Low Noise Amplifier for Short Range UWB Automotive Radar,”
IEEE Texas Symposium on Wireless & Microwave Circuits & System, April, 2013.
- S. Raavi, B. Arigong, R. Zhou, S. Jung, M. Jin, H. Zhang, and H. Kim, “An Optical Wireless Power Transfer System
for Rapid Charging,” IEEE Texas Symposium on Wireless & Microwave Circuits & System, April, 2013.
- H. Kim and S. Jung, “Dual-Band Class-E RF PA Design utilizing Complex Impedance Transformers,” IEEE Texas
Symposium on Wireless & Microwave Circuits & System, April, 2013.
- J. LI, S. Jung, Y. Joo, and P. Gui, “A Current-Steering DAC-Based CMOS Ultra-Wideband Transmitter with Bi-Phase
Modulation,” IEEE ISCAS, pp. 2545-2548, May, 2012.
- S. Koppa, D. Park, Y. Joo, and S. Jung, “A 105.6dB DR and 65dB Peak SNR Self-Reset CMOS Image Sensor Using a
Schmitt Trigger Circuit,” IEEE MWSCAS, pp. 1-4, August, 2011.
- V. Shenoy, D. McBride, and S. Jung, “A High Fill-Factor High-SNR CMOS Image Sensor for IR Camera Applications,”
Proc. of SPIE, vol. 8012, 80120J, April, 2011.
- J. Li, S. Jung, M. Lu, and K. Min, “A CMOS Ultra-Wideband Transmitter with Bi-Phase Modulation for 22-29 GHz
Vehicular Radar Application,” IEEE MWSCAS, pp. 449-452, August, 2010.
- N. Karandikar, S. Jung, P. Gui, and Y. Joo, “Design of an Analog Correlator for 22-29GHz UWB Vehicular Radar
System Using Improved High Gain Multiplier Architecture,” IEEE MWSCAS, pp. 930-933, August, 2010.
- H. Kim, Y. Joo, and S. Jung, “Analytical Model of Pulse Combined UWB Pulse Generator,” IEEE International
Symposium on Communication and Information Technology, pp. 1413-1418, September, 2009.
- J. Li, S. Jung, M. Lu, P. Gui, and Y. Joo, “A Current-Steering DAC-Based CMOS Ultra-Wideband Impulse Generator,”
IEEE International Symposium on Communication and Information Technology, pp. 971-975, September, 2009.
- H. Kim, Y. Joo, and S. Jung, “A Tunable Pulse Generator for Sub-GHz UWB Systems,” IEEE MWSCAS, pp. 292-296,
August, 2009.
- P. Zhu, W. Chen, D. Wu, P. Gui, S. Jung, “A TID Tolerant, Wide Band and Low Jitter Phase-Locked Loop in 0.25um
CMOS Silicon-on-Sapphire Technology”, IEEE Nuclear and Space Radiation Effects (NSREC), presented, July, 2009.
- J. Li, M. Lu, S. Jung and K. Min, “A CMOS Ultra-Wideband Impulse Generator for 22-29 GHz Automotive Radar
Applications,” IEEE Radar Conference, pp. 1-4, May, 2009.
- S. Sha, V. Shenoy, M. Lu, S. Jung, K. Min, and S. Lee, “A hardware architecture for time reversal of short
impulses based on frequency domain approach,” Proc. of SPIE, Vol. 7308, pp. 73080T-1-73080T-9, April, 2009.
- V. Shenoy, S. Sha, S. Jung, and M. Lu, “A Circuit Implementation for Time-Reversal of Short Impulses,” IEEE
APMC, pp. 1-4, December, 2008.
- T. Merkin, J.C. Li, S. Jung, M. Lu, J. Gao, and S. Lee, “A 100-960 MHz CMOS Ultra-Wideband Low Noise Amplifier,
IEEE Midwest Symposium on Circuits and Systems, pp. 141-144, August, 2008.
- V. Shenoy, P. Kalkura, S. Jung, M. Lu, J. Gao, and S. Lee, “A Dual Slope based Pulse Position Modulation for
sub-GHz IR-UWB Systems,” IEEE Midwest Symposium on Circuits and Systems, pp. 846-849, August, 2008.
- M. Lu, J. W. Bredow, S. Jung, and S. Tjuatja, “On the Well-Posedness of Integral Equations Associated with
Cavity Green’s Functions around Resonant Frequency,” IEEE AP-S International Symposium on Antennas and
Propagation, pp. 1-4, July, 2008.
- N. Thakoor, J. Gao, and S. Jung, "Real time planar surface segmentation in disparity space," IEEE Workshop on
Embedded Computer Vision, pp. 1-8, June, 2007.
- M. Lu, J. Bredow, S. Jung, and S. Tjuatja, “Theoretical and Experimental Study of a Quasi-Planar Conical
Antenna,” IEEE International Symposium on Antenna and Propagation, pp. 4777-4780, June, 2007.
- M. Lu, J. Bredow, S. Jung, and S. Tjuatja, “On the Resonant Singularities Associated with the Green’s Functions
of Metallic Rectangular Cavities in the Context of the Method of Moments,” IEEE International Symposium on
Antenna and Propagation, pp. 2793-2796, June, 2007.
- M. Lu, N.-W. Chen, J. Bredow, S. Jung, and S. Tjuatja, “Study of Photonic Crystals at Millimeter Wave Band,”
IEEE International Symposium on Antenna and Propagation, pp. 177-180, June, 2007.
- V. Shenoy, H. Shanmugasundaram, S. Jung, J. Gao, and Y. Joo, “CMOS Optical Transimpedance Amplifier Design for
PAM Application,” IASTED, pp. 70-73, Nov., 2006.
- T. Merkin, S. Jung, J. Gao, and Y. Joo, “A CMOS Ultra-Wideband Differential Low Noise Amplifier,” IEEE APMC, pp.
417-420, Dec., 2006.
- N. Thakoor, J. Gao, and S. Jung, "Detecting occlusion for hidden Markov modeled shapes," Proc. IEEE
International Conference on Image Processing, pp. 945-948, Oct, 2006.
- H. Kim, Y. Joo, and S. Jung, “A Tunable CMOS UWB Pulse Generator,” IEEE Conference on Ultra Wideband,
pp.109-112, September, 2006.
- T. Merkin, S. Jung, S. Tjuatja, Y. Joo, D. Park, and J-B Lee, “An Ultra-Wideband Low Noise Amplifier with
Air-suspended RF MEMS Inductors,” IEEE Conference on Ultra Wideband, pp. 459-464, September, 2006.
- S-C. Chang, S. Jung, S. Tjuatja, J. Gao, and Y. Joo, “A CMOS 5th Derivative Impulse Generator for an IR-UWB
Transmitter,” IEEE MWSCAS, vol. 2, pp. 376-380, August, 2006.
- N. Thakoor, J. Gao, and S. Jung, "Occlusion resistant shape classifier based on warped optimal path matching,"
Proceedings of IEEE International Conference on Pattern Recognition, pp. 60-63, August. 20-24, 2006.
- D. Maxwell, S. Jung, Y. Joo, J. Gao, and H. Doh, “A Two-Stage Cascode CMOS LNA for UWB Wireless Systems”, IEEE
Midwest Symposium on Circuits and Systems, pp. 627-630, August, 2005.
- H. Kim, S. Jung, and Y. Joo, “Digitally Controllable Bi-Phase CMOS UWB Pulse Generator,” IEEE International
Conference on Ultra-Wideband, pp. 442-445, September, 2005.
- N. Thakoor, J. Gao, S. Jung, “Generalized Probabilistic Decent Method based Minimum Error Shape Classification
using Hidden Markov Models,” IEEE ICME, pp. 342-345, July, 2005.
- J. Gao, N. Thakoor, and S. Jung, “A Motion Field Reconstruction Scheme for Smooth Boundary Video Object
Segmentation,” IEEE International conference on image processing (ICIP), Vol. 1, pp. 381-384, Oct., 2004.
- H. Liu, X. Lin, Y. Kim, J. Liu, and S. Jung, “Electronic Dispersion compensation for 10 Gbps Data Transmission
over Multi-mode Fibers,” IEEE Dallas CAS Workshop, pp. 159-162, September, 2004.
- S. Jung, J. Gao, and J. Liu, "CMOS Multi-level Signal Transmitter for Optical Communication," IEEE Midwest
Symposium on Circuits and Systems 2004, pp. II-185 – II-188, July 2004.
- Y. Jeong, H. Doh, S. Jung, D. Park, and J. Lee, "CMOS VCO & LNA Implemented by Air-Suspended On-Chip RF MEMS
LC," IEEE Midwest Symposium on Circuits and Systems, pp. I-373 – I-376, July, 2004.
- H. Doh, Y. Jeong, S. Jung, and Y. Joo, "Design of CMOS UWB Low Noise Amplifier with CMOS Feedback," IEEE Midwest
Symposium on Circuits and Systems 2004, pp. II-641 – II-644, July, 2004.
- S. Nazar, B. A. Shirazi, and S. Jung, “Performance/Energy efficiency analysis of register files in superscalar
processors”, The International Conference on VLSI, pp. 325 – 331, June, 2004.
- S. Vishwakarma, S. Jung, Y. Joo, “Ultra Wideband CMOS Low Noise Amplifier with Active Input Matching,” IEEE
Conference on Ultra Wideband Systems and Technologies, pp 415 – 419, May, 2004.
- Y. Jeong, J. Liu and S. Jung, “A CMOS Impulse Generator for UWB Wireless Communication System,” Proceedings of
2004 IEEE International Symposium on Circuit and Systems, pp. IV-129 – IV-132, May, 2004.
- D.L. Geddis, S.R. Hyun, J. Chang, S. Jung, M.A. Brooke, N.M. Jokerst, “Single fiber Bi-directional links using
3D stacked thin film emitters and detectors integrated onto CMOS transceiver circuits”, IEEE Conference on
Lasers and Electro-Optics, Vol. 2, pp. 270-271, May, 2004.
- G. Zhang, J. Liu, and S. Jung, “An accurate current source with on-chip self-calibration circuits for
low-voltage differential transmitter drivers”, IEEE ISCAS, Vol. 2, pp. II-192 -II-195, May, 2003.
- S. Jung, M. A. Brooke, and N. M. Jokerst, “Packaging Considerations for a 1 Gbps Si CMOS Optical Driver,” IEEE
LEOS Annual Meeting, November, 2000.
- N.M. Jokerst, M.A. Brooke, J. Laskar, D.S. Wills, A.S. Brown, O. Vendier, S. Bond, M. Vrazel, R. Huang, M.
Thomas, H. Kuo, S. Cho, S. Jung, Y.J. Joo, J.J. Chang, “Smart photonic links: Optoelectronics devices integrated
with circuits and interconnection substrates, ” Digest of the Optical Society of America Annual Meeting, pp. 94,
October, 2000.
- N.M. Jokerst, M.A. Brooke, J. Laskar, D.S. Wills, A.S. Brown, O. Vendier, S. Bond, J. Cross, M. Vrazel, M.
Thomas, M. Lee, S. Jung, Y.J. Joo, J.J. Chang, “Smart photonics: Optoelectronics integrated with Si CMOS VLSI
circuits, ” Proceedings of the SPIE Special Symposium on the Future of Computing, Vol. 4109, pp. 241-251, July,
2000.
- J. Chang, S. Jung, M. Vrazel, K. Jung, M. Lee, M. A. Brooke, N. M. Jokerst, and S. Wills, “Mixed Signal Hybrid
OEICs: An InP I-MSM Integrated Onto a Mixed Signal CMOS Analog Optical Receiver with a Digital CMOS
Microprocessor,” Proceedings of the Optics in Computing Conference, May, 2000.
- J. Chang, S. Jung, M. Vrazel, K. Jung, M. A. Brooke, and N. M. Jokerst, “Hybrid Optically Interconnected
Microprocessor: An InP I-MSM Integrated Onto a Mixed Signal CMOS Analog Optical Receiver with a Digital CMOS
Microprocessor,” Proceedings of the SPIE, Vol. 4089, pp. 708-714, 2000.
- N.M. Jokerst, M.A. Brooke, J. Laskar, D.S. Wills, A.S. Brown, O. Vendier, S. Bond, J. Cross, M. Vrazel, M.
Thomas, M. Lee, S. Jung, Y.J. Joo, J.J. Chang, “Smart photonics: Optoelectronics integrated onto Si CMOS
circuits, ” IEEE Lasers and Electro-Optics Society 12th Annual Meeting, Vol. 2, pp. 423-424, November, 1999.
- J. Chang, M. Lee, S. Jung, M. Brooke, N. Jokerst, and D. Wills, “Fully Differential Current-Input CMOS Amplifier
Front-End Suppressing Mixed Signal Substrate Noise for Optoelectronic Applications,” International Symposium on
Circuits and Systems, vol. 1, p. 327-330, June, 1999.
- S. W. Bond, S. Jung, O. Vendier, A. Lopez-Lagunas, S. Chai, G.a Dagnall, M. Brooke, N. Jokerst, D. Wills, and A.
Brown, “3D Stacked Si CMOS VLSI Smart Pixels using Through-Si Optoelectronic Interconnections,” Technical Digest
IEEE LEOS Summer topical meeting, pp. 27-28, July, 1998.


10-30 30-60 60-100
None one more
11-12yrs 12-13yrs 14yrs or later
19yrs or earlier 20-24yrs 25-29yrs none
none one more
white black


--- layout: default ---
This Code of Conduct applies to all Apiary Coding spaces, online and offline. Anyone who violates this Code of Conduct may be sanctioned, expelled and banned indefinitely from these spaces.
Apiary Coding is committed to providing a harrassment-free experience for everyone. We do not tolerate harrasment of participants in any form.
Harassment includes:
Apiary Coding prioritises marginalised people’s safety over privileged people’s comfort. We will not act on complaints regarding:
If you are being harassed by a member of Apiary Coding, notice anyone else being harassed, or have any other concerns, please contact us by emailing<EMAIL_ADDRESS>and we'll respond as promptly as we can.
This code of conduct applies to Apiary Coding spaces, but if you are being harassed by a member of Apiary Coding outside our spaces, we still want to know about it. We will take all good-faith reports of harassment by Apiary Coding members seriously.
This includes harassment outside our spaces and harassment that took place at any point in time. Apiary Coding reserves the right to exclude people from our spaces based on their past behavior, including behavior outside Apiary Coding spaces.
We reserve the right to reject any report we believe to have been made in bad faith. Reports intended to silence legitimate criticism may be deleted without response.


What is this?
Downloads
The main source catalog:
The basic source information from the input folder:
The basic paper information from the input folder
Browse
- You can use the navbar at the top to browse gamma-cat.
- This is mostly for maintainers to quickly look things up and help with data entry.
- A nice end-user interface will come soon at http://gamma-sky.net


{{< layout}} {{$pageTitle}}Required Documents{{/pageTitle}} {{$header}}
Before we can send your new passport we need to see extra documents.We’ll check and return them to you.
If the ceremony has already taken place you need to send:
If you want to change your name before the ceremony you need to send:
If your documents aren't in English or Welsh you also need to get a certified translation.


Contents of this page:
Different forms:
For and For Each statements are converted to an equivalent Python for block. Where the iteration is over an iterable object, the translation just uses the iterable. Where the VB statement is an iteration between two numbers, the vb2Py function vbForRange is used to match the behaviour.
| VB | Python |
|---|---|
|
|
| VB | Python |
|---|---|
|
|
There are no options specific to the For statement.


Last updated 29 August 2007
| Three slightly views of the W80, mod not identified. | ||
Click for large color version |
||
| W80-0 Mod | W80-1 Mod | |
|---|---|---|
ALCM being loaded |
W80 being handled on the ground |
The warhead proper is nearly identical in both the Mod 0 and Mod 1. There are some differences in the design of the fission primary (different grades of plutonium used, some differences in the high explosive assembly), and in the mounting and installation hardware for the different cruise missile bodies, but in little else.
The W80 is the warhead used on the three cruise missiles currently in the U.S. arsenal - the Mod 0 with the BGM-109 Tomahawk SLCM (sea launched cruise missile), the Mod 1 with the AGM-86B ALCM (air launched cruise missile) and the AGM-129 ACM (advanced cruise missile, an air launched weapon incorporating stealth technology). It is a light weight variable yield warhead.
| Available Yields (kt) | 5 / 150 |
|---|---|
| Weight | 290 lbs |
| Length | 31.4 in |
| Diameter | 11.8 in |
| Number In Active Service | Mod 0 (SLCM) 100 Mod 1 (ALCM) 1000 Mod 1 (ACM) 450 |
Two stage radiation implosion thermonuclear weapon.
The W80 is based on the W61 design, so the exterior appearance of the two warheads is probably very similar (if not identical). This is also true of other B61 derivatives: the W84 (in the inactive stockpile), the W81 (no longer in existence), and the W85 (converted to the B61).
The 5 kiloton low yield option presumably represents the boosted primary yield alone, while the high yield adds the full secondary yield . The lowest yield option available for the B61, 0.3 kt, is not available with the W80, presumably because a yield this low is of no strategic interest.
Arming and fuzing system weighs 10 pounds.
Here is a speculative interpretation of the design:
Primary Fissile Material:
Cruise missile, which may be launched by submarine, surface-ship, or aircraft (depending on mod and basing mode). Aircraft for the ALCM is now the B-52H and the B-2 Spirit. SLCMs are now slated for use on 26 Sturgeon-class, 62 Los Angeles-class, and 3 Sea Wolf-class submarines.
See Principles of Nuclear Weapons Security and Safety for explanations of these features.
Supergrade plutonium (which has low neutron emissions) is used in the Mod 0 to reduce occupational radiation exposure to submarine crews who are in close proximity to the weapons for long periods of time while on patrol.
Unknown
Designed and developed by Los Alamos National Laboratory (LANL)
This warhead suffered from an extremely serious problem that was not discovered until after production began. Since the ALCM is carried externally at high altitudes for inter-continental delivery, it is subjected to sub-freezing temperatures for long periods of time. Although PBX-9502 test samples had been fired at temperatures of -65 degrees, and the entire electrical system had been tested in sub-freezing environmental chambers, proof testing of an entire chilled warhead did not occur until after production began.
When a complete W80 was subjected to a low-temperature test in the Baseball shot (Operation Guardian) on 15 January 1981 20:25:00.90 (UCT), it gave only a fraction of the rated yield due to problems with the IHE. Further investigation showed that other B61 family warheads using IHE also suffered from this problem to varying degrees. Redesign and a second proof test (Jornada in Operation Praetorian, 28 January 1982 16:00:00.104 UCT) at -65 degrees F were required to resolve the problem.
| June 1976 | Development engineering begun at LANL (both mods) |
|---|---|
| January 1979 | Production engineering on W80-1 begins |
| January 1981 | First production units of the W80-1 completed |
| September 1981 | Initial deployment of ALCM with W80-1 |
| February 1982 | Quantity production of the W80-1 begins (after resolving the low temperature firing problem) |
| March 1982 | Production engineering on W80-0 begins |
| December 1983 | First production units of the W80-0 completed |
| March 1984 | Quantity production of the W80-0 begins |
| September 1990 | Production of both the W80-0 and W80-1 completed by this date |
Initial manufacture of W80-1 was January 1981
Initial deployment of W80-1 on ALCM was September 1981
Initial manufacture of W80-0 was December 1983
Initial deployment of W80-0 on SLCM was 1984
Initial deployment of W80-1 on ACM was 1991
1750 W80-1 warheads have been manufactured.
367 W80-0 warheads have been manufactured.
Currently in service (active stockpile):
1000 W80-1 on ALCM
450 W80-1 on ACM
100 W80-0 on SLCM (now stored ashore, none are normally deployed on ship)
Inactive:
361 W80-1
194 W80-0
Conversions and Retirements:


What is HDX?
The Humanitarian Data Exchange (HDX) is OCHA’s open platform for sharing humanitarian data. HDX’s objective is to make humanitarian data easy to find and easy to use for analysis.
What is humanitarian data?
1. Baseline / development data
2. Reference data (like CODs)
3. Situational data (needs or damage assessments, logistics)
4. Response data (3W, etc.)
Our short history
HDX was launched at the Open Knowledge Festival in Berlin.
Over 176,000 users visiting HDX since July 2014
About registered users
Approximately users per week visiting the site
Almost one every four () visitors downloads a dataset
organizations
What is metadata? Data about your data.
Why is metadata important?
- Searchability: Good tags and descriptions make your data more discoverable
- Trust: Our users have told us over and over how important it is to know how much they can trust the data.
- Fitness for use: The methods used to collect or process data may influence the suitability of the information for different purposes. Methodology!
- Usability: Without good documentation of license, methods and field names, users may be unable to make use of the data you’ve shared.
Open API


--- date: 2017-07-06T12:08:13+01:00 title: 'DOSE: Disease Ontology Semantic and Enrichment analysis' type: index weight: 1 ---
This package implements five methods proposed by Resnik, Schlicker, Jiang, Lin and Wang respectively for measuring semantic similarities among DO terms and gene products. Enrichment analyses including hypergeometric model and gene set enrichment analysis are also implemented for discovering disease associations of high-throughput biological data.
DOSE
is released within the Bioconductor project and the source code is hosted in GitHub.
Please cite the following article when using DOSE
:
Yu G, Wang L, Yan G and He QY*. DOSE: an R/Bioconductor package for Disease Ontology Semantic and Enrichment analysis. Bioinformatics, 2015, 31(4):608-609.
Find out more on Featured Articles.
Install DOSE
is easy, follow the guide in the Bioconductor page:
## try http:// if https:// URLs are not supported
source("https://bioconductor.org/biocLite.R")
## biocLite("BiocUpgrade") ## you may need this
biocLite("DOSE")
Find out details and examples on Documentation.


S
E
Qu
-
R
Am
A
"ruby reflection examples"
has
158
results in
5.781
seconds from
25
sites.
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
SEQu-RAmA Results 0...9
#0
Index
[~]
http://ruby-metaprogramming.rubylearning.com/html/ruby_ ...
Ask
[?]
Start
Next
#1
Index
[~]
http://blog.khd.me/blog/2008/12/19/ruby-reflection/
Ask
[?]
Start
Next
#2
Index
[~]
https://www.slideshare.net/nirusuma/introduction-to-rub ...
Ask
[?]
Start
Next
#3
Index
[~]
http://angrez.blogspot.com/2006/11/using-reflection-in- ...
Google.AU
[?]
Start
Next
#4
Index
[~]
https://stackoverflow.com/questions/1388055/need-help-w ...
Google.AU
[?]
Start
Next
#5
Index
[~]
https://www.slideshare.net/kim.mens/reflection-in-ruby
Ask
[?]
Start
Next
#6
Index
[~]
http://phrogz.net/programmingruby/ospace.html
Ask
[?]
Start
Next
#7
Index
[~]
https://www.safaribooksonline.com/library/view/the-ruby ...
Ask
[?]
Start
Next
#8
Index
[~]
http://www.jonathanhui.com/ruby-class-manipulation-refl ...
Bing
[?]
Start
Next
#9
Index
[~]
http://blog.khd.me/blog/2008/12/26/ruby-reflection-2/
Google.AU
[?]
Start
Next
SEQu-RAmA Results 10...19
#10
Index
[~]
https://stackoverflow.com/questions/30192968/reflection ...
Ask
[?]
Start
Next
#11
Index
[~]
http://api.rubyonrails.org/classes/ActiveRecord/Reflect ...
DuckDuckGo
[?]
Start
Next
#12
Index
[~]
https://stackoverflow.com/questions/2556193/reflection- ...
Ask
[?]
Start
Next
#13
Index
[~]
https://rubymonk.com/learning/books/2-metaprogramming-r ...
Bing
[?]
Start
Next
#14
Index
[~]
https://stackoverflow.com/questions/6476644/can-i-refle ...
DuckDuckGo
[?]
Start
Next
#15
Index
[~]
https://www.researchgate.net/profile/Kim_Mens/publicati ...
DuckDuckGo
[?]
Start
Next
#16
Index
[~]
http://merbist.com/2011/06/27/golang-reflection-exampl/
Bing
[?]
Start
Next
#17
Index
[~]
https://github.com/jashkenas/ruby-processing/wiki/Java- ...
Bing
[?]
Start
Next
#18
Index
[~]
https://www.ruby-forum.com/topic/1108988
DuckDuckGo
[?]
Start
Next
#19
Index
[~]
http://www.rubyonrailstutorial.net/reflection-usage-in-ruby
DuckDuckGo
[?]
Start
Next
SEQu-RAmA Results 20...29
#20
Index
[~]
http://www.phrogz.net/ProgrammingRuby/ospace.html
DuckDuckGo
[?]
Start
Next
#21
Index
[~]
https://en.wikipedia.org/wiki/Reflection_(computer_science)
DuckDuckGo
[?]
Start
Next
#22
Index
[~]
https://en.wikipedia.org/wiki/Reflection_(computer_prog ...
Ask
[?]
Start
Next
#23
Index
[~]
http://docs.attachmate.com/reflection/14.0/vbug.pdf
Bing
[?]
Start
Next
#24
Index
[~]
http://www.linuxtopia.org/online_books/programming_book ...
Bing
[?]
Start
Next
#25
Index
[~]
http://www.rubyist.net/~slagell/ruby/objinitialization.html
Bing
[?]
Start
Next
#26
Index
[~]
https://thesocietea.org/2016/02/programming-concepts-ty ...
Bing
[?]
Start
Next
#27
Index
[~]
http://tvtropes.org/pmwiki/pmwiki.php/Main/DoesNotLikeMen
MetagerDE
[?]
Start
Next
#28
Index
[~]
http://www.book530.com/painting/101502/Ruby-Reflection.html
MetagerDE
[?]
Start
Next
#29
Index
[~]
http://en.wikiversity.org/wiki/Wikiversity:Learning_by_doing
MetagerDE
[?]
Start
Next
SEQu-RAmA Results 30...39
#30
Index
[~]
http://www.thefullwiki.org/Color
MetagerDE
[?]
Start
Next
#31
Index
[~]
https://www.thoughtco.com/using-attributes-2908103
MetagerDE
[?]
Start
Next
#32
Index
[~]
http://tvtropes.org/pmwiki/pmwiki.php/Main/Inexplicably ...
MetagerDE
[?]
Start
Next
#33
Index
[~]
http://tvtropes.org/pmwiki/pmwiki.php/Main/VideoGamePer ...
MetagerDE
[?]
Start
Next
#34
Index
[~]
http://rosettacode.org/wiki/Documentation
MetagerDE
[?]
Start
Next
#35
Index
[~]
http://tvtropes.org/pmwiki/pmwiki.php/Main/Sidequest
MetagerDE
[?]
Start
Next
#36
Index
[~]
http://tvtropes.org/pmwiki/pmwiki.php/Main/ItWasWithYou ...
MetagerDE
[?]
Start
Next
#37
Index
[~]
http://www.programcreek.com/2013/09/java-reflection-tut ...
MetagerDE
[?]
Start
Next
#38
Index
[~]
http://www.exampleproblems.com/wiki/index.php/Obfuscate ...
MetagerDE
[?]
Start
Next
#39
Index
[~]
http://tvtropes.org/pmwiki/pmwiki.php/Main/TheBet
MetagerDE
[?]
Start
Next
SEQu-RAmA Results 40...49
#40
Index
[~]
https://de.wikibooks.org/wiki/Wikijunior_Wie_Dinge_funk ...
MetagerDE
[?]
Start
Next
#41
Index
[~]
http://www.wowwiki.com/Portal:WotLK
MetagerDE
[?]
Start
Next
#42
Index
[~]
https://en.wikibooks.org/wiki/Ruby_Programming/Syntax/M ...
MetagerDE
[?]
Start
Next
#43
Index
[~]
http://www.tutorialspoint.com/ruby/ruby_loops.htm
MetagerDE
[?]
Start
Next
#44
Index
[~]
http://www.diablowiki.net/Orbs
MetagerDE
[?]
Start
Next
#45
Index
[~]
http://www.osti.gov/servlets/purl/991950-Lv2g2L/
MetagerDE
[?]
Start
Next
#46
Index
[~]
http://www.diablowiki.net/Sources
MetagerDE
[?]
Start
Next
#47
Index
[~]
http://www.exampleproblems.com/wiki/index.php/Categoric ...
MetagerDE
[?]
Start
Next
#48
Index
[~]
https://en.wikibooks.org/wiki/Ruby_Programming/Unit_testing
MetagerDE
[?]
Start
Next
#49
Index
[~]
http://www.techotopia.com/index.php/Simple_Ruby_Examples
MetagerDE
[?]
Start
Next
SEQu-RAmA Results 50...59
#50
Index
[~]
http://cumincad.architexturez.net//doc/oai-cumincadwork ...
MetagerDE
[?]
Start
Next
#51
Index
[~]
http://www.tutorialspoint.com/ruby-on-rails/rails-examp ...
MetagerDE
[?]
Start
Next
#52
Index
[~]
http://jimbojw.com/wiki/index.php?title=Defending_PHP
MetagerDE
[?]
Start
Next
#53
Index
[~]
http://wiki.piratenpartei.de/Bibliothek/Fachbücher_zum_ ...
MetagerDE
[?]
Start
Next
#54
Index
[~]
http://www.rubyist.net/~slagell/ruby/examples.html
MetagerDE
[?]
Start
Next
#55
Index
[~]
http://wiki.inkscape.org/wiki/index.php/ScriptingLanguages
MetagerDE
[?]
Start
Next
#56
Index
[~]
https://hal.archives-ouvertes.fr/hal-01236838
MetagerDE
[?]
Start
Next
#57
Index
[~]
http://newprairiepress.org/aerc/2013/roundtables/7
MetagerDE
[?]
Start
Next
#58
Index
[~]
http://rosettacode.org/wiki/Break_OO_privacy
MetagerDE
[?]
Start
Next
#59
Index
[~]
http://www.ics.uci.edu/~lopes/teaching/inf212W15/lectur ...
MetagerDE
[?]
Start
Next
SEQu-RAmA Results 60...69
#60
Index
[~]
http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1 ...
MetagerDE
[?]
Start
Next
#61
Index
[~]
http://wiki.tcl.tk/9644
MetagerDE
[?]
Start
Next
#62
Index
[~]
http://www.escholarship.org/uc/item/96m0x5dt
MetagerDE
[?]
Start
Next
#63
Index
[~]
http://c2.com/cgi/wiki/wiki?RuntimeReflectionIsaDesignSmell
MetagerDE
[?]
Start
Next
#64
Index
[~]
https://www.fastbot.de/red.php?red=3451702619909200101 ...
MetagerDE
[?]
Start
Next
#65
Index
[~]
http://netbeans.org/projects/ruby/lists/commits/archive ...
Sogou
[?]
Start
Next
#66
Index
[~]
https://chessprogramming.wikispaces.com/Ruby
Sogou
[?]
Start
Next
#67
Index
[~]
http://www.oschina.net/translate/implementation-and-app ...
Sogou
[?]
Start
Next
#68
Index
[~]
http://www.learntosolveit.com/java/
Sogou
[?]
Start
Next
#69
Index
[~]
http://guides.rubyonrails.org/4_2_release_notes.html
Sogou
[?]
Start
Next
SEQu-RAmA Results 70...79
#70
Index
[~]
http://stackoverflow.com/questions/4976179/variable-sco ...
Sogou
[?]
Start
Next
#71
Index
[~]
http://www.oracle.com/technetwork/articles/saternos-ror ...
Sogou
[?]
Start
Next
#72
Index
[~]
http://stackoverflow.com/questions/3790412/ruby-reflect ...
QWant
[?]
Start
Next
#73
Index
[~]
http://stackoverflow.com/questions/2556193/reflection-i ...
QWant
[?]
Start
Next
#74
Index
[~]
http://en.wikibooks.org/wiki/Ruby_Programming/Syntax/Me ...
QWant
[?]
Start
Next
#75
Index
[~]
http://stackoverflow.com/questions/6476644/can-i-reflec ...
QWant
[?]
Start
Next
#76
Index
[~]
http://www.slideshare.net/nirusuma/introduction-to-ruby ...
QWant
[?]
Start
Next
#77
Index
[~]
http://stackoverflow.com/questions/30192968/reflection- ...
QWant
[?]
Start
Next
#78
Index
[~]
http://en.wikipedia.org/wiki/Reflection_(computer_science)
QWant
[?]
Start
Next
#79
Index
[~]
http://stackoverflow.com/questions/1388055/need-help-wi ...
QWant
[?]
Start
Next
SEQu-RAmA Results 80...89
#80
Index
[~]
https://p16.praetorian.com/blog/ruby-unsafe-reflection- ...
Startpage
[?]
Start
Next
#81
Index
[~]
http://wannabeanglican.blogspot.com/2004/
GoodGopher
[?]
Start
Next
#82
Index
[~]
http://conspiracyscope.blogspot.com/2011/12/
GoodGopher
[?]
Start
Next
#83
Index
[~]
http://www.ukcolumn.org/article/smart-power-human-right ...
GoodGopher
[?]
Start
Next
#84
Index
[~]
http://www.paulstramer.net/2010/07/
GoodGopher
[?]
Start
Next
#85
Index
[~]
http://www.wakingtimes.com/2014/12/29/loneliness-dilemm ...
GoodGopher
[?]
Start
Next
#86
Index
[~]
http://www.transients.info/2016/10/cosmic-journey-of-la ...
GoodGopher
[?]
Start
Next
#87
Index
[~]
http://theopenscroll.blogspot.com/2016/09/
GoodGopher
[?]
Start
Next
#88
Index
[~]
http://theopenscroll.blogspot.com/2013/02/
GoodGopher
[?]
Start
Next
#89
Index
[~]
http://northerntruthseeker.blogspot.ca/2010/03/
GoodGopher
[?]
Start
Next
SEQu-RAmA Results 90...99
#90
Index
[~]
http://northerntruthseeker.blogspot.ca/2014/10/
GoodGopher
[?]
Start
Next
#91
Index
[~]
http://antipastohw.blogspot.com/2008/
Naver
[?]
Start
Next
#92
Index
[~]
http://farmacists.blogspot.com/2009/05/comparitive-stud ...
Naver
[?]
Start
Next
#93
Index
[~]
http://butteryoon.tistory.com/949
Naver
[?]
Start
Next
#94
Index
[~]
http://blog.daum.net/livemocha/2083
Naver
[?]
Start
Next
#95
Index
[~]
http://kslofs.blog.me/50163897905
Naver
[?]
Start
Next
#96
Index
[~]
http://www.infoworld.com/article/2889320/microsoft-net/ ...
Nate
[?]
Start
Next
#97
Index
[~]
https://theplana.wordpress.com/2007/03/11/variableoptio ...
Nate
[?]
Start
Next
#98
Index
[~]
http://www.slideshare.net/vishnu/the-ruby-programming-l ...
Nate
[?]
Start
Next
#99
Index
[~]
http://pig.apache.org/docs/r0.11.0/udf.html
Nate
[?]
Start
Next
SEQu-RAmA Results 100...109
#100
Index
[~]
http://www.kyobobook.co.kr/product/detailViewEng.laf?ma ...
Nate
[?]
Start
Next
#101
Index
[~]
https://lorenzod8n.wordpress.com/2007/05/28/yes-jruby-i ...
Nate
[?]
Start
Next
#102
Index
[~]
https://developers.google.com/youtube/v3/docs/search/list
Nate
[?]
Start
Next
#103
Index
[~]
http://bmcbioinformatics.biomedcentral.com/articles/10. ...
Nate
[?]
Start
Next
#104
Index
[~]
http://lists.apple.com/archives/cocoa-dev/2004/Jun/msg0 ...
Nate
[?]
Start
Next
#105
Index
[~]
https://gist.github.com/boveus/41eec1daf1f1bc2309561a13 ...
Nate
[?]
Start
Next
#106
Index
[~]
https://code.tutsplus.com/tutorials/reflection-in-php-- ...
Rambler
[?]
Start
Next
#107
Index
[~]
https://www.ahaprocess.com/wp-content/uploads/2013/09/U ...
Rambler
[?]
Start
Next
#108
Index
[~]
http://confreaks.tv/events/rubyconf2010
Rambler
[?]
Start
Next
#109
Index
[~]
http://blog.librato.com/posts/2016/1/14/reflections-on- ...
Rambler
[?]
Start
Next
SEQu-RAmA Results 110...119
#110
Index
[~]
http://blog.honeybadger.io/ruby-self-cheat-sheet/
Goo
[?]
Start
Next
#111
Index
[~]
https://stackoverflow.com/questions/2309255/how-do-i-ge ...
Goo
[?]
Start
Next
#112
Index
[~]
http://www.rubyflow.com/p/1396
DuckDuckGo
[?]
Start
Next
#113
Index
[~]
http://arubysreflection.weebly.com/
DuckDuckGo
[?]
Start
Next
#114
Index
[~]
https://www.linkedin.com/pulse/utilizing-existing-rpg-c ...
Rambler
[?]
Start
Next
#115
Index
[~]
http://wps.prenhall.com/wps/media/objects/3918/4012970/ ...
Rambler
[?]
Start
Next
#116
Index
[~]
http://ruby.bastardsbook.com/chapters/web-crawling
Rambler
[?]
Start
Next
#117
Index
[~]
http://www.benelexblog.law.ed.ac.uk/2015/08/03/equity-a ...
Rambler
[?]
Start
Next
#118
Index
[~]
https://rmagick.github.io/usage.html
Rambler
[?]
Start
Next
#119
Index
[~]
https://www.brainpop.com/games/therubyrealm/
Rambler
[?]
Start
Next
SEQu-RAmA Results 120...129
#120
Index
[~]
https://stackoverflow.com/questions/7788221/get-methods ...
DuckDuckGo
[?]
Start
Next
#121
Index
[~]
http://www.planetstoneglobal.com/colors.php?price=54&co ...
DuckDuckGo
[?]
Start
Next
#122
Index
[~]
https://gumroad.com/l/xztbD
DuckDuckGo
[?]
Start
Next
#123
Index
[~]
http://stackoverflow.com/questions/622324/how-to-get-ar ...
DuckDuckGo
[?]
Start
Next
#124
Index
[~]
https://stackoverflow.com/questions/3790412/ruby-reflec ...
DuckDuckGo
[?]
Start
Next
#125
Index
[~]
http://collegeessayexample.blogspot.com/2011/06/rudy_16.html
DuckDuckGo
[?]
Start
Next
#126
Index
[~]
https://stackoverflow.com/questions/199527/get-the-name ...
DuckDuckGo
[?]
Start
Next
#127
Index
[~]
https://stackoverflow.com/questions/3456827/reflection- ...
DuckDuckGo
[?]
Start
Next
#128
Index
[~]
https://stackoverflow.com/questions/2452077/is-there-a- ...
DuckDuckGo
[?]
Start
Next
#129
Index
[~]
http://xunitpatterns.com/XUnitBasics.html
ExactSeek
[?]
Start
Next
SEQu-RAmA Results 130...139
#130
Index
[~]
http://www.curatormagazine.com/author/christytennant/
ExactSeek
[?]
Start
Next
#131
Index
[~]
http://planet.plone.org
ExactSeek
[?]
Start
Next
#132
Index
[~]
http://blogs.unpas.ac.id/heru/tentang-akhyuuuu/
ExactSeek
[?]
Start
Next
#133
Index
[~]
http://research.pcru.ac.th/pcrubi/index.php?option=com_ ...
ExactSeek
[?]
Start
Next
#134
Index
[~]
http://weliveentertainment.com/welivefilm/john-wick-cha ...
ExactSeek
[?]
Start
Next
#135
Index
[~]
https://baka-tsuki.org/project/index.php?title=Zero_no_ ...
ExactSeek
[?]
Start
Next
#136
Index
[~]
http://blog.darevay.com
ExactSeek
[?]
Start
Next
#137
Index
[~]
http://gerardoxtni837blog.ampblogs.com
ExactSeek
[?]
Start
Next
#138
Index
[~]
http://alttech.discountfloors.us/forum-beta/index.php?a ...
ExactSeek
[?]
Start
Next
#139
Index
[~]
http://apidock.com/rails/ActiveRecord/Associations/Prel ...
ExactSeek
[?]
Start
Next
SEQu-RAmA Results 140...149
#140
Index
[~]
http://www.patheos.com/blogs/livingtradition/2017/02/pr ...
ExactSeek
[?]
Start
Next
#141
Index
[~]
http://cs.mines.edu/Courses/csci400/CHAPTERS/Ruby/Ruby- ...
Google.UK
[?]
Start
Next
#142
Index
[~]
http://arsdnet.net/this-week-in-d/sep-06.html
ExactSeek
[?]
Start
Next
#143
Index
[~]
https://www.hyperink.com/Effective-Programming-More-Tha ...
ExactSeek
[?]
Start
Next
#144
Index
[~]
http://ntcore.com/files/dyncpp.htm
ExactSeek
[?]
Start
Next
#145
Index
[~]
http://arsdnet.net/this-week-in-d/jun-21.html
ExactSeek
[?]
Start
Next
#146
Index
[~]
http://arsdnet.net/this-week-in-d/2016-may-29.html
ExactSeek
[?]
Start
Next
#147
Index
[~]
http://ronaldbradford.com/blog/2008/08/
ExactSeek
[?]
Start
Next
#148
Index
[~]
http://www.slideserve.com/Kevlin/sorted
ExactSeek
[?]
Start
Next
#149
Index
[~]
http://beust.com/weblog/2005/04/15/the-perils-of-duck-t ...
ExactSeek
[?]
Start
Next
SEQu-RAmA Results 150...159
#150
Index
[~]
http://www.britannica.com/print/topic/471439
Egerin
[?]
Start
#151
Index
[~]
http://www.oxforddictionaries.com/definition/english/bump
Egerin
[?]
Start
#152
Index
[~]
http://www.slideserve.com/ping/ruby-reflection
Bing
[?]
Start
#153
Index
[~]
http://timkellogg.me/blog/2012/02/10/c-reflection-perfo ...
Bing
[?]
Start
#154
Index
[~]
https://www.safaribooksonline.com/library/view/learning ...
Bing
[?]
Start
#155
Index
[~]
http://dl.acm.org/citation.cfm?id=1229688.1229714
Bing
[?]
Start
#156
Index
[~]
https://en.wikipedia.org/wiki/Ruby_programming
Bing
[?]
Start
#157
Index
[~]
https://en.wikipedia.org/wiki/Code_reflection
Bing
[?]
Start
Copyright © 2017 William F. Gilreath. All Rights Reserved.
Meta-search for 'ruby reflection examples' has 158 results on Sat Jul 22 09:19:34 PDT 2017
Internal IP address: '<IP_ADDRESS>'. External IP address/hostname: '<IP_ADDRESS>'/'ipNameExternal'.


Margin is used to create space around elements outside of defined borders while Border(s) are used to specify the style, width and colour of an element's border. Furthermore Padding is used to create space around an element's content inside of defined borders and it alongside Margin is transparent.
Each property can be compared to a shoe box with the shoes being the content/elements, the paper being the Padding, the box edge being the Border and the space outside of the box edge being the Margin.
Image 1. Illustration of Margin, Border, Padding & Content.
Looking at the below screenshots the div tag has been modified (refer to Image 2) in order to space the outside borders of the boxed content (refer to Image 3).
Image 2. Margin Code Example.
Image 3. Margin Example Live Result.
The border style property specifies what kind of border to display around an element.
In the screenshots below different border styles (see Image 4) are created around different text elements (see Image 5).
Image 4. Border Code Example.
Image 5. Border Example Live Result.
Looking at the screenshots below this time the div tag has been modified in Image 6 to create space inside the borders of the boxed content (refer to Image 7).
Image 6. Padding Code Example.
Image 7. Padding Example Live Result.
< Back to Home