| Opcode/Instruction | Op / En | 64/32 bit Mode Support | CPUID Feature Flag | Description |
|---|---|---|---|---|
| F2 0F 10 /r MOVSD xmm1, xmm2 | A | V/V | SSE2 | Move scalar double-precision floating-point value from xmm2 to xmm1 register. |
| F2 0F 10 /r MOVSD xmm1, m64 | A | V/V | SSE2 | Load scalar double-precision floating-point value from m64 to xmm1 register. |
| F2 0F 11 /r MOVSD xmm1/m64, xmm2 | C | V/V | SSE2 | Move scalar double-precision floating-point value from xmm2 register to xmm1/m64. |
| VEX.LIG.F2.0F.WIG 10 /r VMOVSD xmm1, xmm2, xmm3 | B | V/V | AVX | Merge scalar double-precision floating-point value from xmm2 and xmm3 to xmm1 register. |
| VEX.LIG.F2.0F.WIG 10 /r VMOVSD xmm1, m64 | D | V/V | AVX | Load scalar double-precision floating-point value from m64 to xmm1 register. |
| VEX.LIG.F2.0F.WIG 11 /r VMOVSD xmm1, xmm2, xmm3 | E | V/V | AVX | Merge scalar double-precision floating-point value from xmm2 and xmm3 registers to xmm1. |
| VEX.LIG.F2.0F.WIG 11 /r VMOVSD m64, xmm1 | C | V/V | AVX | Store scalar double-precision floating-point value from xmm1 register to m64. |
| EVEX.LIG.F2.0F.W1 10 /r VMOVSD xmm1 {k1}{z}, xmm2, xmm3 | B | V/V | AVX512F | Merge scalar double-precision floating-point value from xmm2 and xmm3 registers to xmm1 under writemask k1. |
| EVEX.LIG.F2.0F.W1 10 /r VMOVSD xmm1 {k1}{z}, m64 | F | V/V | AVX512F | Load scalar double-precision floating-point value from m64 to xmm1 register under writemask k1. |
| EVEX.LIG.F2.0F.W1 11 /r VMOVSD xmm1 {k1}{z}, xmm2, xmm3 | E | V/V | AVX512F | Merge scalar double-precision floating-point value from xmm2 and xmm3 registers to xmm1 under writemask k1. |
| EVEX.LIG.F2.0F.W1 11 /r VMOVSD m64 {k1}, xmm1 | G | V/V | AVX512F | Store scalar double-precision floating-point value from xmm1 register to m64 under writemask k1. |
| Op/En | Tuple Type | Operand 1 | Operand 2 | Operand 3 | Operand 4 |
| A | NA | ModRM:reg (r, w) | ModRM:r/m (r) | NA | NA |
| B | NA | ModRM:reg (w) | VEX.vvvv (r) | ModRM:r/m (r) | NA |
| C | NA | ModRM:r/m (w) | ModRM:reg (r) | NA | NA |
| D | NA | ModRM:reg (w) | ModRM:r/m (r) | NA | NA |
| E | NA | ModRM:r/m (w) | vvvv (r) | ModRM:reg (r) | NA |
| F | Tuple1 Scalar | ModRM:reg (r, w) | ModRM:r/m (r) | NA | NA |
| G | Tuple1 Scalar | ModRM:r/m (w) | ModRM:reg (r) | NA | NA |
Moves a scalar double-precision floating-point value from the source operand (second operand) to the destination operand (first operand). The source and destination operands can be XMM registers or 64-bit memory locations. This instruction can be used to move a double-precision floating-point value to and from the low quadword of an XMM register and a 64-bit memory location, or to move a double-precision floating-point value between the low quadwords of two XMM registers. The instruction cannot be used to transfer data between memory locations.
Legacy version: When the source and destination operands are XMM registers, bits MAXVL:64 of the destination operand remains unchanged. When the source operand is a memory location and destination operand is an XMM registers, the quadword at bits 127:64 of the destination operand is cleared to all 0s, bits MAXVL:128 of the destination operand remains unchanged.
VEX and EVEX encoded register-register syntax: Moves a scalar double-precision floating-point value from the second source operand (the third operand) to the low quadword element of the destination operand (the first operand). Bits 127:64 of the destination operand are copied from the first source operand (the second operand). Bits (MAXVL-1:128) of the corresponding destination register are zeroed.
VEX and EVEX encoded memory store syntax: When the source operand is a memory location and destination operand is an XMM registers, bits MAXVL:64 of the destination operand is cleared to all 0s.
EVEX encoded versions: The low quadword of the destination is updated according to the writemask.
Note: For VMOVSD (memory store and load forms), VEX.vvvv and EVEX.vvvv are reserved and must be 1111b, otherwise instruction will #UD.
IF k1[0] or *no writemask* THEN DEST[63:0] ← SRC[63:0] ELSE IF *merging-masking* ; merging-masking THEN *DEST[63:0] remains unchanged* ELSE ; zeroing-masking THEN DEST[63:0]←0 FI; FI; DEST[MAXVL-1:64] ← 0
IF k1[0] or *no writemask* THEN DEST[63:0] ← SRC[63:0] ELSE *DEST[63:0] remains unchanged* ; merging-masking FI;
IF k1[0] or *no writemask* THEN DEST[63:0] ← SRC2[63:0] ELSE IF *merging-masking* ; merging-masking THEN *DEST[63:0] remains unchanged* ELSE ; zeroing-masking THEN DEST[63:0]←0 FI; FI; DEST[127:64] ← SRC1[127:64] DEST[MAXVL-1:128] ← 0
DEST[63:0] ←SRC[63:0] DEST[MAXVL-1:64] (Unmodified)
DEST[63:0] ←SRC2[63:0] DEST[127:64] ←SRC1[127:64] DEST[MAXVL-1:128] ←0
DEST[63:0] ←SRC2[63:0] DEST[127:64] ←SRC1[127:64] DEST[MAXVL-1:128] ←0
DEST[63:0] ←SRC[63:0] DEST[MAXVL-1:64] ←0
DEST[63:0] ←SRC[63:0]
DEST[63:0] ←SRC[63:0] DEST[127:64] ←0 DEST[MAXVL-1:128] (Unmodified)
VMOVSD __m128d _mm_mask_load_sd(__m128d s, __mmask8 k, double * p);
VMOVSD __m128d _mm_maskz_load_sd( __mmask8 k, double * p);
VMOVSD __m128d _mm_mask_move_sd(__m128d sh, __mmask8 k, __m128d sl, __m128d a);
VMOVSD __m128d _mm_maskz_move_sd( __mmask8 k, __m128d s, __m128d a);
VMOVSD void _mm_mask_store_sd(double * p, __mmask8 k, __m128d s);
MOVSD __m128d _mm_load_sd (double *p)
MOVSD void _mm_store_sd (double *p, __m128d a)
MOVSD __m128d _mm_move_sd ( __m128d a, __m128d b)
None
Non-EVEX-encoded instruction, see Exceptions Type 5; additionally
| #UD | If VEX.vvvv != 1111B. |
EVEX-encoded instruction, see Exceptions Type E10.


Name
HPL_dlaswp01N copies rows of A into itself and into U.
Synopsis
#include "hpl.h"
void
HPL_dlaswp01N(
const int
M
,
const int
N
,
double *
A
,
const int
LDA
,
double *
U
,
const int
LDU
,
const int *
LINDXA
,
const int *
LINDXAU
);
Description
HPL_dlaswp01N
copies scattered rows of A into itself and into an
array U. The row offsets in A of the source rows are specified by
LINDXA. The destination of those rows are specified by LINDXAU. A
positive value of LINDXAU indicates that the array destination is U,
and A otherwise.
Arguments
M (local input) const int
On entry, M specifies the number of rows of A that should be
moved within A or copied into U. M must be at least zero.
N (local input) const int
On entry, N specifies the length of rows of A that should be
moved within A or copied into U. N must be at least zero.
A (local input/output) double *
On entry, A points to an array of dimension (LDA,N). The rows
of this array specified by LINDXA should be moved within A or
copied into U.
LDA (local input) const int
On entry, LDA specifies the leading dimension of the array A.
LDA must be at least MAX(1,M).
U (local input/output) double *
On entry, U points to an array of dimension (LDU,N). The rows
of A specified by LINDXA are be copied within this array U at
the positions indicated by positive values of LINDXAU.
LDU (local input) const int
On entry, LDU specifies the leading dimension of the array U.
LDU must be at least MAX(1,M).
LINDXA (local input) const int *
On entry, LINDXA is an array of dimension M that contains the
local row indexes of A that should be moved within A or
or copied into U.
LINDXAU (local input) const int *
On entry, LINDXAU is an array of dimension M that contains
the local row indexes of U where the rows of A should be
copied at. This array also contains the local row offsets in
A where some of the rows of A should be moved to. A positive
value of LINDXAU[i] indicates that the row LINDXA[i] of A
should be copied into U at the position LINDXAU[i]; otherwise
the row LINDXA[i] of A should be moved at the position
-LINDXAU[i] within A.
See Also
HPL_dlaswp00N,
HPL_dlaswp10N,
HPL_dlaswp01N,
HPL_dlaswp01T,
HPL_dlaswp02N,
HPL_dlaswp03N,
HPL_dlaswp03T,
HPL_dlaswp04N,
HPL_dlaswp04T,
HPL_dlaswp05N,
HPL_dlaswp05T,
HPL_dlaswp06N,
HPL_dlaswp06T.


FlashControl extension can be easily bypassed using the .click()
trick.
FlashBlock extension (an older version?) can also be bypassed using the same trick.
Chrome's click to play setting can be bypassed, see related Chrome issue. As per the issue's last comment, Chrome is removing left-click-to-play in version 41.
Screenshot from Chrome 46.


Magnitude / Symbolic Toggle
SFG section
Circuit Parameters
Transfer Function
Transfer Function Bode Plot
Loop Gain
Loop Gain Bode Plot
Transfer Funtion:
Loop Gain:
Bode plot section


ÁVision Build Log
Tool Versions:
IDE-Version: ÁVision V<IP_ADDRESS> Copyright (C) 2018 ARM Ltd and ARM Germany GmbH. All rights reserved. License Information: Irina Anokhina, Home, LIC=4ZLII-TEB96-D0BN3-A224F-8NH05-P6ATD Tool Versions: Toolchain: MDK-ARM Professional Version: <IP_ADDRESS> Toolchain Path: C:\Keil_v5\ARM\ARMCC\Bin C Compiler: Armcc.exe V5.06 update 6 (build 750) Assembler: Armasm.exe V5.06 update 6 (build 750) Linker/Locator: ArmLink.exe V5.06 update 6 (build 750) Library Manager: ArmAr.exe V5.06 update 6 (build 750) Hex Converter: FromElf.exe V5.06 update 6 (build 750) CPU DLL: SARMCM3.DLL V<IP_ADDRESS> Dialog DLL: DCM.DLL V<IP_ADDRESS> Target DLL: STLink\ST-LINKIII-KEIL_SWO.dll V<IP_ADDRESS> Dialog DLL: TCM.DLL V<IP_ADDRESS>Project:
E:\Ira\Example_for_Nucleo\STM32CubeExpansion_MEMS1_V6.2.0\Projects\STM32F401RE-Nucleo\Applications\IKS01A2\My_proj\MDK-ARM\Project.uvprojx Project File Date: 08/08/2019Output:
*** Using Compiler 'V5.06 update 6 (build 750)', folder: 'C:\Keil_v5\ARM\ARMCC\Bin' Build target 'STM32F4xx-Nucleo-IKS01A2' creating preprocessor file for hts221.c... creating preprocessor file for hts221_reg.c... creating preprocessor file for lps22hb.c... creating preprocessor file for lps22hb_reg.c... creating preprocessor file for lsm6dsl.c... creating preprocessor file for lsm6dsl_reg.c... creating preprocessor file for lsm303agr.c... creating preprocessor file for lsm303agr_reg.c... creating preprocessor file for stm32f4xx_nucleo.c... creating preprocessor file for iks01a2_env_sensors.c... creating preprocessor file for iks01a2_env_sensors_ex.c... creating preprocessor file for iks01a2_motion_sensors.c... creating preprocessor file for iks01a2_motion_sensors_ex.c... creating preprocessor file for system_stm32f4xx.c... creating preprocessor file for stm32f4xx_hal.c... creating preprocessor file for stm32f4xx_hal_cortex.c... creating preprocessor file for stm32f4xx_hal_crc.c... creating preprocessor file for stm32f4xx_hal_dma.c... creating preprocessor file for stm32f4xx_hal_flash.c... creating preprocessor file for stm32f4xx_hal_flash_ex.c... creating preprocessor file for stm32f4xx_hal_flash_ramfunc.c... creating preprocessor file for stm32f4xx_hal_gpio.c... creating preprocessor file for stm32f4xx_hal_i2c.c... creating preprocessor file for stm32f4xx_hal_i2c_ex.c... creating preprocessor file for stm32f4xx_hal_pwr.c... creating preprocessor file for stm32f4xx_hal_pwr_ex.c... creating preprocessor file for stm32f4xx_hal_rcc.c... creating preprocessor file for stm32f4xx_hal_rcc_ex.c... creating preprocessor file for stm32f4xx_hal_rtc.c... creating preprocessor file for stm32f4xx_hal_rtc_ex.c... creating preprocessor file for stm32f4xx_hal_tim.c... creating preprocessor file for stm32f4xx_hal_tim_ex.c... creating preprocessor file for stm32f4xx_hal_uart.c... creating preprocessor file for stm32f4xx_hal_adc.c... creating preprocessor file for stm32f4xx_hal_adc_ex.c... creating preprocessor file for stm32f4xx_hal_spi.c... creating preprocessor file for DemoSerial.c... creating preprocessor file for com.c... creating preprocessor file for main.c... creating preprocessor file for stm32f4xx_hal_msp.c... creating preprocessor file for cube_hal_f4.c... compiling main.c... .\LSM9DS1\LSM9DS1.h(4): warning: #1295-D: Deprecated declaration init_LSM9DS1_I2C - give arg types void init_LSM9DS1_I2C (); ..\Src\main.c(100): warning: #1295-D: Deprecated declaration sensors_enable - give arg types void sensors_enable(); ..\Src\main.c: 2 warnings, 0 errors creating preprocessor file for stm32f4xx_it.c... creating preprocessor file for serial_protocol.c... creating preprocessor file for MotionEC_Manager.c... creating preprocessor file for MotionMC_Manager.c... creating preprocessor file for nucleo_f401re_bus.c... creating preprocessor file for LSM9DS1.c... compiling MotionMC_Manager.c... creating preprocessor file for i2c.c... linking... Program Size: Code=58684 RO-data=800 RW-data=584 ZI-data=37056 FromELF: creating hex file... After Build - User command #1: C:\Keil_v5\\ARM\ARMCC\bin\fromelf.exe --bin --output=.\STM32F4xx-Nucleo-IKS01A2\Objects\STM32F4xx-Nucleo-IKS01A2.bin .\STM32F4xx-Nucleo-IKS01A2\Objects\STM32F4xx-Nucleo-IKS01A2.axf ".\STM32F4xx-Nucleo-IKS01A2\Objects\STM32F4xx-Nucleo-IKS01A2.axf" - 0 Error(s), 2 Warning(s).Software Packages used:
Package Vendor: Keil http://www.keil.com/pack/Keil.STM32F4xx_DFP.2.13.0.pack Keil.STM32F4xx_DFP.2.13.0 STMicroelectronics STM32F4 Series Device Support, Drivers and ExamplesCollection of Component include folders:
.\RTE\_STM32F4xx-Nucleo-IKS01A2 C:\Keil_v5\ARM\PACK\Keil\STM32F4xx_DFP\2.13.0\Drivers\CMSIS\Device\ST\STM32F4xx\IncludeCollection of Component Files used:
Build Time Elapsed: 00:00:10


The controller was designed to work with the car roof rack-mounted satellite antenna system (a separate project), but can be used with any other design based on the supported rotator hardware.
The first version of the controller supports Alfa Radio rotator, model RAU only, performing horizontal rotation of the antenna system. For satellite use the fixed elevation technique can be employed. It is expected that the future versions of the controller could control the elevation antenna mechanism as well. The following functions are provided by the controller:
The controller is based on the Arduino Micro Pro board, 16Mhz version. It also has a DC to DC down stepper to convert power from 12V DC to 5V DC. A Relay block controlled by the microprocessor is used to control the rotator. There is also a quartz-stabilized clock board for keeping accurate time (with an accuracy of less than a second per day). It communicates with the Arduino microprocessor using the I2C interface.
A 20-character 2 line display (40 characters in total) is also connected to the I2C bus. 5 buttons (4 on the front panel and the menu button on the back panel) are also connected to the Arduino board.
In addition to the mentioned above components the logic level converters were used where it was necessary to connect the circuits using 5V and 3.3V TTL logic. Note a RC filter at the sensor input. This input is used to read pulses from the rotator. The purpose of the filter is to reduce jitter noise coming in from the rotator. This issue also exists for the buttons, but their state is polled on a regular basis and, therefore, the jitter noise generated by them can be dealt with in the software. As for the rotational sensor, its contacts are used to trigger an interrupt in the microprocessor. To avoid multiple interrupts occurring in a small fraction of a second, a simple RC filter was used. The rest of the schematic is self-explanatory.
The front panel has 4 control buttons (left, right, up and down). In the manual control mode (shown on the picture) the left and right buttons are used to rotate the antenna counter clock-wise and clock-wise correspondingly. The up and down buttons are not functioning in this mode but might be used in the future versions for the elevation control. All 4 buttons are used in the menu mode. In this mode the left and right buttons are used to switch between menu choices on the current menu level and the down button selects the desired choice. The up buttons acts like a backwards button in the menu mode. The same buttons can be used to change numeric values of some parameters in the menu as well (the initial antenna azimuth, for instance).
All connection sockets of the controller are located on the back along with some additional controls. Normally, the controller is powered by a 12V DC source. It is used to power the electronics of the controller and the rotator. Although, when you upload pass information from your PC to the controller, it could be more convenient to power the controller's electronics from the PC's USB port, without using 12 V DC power supply or battery. This can be done by switching the AUX power switch to ON. A special cable is used to connect PC USB port to the controller's communication port. A rotator is connected to the controller using a 4 wire cable. Two wires are used to carry 12V power to the rotator and the other two are used to read the pulses generated by the rotator for every degree of its rotation. Another 4-pole socket is not presently connected anywhere and is meant to be used in the future versions of the device for elevation control.
The software for the controller was written in C using Arduino SDK. One of the libraries (the one providing an interface to the Real-Time clock module) was updated to better suit the needs of this project. To view the controller source code click the icon on the right. The biggest challenge was to make the code as compact as possible due to the choice of the Arduino board. To do this, the embedded boot loader had to be removed to free some additional space. Uploading the code now has to be done by using an external programmer.


|
TouhouFanGame
A RPG Touhou fan game
|
#include <vector>
#include <iostream>
#include <cmath>
#include "../Core/ECS/Entity.hpp"
#include "../Core/ECS/Components/PositionComponent.hpp"
#include "../Core/ECS/Components/MovableComponent.hpp"
#include "../Core/ECS/Components/DisplayableComponent.hpp"
#include "../Core/ECS/Core.hpp"
#include "../Core/ECS/Components/OobDieComponent.hpp"
#include "../Core/DataType/Vector.hpp"
Go to the source code of this file.
Functions | |
| TouhouFanGame::ECS::Entity * | makeProjectile (TouhouFanGame::Map &map, TouhouFanGame::Resources &resources, TouhouFanGame::Vector2f pos, double dir) |
| void | update () |
| void | attackDefault (std::vector< void * > args) |
Variables | |
| unsigned int | timer = 0 |
| void attackDefault | ( | std::vector< void * > | args | ) |
Definition at line 54 of file test_attack.cpp.
| TouhouFanGame::ECS::Entity* makeProjectile | ( | TouhouFanGame::Map & | map, |
| TouhouFanGame::Resources & | resources, | ||
| TouhouFanGame::Vector2f | pos, | ||
| double | dir | ||
| ) |
Definition at line 18 of file test_attack.cpp.
| void update | ( | ) |
Definition at line 48 of file test_attack.cpp.
| unsigned int timer = 0 |
Definition at line 16 of file test_attack.cpp.


This beautiful spiral galaxy shows its edge to us - we look through a thick pancake-like disk of dust that looks dark as it blocks the light from the stars shining behind it.
Detailed data for this object is not in the public catalog.
The amount of data LSST captures is truely immense and requires thousands of scientists using the most advanced technologies to sift through it. We, unfortunately, can’t bring every bit of data to your phone, so LSST has curated a set of some of the most notable and intersting objects LSST scientists are observing.
A few sentences about what makes this object very interesting. This would be the same text a user would see if they were browsing through the object tours.
+ VIEW OTHER OBJECTS LIKE THISIt would take 300 billion years to get here with modern spacecraft
The U filter stands for ultraviolet, and it allows light of wavelengths between about 350 nanometers (nm) and 400 nm to pass through. Thus, the U band is about 100 nm wide.


#{extends 'main.html' /}
Enter current and new passwords.
Current Password #{if badPassword}Incorrect password#{/if}
New Password
New Password (again) Passwords don't match.
Change


placekitten
A quick and simple service for getting pictures of kittens for use as placeholders in your designs or code. Just put your image size after our URL and you'll get a placeholder.
Like this: http://placekitten.com/200/287
or: http://placekitten.com/g/200/287


Rob Kardashian makes a rare appearance – and fans can’t get enough of how good he looks
by Bashiera Parker (@bparks_)Cape Town – Rob Kardashian stepped out over the weekend to attend Kendall Jenner’s birthday party – and fans can’t get enough of how good the most private Kardashian is looking.
Kendall turned 24, but hosted a big bash days before at Blind Dragon nightclub in West Hollywood, reports People. And in a photograph posted on Instagram by Kylie, though Rob’s wearing an oversized hoodie, he’s looking happy and healthy with a jawline sharp enough to make you swoon.
And fans did!
 while another wrote, "Rob looks so good," complete with an in-love emoji.
"He looks amazing, this makes me so happy," said another user, while others added a flame emoji commenting, "Rob looking fya."
SEE THE POST HERE:
According to E! News, Rob hasn’t been photographed, or rather, hasn’t posted a photo of himself, in more than a year. But before the party, he also shared a picture of himself next to mom, Kris Jenner, on Halloween. Again, he looks “fya” wearing apparel from his Halfway Dead streetwear line.
SEE THAT PHOTO HERE:
Adorably, he dressed up as Papa Troll while Dream dressed as Poppy Troll.
(Photo: Greatstock/Splash)


Forgot Password?
Next
Choose...
What is the name of your favorite childhood friend?
What is your favorite movie?
What was your favorite sport in high school?
What was your favorite food as a child?
What school did you attend for sixth grade?
What primary school did you attend?
What is your favorite movie?
What were the last four digits of your childhood telephone number?
In what town or city did your mother and father meet?
What was your dream job as a child?
Next
Submit
Already have an account?
Login


? Toggle Keyboard Usage display
Esc Deselect label
Backspace / delete Delete selected label
↑ Zoom in
↓ Zoom out
← Previous frame
→ Next frame
Label Category


Hi {{ name }}!
We have just created Codepot account for you.
Please reset your password with this link: {{ reset_link }} and using the email address this message was sent to.


CLASSES VS IDS
WHAT ARE CLASSES AND IDS?
A class can be used multiple times within an html document. Use a class when you want to consistently style multiple elements throughout your site. Classes are useful when you have more than one element that shares the same style.
The simple difference between the two is that while a class can be used repeatedly on a page, an ID must only be used once per page. Therefore, it is appropriate to use an ID on the div element that is marking up the main content on the page, as there will only be one main content section.
IDs are an incredibly powerful tool. An element with an ID can be the target of a piece of JavaScript that manipulates the element or its contents in some way. The ID attribute can be used as the target of an internal link, replacing anchor tags with name attributes.
Finally, it considered good coding practice to make your IDs clear and logical, they can serve “self-documentation” within an html document. For example, you do not necessarily need to add a comment before a block stating that a block of code will contain the main content if the opening tag of the block has an ID of, say, "main", "header", "footer", etc.


Even though the Chicago River now flows towards the Mississippi, billions of gallons of polluted water still spill backwards into the lake each year. The culprit is stormwater that flows off rooftops, parking lots, roads, and sidewalks and into sewer overflow pipes that empty into the river. Less than an inch of rain is all that is needed to flood the city’s sewer system and force water into the river. During big storms, the river can become so swollen with stormwater that officials have to open the Chicago Harbor Lock and let water flush into the lake to prevent the city from flooding.
It is not just water that fills the river and pours into the lake when it rains. Stormwater brings with it a toxic blend of pollutants from city streets and lawns—everything from gasoline and trash to fertilizers and pesticides. In fact, stormwater is one of the biggest sources of water pollution. These contaminants degrade water quality, raise water temperatures, and suffocate fish eggs and newly hatched larvae. Bacteria carried in rainwater can also make swimming in the lake dangerous. In fact, stormwater is behind most of the swimming advisories and beach closures that plague the Great Lakes region each summer.
Concerns about stormwater pollution are on the rise as heavy rains are becoming more common. Between 2007 and 2010, a new high of 19 billion gallons of contaminated water was released into Lake Michigan. The spike was largely because of two downpours in 2008 and 2010, some of the worst in Chicago history.


As a Tech Enthusiast and everything Business I am always looking to collaborate with like minded people across the continent in building world class sustainable African owned enterprises.
My background is in data analytics which allows me to identify patterns others dont, sales, business development and strategy development in regards to go to market strategies for businesses.
I believe in Generational Leadership: that problems are generational, and only the generation of today can solve the current problems Africa faces. I strongly believe it is our responsibility to build the value in them and motivate them to be great by enlighting them with stories of Africans who once sat where they are sitted today.
I am not special, rather I am part of a movement of millions of young Africans who are tired of mediocrity. We are both agents for social and economical change for our continent, changing the status qou by pushing bounderies.
National Certificate, South Africa
Bachelor of Arts in International Relations, South Africa
Entrepreneur In Training, Ghana


Ctrl-Y: open file
- will return dir list if a dir specified
- will add the selected text to the current path
Ctrl-Shift-L: expand selection to whole line
Ctrl-Shift-Left/Right: expand selection to word to the left/right
Ctrl-X: save file
use ssh terminal to build


Web development, due to its decentralized nature (no one web browser is in charge of running the internet), is slightly more difficult to recommend resources for especially with the prevalance of libraries in development. To learn the basics of the technology (JavaScript, CSS, HTML) the Mozilla Development Network learning resources.
https://developer.mozilla.org/en-US/docs/LearnAfter the basics, it's extremely uncommon to develop web applications without the use of a library of some kind. Typically, a client-side framework is used, some guides for the most popular frameworks are liked below.
https://reactjs.org/tutorial/tutorial.htmlWe love to help out new developers, if you have any questions about programming on any platforms or frameworks please stop by the #dev-help channel on our Discord and we'll do our best to help!


The closest planet to the Sun with a mean distance of 58 million kilometers. Revolving around the Sun every 88 days and rotating around its own axis every 56 Earth days, Mercury has only recently begun to be studied thoroughly.
Counter to the planet's name, based upon theoretical evidence, Mercury probably would contain iron and nickel.
Caused by deviating temperatures, Mercury's surface is covered with a layer of reddish iron dust. These metals, combined from the solar particles of the Sun, thus contribute to Mercury's high density compared to Mars, Venus, and the Earth.
The enormous range in temperatures cause erosion of exposed rock, which contributes to the layer of dust, which cloaks the surface. Deviating from a boiling 430 degrees Celcius during the day and -180 degrees Celcius during the planet's night cycle, Mercury does not follow expectations.


Arkansas takes on Alabama at 5pm central
The men's basketball team takes on a surging Crimson Tide as they fight for better seeds in the NCAA tournament and SEC tournament
The men's basketball team takes on a surging Crimson Tide as they fight for better seeds in the NCAA tournament and SEC tournament
| date | location | team | score | team | score |
|---|---|---|---|---|---|
| 2/6 | Columbia, SC | South Carolina | 65 | Arkansas | 81 |
| 2/10 | Nashville, TN | Vanderbilt | 54 | Arkansas | 72 |
| 2/13 | Fayetteville, AR | Arkansas | 75 | Ole Miss | 64 |
| 2/17 | College Station, TX | Texas A&M | 75 | Arkansas | 94 |
| 2/20 | Lexington, KY | Kentucky | 87 | Arkansas | 72 |
Arkansas got off to probably their best start of the season.  Then Kentucky took that punch, shook it off, and systematically took apart Arkansas for the remainder of the game. They left Fayetteville with a 87-72 win.
The 2018 college baseball season is upon us, and the Diamond Hogs’ roster is chock-full of veterans to go along with the nation’s 3rd ranked recruiting class from a year ago. While the lineup will include many familiar faces, the weekend rotation will consist of a couple of pitchers returning from injury with high ceilings.
After a rocky start, Arkansas put all the pieces together for a comfortable 72-54 win over Vanderbilt. Jaylen Barford and Daryl Macon were a combined 8/12 from 3 point range and had 37 points together. Daniel Gafford put in 16 with nine boards and a career high seven blocks with some highlight plays to cap off the win.
The Hogs picked up a late addition to the class and it’s a big one. Dorian Gerald, the 27th ranked overall JUCO player and top DE. Picked the Hogs over Texas A&M, and he did so with a good looking cookie cake.


Spend some quality time with the room you are going to put your new home theater audio system. Believe it or not but the room is as much a component in your home theater system as any of the electronics you will ever buy. Ask yourself which room you will be putting your new system in. Consider whether or not this room is going to be used solely for you system or will it be used for other activities. Will there be any size considerations for the components and speakers you plan on using with the dimensions of the room? Consider drawing a map of your room and sketch the possible placements of your furniture, components and speakers. Measure the room’s dimensions and write them down. Make a list of all the inputs you currently have and will continue to use. Make a list of the inputs you intend to add to your new audio system. You should write down which components are going to need cables and wires. Also, write down the approximate lengths of those cables and wires. Once all of this is worked out carry this information and map with you when you go out to buy your new audio system.
| ID объекта | 3014 |
| Тип недвижимости | офисные помещения |
| Тип сделки | Продажа |
| Этаж/этажность | 2/9 |
| Тип здания | нежилое |
| Район | Бго-восточный |
| Помещение | с отдельным входом |
| Расстояние транспортом до метро | 2 |


Home
Single Player
Multi Player
Puzzles
Please Donate
About us
Lessons
Beginner
Single Player
Multi Player
Puzzles
Lessons
Single Player
Multi Player
Puzzles
Lessons
Intermediate
Single Player
Multi Player
Puzzles
Lessons
Single Player
Multi Player
Puzzles
Lessons
Advanced
Single Player
Multi Player
Puzzles
Lessons
Single Player
Multi Player
Puzzles
Lessons
Thanks for visiting


Dodgeball Masters is a frenetic multiplayer sports game where two teams compete
until one of them stands above the other by eliminating all the rival team members.
There are 8 different characters to choose from for your 3 members team, with differents statistics and skill sets that enable a
wide range of possibilities and strategies.
Platforms: Linux
GITHUB REPOSITORY
Dodgeball Master's main game mode consists of 3 vs 3 dodgeball games, where players control the three characters
they have chosen for their team. To create their team, players can choose between 8 different characters with +20 different
special abilities and characteristics that enable a wide range of possibilities and strategies during the games.
To win a game, players must eliminate all the characters on the opposing team by hitting them with the ball. To protect
their characters, players can both use special dodging abilities and catch the ball in the air. When all the characters
of one of the teams are eliminated, the game ends.
Finally, the game has a local multiplayer mode that allows 2 players to face each other and see who is the true dodgeball master.
• Led the project, distributed tasks and ensured the development of the project aligned with the team goals.
• Responsible for creating and optimizing the rendering pipeline in OpenGL with another member of the team.
• Designed and developed the arquitecture of the custom game engine.
• Implemented realistic physics simulation and a collision management system.
• Created a scalable and dynamic UI system.


GRMID
Section: GNU (1)Updated: 2011-04-16
Index Return to Main Contents
NAME
grmid - - RMI activation system daemonSYNOPSIS
grmid [OPTIONS]...DESCRIPTION
rmiregistry starts a remote object registry on the current host. If no port number is specified, then port 1099 is used.OPTIONS
Activation process control:- -port PORT
- Port on which activation system is to be started.
- -restart
- Restart activation system, clearing persistent naming database, if any.
- -stop
- Stop activation system.
Persistence:
- -persistent
- Make activation system persistent.
- -directory DIR
- Directory in which to store persistent data.
Debugging:
Standard options:
- -help
- Print help text, then exit.
- -version
- Print version number, then exit.
- -JOPTION
- Pass argument to the Java runtime.
BUGS
SEE ALSO
java(1), ...AUTHOR
Index
This document was created by man2html, using the manual pages.
Time: 05:29:04 GMT, December 24, 2015


HEAD ======= >>>>>>> eaff2cf4c21c0af217c72da01f22153f89630b11
Blessing Tayedzerwa's Portfolio Will Be Live In


Humanizing your insurance.
Get your life insurance coverage easier and faster. We blend our expertise and technology to help you find the plan that’s right for you. Ensure you and your loved ones are protected.
Get your life insurance coverage easier and faster. We blend our expertise and technology to help you find the plan that’s right for you. Ensure you and your loved ones are protected.
Our application process can be completed in minutes, not hours. Don’t get stuck filling in tedious forms.
We don’t want you worrying about high monthly costs. Our prices may be low, but we still offer the best coverage possible.
Our plans aren’t full of conditions and clauses to prevent payouts. We make sure you’re covered when you need it.


Summary
The perfstat application can send smtp alerts. Any device that can receive and email can also receive an alert from the perfstat application. Alerts are enabled by event status in the perf-conf and further configured in the notify-rules file. This allows you to configure alerts both globaly and at a host/service level.
Enable Events
1) Ensure EVENTLOG is enabled in perf-conf and set to "Y" by running the following command:
/perfhome/bin/tools/perfconfig -list
2) To change any of the perf-conf settings run the following command:
/perfhome/bin/tools/perfconfig -server
Note: if you are logged in as root you will need to the "-root" flag. You can also simply cat the /perfhome/etc/perf-conf file.
3) Ensure service is not disabled in the /perfhome/etc/events-disable configuration file.
Enable Global Alerts
1) Ensure EMAIL and one of the email status types is enabled and set to "Y" in the perf-conf file by running the following command:
/perfhome/bin/tools/perfconfig -list
Note: at a minimum you must enable EMAIL and EMAIL_ALL, or EMAIL_CRIT, or EMAIL_WARN, or EMAIL_NOSTATUS.
2) To change any of the perf-conf settings run the following command:
/perfhome/bin/tools/perfconfig -server
Note: if you are logged in as root you will need to the "-root" flag. You can also simply cat the /perfhome/etc/perf-conf file.
3) If you make any changes to the perf-conf you must restart perfstat by running the following command:
/perfhome/perf.sh restart
Configure notify-rules file
In order for alerts to be sent you must configure notify rules. The rules are a collection of hosts, hours, days, services, and email addresses. When a rule is matched an alert is sent to the email addresses on that rule.
1) Using an editor such as vi open the /perfhome/etc/notify-rules file.
2) Add a rule using the template within the file.
Notification rules use the following format:
<hostname>:<comma separated hour list>:<comma separeated day list>:<comma separated service list>:comma separated email list>
Hostname - name of the client you are configuring alerts for.
Hour List - Hours when alerts can be sent (separated by commas). If you wanted to send alerts only between 8am-10am and 8pm-10pm it would be as follows: 8-10,20-22. The "*" wildcard can be used for every hour.
Day List - Days of the month when alerts can be sent (separated by commas). If you wanted to send alerts only on the 5th and 10th-15th of every month it would be as follows: 5,10-15. The "*" wildcard can be used for all days.
Service List - Services you want to send alerts for (separated by commas). If you wanted to send alerts for only cpu, mem, and io it would be as follows: cpu,mem,io. The "*" wildcard can be used for all services.
Email List - List of email addresses to send alerts to (separated by commas). If you wanted to send alerts to<EMAIL_ADDRESS>and<EMAIL_ADDRESS>it would be as follows: myemail1<EMAIL_ADDRESS>Note: a restart of the perfstat application is not needed when updating notify-rules.


This site combining Danny's years of experience covering software engineering, game programming, and artificial intelligence research.
I am a graduate student majoring in Entertainment Technology at Carnegie Mellon University in Pittsburgh, Pennsylvania.
I have worked on building web application at a startup company during summer 2020. Building websites is meaningful because it enables people to reach resources without physical limitations, which then creates sorts of equality.
I have been working on traffic system/autonomous vehicle simulation scenarios for artificial intelligence research at Aipex Lab. Simulation environment is interesting because it does experiments millions of times faster than real world experiments. By looping between experiment results and pivoting, I am excited to see the progress that has been made.
It is a joy for me to do programming in web application, and artificial intelligence research.
I have earned an MBA in Finance at National Taiwan University (NTU), and a BS in Risk Management and Insurance at National Chengchi University (NCCU).


SQL is a set-based declarative language used to interact with relational databases. SQL is different from imperative languages (such as Java) in that we do not use SQL to tell a relational database what to do; rather, we write SQL statements which describe the results we want.
We'll be using SQLite, a small, lightweight relational database which is freely available at http://www.sqlite.org. Download SQLite for your particular platform, and then place it in an appropriate spot within your file system. The examples shown here will be on Mac OS X, with the sqlite3 executable file placed in the /Applications directory.
We now have a database called 'test', and we have a SQLite command shell which we can use to execute SQL statements against our newly-created database. We'll start by creating a simple table to store employee data:
(Note that we're following the commonly used convention of capitalizing SQL keywords, and using lowercase letters for table and column names.)
In the previous create statement, we defined a table called employees withInsert some data...
...and then read it back out. The * wildcard character is a shortcut indicating that we simply which to see the data for every column in the table:
Most database command line shells enable you to modify the output formatting to make result sets easier to read:
A little bit of magic happened when we executed our INSERT statement: by specifying null for the primary key field, SQLite was kind enough to automatically generate a unique ID for us, which is exactly what we want.
TBD - delete from WUBBA where x > 33 TBD - update FUBBA set x = 33 where y < 100


| Battlecruisers
| Attack Battlecruisers:
Combat Battlecruisers:
- Harbinger/Navy
- Prophecy/Navy
Command Ships:
| Attack Battlecruisers:
Combat Battlecruisers:
Command Ships:
| Attack Battlecruisers:
Combat Battlecruisers:
- Brutix/Navy
- Myrmidon/Navy
Command Ships:
| Attack Battlecruisers:
Combat Battlecruisers:
- Cyclone/Fleet
- Hurricane/Fleet
Command Ships:
| Combat Battlecruisers:
|
| Battleships
| Battleships:
- Abaddon
- Apocalypse/Imperial/Navy
- Armageddon/Imperial/Navy
Black Ops:
Marauders:
| Battleships:
- Raven/Navy/State
- Rokh
- Scorpion/Navy/Ishukone Watch
Black Ops:
Marauders:
| Battleships:
Black Ops:
Marauders:
| Battleships:
- Maelstrom
- Tempest/Fleet/Tribal
- Typhoon/Fleet
Black Ops:
Marauders:
| Battleships:
- Barghest
- Bhaalgorn
- Leshak
- Machariel
- Nestor
- Nightmare
- Praxis
- Rattlesnake/Victory
- Thunderchild
- Vindicator
Black Ops:
|
| Carriers
| Carriers:
Supercarriers:
Fighters:
- Ametat
- Cenobite
- Equite
- Malleus
- Templar
| Carriers:
Supercarriers:
Fighters:
- Dragonfly
- Locust
- Mantis
- Scarab
- Termite
| Carriers:
Supercarriers:
Fighters:
- Antaeus
- Cyclops
- Firbolg
- Satyr
- Siren
| Carriers:
Supercarriers:
Fighters:
- Dromi
- Einherji
- Gram
- Gungnir
- Tyrfing
| Supercarriers:
Fighters:
|
| Corvettes
|
|
|
| Reaper
|
|
| Cruisers
| Combat Recons:
Cruisers:
- Arbitrator
- Augoror/Navy
- Maller
- Omen/Navy
Force Recons:
Heavy Assault Cruisers:
Heavy Interdiction Cruisers:
Logistics:
| Combat Recons:
Cruisers:
- Blackbird
- Caracal/Navy
- Moa
- Osprey/Navy
Force Recons:
Heavy Assault Cruisers:
Heavy Interdiction Cruisers:
Logistics:
| Combat Recons:
Cruisers:
- Celestis
- Exequror/Navy
- Guardian-Vexor
- Thorax
- Vexor/Navy
Force Recons:
Heavy Assault Cruisers:
Heavy Interdiction Cruisers:
Logistics:
| Combat Recons:
Cruisers:
- Bellicose
- Rupture
- Scythe/Fleet
- Stabber/Fleet
Force Recons:
Heavy Assault Cruisers:
- Bestla
- Mimir
- Muninn
- Vagabond
Heavy Interdiction Cruisers:
Logistics:
|
Cruisers:
- Ashimmu
- Cynabal
- Gila
- Opux Luxury Yacht
- Orthrus
- Phantasm
- Rodiva
- Stormbringer
- Stratios/Emergency Responder
- Vedmak
- Victorieux Luxury Yacht
- Vigilant
Flag Cruisers:
Force Recons:
- Chameleon
- Enforcer
- Moracha
- Tiamat
- Victor
Heavy Assault Cruisers:
Heavy Interdiction Cruisers:
Logistics:
|
| Destroyers
| Command Destroyers:
Destroyers:
Interdictors:
| Command Destroyers:
Destroyers:
Interdictors:
| Command Destroyers:
Destroyers:
- Algos
- Catalyst/Aliastra/Inner Zone Shipping/Intaki Syndicate/InterBus/Navy/Nefantar/Quafe
Interdictors:
| Command Destroyers:
Destroyers:
Interdictors:
| Command Destroyers:
Destroyers:
|
| Dreadnoughts
| Revelation/Navy
| Phoenix/Navy
| Moros/Navy
| Naglfar/Fleet
|
- Caiman
- Chemosh
- Vehement
- Zirnitra
|
| Drones
| EM Damage:
- Small: Acolyte
- Medium: Infiltrator
- Large: Praetor
- Sentry: Curator
Energy Neutalizing:
- Small: Acolyte EV-300
- Medium: Infiltrator EV-600
- Large: Praetor EV-900
Tracking Disruption:
- Small: Acolyte TD-300
- Medium: Infiltrator TD-600
- Large: Praetor TD-900
| Kinetic Damage:
- Small: Hornet
- Medium: Vespa
- Large: Wasp
- Sentry: Warden
Electronic Countermeasures:
- Small: Hornet EC-300
- Medium: Vespa EC-600
- Large: Wasp EC-900
Other:
| Thermal Damage:
- Small: Hobgoblin
- Medium: Hammerhead
- Large: Ogre
- Sentry: Garde
Sensor Dampening:
- Small: Hobgoblin SD-300
- Medium: Hammerhead SD-600
- Large: Ogre SD-900
| Explosive Damage:
- Small: Warrior
- Medium: Valkyrie
- Large: Berserker
- Sentry: Bouncer
Stasis Webifier:
- Small: Warrior SW-300
- Medium: Valkyrie SW-600
- Large: Berserker SW-900
Target Painting:
- Small: Warrior TP-300
- Medium: Valkyrie TP-600
- Large: Berserker TP-900
|
- Medium: 'Subverted' JVN-UC49
- Large: Gecko
|
| Force Auxiliarys
| Apostle
| Minokawa
| Ninazu
| Lif
|
|
| Freighters
| Freighters:
Jump Freighters:
| Freighters:
Jump Freighters:
| Freighters:
Jump Freighters:
| Freighters:
Jump Freighters:
| Freighters:
|
| Frigates
| Assault Frigates:
- Malice
- Retribution
- Vengeance
Covert Ops:
Electronic Attack Ships:
Frigates:
Interceptors:
Logistics Frigates:
Stealth Bombers:
| Assault Frigates:
Covert Ops:
Electronic Attack Ships:
Frigates:
Interceptors:
Logistics Frigates:
Stealth Bombers:
| Assault Frigates:
Covert Ops:
Electronic Attack Ships:
Frigates:
- Atron
- Federation Navy Comet
- Imicus/Navy
- Incursus
- Maulus/Navy
- Navitas
- Tristan
Interceptors:
Logistics Frigates:
Stealth Bombers:
| Assault Frigates:
Covert Ops:
Electronic Attack Ships:
Frigates:
- Breacher
- Burst
- Probe/Fleet
- Republic Fleet Firetail
- Rifter
- Slasher
- Vigil/Fleet
Interceptors:
Logistics Frigates:
Stealth Bombers:
| Assault Frigates:
Covert Ops:
Electronic Attack Ships:
Expedition Frigates:
Frigates:
- AIR Civilian Astero
- Astero
- Cruor
- Damavik
- Daredevil
- Dramiel
- Echelon
- Garmur
- Metamorphosis
- Skybreaker
- Succubus
- Venture
- Worm
Interceptors:
Stealth Bombers:
|
| Industrials
| Blockade Runners:
Deep Space Transports:
Haulers:
| Blockade Runners:
Deep Space Transports:
Haulers:
| Blockade Runners:
Deep Space Transports:
Haulers:
- Epithal
- Iteron Mark V
- Kryos
- Miasmos/Amastris/Quafe Ultra/Quafe Ultramarine
- Nereus
| Blockade Runners:
Deep Space Transports:
Haulers:
| Capital Industrial Ships:
Exhumers:
Haulers:
Industrial Command Ships:
Mining Barges:
- Covetor
- Procurer
- Retriever
|
| NPC Corps with Players
| Faction Warfare:
- [IC24] 24th Imperial Crusade
Starter:
- [HU] Hedion University
- [IAC] Imperial Academy
- [RIN] Royal Amarr Institute
Default:
- [IS] Imperial Shipment
- [MW] Ministry of War
- [VI] Viziam
| Faction Warfare:
- [SPROT] State Protectorate
Starter:
- [SAK] School of Applied Knowledge
- [STI] Science and Trade Institute
- [SWA] State War Academy
Default:
- [CP] Caldari Provisions
- [DCMI] Deep Core Mining Inc.
- [P] Perkone
| Faction Warfare:
- [FEDEF] Federal Defense Union
Starter:
- [CAS] Center for Advanced Studies
- [UC] University of Caille
- [FNA] Federal Navy Academy
Default:
- [A] Aliastra
- [GIB] Garoun Investment Bank
- [TS] The Scope
| Faction Warfare:
- [TLIB] Tribal Liberation Force
Starter:
- [PTS] Pator Tech School
- [RMS] Republic Military School
- [RUN] Republic University
Default:
- [B] Brutor Tribe
- [NF] Native Freshfood
- [S] Sebiestor Tribe
|
|
| Races
|
- Amarr: "True Amarrians are proud and supercilious, with a great sense of tradition and ancestry."
- Khanid: "Swept up by the Amarr's message of faith during the original Reclaiming, the Khanid were for centuries exalted members of Amarr society, until a bitter feud between the Empire and a Khanid heir forced a secession which led to the creation of the independent Khanid Kingdom."
- Ni-Kunni: "With the exception of the Khanid, the Ni-Kunni were assimilated into Amarr society far more easily than the majority of Amarrian conquests."
|
- Achura: "Achura has been part of the Caldari State for three centuries, and yet their culture has always remained something of a mystery."
- Civire: "Whether engaged in trade or combat, the Civire are absolute masters of focused aggression."
- Deteis: "The Deteis are regarded as the face of leadership in Caldari society."
|
- Gallente: "The Gallente value freedom and individual liberty above all else."
- Intaki: "The Intaki are one of the largest ethnicities of the Federation."
- Jin-Mei: "The nation of Jin-Mei is the latest addition to the Federation."
|
- Brutor: "A martial, strong-willed people, the Brutor hold their tribal heritage close to their hearts, and are renowned for living regimented, disciplined lives."
- Sebiestor: "Widely respected as some of the cluster's most innovative thinkers, the Sebiestor are an ingenious people with a natural fondness for engineering."
- Vherokior: "Originally nomads in Matar's vast and inhospitable desert regions, the Vherokior are among the most diverse individuals of the Republic."
|
|
| Sensors
| Radar
| Gravimetric
| Magnetometric
| Ladar
|
|
| Shuttles
| +10% Explosive Armor Resist:
- Amarr Shuttle
- Civilian Amarr Shuttle
| +10% Thermal Armor Resist:
- Goru's Shuttle
- Boobook
- Caldari Shuttle
- Civilian Caldari Shuttle
- Guristas Shuttle
| +10% Kinetic Armor Resist:
- Gallente Shuttle
- Civilian Gallente Shuttle
| +10% EM Armor Resist:
- Minmatar Shuttle
- Civilian Minmatar Shuttle
| Prototype Exploration Ships:
Shuttles:
- Apotheosis
- Council Diplomatic Shuttle
- InterBus Shuttle
- Leopard
|
| Strategic Cruisers
| Legion
| Tengu
| Proteus
| Loki
|
|
| Structures
| 'Draccous' Fortizar
| 'Horizon' Fortizar
| 'Marginis' Fortizar
| 'Prometheus' Fortizar
|
- 'Moreau' Fortizar
- Ansiblex Jump Gate
- Astrahus
- Athanor
- Azbel
- Fortizar
- Keepstar
- Pharolux Cyno Beacon
- Raitaru
- Sotiyo
- Tatara
- Tenebrex Cyno Jammer
- Upwell Palatine Keepstar
|
| Tactical Destroyers
| Confessor
| Jackdaw
| Hecate
| Svipul
|
|
| Titans
| Avatar
| Leviathan
| Erebus
| Ragnarok
|
|


| ReferenceClasses {methods} | R Documentation |
The software described here allows packages to define reference classes that behave in the style of “OOP” languages such as Java and C++. This model for OOP differs from the functional model implemented by S4 (and S3) classes and methods, in which methods are defined for generic functions. Methods for reference classes are “encapsulated” in the class definition.
Computations with objects from reference classes invoke methods on them and
extract or set their fields, using the `$`
operator in R.
The field and method computations potentially modify the object.
All computations referring to the objects see the modifications, in contrast to
the usual functional programming model in R.
A call to
setRefClass
in the source code for a package defines the class and returns a generator object.
Subsequent calls to the $methods()
method of the generator will define methods for the class.
As with functional classes, if the class is exported from the package,
it will be available when the package is loaded.
Methods are R functions. In their usual implementation, they refer to fields and other methods of the class directly by name. See the section on “Writing Reference Methods”.
As with functional classes, reference classes can inherit from other
reference classes via a contains=
argument to
setRefClass
. Fields and methods will be inherited, except where the
new class overrides method definitions. See the section on “Inheritance”.
setRefClass(Class, fields = , contains = , methods =, where =, inheritPackage =, ...) getRefClass(Class, where =)
Class |
character string name for the class. In the call to |
fields |
either a character vector of field names or a named list of the fields. The resulting fields will be accessed with reference semantics (see the section on “Reference Objects”). If the argument is a list, each element of the list should usually be the character string name of a class, in which case the object in the field must be from that class or a subclass. An alternative, but not generally recommended, is to supply an accessor function; see the section on “Implementation” for accessor functions and the related internal mechanism. Note that fields are distinct from slots. Reference classes should not define class-specific slots. See the note on slots in the “Implementation” section. |
contains |
optional vector of superclasses for this class. If a superclass is also a reference class, the fields and class-based methods will be inherited. |
methods |
a named list of function definitions that can be invoked on objects
from this class. These can also be created by invoking the
|
where |
for For |
inheritPackage |
Should objects from the new class inherit the package environment of a
contained superclass? Default |
... |
other arguments to be passed to |
setRefClass()
returns a generator function suitable for
creating objects from the class, invisibly. A call to this function
takes any number of arguments,
which will be passed on to the initialize method. If no
initialize
method is defined for the class or one of its
superclasses, the default method expects named arguments with the
name of one of the fields and unnamed arguments, if any, that are
objects from one of the superclasses of this class (but only
superclasses that are themselves reference classes have any effect).
The generator function is similar to the S4 generator function
returned by setClass
. In addition to being a generator
function, however, it is also a reference class generator object,
with reference class methods for various utilities. See the section
on reference class generator objects below.
getRefClass()
also returns the generator function for the
class. Note that the package slot in the value is the correct package
from the class definition, regardless of the where
argument,
which is used only to
find the class if necessary.
Normal objects in R are passed as arguments in function calls consistently with functional programming semantics; that is, changes made to an object passed as an argument are local to the function call. The object that supplied the argument is unchanged.
The functional model (sometimes called pass-by-value, although this is inaccurate for R) is suitable for many statistical computations and is implicit, for example, in the basic R software for fitting statistical models. In some other situations, one would like all the code dealing with an object to see the exact same content, so that changes made in any computation would be reflected everywhere. This is often suitable if the object has some “objective” reality, such as a window in a user interface.
In addition, commonly used languages, including Java, C++ and many
others, support a version of classes and methods assuming reference
semantics.
The corresponding programming mechanism
is to invoke a method on an object.
In the R syntax we use "$"
for this operation; one invokes a method,
m1
say, on an object x
by the expression
x$m1(...)
.
Methods in this paradigm are associated with the object, or more precisely with the class of the object, as opposed to methods in a function-based class/method system, which are fundamentally associated with the function (in R, for example, a generic function in an R session has a table of all its currently known methods). In this document “methods for a class” as opposed to “methods for a function” will make the distinction.
Objects in this paradigm usually have named fields on which
the methods operate.
In the R implementation, the fields are defined when the class is
created.
The field itself can optionally have a specified class, meaning that only objects
from this class or one of its subclasses can be assigned to the field.
By default, fields have class "ANY"
.
Fields are accessed by reference. In particular, invoking a method may modify the content of the fields.
Programming for such classes involves writing new methods for a
particular class.
In the R implementation, these methods are R functions, with zero or
more formal arguments.
For standard reference methods, the object itself is not an explicit
argument to the method.
Instead, fields and methods for the class can be referred to by name
in the method definition.
The implementation uses R environments to make fields and other methods
available by name within the method.
Specifically, the parent environment of the method is the object itself.
See the section on “Writing
Reference Methods”.
This special use of environments is optional. If a method is defined
with an initial formal argument .self
, that will be passed in
as the whole object, and the method follows the standard rules for any
function in a package. See the section on “External Methods”
The goal of the software described here is to provide a uniform programming style in R for software dealing with reference classes, whether implemented directly in R or through an interface to one of the OOP languages.
Reference methods are functions supplied as elements of a named list,
either
when invoking $methods()
on a generator object g
or as
the argument methods
in a call to setRefClass
.
The two mechanisms have the same effect, but the first makes the code more readable.
Methods are written as ordinary R functions but have some special features and restrictions in their usual form. In contrast to some other languages (e.g., Python), the object itself does not need to be an argument in the method definition. The body of the function can contain calls to any other reference method, including those inherited from other reference classes and may refer to methods and to fields in the object by name.
Alternatively, a method may be an external method.
This is signalled by .self
being the first formal argument to the method.
The body of the method then works like any ordinary function.
The methods are called like other methods (without the .self
argument, which is supplied internally and always refers to the object
itself).
Inside the method, fields and other methods are accessed in the form
.self$x
.
External methods exist so that reference classes can inherit the
package environment of superclasses
in other packages; see the section on “External Methods”.
Fields may be modified in a method by using the
non-local assignment operator, <<-
, as in the $edit
and $undo
methods in the example below.
Note that non-local assignment is required: a local assignment with
the <-
operator just creates a local object in the function
call, as it would in any R function.
When methods are installed, a heuristic check is made for local
assignments to field names and a warning issued if any are detected.
Reference methods should be kept simple; if they need to do some specialized R computation, that computation should use a separate R function that is called from the reference method. Specifically, methods can not use special features of the enclosing environment mechanism, since the method's environment is used to access fields and other methods. In particular, methods should not use non-exported entries in the package's namespace, because the methods may be inherited by a reference class in another package.
Two method names are interpreted specially, initialize
and finalize
. If an initialize
method is defined, it
will be invoked when an object is generated from the class. See the
discussion of method $new(...)
in the section “Initialization Methods”.
If a finalize
method is defined, a function will be
registered to invoke it before the environment in
the object is discarded by the garbage collector; finalizers are
registered with atexit=TRUE
, and so are also run at the end of
R sessions. See the matrix viewer example for both initialize and
finalize methods.
Reference methods can not themselves be generic functions; if you want additional function-based method dispatch, write a separate generic function and call that from the method.
Two special object names are available.
The entire object can be referred to in a method by the reserved
name .self
.
The object .refClassDef
contains the definition of the
class of the object.
These are accessed as fields but are read-only, with one exception.
In principal, the .self
field can be modified in the $initialize
method, because the object is still being created at this stage.
This is not recommended, as it can invalidate the object with respect
to its class.
The methods available include methods inherited from superclasses, as discussed in the section “Inheritance”.
Only methods actually used will be included in the environment
corresponding to an individual object. To declare that a method requires a
particular other method, the first method should include a call
to $usingMethods()
with the name of the other method as an argument.
Declaring the methods this way is essential if the other method is used indirectly (e.g., via sapply()
or do.call()
).
If it is called directly, code analysis will find it.
Declaring the method is harmless in any case, however, and may aid
readability of the source code.
Documentation for the methods can be obtained by the $help
method for the generator object.
Methods for classes are not documented in the Rd
format used
for R functions.
Instead, the $help
method prints the calling sequence of the method, followed by
self-documentation from the method definition, in the style of Python.
If the first element of the body of the method is a literal character
string (possibly multi-line), that string is interpreted as documentation.
See the method definitions in the example.
If the class has a method defined for $initialize()
,
this method will be called once the reference object has been
created. You should write such a method for a class that needs to do
some special initialization.
In particular, a reference method is recommended rather than a method
for the S4 generic function initialize()
, because some special initialization is
required for reference objects before the initialization of
fields.
As with S4 classes, methods are written for $initialize()
and not for $new()
,
both for the previous reason and also because $new()
is invoked on the generator object and would be a method for that class.
The default method for $initialize()
is equivalent to invoking the method $initFields(...)
.
Named arguments assign initial values to the corresponding fields.
Unnamed arguments must be objects from this class or a reference
superclass of this class.
Fields will be initialized to the contents of the fields in such
objects, but named arguments override the corresponding inherited
fields.
Note that fields are simply assigned. If the field is itself a
reference object, that object is not copied.
The new and previous object will share the reference.
Also, a field assigned from an unnamed argument counts as an
assignment for locked fields.
To override an inherited value for a locked field, the new value must
be one of the named arguments in the initializing call.
A later assignment of the field will result in an error.
Initialization methods need some care in design.
The generator
for a reference class will be called with no arguments, for example
when copying the object.
To ensure that these calls do not fail, the method must have defaults
for all arguments or check for missing()
.
The method
should include ...
as an argument and
pass this on via $callSuper()
(or $initFields()
if
you know that your superclasses have no initialization methods).
This allows future class definitions that subclass this class, with
additional fields.
Reference classes inherit from other reference classes by using the
standard R inheritance; that is, by including the superclasses in the
contains=
argument when creating the new class.
The names of the reference superclasses are in slot
refSuperClasses
of the class definition.
Reference classes can inherit from ordinary S4 classes also, but this
is usually a bad idea if it mixes reference fields and non-reference slots.
See the comments in the section on “Implementation”.
Class fields are inherited. A class definition can override a field of the same name in a superclass only if the overriding class is a subclass of the class of the inherited field. This ensures that a valid object in the field remains valid for the superclass as well.
Inherited methods are installed in the same way as directly specified methods. The code in a method can refer to inherited methods in the same way as directly specified methods.
A method may override a method of the same name in a superclass.
The overriding method can call the superclass method by
callSuper(...)
as described below.
All reference classes inherit from the class "envRefClass"
.
All reference objects can use the following methods.
$callSuper(...)
Calls the method inherited from a reference superclass.
The call is meaningful only from within another method, and will be
resolved to call the inherited method of the same name.
The arguments to $callSuper
are passed to the superclass version.
See the matrix viewer class in the example.
Note that the intended arguments for the superclass method must be supplied explicitly; there is no convention for supplying the arguments automatically, in contrast to the similar mechanism for functional methods.
$copy(shallow = FALSE)
Creates a copy of the object. With reference classes, unlike ordinary
R objects, merely assigning the object with a different name does not
create an independent copy. If shallow
is FALSE
, any
field that is itself a reference object will also be copied, and
similarly recursively for its fields. Otherwise, while reassigning a
field to a new reference object will have no side effect, modifying
such a field will still be reflected in both copies of the object.
The argument has no effect on non-reference objects in fields. When
there are reference objects in some fields but it is asserted that
they will not be modified, using shallow = TRUE
will save some
memory and time.
$field(name, value)
With one argument, returns the field of the object with character
string name
. With two arguments, the corresponding field is
assigned value
. Assignment checks that name
specifies a
valid field, but the single-argument version will attempt to get
anything of that name from the object's environment.
The $field()
method replaces the direct use of a field name, when the name of the
field must be calculated, or for looping over several fields.
$export(Class)
Returns the result of coercing the object to Class
(typically
one of the superclasses of the object's class). Calling the method
has no side effect on the object itself.
$getRefClass()
; $getClass()
These return respectively the generator object and the formal class definition for the reference class of this object, efficiently.
$import(value, Class = class(value))
Import the object value
into the current object, replacing the
corresponding fields in the current object.
Object value
must come from one of the superclasses of the
current object's class.
If argument Class
is supplied, value
is first coerced to
that class.
$initFields(...)
Initialize the fields of the object from the supplied arguments. This
method is usually only called from a class with a $initialize()
method. It corresponds to the default initialization for reference
classes. If there are slots and non-reference superclasses, these may
be supplied in the ... argument as well.
Typically, a specialized $initialize()
method carries out its own computations, then invokes $initFields()
to perform standard initialization, as shown in the
matrixViewer
class in the example below.
$show()
This method is called when the object is printed automatically,
analogously to the show
function. A general method is
defined for class "envRefClass"
. User-defined reference
classes will often define their own method: see the Example below.
Note two points in the example. As with any show()
method, it
is a good idea to print the class explicitly to allow for subclasses
using the method. Second, to call the function show()
from the method, as opposed to the $show()
method itself, refer to methods::show()
explicitly.
$trace(what, ...)
, $untrace(what)
Apply the tracing and debugging facilities of the trace
function to the reference method what
.
All the arguments of the trace
function can be supplied, except for signature
, which is not
meaningful.
The reference method can be invoked on either an object or the generator for the class. See the section on Debugging below for details.
$usingMethods(...)
Reference methods used by this method are named as the arguments
either quoted or unquoted. In the code analysis phase of installing the
the present method, the declared methods will be included. It is essential
to declare any methods used in a nonstandard way (e.g., via an apply function).
Methods called directly do not need to be declared, but it is harmless to do so.
$usingMethods()
does nothing at run time.
Objects also inherit two reserved fields:
.self
a reference to the entire object;
.refClassDef
the class definition.
The defined fields should not override these, and in general it is
unwise to define a field whose name begins with "."
, since the
implementation may use such names for special purposes.
The environment of a method in a reference class is the object itself,
as an environment.
This allows the method to refer directly to fields and other methods,
without using the whole object and the "$"
operator.
The parent of that environment is the namespace of the package in
which the reference class is defined.
Computations in the method have access to all the objects in the
package's namespace, exported or not.
When defining a class that contains a reference superclass in another
package, there is an ambiguity about which package namespace should
have that role.
The argument inheritPackage
to setRefClass()
controls
whether the environment of new objects should inherit from an
inherited class in another package or continue to inherit from the
current package's namespace.
If the superclass is “lean”, with few methods, or exists primarily to support a family of subclasses, then it may be better to continue to use the new package's environment. On the other hand, if the superclass was originally written as a standalone, this choice may invalidate existing superclass methods. For the superclass methods to continue to work, they must use only exported functions in their package and the new package must import these.
Either way, some methods may need to be written that do not assume the standard model for reference class methods, but behave essentially as ordinary functions would in dealing with reference class objects.
The mechanism is to recognize external methods.
An external method is
written as a function in which the first argument, named .self
,
stands for the reference class object.
This function is supplied as the definition for a reference class method.
The method will be called, automatically, with the first argument
being the current object and the other arguments, if any, passed along
from the actual call.
Since an external method is an ordinary function in the source code
for its package, it has access to all the objects in the namespace.
Fields and methods in the reference class must be referred to in the
form .self$name
.
If for some reason you do not want to use .self
as the first
argument, a function f()
can be converted explicitly as
externalRefMethod(f)
, which returns an object of class
"externalRefMethod"
that can be supplied as a method for the
class.
The first argument will still correspond to the whole object.
External methods can be supplied for any reference class, but there is no obvious advantage unless they are needed. They are more work to write, harder to read and (slightly) slower to execute.
NOTE: If you are the author of a package whose reference classes are likely to be subclassed in other packages, you can avoid these questions entirely by writing methods that only use exported functions from your package, so that all the methods will work from another package that imports yours.
The call to setRefClass
defines the specified class and
returns a “generator function” object for that class.
This object has class "refObjectGenerator"
; it inherits
from "function"
via "classGeneratorFunction"
and can be
called to generate new objects from the reference class.
The returned object is also a reference class object, although not of
the standard construction.
It can be used to invoke reference methods and access fields in the usual way, but
instead of being implemented directly as an environment it has a
subsidiary generator object as a slot, a
standard reference object (of class
"refGeneratorSlot"
).
Note that if one wanted to extend the reference class generator
capability with a subclass, this should be done by subclassing
"refGeneratorSlot"
, not "refObjectGenerator"
.
The fields are def
, the class definition, and className
,
the character string name of the class.
Methods generate objects
from the class, to access help on reference methods, and to
define new reference methods for the class.
The currently available methods are:
$new(...)
This method is equivalent to calling the generator function returned
by setRefClass
.
$help(topic)
Prints brief help on the topic. The topics recognized are reference method names, quoted or not.
The information printed is the calling sequence for the method, plus self-documentation if any. Reference methods can have an initial character string or vector as the first element in the body of the function defining the method. If so, this string is taken as self-documentation for the method (see the section on “Writing Reference Methods” for details).
If no topic is given or if the topic is not a method name, the definition of the class is printed.
$methods(...)
With no arguments, returns the names of the reference methods for this class. With one character string argument, returns the method of that name.
Named arguments
are method definitions, which will be
installed in the class, as if they had been supplied in the
methods
argument to setRefClass()
.
Supplying methods in this way, rather than in the call to
setRefClass()
, is recommended for the sake of clearer source
code.
See the section on “Writing Reference Methods” for details.
All methods for a class should be defined in the source code that defines the class, typically as part of a package. In particular, methods can not be redefined in a class in an attached package with a namespace: The class method checks for a locked binding of the class definition.
The new methods can refer to any currently defined method by name
(including other methods supplied in this call to
$methods()
.
Note though that previously defined methods are not re-analyzed
meaning that they will not call the new method (unless it redefines an
existing method of the same name).
To remove a method, supply NULL
as its new definition.
$fields()
Returns a list of the fields, each with its corresponding class.
Fields for which an accessor function was supplied in the definition
have class "activeBindingFunction"
.
$lock(...)
The fields named in the arguments are locked; specifically, after the lock method is called, the field may be set once. Any further attempt to set it will generate an error.
If called with no arguments, the method returns the names of the locked fields.
Fields that are defined by an explicit accessor function can not be locked (on the other hand, the accessor function can be defined to generate an error if called with an argument).
All code to lock fields should normally be part of the definition of a class; that is, the read-only nature of the fields is meant to be part of the class definition, not a dynamic property added later. In particular, fields can not be locked in a class in an attached package with a namespace: The class method checks for a locked binding of the class definition. Locked fields can not be subsequently unlocked.
$trace(what, ..., classMethod = FALSE)
Establish a traced version of method what
for objects generated
from this class. The generator object tracing works like the
$trace()
method for objects from the class, with two differences.
Since it changes the method definition in the class object itself,
tracing applies to all objects, not just the one on which the trace
method is invoked.
Second, the optional argument classMethod = TRUE
allows tracing
on the methods of the generator object itself.
By default, what
is interpreted as the name of a method in the
class for which this object is the generator.
$accessors(...)
A number of
systems using the OOP programming paradigm recommend or enforce
getter and setter methods
corresponding to each field, rather than direct access by name.
If you like this style and want to extract a field named abc
by x$getAbc()
and assign it by
x$setAbc(value)
,
the $accessors
method is a convenience function that creates such getter and setter methods for the
specified fields.
Otherwise there is no reason to use this mechanism. In particular, it
has nothing to do with the general ability to define fields by
functions as described in the section on “Reference Objects”.
Reference classes are implemented as S4 classes with a data part of
type "environment"
.
Fields correspond to named objects in the environment.
A field associated with a function is implemented as an
active binding.
In particular, fields with a specified class are implemented as a
special form of active binding to enforce valid assignment to the
field.
As a related feature, the element in the fields=
list supplied
to setRefClass
can be an accessor
function, a function of one argument that returns
the field if called with no argument or sets it to the value of the
argument otherwise.
Accessor functions are used internally and for inter-system interface
applications, but not generally recommended as they blur the concept
of fields as data within the object.
A field, say data
, can be accessed generally by an expression
of the form x$data
for any object from the relevant class.
In an internal method for this class, the field can be accessed by the name
data
.
A field that is not locked can be set by an expression of the form
x$data <- value
.
Inside an internal method, a field can be assigned by an expression of the form
x <<- value
.
Note the non-local assignment operator.
The standard R interpretation of this operator works to assign it in
the environment of the object.
If the field has an accessor function defined, getting and setting
will call that function.
When a method is invoked on an object, the function defining the method is installed in the object's environment, with the same environment as the environment of the function.
Reference classes can have validity methods in the same sense as any
S4 class (see setValidity
).
Such methods are often a good idea; they will be called by calling
validObject
and a validity method, if one is defined,
will be called when a reference object is created (from version 3.4 of
R on).
Just remember that these are S4 methods. The function will be called
with the object
as its argument. Fields and methods must be
accessed using $
.
Note: Slots. Because of the implementation, new reference classes can inherit from non-reference S4 classes as well as reference classes, and can include class-specific slots in the definition. This is usually a bad idea, if the slots from the non-reference class are thought of as alternatives to fields. Slots will as always be treated functionally. Therefore, changes to the slots and the fields will behave inconsistently, mixing the functional and reference paradigms for properties of the same object, conceptually unclear and prone to errors. In addition, the initialization method for the class will have to sort out fields from slots, with a good chance of creating anomalous behavior for subclasses of this class.
Inheriting from a class union, however, is a reasonable strategy (with all members of the union likely to be reference classes).
The standard R debugging and tracing facilities can be applied to
reference methods.
Reference methods can be passed to debug
and its
relatives from an object to debug further method invocations on that
object; for example, debug(xx$edit)
.
Somewhat more flexible use is available for a reference method version
of the trace
function.
A corresponding $trace()
reference method is available for
either an object or for the reference class generator
(xx$trace()
or mEdit$trace()
in the example below).
Using $trace()
on an object sets up a tracing
version for future invocations of the specified method for that
object.
Using $trace()
on the generator for the class sets up a
tracing version for all future objects from that class (and sometimes for
existing objects from the class if the method is not declared or
previously invoked).
In either case, all the arguments to the standard trace
function are available, except for signature=
which is
meaningless since reference methods can not be S4 generic functions.
This includes the typical style trace(what, browser)
for
interactive debugging and trace(what, edit = TRUE)
to edit the
reference method interactively.
Chambers, John M. (2016) Extending R, Chapman & Hall. (Chapters 9 and 11.)
## a simple editor for matrix objects. Method $edit() changes some ## range of values; method $undo() undoes the last edit. mEdit <- setRefClass("mEdit", fields = list( data = "matrix", edits = "list")) ## The basic edit, undo methods mEdit$methods( edit = function(i, j, value) { ## the following string documents the edit method 'Replaces the range [i, j] of the object by value. ' backup <- list(i, j, data[i,j]) data[i,j] <<- value edits <<- c(edits, list(backup)) invisible(value) }, undo = function() { 'Undoes the last edit() operation and update the edits field accordingly. ' prev <- edits if(length(prev)) prev <- prev[[length(prev)]] else stop("No more edits to undo") edit(prev[[1]], prev[[2]], prev[[3]]) ## trim the edits list length(edits) <<- length(edits) - 2 invisible(prev) }) ## A method to automatically print objects mEdit$methods( show = function() { 'Method for automatically printing matrix editors' cat("Reference matrix editor object of class", classLabel(class(.self)), "\n") cat("Data: \n") methods::show(data) cat("Undo list is of length", length(edits), "\n") } ) xMat <- matrix(1:12,4,3) xx <- mEdit(data = xMat) xx$edit(2, 2, 0) xx xx$undo() mEdit$help("undo") stopifnot(all.equal(xx$data, xMat)) utils::str(xx) # show fields and names of methods ## A method to save the object mEdit$methods( save = function(file) { 'Save the current object on the file in R external object format. ' base::save(.self, file = file) } ) tf <- tempfile() xx$save(tf) ## Not run: ## Inheriting a reference class: a matrix viewer mv <- setRefClass("matrixViewer", fields = c("viewerDevice", "viewerFile"), contains = "mEdit", methods = list( view = function() { dd <- dev.cur(); dev.set(viewerDevice) devAskNewPage(FALSE) matplot(data, main = paste("After",length(edits),"edits")) dev.set(dd)}, edit = # invoke previous method, then replot function(i, j, value) { callSuper(i, j, value) view() })) ## initialize and finalize methods mv$methods( initialize = function(file = "./matrixView.pdf", ...) { viewerFile <<- file pdf(viewerFile) viewerDevice <<- dev.cur() dev.set(dev.prev()) callSuper(...) }, finalize = function() { dev.off(viewerDevice) }) ## debugging an object: call browser() in method $edit() xx$trace(edit, browser) ## debugging all objects from class mEdit in method $undo() mEdit$trace(undo, browser) ## End(Not run)


FEUP/EIC0028 Compilers - Turing Machine
About Us
Drop file here (txt)
n 0s followed by n 1s
even # of 1s and even # of 0s
copy string
check palindrome
sum two numbers (same length)
unary to binary
Code Editor
Open
Submit Code
Formal Definition
State Transitions
#
Current State
Next State
Scan Symbol
Print Symbol
Direction
1
Clear All
Check Input
Input
Step
Run
Stop
Pause
Resume
Tape Breakpoints:
Output
Number of Steps
0
Current State
x
Execution Time
0
Options
Real time
Breakpoints


Sir Paul McCartney confirmed as Glastonbury headliner
The Beatle will take to the Pyramid stage on the Saturday night next year.
Sir Paul McCartney will headline the Saturday night of Glastonbury 2020, it has been confirmed.
The Beatle sparked speculation he would take to the Pyramid stage for the festival’s 50th anniversary when he tweeted a picture featuring American composer and pianist Philip Glass, Hollywood star Emma Stone and musician Chuck Berry.
Their surnames Glass, Stone and Berry, when said together, are similar to Glastonbury.
The news was confirmed on the festival’s official Twitter page hours later, with a statement reading: “We are incredibly excited to announce that @PaulMcCartney will headline the Pyramid Stage on the Saturday night of Glastonbury 2020.”
Sir Paul retweeted the message, adding: “Hey Glasto – excited to be part of your Anniversary celebrations. See ya next summer!”
Festival organiser Emily Eavis, daughter of Glastonbury founder Micheal Eavis, shared the news on Instagram, writing: “IT’S REAL!! So excited.. Having Paul McCartney coming back to headline the Pyramid next year is an absolute dream come true.
“There really was no one that we wanted more for the 50th anniversary.”
Sir Paul last played the festival’s Pyramid Stage in 2004, delivering a set spanning his career from his time in the Fab Four to Wings and his solo material.
Last month, Diana Ross was the first artist to be confirmed for Glastonbury 2020.
The Motown star will play in the coveted Legends slot at the festival, which takes place from June 24 to 28.
Tickets for Glastonbury Festival’s 50th anniversary sold out in just over half an hour when they went on sale in October.
All 135,000 tickets were bought within 34 minutes, according to organisers.


Please send your friend this code {{uniq}}
Once your friend has filled out their form, you can view the results here using the same code


Class Diagram Example: Multiple Views Using the Built-in Support
Documenting a big project often requires multiple diagrams:
each to show a specific and limited portion of the system.
Each diagram is usually composed of few classes, possibily using a different detail level.
The @view
tag, marks a special class used to describe a single class diagram.
Similarly to UMLOptions, the view can define its own general options,
but allows to define overrides that allow to adopt different options
for different classes based on regular expressions matching.
The general syntax for defining a view is:
/**
* @view
* @opt [!]viewOption1
* @opt [!]viewOption2
* ...
* @match regularExpression1
* @opt [!]option1.1 [argument]
* @opt [!]option1.2 [argument]
* ...
* @match regularExpression2
* @opt [!]option2.1 [argument]
* @opt [!]option2.2 [argument]
* ...
*/
The view options are applied to every class in the view (so they are the
global options for this class diagram).
The regular expression will be used to match a single class, a group of
classes, or a package, and the options that follow will be applied to
those classes.
Multiple matches will be evaluted in the order of specification.
Refer to the Pattern
class documentation for details on a proper regular expression specification.
Each view will generate a .dot file whose name is the name of the view,
unless the "output" option is specified to override it.
View inheritance
View classes can inherit from other view classes, allowing views to
share a set of common matches. The standard java inheritance mechanism
is used to specify inheritance.
Abstract view classes won't be used to generate diagrams, the common
idiom is to declare a base abstract view to share common options and
overrides, and have concrete view classes that extend for diagram generation.
Example: views at different detail of specification
The previous multiple view example can be generated by using internal
view support by means of the following sources (note the use of UmlOptions
to set the common appearance options, and the views to generate multiple
diagrams at different detail level).
// Author: Vadim Nasardinov
// Author: Andrea Aime
// Version: $Id$
import java.util.List;
import java.util.Map;
/**
* @assoc "1..1" - "0..n" Adapter
* @assoc "" - "0..n" ObjectType
* @assoc "" - "0..n" ObjectMap
* @assoc "" - "0..n" Table
* @assoc "" - "0..n" DataOperation
**/
class Root {
private Map m_adapters;
private List m_types;
private List m_maps;
private List m_tables;
private List m_ops;
public Adapter getAdapter(Class klass) {}
}
class Adapter {
public Root getRoot();
}
abstract class Element {
Root getRoot() {}
}
class ObjectType extends Element {}
/**
* @has "1..1" - "1..1" ObjectType
**/
class ObjectMap extends Element {
private ObjectType m_type;
}
class Table extends Element {}
class DataOperation extends Element {}
/**
* @hidden
* @opt nodefontname luxisr
* @opt nodefontabstractname luxisri
* @opt edgefontname luxisr
* @opt nodefontsize 8
* @opt edgefontsize 8
* @opt nodefillcolor LemonChiffon
*/
class UMLOptions {}
/**
* @view
* @opt attributes
* @opt operations
*/
class DetailedView {}
/**
* @view
*/
class Overview {}
and by invoking the following commands (assuming UmlGraph.jar is in the
current directory):
javadoc -doclet gr.spinellis.umlgraph.doclet.UmlGraph -private -docletpath UmlGraph.jar -views RootViews.java
dot -Tpng -o root-small.png Overview.dot
dot -Tpng -o root.png DetailedView.dot
Example: per package views
Views are especially interesting in big projects, since they allow to
generate package specific diagrams and overview diagrams in a quick and
consistent way.
As an example we include a few class diagrams that have been generated
from the DBCP connection pool,
without altering the sources and using association and dependency inference
instead.
The base view defines commons options, in particular the use of inference,
common class coloring and class visibility (in particular, we hide the
java runtime classes, with the exclusion of a few java.sql classes).
To avoid visual clutter, we have first shown the java.sql package contents, and
then hid selected classes.
The Overview
view provides a full view of the DBCP package,
generating quite a big diagram (click on the diagram to show a full size version).
package org.apache.commons;
/**
* @view
* @opt inferassoc
* @opt inferdep
* @opt useimports
*
* @match .*
* @opt nodefillcolor LightGray
*
* @match org.apache.commons.*
* @opt nodefillcolor PaleGreen
*
* @match org.apache.commons.dbcp.*
* @opt nodefillcolor LemonChiffon
*
* @match java.*|org.xml.*
* @opt hide
*
* @match java.sql.*
* @opt !hide
*
* @match java.sql\.(Ref|Time|Timestamp|Array|Date|Time|Clob|Blob|SQLException|.*MetaData.*|SQLWarning)
* @opt hide
*/
public abstract class BaseView {
}
/**
* @view
*/
public class Overview extends BaseView {
}
The CommonsDbcp
view concentrates on the content of org.apache.commons.dbcp
package, hiding other packages and subpackages available in the sources
(click on the diagram to show a full size version).
package org.apache.commons;
/**
* @view
*
* @match org.apache.commons.*
* @opt hide
*
* @match org.apache.commons.dbcp..*
* @opt !hide
*
* @match org.apache.commons.dbcp..*\..*
* @opt hide
*/
public class CommonsDbcp extends BaseView {}
Finally, the Statement
view shows only the Statement related
classes and their dependencies.
package org.apache.commons;
/**
* @view
*
* @match org.apache.commons.*
* @opt hide
*
* @match org.apache.commons.dbcp\..*Statement.*
* @opt !hide
*
* @match org.apache.commons.dbcp..*\..*
* @opt hide
*/
public class Statement extends BaseView {
}