| 1 |
Sun_Q_2020 |
Enhanced nano-aerosol loading performance of multilayer PVDF nanofiber electret filters |
Sun, Qiangqiang; Leung, Wallace Woon-Fong |
2020 |
2020-06-01 |
PMC |
N |
PMC7108370 |
|
10.1016/j.seppur.2020.116606 |
655polth |
0.996743 |
Yang_2007, Joe_Y_2014 |
Leung_2017, Park_2014, Hau_C_2016, Li_H_2009 |
| 2 |
Joe_Y_2014 |
Fabrication of an anti-viral air filter with SiO2–Ag nanoparticles and performance evaluation in a continuous airflow condition |
Joe, Yun Haeng; Woo, Kyoungja; Hwang, Jungho |
2014 |
2014-09-15 |
PMC |
N |
PMC7116941 |
25179108.0 |
10.1016/j.jhazmat.2014.08.013 |
568995ed |
0.990681 |
Sun_Q_2020, Yang_2007 |
Park_2014, Park_2020 |
| 3 |
Lin_T_2017 |
Filter quality of electret masks in filtering 14.6–594 nm aerosol particles: Effects of five decontamination methods |
Lin, Tzu-Hsien; Chen, Chih-Chieh; Huang, Sheng-Hsiu; Kuo, Chung-Wen; Lai, Chane-Yu; Lin, Wen-Yinn |
2017 |
2017-10-12 |
COMM-USE |
N |
PMC5638397 |
29023492.0 |
10.1371/journal.pone.0186217 |
3kzuvyqx |
0.968229 |
Sun_Q_2020 |
|
| 4 |
Woo_M_2012 |
Use of dialdehyde starch treated filters for protection against airborne viruses |
Woo, Myung-Heui; Grippin, Adam; Wu, Chang-Yu; Baney, Ronald H. |
2012 |
2012-04-30 |
PMC |
N |
PMC7094346 |
|
10.1016/j.jaerosci.2011.09.006 |
94713fz6 |
0.945608 |
Joe_Y_2014 |
Thevenin_2013, Quan_2017 |
| 5 |
Leung_2017 |
Skin layer in cyclic loading-cleaning of a nanofiber filter in filtering nano-aerosols |
Leung, Wallace Woon-Fong; Hau, Curie Wing Yi |
2017 |
2017-11-29 |
PMC |
N |
PMC7108461 |
|
10.1016/j.seppur.2017.07.043 |
wkep9ft5 |
0.907770 |
Sun_Q_2020, Yang_2007 |
Hau_C_2016, Park_2014, Sun_Q_2020 |
| 6 |
Rengasamy_2016 |
A comparison of facemask and respirator filtration test methods |
Rengasamy, Samy; Shaffer, Ronald; Williams, Brandon; Smit, Sarah |
2016 |
2016-12-20 |
PMC |
N |
PMC7157953 |
27540979.0 |
10.1080/15459624.2016.1225157 |
jydbfyvn |
0.886989 |
|
|
| 7 |
Li_H_2009 |
Removal and retention of viral aerosols by a novel alumina nanofiber filter |
Li, Hsing-Wang; Wu, Chang-Yu; Tepper, Fred; Lee, Jin-Hwa; Lee, Christiana Nicole |
2009 |
2009-01-31 |
PMC |
N |
PMC7094474 |
|
10.1016/j.jaerosci.2008.09.003 |
y19sfw69 |
0.863321 |
Sun_Q_2020, Yang_2007, Joe_Y_2014 |
Leung_2017, Hau_C_2016 |
| 8 |
Hyun_2017 |
Application of corona discharge-generated air ions for filtration of aerosolized virus and inactivation of filtered virus |
Hyun, Junho; Lee, Sang-Gu; Hwang, Jungho |
2017 |
2017-05-31 |
PMC |
N |
PMC7094352 |
|
10.1016/j.jaerosci.2017.02.004 |
1ct2cllv |
0.849426 |
Pocock_1975 |
Park_2014, Park_2020 |
| 9 |
Park_2014 |
Filtration and inactivation of aerosolized bacteriophage MS2 by a CNT air filter fabricated using electro-aerodynamic deposition |
Park, Kyu-Tae; Hwang, Jungho |
2014 |
2014-08-31 |
PMC |
N |
PMC7094535 |
|
10.1016/j.carbon.2014.04.019 |
g13zteit |
0.840470 |
Sun_Q_2020, Yang_2007, Joe_Y_2014 |
Hyun_2017 |
| 10 |
Hau_C_2016 |
Experimental investigation of backpulse and backblow cleaning of nanofiber filter loaded with nano-aerosols |
Hau, Curie Wing-Yi; Leung, Wallace Woon-Fong |
2016 |
2016-05-11 |
PMC |
N |
PMC7108244 |
|
10.1016/j.seppur.2016.02.041 |
6must45q |
0.832470 |
Yang_2007, Sun_Q_2020, Li_H_2009 |
Leung_2017, Park_2014, Sun_Q_2020, Li_H_2009 |
| 11 |
Woon_Fong_Leung_2020 |
Electrostatic Charged Nanofiber Filter for Filtering Airborne Novel Coronavirus (COVID-19) and Nano-aerosols |
Woon Fong Leung, Wallace; Sun, Qiangqiang |
2020 |
2020-04-22 |
PMC |
Y |
|
|
10.1016/j.seppur.2020.116886 |
ifpu2nyu |
0.796246 |
Sun_Q_2020 |
|
| 12 |
Yang_2007 |
Preparation and properties of hydroxyapatite filters for microbial filtration |
Yang, Lei; Ning, Xiaoshan; Chen, Kexin; Zhou, Heping |
2007 |
2007-04-30 |
PMC |
N |
PMC7115728 |
|
10.1016/j.ceramint.2005.10.014 |
huq2osyf |
0.780657 |
Sun_Q_2020 |
Wehling_2015 |
| 13 |
Park_2013 |
Susceptibility constants of airborne bacteria to dielectric barrier discharge for antibacterial performance evaluation |
Park, Chul Woo; Hwang, Jungho |
2013 |
2013-01-15 |
PMC |
N |
PMC7117052 |
23274942.0 |
10.1016/j.jhazmat.2012.12.006 |
e6r6pdm9 |
0.768470 |
|
Wang_2019, Shimoda_2019, Chang_2008, Yu_K_2008 |
| 14 |
Zhang_2006 |
Fabrication of a lithium chloride solution based composite supported liquid membrane and its moisture permeation analysis |
Zhang, Li-Zhi |
2006 |
2006-05-01 |
PMC |
N |
PMC7126743 |
|
10.1016/j.memsci.2005.09.035 |
y7lewk1t |
0.618637 |
Yang_2007 |
Yu_J_2009, Sun_Y_2017, Wehling_2015 |
| 15 |
Mukhopadhyay_2014 |
8 Composite nonwovens in filters: applications |
Mukhopadhyay, A. |
2014 |
2014-12-31 |
PMC |
N |
PMC7152121 |
|
10.1533/9780857097750.164 |
fjedzpu3 |
0.618510 |
Yang_2007, Sun_Q_2020 |
Yang_2007 |
| 16 |
Woo_M_2010 |
Method for contamination of filtering facepiece respirators by deposition of MS2 viral aerosols |
Woo, Myung-Heui; Hsu, Yu-Mei; Wu, Chang-Yu; Heimbuch, Brian; Wander, Joseph |
2010 |
2010-10-31 |
PMC |
N |
PMC7094656 |
|
10.1016/j.jaerosci.2010.07.003 |
7yuzl5he |
0.617646 |
Sun_Q_2020 |
Rengasamy_2010, Park_2014 |
| 17 |
Lv_W_2006 |
Virus removal performance and mechanism of a submerged membrane bioreactor |
Lv, Wenzhou; Zheng, Xiang; Yang, Min; Zhang, Yu; Liu, Ying; Liu, Junxin |
2006 |
2006-02-28 |
PMC |
N |
PMC7108226 |
|
10.1016/j.procbio.2005.06.005 |
3yjlndm4 |
0.598464 |
|
Lipson_2007, Sun_Y_2017, Pocock_1975 |
| 18 |
Yu_H_2018 |
An efficient virus aerosol sampler enabled by adiabatic expansion |
Yu, Haoran; Afshar-Mohajer, Nima; Theodore, Alexandros D.; Lednicky, John A.; Fan, Z. Hugh; Wu, Chang-Yu |
2018 |
2018-03-31 |
PMC |
N |
PMC7094368 |
|
10.1016/j.jaerosci.2018.01.001 |
q7r4p5u1 |
0.592507 |
|
Tseng_2005, Turgeon_2016, Park_2020 |
| 19 |
Lin_T_2018 |
Relative survival of Bacillus subtilis spores loaded on filtering facepiece respirators after five decontamination methods |
Lin, T.‐H.; Tang, F.‐C.; Hung, P.‐C.; Hua, Z.‐C.; Lai, C.‐Y. |
2018 |
2018-07-09 |
PMC |
N |
PMC7165566 |
29855107.0 |
10.1111/ina.12475 |
64ype84r |
0.554379 |
Pujols_2014, Pocock_1975 |
|
| 20 |
Nazeeri_2020 |
An Efficient Ethanol-Vacuum Method for the Decontamination and Restoration of Polypropylene Microfiber Medical Masks & Respirators |
Albert I. Nazeeri; Isaac A. Hilburn; Daw-An Wu; Kabir A. Mohammed; D. Yovan Badal; Moses H.W. Chan; Joseph L. Kirschvink |
2020 |
2020-04-16 |
BioRxiv |
Y |
|
|
10.1101/2<IP_ADDRESS>59709 |
ncjdsbn4 |
0.502226 |
|
|
| 21 |
Xia_T_2019 |
Inactivation of airborne viruses using a packed bed non-thermal plasma reactor |
Xia, T; Kleinheksel, A; Lee, E M; Qiao, Z; Wigginton, K R; Clack, H L |
2019 |
2019-06-19 |
PMC |
N |
PMC7106774 |
|
10.1088/1361-6463/ab1466 |
ycldu1vj |
0.454317 |
|
Park_2020 |
| 22 |
Yu_K_2016 |
Improving the collection efficiency of the liquid impinger for ultrafine particles and viral aerosols by applying granular bed filtration |
Yu, Kuo-Pin; Chen, Yen-Ping; Gong, Jia-You; Chen, Yen-Chi; Cheng, Chih-Ching |
2016 |
2016-11-30 |
PMC |
N |
PMC7127017 |
|
10.1016/j.jaerosci.2016.08.002 |
364jmby6 |
0.437033 |
Sun_Q_2020, Tseng_2005, Yang_2007 |
Tseng_2005, Park_2014, Sun_Y_2017 |
| 23 |
Park_2020 |
Determination of Air Filter Anti-Viral Efficiency against an Airborne Infectious Virus |
Park, Dae Hoon; Joe, Yun Haeng; Piri, Amin; An, Sanggwon; Hwang, Jungho |
2020 |
2020-04-12 |
PMC |
N |
|
|
10.1016/j.jhazmat.2020.122640 |
xpkwrwy9 |
0.431540 |
|
|
| 24 |
Li_J_2018 |
Comparing the performance of 3 bioaerosol samplers for influenza virus |
Li, Jiayu; Leavey, Anna; Wang, Yang; O’Neil, Caroline; Wallace, Meghan A.; Burnham, Carey-Ann D.; Boon, Adrianus CM; Babcock, Hilary; Biswas, Pratim |
2018 |
2018-01-31 |
PMC |
N |
PMC7125700 |
|
10.1016/j.jaerosci.2017.08.007 |
284yyvzr |
0.412309 |
Tseng_2005, Kylberg_2009 |
Thevenin_2013 |
| 25 |
Quan_2017 |
Universal and reusable virus deactivation system for respiratory protection |
Quan, Fu-Shi; Rubino, Ilaria; Lee, Su-Hwa; Koch, Brendan; Choi, Hyo-Jick |
2017 |
2017-01-04 |
COMM-USE |
N |
PMC5209731 |
28051158.0 |
10.1038/srep39956 |
imivfkaj |
0.407277 |
|
|
| 26 |
Wehling_2015 |
Silver nanoparticle-doped zirconia capillaries for enhanced bacterial filtration |
Wehling, Julia; Köser, Jan; Lindner, Patrick; Lüder, Christian; Beutel, Sascha; Kroll, Stephen; Rezwan, Kurosch |
2015 |
2015-03-01 |
PMC |
N |
PMC7126630 |
25579912.0 |
10.1016/j.msec.2014.12.001 |
qh1mlxn3 |
0.391729 |
Yang_2007, Sun_Q_2020, Joe_Y_2014 |
Chang_2008 |
| 27 |
Liao_2020 |
Can N95 respirators be reused after disinfection? And for how many times? |
Lei Liao; Wang Xiao; Mervin Zhao; Xuanze Yu; Haotian Wang; Qiqi Wang; Steven Chu; Yi Cui |
2020 |
2020-04-07 |
BioRxiv |
Y |
|
|
10.1101/2<IP_ADDRESS>50443 |
dm1wkpnv |
0.350733 |
|
Kenney_2020, Goyal_2014 |
| 28 |
Oh_S_2010 |
Development and evaluation of a novel bioaerosol amplification unit (BAU) for improved viral aerosol collection |
Oh, Sewon; Anwar, Diandra; Theodore, Alexandros; Lee, Jin-Hwa; Wu, Chang-Yu; Wander, Joe |
2010 |
2010-09-30 |
PMC |
N |
PMC7094383 |
|
10.1016/j.jaerosci.2010.06.002 |
ex0lpl4q |
0.328583 |
Tseng_2005 |
|
| 29 |
Cramer_2020 |
Disposable N95 Masks Pass Qualitative Fit-Test But Have Decreased Filtration Efficiency after Cobalt-60 Gamma Irradiation |
Avilash Cramer; Enze Tian; Sherryl H Yu; Mitchell Galanek; Edward Lamere; Ju Li; Rajiv Gupta; Michael P Short |
2020 |
2020-03-30 |
BioRxiv |
Y |
|
|
10.1101/2<IP_ADDRESS>43471 |
kl9huu33 |
0.324914 |
|
Smith_2020, Kenney_2020 |


@* * Copyright 2021 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @(form: Form[_], html: Html)(implicit messages: Messages) @errs = @{form.errors.filter(_.key.contains("noFieldsCompleted"))}


| Opcode*/Instruction | Op/En | 64/32 bit Mode Support | CPUID Feature Flag | Description |
| 66 0F C6 /r ib SHUFPD xmm1, xmm2/m128, imm8 | RMI | V/V | SSE2 | Shuffle packed double-precision floatingpoint values selected by imm8 from xmm1 and xmm2/m128 to xmm1. |
| VEX.NDS.128.66.0F.WIG C6 /r ib VSHUFPD xmm1, xmm2, xmm3/m128, imm8 | RVMI | V/V | AVX | Shuffle Packed double-precision floatingpoint values selected by imm8 from xmm2 and xmm3/mem. |
| VEX.NDS.256.66.0F.WIG C6 /r ib VSHUFPD ymm1, ymm2, ymm3/m256, imm8 | RVMI | V/V | AVX | Shuffle Packed double-precision floatingpoint values selected by imm8 from ymm2 and ymm3/mem. |
| Op/En | Operand 1 | Operand 2 | Operand 3 | Operand 4 |
| RMI | ModRM:reg (r, w) | ModRM:r/m (r) | imm8 | NA |
| RVMI | ModRM:reg (w) | VEX.vvvv (r) | ModRM:r/m (r) | imm8 |
Moves either of the two packed double-precision floating-point values from destination operand (first operand) into the low quadword of the destination operand; moves either of the two packed double-precision floating-point values from the source operand into to the high quadword of the destination operand (see Figure 4-21). The select operand (third operand) determines which values are moved to the destination operand.
In 64-bit mode, using a REX prefix in the form of REX.R permits this instruction to access additional registers (XMM8-XMM15). 128-bit Legacy SSE version: The source can be an XMM register or an 128-bit memory location. The destination is not distinct from the first source XMM register and the upper bits (VLMAX-1:128) of the corresponding YMM register destination are unmodified. VEX.128 encoded version: the first source operand is an XMM register or 128-bit memory location. The destination operand is an XMM register. The upper bits (VLMAX-1:128) of the corresponding YMM register destination are zeroed. VEX.256 encoded version: The first source operand is a YMM register. The second source operand can be a YMM register or a 256-bit memory location. The destination operand is a YMM register.
| X1 | X0 DEST |
| Y1 | Y0 X1 or X0 |
| SHUFPD Shuffle Operation | Figure 4-21. |
The source operand can be an XMM register or a 128-bit memory location. The destination operand is an XMM register. The select operand is an 8-bit immediate: bit 0 selects which value is moved from the destination operand to the result (where 0 selects the low quadword and 1 selects the high quadword) and bit 1 selects which value is moved from the source operand to the result. Bits 2 through 7 of the select operand are reserved and must be set to 0.
IF SELECT[0] = 0 THEN DEST[63:0] ELSE DEST[63:0] IF SELECT[1] = 0 THEN DEST[127:64] ELSE DEST[127:64] SHUFPD (128-bit Legacy SSE version) IF IMM0[0] = 0 THEN DEST[63:0] ← SRC1[63:0] ELSE DEST[63:0] ← SRC1[127:64] FI; IF IMM0[1] = 0 THEN DEST[127:64] ← SRC2[63:0] ELSE DEST[127:64] ← SRC2[127:64] FI; DEST[VLMAX-1:128] (Unmodified) VSHUFPD (VEX.128 encoded version) IF IMM0[0] = 0 THEN DEST[63:0] ← SRC1[63:0] ELSE DEST[63:0] ← SRC1[127:64] FI; IF IMM0[1] = 0 THEN DEST[127:64] ← SRC2[63:0] ELSE DEST[127:64] ← SRC2[127:64] FI; DEST[VLMAX-1:128] ← 0 VSHUFPD (VEX.256 encoded version) IF IMM0[0] = 0 THEN DEST[63:0] ← SRC1[63:0] ELSE DEST[63:0] ← SRC1[127:64] FI; IF IMM0[1] = 0 THEN DEST[127:64] ← SRC2[63:0] ELSE DEST[127:64] ← SRC2[127:64] FI; IF IMM0[2] = 0 THEN DEST[191:128] ← SRC1[191:128] ELSE DEST[191:128] ← SRC1[255:192] FI; IF IMM0[3] = 0 THEN DEST[255:192] ← SRC2[191:128] ELSE DEST[255:192] ← SRC2[255:192] FI;
| SHUFPD: | __m128d _mm_shuffle_pd(__m128d a, __m128d b, unsigned int imm8) |
| VSHUFPD: | __m256d _mm256_shuffle_pd (__m256d a, __m256d b, const int select); |
None.
See Exceptions Type 4.


Around The World in 263 ISO 3166-1 alpha-2 codes
This is a simple quiz game designed to aid the learning of the 2 digit ISO country code abbreviations, e.g. pt = Portugal, am = Armenia. For more information on them and a full listing see this Wikipedia article.
Click a button to select your game type.


Implements reinforcement learning environments and algorithms as described in Sutton & Barto (1998, ISBN:0262193981). The Q-Learning algorithm can be used with different types of function approximation (tabular and neural network), eligibility traces (Singh & Sutton (1996) <doi:10.1007/BF00114726>) and experience replay (Mnih et al. (2013) <arXiv:1312.5602>).
| Version: | 0.1.0 |
| Depends: | R (≥ 3.0.0) |
| Imports: | checkmate (≥ 1.8.4), R6 (≥ 2.2.2), nnet (≥ 7.3-12), purrr (≥ 0.2.4) |
| Suggests: | reticulate, keras, knitr, rmarkdown, testthat, covr, lintr |
| Published: | 2018-01-03 |
| Author: | Markus Dumke [aut, cre] |
| Maintainer: | Markus Dumke <markusdumke at gmail.com> |
| BugReports: | https://github.com/markusdumke/reinforcelearn/issues |
| License: | MIT + file LICENSE |
| URL: | http://markusdumke.github.io/reinforcelearn |
| NeedsCompilation: | no |
| SystemRequirements: | (Python and gym only required if gym environments are used) |
| Materials: | README NEWS |
| CRAN checks: | reinforcelearn results |
| Reference manual: | reinforcelearn.pdf |
| Vignettes: |
Agents Environments |
| Package source: | reinforcelearn_0.1.0.tar.gz |
| Windows binaries: | r-devel: reinforcelearn_0.1.0.zip, r-release: reinforcelearn_0.1.0.zip, r-oldrel: reinforcelearn_0.1.0.zip |
| OS X binaries: | r-release: reinforcelearn_0.1.0.tgz, r-oldrel: reinforcelearn_0.1.0.tgz |
Please use the canonical form https://CRAN.R-project.org/package=reinforcelearn to link to this page.


{% extends 'email-layout.server.view.html' %} {% block content %}
Below is the final attendance tally for event {{eventName}} in group {{groupName}}


QUIZ SHOW A film review by Eric Grossman Copyright 1994 LOS ANGELES INDEPENDENT
In our cynical times, a rigged game show would probably have a tough time making the front page of a newspaper, let alone throwing a nation into shock. However, it is substantial enough to make a compelling film. QUIZ SHOW, Robert Redford's latest directorial effort is a thoughtful, extremely well crafted movie about the fixing of the 1950's game show, "Twenty One."
John Turturro plays Herb Stempel, a smart but uncharismatic man who, as someone in the film said, "has a face fit for radio." Stempel is the top- rated show's reigning champion, battling new-comers each week as he heads towards the big win. But when the ratings begin to slip, the chairman of NBC and the show's sponsor, Geritol, tell the producer, Dan Enright (David Paymer),to find a more charismatic champion. Enright quickly takes action and offers Stempel seventy thousand dollars if he will take a dive to challenger Charles Van Doren (Ralph Fiennes).
A member of the aristocracy, Van Doren is a handsome college professor who is at first wary of Enright's proposal but is soon overwhelmed by the chance for fame and fortune. To take over the role of reigning champion, Van Doren is fed the supposedly secret questions and answers before the show. Richard Goodwin (Rob Morrow) is a bright, young lawyer fresh out of Harvard LawSchool who begins investigating for the Congressional Oversight Committee, Stempel's claim that the show was rigged. During the investigation, Goodwin becomes friends with the charming Van Doren and he must then wrestle with the dilemma of putting television on trial without destroying the lives of the contestants in a McCarthy-like ordeal.
A major theme in QUIZ SHOW is temptation. The temptation to violate the public trust for the sake of higher ratings, the temptation to trade one's values for fame and fortune, and the temptation to look the other way to be accepted by the Establishment. As Jews, Stempel and Goodwin are both outsider to society's elite. However, Goodwin is more polished, more acceptable with his educational background and last name ("its Goodwin, not Goodman," he says) to the Charlie Van Dorens of the world. Goodwin wants to be Van Doren's friend so badly that at one point his wife tells him that he is "the Uncle Tom of the Jews." By the end of the film, Goodwin learns that Van Doren does not have the character he thought he had, but he still cannot help but admire him.
John Turturro once again turns in an excellent performance as Stempel, the man who blows the whistle on the show because he was denied fame and fortune. The tragedy of Stempel's character is that he failed to realize that the public did not want someone like him, they wanted a handsome, wholesome face.
It will be very surprising if Ralph Fiennes does not receive a second Oscar nomination for his performance as Charles Van Doren. Unlike his character in SCHINDLER'S LIST, we feel sympathy for this man who has done a great wrong but who is also a victim. The primary basis for the sympathy is that Van Dorenis a man living under the shadow of his over-achieving uncle and father. Desperately wanting to carve out his own name and success, he succumbs to temptation. It is difficult to condemn him for taking the road to easy money and fame which had eluded him, despite his high intellect and strong pedigree. In addition, the network (NBC) and the sponsor (Geritol) are the ones who were the were the most guilty and who got off with the least punishment. Goodwin does place television on trial but ends up hurting only the contestants in the end. The producers who were implicated went on to do the "Joker's Wild" and Goodwin ended up being a speech-writer for Kennedy before settling down as a writer.
The film's beautiful look created by cinematographer Michael Ballhaus, production designer John Hutman and costume designer Kathy O'Rear is as much of a treat to watch as the acting. Redford's direction is nearly flawless. His choices of shots, grasp of the conflict and use of subtlety is what makes the difference in this film. The screenplay by Paul Attanasio does drag in parts but overall it is well written, particularly the scenes between Charles and his father, played with powerful presence by Paul Scofield.
QUIZ SHOW gives us an entertaining account of the genesis of television's moral decay. The film shows us a time when people were not cynical and trusted that whatever they saw on the "tube," was true. Redford uses the rigging of "Twenty One" as a focal point for the beginning of the end of that trust. But far more sobering than the rigging of the quiz shows is that even today, with all the talk-shows, tabloid news, "Date Line" scandals and political commercials, is that television influences our opinions more than ever.
.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Welcome support personnel!
To begin, please tell us who you are, and click the Begin button to make yourself available to customers.
Your name:


+234<PHONE_NUMBER>
<EMAIL_ADDRESS>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut elit tellus, luctus nec ullamcorper mattis, pulvinar dapibus leo. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut elit tellus, luctus nec ullamcorper mattis, pulvinar dapibus leo. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut elit tellus, luctus nec ullamcorper mattis, pulvinar dapibus leo.
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut elit tellus, luctus nec ullamcorper mattis, pulvinar dapibus leo. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut elit tellus, luctus nec ullamcorper mattis, pulvinar dapibus leo. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut elit tellus, luctus nec ullamcorper mattis, pulvinar dapibus leo.
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry’s standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry’s standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into
8 June, 2020
8 June, 2020
8 June, 2020
8 June, 2020
8 June, 2020
8 June, 2020
+234<PHONE_NUMBER>
contact@landmarklagos.com


SAFS Framework Development
by Carl Nagle
Last Updated:
This document attempts to illustrate the basic flow of our ever-growing SAFS Framework Architecture. This document will grow with information as our development moves forward.
See also:
Java Interface,
SAFSDEV Project
Fig. 1: SAFS Framework Architecture Flow
(click a node for API info)
Figure 1 shows the existing SAFS Framework tools and STAF services. The upcoming Selenium engine is also shown. The completion of this engines is tentatively expected in the first quarter of 2008.
- Note: IBM Rational Robot (SAFS/RRAFS) currently cannot be run as a standalone SAFS/STAF engine. It can be a Driver, it is its own engine, and it can talk to or drive other SAFS/STAF Engines like IBM Rational Functional Tester (SAFS/RobotJ). However, currently IBM Rational Robot cannot be externally driven as a standard SAFS engine by another Driver like the TID (SAFSDRIVER).
- Note: WinRunner (SAFS/WRAFS) is a standalone execution engine that cannot call other SAFS engines and it cannot be externally driven by another Driver like the TID (SAFSDRIVER).
- Note: The Java JVMAgents and Abbot are essentially the same. Abbot is a subclass implementation exploiting the tool-independent JVMAgents. Abbot has minimal support implemented for proof-of-concept until such time as a greater need arises and resources are dedicated.
Fig. 2: SAFS Framework Application Environment Support
Figure 2 shows the existing SAFS Framework support. This is intended to show which types of application environments are supported by specific toolsets.


|
EmberZNet API Reference: For the EM35x SoC Platform
EmberZNet <IP_ADDRESS>
For the EFR32 and EM3xx Platforms
|
Functions | |
| uint8_t | emberGetCurrentNetwork (void) |
| Returns the current network index. More... | |
| EmberStatus | emberSetCurrentNetwork (uint8_t index) |
| Sets the current network. More... | |
| uint8_t | emberGetCallbackNetwork (void) |
| Can only be called inside an application callback. More... | |
See multi-network.h for source code.
| uint8_t emberGetCallbackNetwork | ( | void | ) |
Can only be called inside an application callback.
| uint8_t emberGetCurrentNetwork | ( | void | ) |
Returns the current network index.
| EmberStatus emberSetCurrentNetwork | ( | uint8_t | index | ) |
Sets the current network.
| index | The network index. |


Lewis Carroll
The Reverend Charles Lutwidge Dodgson, better known by the pen name Lewis Carroll, was an English author, mathematician, logician, Anglican clergyman, and photographer. His most famous writings are Alice’s Adventures in Wonderland and its sequel Through the Looking-Glass as well as the poems “The Hunting of the Snark” and “Jabberwocky.”
- Nationality: English
- Birth Date: 27 Jan 1832
- Death Date: 14 Jan 1898
Available Works
- Alice's Adventures in Wonderland (1865)
- Alice’s Adventures in Wonderland is a work of children’s literature by the English mathematician and author, Reverend Charles Lutwidge Dodgson, written under the pseudonym Lewis Carroll. It tells the story of a girl named Alice who falls down a rabbit-hole into a fantasy realm populated by talking playing cards and anthropomorphic creatures. The tale is fraught with satirical allusions to Dodgson’s friends and to the lessons that British schoolchildren were expected to memorize. The Wonderland described in the tale plays with logic in ways that has made the story of lasting popularity with children as well as adults. The book is often referred to by the abbreviated title Alice in Wonderland. This alternate title was popularized by the numerous film and television adaptations of the story produced over the years. Some printings of this title contain both Alice’s Adventures in Wonderland and its sequel Through the Looking-Glass, and What Alice Found There. To access artwork from the 1889 Harper's publication, visit the Alice's Adventures in Wonderland collection on ClipArt ETC.
- The Game of Logic (1886)
- Lewis Carroll's Game of Logic is a way to understand classical logic by means of symbols.
- Sylvie and Bruno (1889)
- Sylvie and Bruno, first published in 1889, and its 1893 second volume Sylvie and Bruno Concluded form the last novel by Lewis Carroll published during his lifetime. Both volumes were illustrated by Harry Furniss. The novel has two main plots: one set in the real world at the time the book was published (the Victorian era), the other in the fictional world of Fairyland. While the latter plot is a fairytale with many nonsense elements and poems, similar to Carroll’s most famous children’s book Alice’s Adventures in Wonderland, the story set in Victorian Britain is a social novel, with its characters discussing various concepts and aspects of religion, society, philosophy and morality.
- Sylvie and Bruno Concluded (1893)
- Sylvie and Bruno, first published in 1889, and its 1893 second volume Sylvie and Bruno Concluded form the last novel by Lewis Carroll published during his lifetime. Both volumes were illustrated by Harry Furniss. The novel has two main plots: one set in the real world at the time the book was published (the Victorian era), the other in the fictional world of Fairyland. While the latter plot is a fairytale with many nonsense elements and poems, similar to Carroll’s most famous children’s book Alice’s Adventures in Wonderland, the story set in Victorian Britain is a social novel, with its characters discussing various concepts and aspects of religion, society, philosophy and morality.
- Symbollic Logic (1896)
- Symbollic Logic is a text discussing the area of mathematics which studies the purely formal properties of strings of symbols.
- Poems, Puzzles, and Stories of Lewis Carroll (2012)
- Lewis Carroll, author of Alice in Wonderland and Through the Looking Glass, also compoosed logic puzzles, riddles, and satirical poems. This collection includes several that were including in longer works and those intended to stand alone.


Foreign Exchange Department First National Bank South Africa. DR. Taofeek Marvin<EMAIL_ADDRESS>Dear Friend, I,DR Taofeek Marvin, the Director of Bills & Exchange of the foreign Remittance Department at FIRST NATIONAL BANK SOUTH AFRICA. I got your address while searching for trustworthy individuals in various countries. In my department, we discovered an abandoned sum of $25, 5 million US Dollars in an account that belongs to one of our foreign customers who died with his family in the September 11th plane crash. Since we got information about his death, we have been expecting his next of kin to come to our bank and claim his money because we cannot release it unless somebody applies for it as a next of kin or relative to the deceased as indicated in our banking guidelines but unfortunately we learnt that all his supposed relatives died in the same plane crash leaving no relative behind to claim the fund. It is upon this discovery that l and other officials in my department decided to make this business proposal to you and release the money to you as the next of kin or relative to the deceased for safety and subsequent disbursement since nobody is coming for it and we do not want this money to go into our bank treasury as an unclaimed fund. The banking law and guidelines here stipulate that if such money remained unclaimed after four years, the money will be transferred into the bank treasury as unclaimed funds. The request for a foreigner as a relative for this claim is occasioned by the fact that the customer was a foreigner and a South African cannot claim this fund as next of kin. We agreed that 20% of this money will go to the foreign partner who will supply the foreign account, 5% will be set aside for expenses incurred during the transaction and 75% will be for me and my colleagues. Thereafter and my colleagues will visit your country for disbursement of the percentages as indicated above. If you are interested to assist in this transaction, kindly contact the writer on the above mobile number or private e-mail address. Please this transaction is risk free and you should not entertain any atom of fear as all required arrangements have been made for transfer. Yours Faithfully, DR Taofeek Marvin Bill & Exchange Director


From 4-15 April, history will be made on the Gold Coast.
The Gold Coast 2018 Commonwealth Games (GC2018) will welcome more than 6,600 athletes and team officials from 70 Commonwealth nations and territories to the Gold Coast and event cities Brisbane, Cairns and Townsville, to share in the celebration of sport, entertainment and culture.
In a hotly-anticipated blockbuster summer of sport, the Gabba opens the toss on the first Ashes Test between England and Australia from November 23. Itself a part of cricketing folklore in the heart of Brisbane, the venue is aptly nicknamed the ‘fortress’ in international cricketing circles. Why? Australia has not lost a Test at the Gabba since 1988, winning 21 and drawing seven.
Queensland cements its reputation as the home of Rugby League, securing the ultimate advantage as host of the grand final of the 2017 Rugby League World Cup in Brisbane. What’s more, Brisbane also scored one of two semi-final games (in November), while fans in Townsville and Cairns secured front row seats to World Cup action during six pool matches (in October and November). Guaranteed: blood, sweat and cheers!


{% extends "_post.html" %} {%hyde title: "rcd for fedora core 3" created: 2005-03-30 01:59:54 %} {% block article %} {%article%}
A volunteer has packaged rcd/rug for fc3, and I have put the rpms here. Enjoy.


UCLA Engineering Commencement Speech
On June 17, 2017, I had the honor to speak about what being an Engineer means to me in front of 10,000+ people in Pauley Pavilion, at the 2017 UCLA Engineering Commencement for PhDs, Masters, and Bachelors degree recipients. As the Commencement Student Speaker, I wanted to find a voice that resonates with all Engineers, and so I focused on the qualities that applies to all of us moving forward: Mentorship. Learning. Community.
“Power comes not from knowledge kept, but from knowledge shared.”” — Bill Gates
Likewise, I believe that shared knowledge is very powerful, so I have provided my full commencement speech below. The full video of my speech is on YouTube here (starts at 1:59:20).
Good afternoon, friends, family, UCLA engineering faculty, and of course, the UCLA Engineering Class of 2017!
Tomorrow is Father’s Day, so I wanted to thank my dad, and all the fathers out there in this stadium. Thank you!
And now, to the graduates: Congratulations on this phenomenal achievement. It is absolutely amazing that we have the opportunity to celebrate our commencement in the legendary Pauley Pavilion. I had a lot of great memories in this space: cheering in the student section during Basketball games and Gymnastics meets, watching my friends perform at UCLA’s annual Spring Sing Talent Show, dancing for 26 hours non-stop at Dance Marathon, and lastly, organizing an event here that is very special to me: LA Hacks.
LA Hacks is a hackathon, a competition where the goal is to build innovative products within the span of 36 hours. The LA Hacks team has always believed that hackathons inspire the next generation of students to pursue STEM related fields; I was inspired to major in Computer Science after attending my first hackathon; While choosing my major was straightforward for me, I found myself constantly trying to answer the question: “What does being an engineer mean to me?”
Engineer.
When you hear the word ‘Engineer’, what is the first image, or word, or description you think of? Now I know we are all proud to be graduating engineers, and I am sure some of us will move on to make a breakthrough in the STEM cell research, develop new synthetic materials, create the next unicorn startup, send a team of astronauts to new planets and beyond, or construct a brand-new transportation system that can finally solve LA’s traffic. In fact, that might be what you all thought about: the technical problems your engineering major can solve.
When I hear the word Engineer, these are the three universal things I see:
First, I see MENTORSHIP. There continues to be a large barrier of entry for STEM related fields, especially engineering. As we move on to industry, graduate school, or other fields of work, we have the power to be advocates for the next generation of engineers. Bill Gates once said “Power comes not from knowledge kept but from knowledge shared”, and this resonated with me every week in my CS 88S class, an undergraduate seminar I taught on cybersecurity. The class was open to any student, no programming or CS background required, just an interest for a more cybersecurity-aware society. The first step to breaking down the barrier to STEM is to spark passion, and that cannot happen without mentorship. Being an engineer is about helping others, spreading knowledge, and using your experience to guide people in doing their best.
Next, I see LEARNING. We received two forms of education here at UCLA. In the classrooms and lectures, we learned about engineering methodologies — all the core math, physics, and chemistry that we have grown to love. However, in the college environment and student body, we became aware about our field’s gender, intersectionality, and diversity issues. Only when we are open to learning new ideas will we understand the problems that lie ahead, and in turn, what we need to do to solve them. Learning does not stop once we leave college; in fact, learning is a lifelong endeavor, an intellectual growth way beyond university. It is up to us to grow as individuals, learn with each other, and live those moments well.
This leads me to my last observation: I see a COMMUNITY. There are more than 40 UCLA engineering student organizations. Some cater to specific majors, some welcome any type of engineering, but they all have one theme in common: they build community, a supportive group of individuals who treat each other equally and with respect. We did not make it to this day by ourselves alone. At some point or another, we all had our community to fall back on, to support us, and to carry us to this day! While engineers around the world have made significant technological advancements, such as self-driving cars, bionic limbs, and reusable rockets, we have yet to resolve key issues in our very own community: gender discrimination and racial inequality in the workplace. We were able to build such a great engineering community here at UCLA, now it is our time to help make that happen outside of the college campus.
Engineer.
A single word, now with a deeper meaning than before: Mentorship. Learning. Community. That is what being an engineer means for me. Let us all not only keep these three qualities in mind, but also bring them to reality in our own respective fields! Today, we graduate; but tomorrow, while we all have our own path to follow, we have a collective responsibility to uphold our understanding of what being an Engineer means to us, to our society, and to the future we will help create! Thank you!


« CSS « CSS Reference
The border-color
CSS property is a shorthand property for setting the color of the four sides of an element's border:
border-top-color
,
border-right-color
,
border-bottom-color
,
border-left-color
color
propertyvisual
color
by default, or as specified.border-color: [ <color> || transparent ]{1,4} | inherit
Accepts one, two, tree or four values.
<color>
value for possible keywords and units.If one color value is given, it applies to all four borders.
Two values apply first to the top and bottom border and second to the left and right border.
Three values apply first to the top, second to the left and right and third to the bottom border.
Four values apply to top, right, bottom and left border in that order.
In order to see the border you must at least set the
border-style
to something visible.
| Feature | Firefox (Gecko) | Chrome | Internet Explorer | Opera | Safari |
|---|---|---|---|---|---|
| Basic support | 1.0 (1.7 or earlier) | 1.0 | 4.0 | 3.5 | 1.0 (85) |
| Feature | Firefox Mobile (Gecko) | Android | IE Phone | Opera Mobile | Safari Mobile |
|---|---|---|---|---|---|
| Basic support | 1.0 (1.9.2) | ? | ? | ? | ? |
The following Mozilla extensions set the border sides to multiple colors for Gecko based browsers like Firefox.
-moz-border-top-colors
,
-moz-border-right-colors
,
-moz-border-bottom-colors
,
-moz-border-left-colors


Work Day Scheduler
A simple calendar app for scheduling your work day
8 AM
Save
9 AM
Save
10 AM
Save
11 AM
Save
12 PM
Save
1 PM
Save
2 PM
Save
3 PM
Save
4 PM
Save
5 PM
Save


--- layout: post title: 'Java Enums: You have grace, elegance and power and this is what I Love!' date: 2012-09-07 12:34:42.000000000 +02:00 type: post published: true status: publish categories: - Programmation tags: - clean - dsl - enum - hack - immutable - interface - java - object - optimization - polymorphism - programming - singleton - state - strategy - syntax - valueobject meta: _edit_last: '1' _activeshortener: tiny _twitterrelated_short_url: http://tinyurl.com/d6ompm9 _twitterrelated_short_urlHash: 04d5537c249c1e4729cb88ac21030f6b sfw_pwd: yG4zMVVjHpgc _wpcom_is_markdown: '1' author: login: cyrille martraire email<EMAIL_ADDRESS>display_name: Cyrille first_name: Cyrille last_name: Martraire ---
While Java 8 is coming, are you sure you know well the enums that were introduced in Java 5? Java enums are still underestimated, and it’s a pity since they are more useful than you might think, they’re not just for your usual enumerated constants!
Java enums are real classes that can have behavior and even data.
Let’s represent the Rock-Paper-Scissors game using an enum with a single method. Here are the unit tests to define the behavior:
@Test public void paper_beats_rock() { assertThat(PAPER.beats(ROCK)).isTrue(); assertThat(ROCK.beats(PAPER)).isFalse(); } @Test public void scissors_beats_paper() { assertThat(SCISSORS.beats(PAPER)).isTrue(); assertThat(PAPER.beats(SCISSORS)).isFalse(); } @Test public void rock_beats_scissors() { assertThat(ROCK.beats(SCISSORS)).isTrue(); assertThat(SCISSORS.beats(ROCK)).isFalse(); }
/** Enums have behavior! */ public enum Gesture { ROCK() { // Enums are polymorphic, that's really handy! @Override public boolean beats(Gesture other) { return other == SCISSORS; } }, PAPER, SCISSORS; // we can implement with the integer representation public boolean beats(Gesture other) { return ordinal() - other.ordinal() == 1; } }
Notice that there is not a single IF statement anywhere, all the business logic is handled by the integer logic and by the polymorphism, where we override the method for the ROCK case. If the ordering between the items was not cyclic we could implement it just using the natural ordering of the enum, here the polymorphism helps deal with the cycle.
This Java enum is also a perfect example that you can have your cake (offer a nice object-oriented API with intent-revealing names), and eat it too (implement with simple and efficient integer logic like in the good ol’ days).
Over my last projects I’ve used a lot enums as a substitute for classes: they are guaranted to be singleton, have ordering, hashcode, equals and serialization to and from text all built-in, without any clutter in the source code.
If you’re looking for Value Objects and if you can represent a part of your domain with a limited set of instances, then the enum is what you need! It’s a bit like the Sealed Case Class in Scala, except it’s totally restricted to a set of instances all defined at compile time. The bounded set of instances at compile-time is a real limitation, but now with continuous delivery, you can probably wait for the next release if you really need one extra case.
Let’s move to to a system for the (in-)famous Eurovision song contest; we want to be able to configure the behavior on when to notify (or not) users of any new Eurovision event. It’s important. Let’s do that with an enum:
/** The policy on how to notify the user of any Eurovision song contest event */ public enum EurovisionNotification { /** I love Eurovision, don't want to miss it, never! */ ALWAYS() { @Override public boolean mustNotify(String eventCity, String userCity) { return true; } }, /** * I only want to know about Eurovision if it takes place in my city, so * that I can take holidays elsewhere at the same time */ ONLY_IF_IN_MY_CITY() { // a case of flyweight pattern since we pass all the extrinsi data as // arguments instead of storing them as member data @Override public boolean mustNotify(String eventCity, String userCity) { return eventCity.equalsIgnoreCase(userCity); } }, /** I don't care, I don't want to know */ NEVER() { @Override public boolean mustNotify(String eventCity, String userCity) { return false; } }; // no default behavior public abstract boolean mustNotify(String eventCity, String userCity); }
And a unit test for the non trivial case ONLY_IF_IN_MY_CITY:
@Test public void notify_users_in_Baku_only() { assertThat(ONLY_IF_IN_MY_CITY.mustNotify("Baku", "BAKU")).isTrue(); assertThat(ONLY_IF_IN_MY_CITY.mustNotify("Baku", Paris")).isFalse(); }
Here we define the method abstract, only to implement it for each case. An alternative would be to implement a default behavior and only override it for each case when it makes sense, just like in the Rock-Paper-Scissors game.
Again we don’t need the switch on enum to choose the behavior, we rely on polymorphism instead. You probably don’t need the switch on enum much, except for dependency reasons. For example when the enum is part of a message sent to the outside world as in Data Transfer Objects (DTO), you do not want any dependency to your internal code in the enum or its signature.
For the Eurovision strategy, using TDD we could start with a simple boolean for the cases ALWAYS and NEVER. It would then be promoted into the enum as soon as we introduce the third strategy ONLY_IF_IN_MY_CITY. Promoting primitives is also in the spirit of the 7th rule « Wrap all primitives » from the Object Calisthenics, and an enum is the perfect way to wrap a boolean or an integer with a bounded set of possible values.
Because the strategy pattern is often controlled by configuration, the built-in serialization to and from String is also very convenient to store your settings.
Just like the Strategy pattern, the Java enum is very well-suited for finite state machines, where by definition the set of possible states is finite.
Let’s take the example of a baby simplified as a state machine, and make it an enum:
/** * The primary baby states (simplified) */ public enum BabyState { POOP(null), SLEEP(POOP), EAT(SLEEP), CRY(EAT); private final BabyState next; private BabyState(BabyState next) { this.next = next; } public BabyState next(boolean discomfort) { if (discomfort) { return CRY; } return next == null ? EAT : next; } }
And of course some unit tests to drive the behavior:
@Test public void eat_then_sleep_then_poop_and_repeat() { assertThat(EAT.next(NO_DISCOMFORT)).isEqualTo(SLEEP); assertThat(SLEEP.next(NO_DISCOMFORT)).isEqualTo(POOP); assertThat(POOP.next(NO_DISCOMFORT)).isEqualTo(EAT); } @Test public void if_discomfort_then_cry_then_eat() { assertThat(SLEEP.next(DISCOMFORT)).isEqualTo(CRY); assertThat(CRY.next(NO_DISCOMFORT)).isEqualTo(EAT); }
Yes we can reference enum constants between them, with the restriction that only constants defined before can be referenced. Here we have a cycle between the states EAT -> SLEEP -> POOP -> EAT etc. so we need to open the cycle and close it with a workaround at runtime.
We indeed have a graph with the CRY state that can be accessed from any state.
I’ve already used enums to represent simple trees by categories simply by referencing in each node its elements, all with enum constants.
Enums also have the benefits of coming with their dedicated implementations for Map and Set: EnumMap and EnumSet.
These collections have the same interface and behave just like your regular collections, but internally they exploit the integer nature of the enums, as an optimization. In short you have old C-style data structures and idioms (bit masking and the like) hidden behind an elegant interface. This also demonstrate how you don’t have to compromise your API’s for the sake of efficiency!
To illustrate the use of these dedicated collections, let’s represent the 7 cards in Jurgen Appelo’s Delegation Poker:
public enum AuthorityLevel { /** make decision as the manager */ TELL, /** convince people about decision */ SELL, /** get input from team before decision */ CONSULT, /** make decision together with team */ AGREE, /** influence decision made by the team */ ADVISE, /** ask feedback after decision by team */ INQUIRE, /** no influence, let team work it out */ DELEGATE;
There are 7 cards, the first 3 are more control-oriented, the middle card is balanced, and the 3 last cards are more delegation-oriented (I made that interpretation up, please refer to his book for explanations). In the Delegation Poker, every player selects a card for a given situation, and earns as many points as the card value (from 1 to 7), except the players in the « highest minority ».
It’s trivial to compute the number of points using the ordinal value + 1. It is also straightforward to select the control oriented cards by their ordinal value, or we can use a Set built from a range like we do below to select the delegation-oriented cards:
public int numberOfPoints() { return ordinal() + 1; } // It's ok to use the internal ordinal integer for the implementation public boolean isControlOriented() { return ordinal() < AGREE.ordinal(); } // EnumSet is a Set implementation that benefits from the integer-like // nature of the enums public static Set DELEGATION_LEVELS = EnumSet.range(ADVISE, DELEGATE); // enums are comparable hence the usual benefits public static AuthorityLevel highest(List levels) { return Collections.max(levels); } }
EnumSet offers convenient static factory methods like range(from, to), to create a set that includes every enum constant starting between ADVISE and DELEGATE in our example, in the declaration order.
To compute the highest minority we start with the highest card, which is nothing but finding the max, something trivial since the enum is always comparable.
Whenever we need to use this enum as a key in a Map, we should use the EnumMap, as illustrated in the test below:
// Using an EnumMap to represent the votes by authority level @Test public void votes_with_a_clear_majority() { final Map<AuthorityLevel, Integer> votes = new EnumMap(AuthorityLevel.class); votes.put(SELL, 1); votes.put(ADVISE, 3); votes.put(INQUIRE, 2); assertThat(votes.get(ADVISE)).isEqualTo(3); }
I love Java enums: they’re just perfect for Value Objects in the Domain-Driven Design sense where the set of every possible values is bounded. In a recent project I deliberatly managed to have a majority of value types expressed as enums. You get a lot of awesomeness for free, and especially with almost no technical noise. This helps improve my signal-to-noise ratio between the words from the domain and the technical jargon.
Or course I make sure each enum constant is also immutable, and I get the correct equals, hashcode, toString, String or integer serialization, singleton-ness and very efficient collections on them for free, all that with very little code.
The enum polymorphism is very handy, and I never use instanceof on enums and I hardly need to switch on the enum either.
I’d love that the Java enum is completed by a similar construct just like the case class in Scala, for when the set of possible values cannot be bounded. And a way to enforce immutability of any class would be nice too. Am I asking too much?
Also <troll>don’t even try to compare the Java enum with the C# enum…</troll>


| File | Statements | Branches | Functions | Lines | |||||
|---|---|---|---|---|---|---|---|---|---|
| actions | 88.64% | 78/88 | 100% | 0/0 | 80.77% | 42/52 | 86.67% | 65/75 | |
| assets/jss | 100% | 32/32 | 100% | 0/0 | 100% | 0/0 | 100% | 32/32 | |
| assets/jss/material-dashboard-react/components | 100% | 4/4 | 100% | 0/0 | 100% | 0/0 | 100% | 4/4 | |
| assets/jss/material-dashboard-react/views | 100% | 1/1 | 100% | 0/0 | 100% | 0/0 | 100% | 1/1 | |
| components/Card | 25% | 3/12 | 100% | 0/0 | 0% | 0/3 | 25% | 3/12 | |
| components/CustomButtons | 25% | 1/4 | 100% | 0/0 | 0% | 0/1 | 25% | 1/4 | |
| reducers | 100% | 18/18 | 100% | 16/16 | 100% | 5/5 | 100% | 18/18 | |
| selectors | 97.14% | 34/35 | 90% | 9/10 | 100% | 6/6 | 96.67% | 29/30 | |
| utils | 100% | 7/7 | 87.5% | 7/8 | 100% | 2/2 | 100% | 7/7 | |
| views/CreateNewPoll | 52.58% | 51/97 | 41.38% | 12/29 | 57.45% | 27/47 | 53.19% | 50/94 | |
| views/SignIn | 76.92% | 10/13 | 50% | 3/6 | 62.5% | 5/8 | 90.91% | 10/11 | |
| views/SignUp | 76.92% | 10/13 | 50% | 3/6 | 62.5% | 5/8 | 90.91% | 10/11 |


[§321-195] Annual report to the legislature. The department shall submit an annual report to the legislature detailing its progress in the implementation of the state plan for substance abuse. The report shall be submitted twenty days before the beginning of each regular session of the legislature. [L 1975, c 190, pt of §2]
Note
Other annual reporting requirements. L 2004, c 40, §29.


By using the mouseout
event you can easily make a chart where the tooltips are hidden when the mouse is moved away from the
canvas. The line chart here shows it in action and the code is below. It's a simple matter of adding the mouseout
event
listener after the chart has been created.
<script src="RGraph.common.core.js"></script> <script src="RGraph.common.dynamic.js"></script> <script src="RGraph.common.tooltips.js"></script> <script src="RGraph.line.js"></script>Put this where you want the chart to show up:
<canvas id="cvs" width="600" height="250"> [No canvas support] </canvas>This is the code that generates the chart - it should be placed AFTER the canvas tag(s):


Gecode::Gist::TreeCanvas Class Reference
A canvas that displays the search tree. More...
#include <treecanvas.hh>
Public Slots | |
| void | scaleTree (int scale0, int zoomx=-1, int zoomy=-1) |
| Set scale factor to scale0. | |
| void | searchAll (void) |
| Explore complete subtree of selected node. | |
| void | searchOne (void) |
| Find next solution below selected node. | |
| void | toggleHidden (void) |
| Toggle hidden state of selected node. | |
| void | hideFailed (void) |
| Hide failed subtrees of selected node. | |
| void | unhideAll (void) |
| Unhide all nodes below selected node. | |
| void | toggleStop (void) |
| Do not stop at selected stop node. | |
| void | unstopAll (void) |
| Do not stop at any stop node. | |
| void | exportPDF (void) |
| Export pdf of the current subtree. | |
| void | exportWholeTreePDF (void) |
| Export pdf of the whole tree. | |
| void | print (void) |
| Print the tree. | |
| void | zoomToFit (void) |
| Zoom the canvas so that the whole tree fits. | |
| void | centerCurrentNode (void) |
| Center the view on the currently selected node. | |
| void | inspectCurrentNode (bool fix=true, int inspectorNo=-1) |
| Call the double click inspector for the currently selected node. | |
| void | inspectBeforeFP (void) |
| Calls inspectCurrentNode(false). | |
| void | labelBranches (void) |
| Label all branches in subtree under current node. | |
| void | labelPath (void) |
| Label all branches on path to root node. | |
| void | stopSearch (void) |
| Stop current search. | |
| void | reset (void) |
| Reset. | |
| void | navUp (void) |
| Move selection to the parent of the selected node. | |
| void | navDown (void) |
| Move selection to the first child of the selected node. | |
| void | navLeft (void) |
| Move selection to the left sibling of the selected node. | |
| void | navRight (void) |
| Move selection to the right sibling of the selected node. | |
| void | navRoot (void) |
| Move selection to the root node. | |
| void | navNextSol (bool back=false) |
| Move selection to next solution (in DFS order). | |
| void | navPrevSol (void) |
| Move selection to previous solution (in DFS order). | |
| void | bookmarkNode (void) |
| Bookmark current node. | |
| void | setPath (void) |
| Set the current node to be the head of the path. | |
| void | inspectPath (void) |
| Call the double click inspector for all nodes on the path from root to head of the path. | |
| void | startCompareNodes (void) |
| Wait for click on node to compare with current node. | |
| void | startCompareNodesBeforeFP (void) |
| Wait for click on node to compare with current node before fixpoint. | |
| void | emitStatusChanged (void) |
| Re-emit status change information for current node. | |
| void | setRecompDistances (int c_d, int a_d) |
| Set recomputation distances. | |
| void | setAutoHideFailed (bool b) |
| Set preference whether to automatically hide failed subtrees. | |
| void | setAutoZoom (bool b) |
| Set preference whether to automatically zoom to fit. | |
| bool | getAutoHideFailed (void) |
| Return preference whether to automatically hide failed subtrees. | |
| bool | getAutoZoom (void) |
| Return preference whether to automatically zoom to fit. | |
| void | setShowCopies (bool b) |
| Set preference whether to show copies in the tree. | |
| bool | getShowCopies (void) |
| Return preference whether to show copies in the tree. | |
| void | setRefresh (int i) |
| Set refresh rate. | |
| void | setRefreshPause (int i) |
| Set refresh pause in msec. | |
| bool | getSmoothScrollAndZoom (void) |
| Return preference whether to use smooth scrolling and zooming. | |
| void | setSmoothScrollAndZoom (bool b) |
| Set preference whether to use smooth scrolling and zooming. | |
| bool | getMoveDuringSearch (void) |
| Return preference whether to move cursor during search. | |
| void | setMoveDuringSearch (bool b) |
| Set preference whether to move cursor during search. | |
| void | resizeToOuter (void) |
| Resize to the outer widget size if auto zoom is enabled. | |
| bool | finish (void) |
| Stop search and wait for it to finish. | |
| void | update (void) |
| Update display. | |
| void | scroll (void) |
| React to scroll events. | |
| void | layoutDone (int w, int h, int scale0) |
| Layout done. | |
| void | setCurrentNode (VisualNode *n, bool finished=true, bool update=true) |
| Set the selected node to n. | |
Signals | |
| void | scaleChanged (int) |
| The scale factor has changed. | |
| void | autoZoomChanged (bool) |
| The auto-zoom state was changed. | |
| void | contextMenu (QContextMenuEvent *) |
| Context menu triggered. | |
| void | statusChanged (VisualNode *, const Statistics &, bool) |
| Status bar update. | |
| void | solution (const Space *) |
| Signals that a solution has been found. | |
| void | searchFinished (void) |
| Signals that Gist is finished. | |
| void | addedBookmark (const QString &id) |
| Signals that a bookmark has been added. | |
| void | removedBookmark (int idx) |
| Signals that a bookmark has been removed. | |
Public Member Functions | |
| TreeCanvas (Space *rootSpace, bool bab, QWidget *parent, const Options &opt) | |
| Constructor. | |
| ~TreeCanvas (void) | |
| Destructor. | |
| void | addDoubleClickInspector (Inspector *i) |
| Add inspector i. | |
| void | activateDoubleClickInspector (int i, bool active) |
| Set active inspector. | |
| void | addSolutionInspector (Inspector *i) |
| Add inspector i. | |
| void | activateSolutionInspector (int i, bool active) |
| Set active inspector. | |
| void | addMoveInspector (Inspector *i) |
| Add inspector i. | |
| void | activateMoveInspector (int i, bool active) |
| Set active inspector. | |
| void | addComparator (Comparator *c) |
| Add comparator c. | |
| void | activateComparator (int i, bool active) |
| Set active comparator. | |
Protected Member Functions | |
| VisualNode * | eventNode (QEvent *event) |
| Return the node corresponding to the event position. | |
| bool | event (QEvent *event) |
| General event handler, used for displaying tool tips. | |
| void | paintEvent (QPaintEvent *event) |
| Paint the tree. | |
| void | mousePressEvent (QMouseEvent *event) |
| Handle mouse press event. | |
| void | mouseDoubleClickEvent (QMouseEvent *event) |
| Handle mouse double click event. | |
| void | contextMenuEvent (QContextMenuEvent *event) |
| Handle context menu event. | |
| void | resizeEvent (QResizeEvent *event) |
| Handle resize event. | |
| void | wheelEvent (QWheelEvent *event) |
| Handle mouse wheel events. | |
| virtual void | timerEvent (QTimerEvent *e) |
| Timer invoked for smooth zooming and scrolling. | |
Protected Attributes | |
| QMutex | mutex |
| Mutex for synchronizing acccess to the tree. | |
| QMutex | layoutMutex |
| Mutex for synchronizing layout and drawing. | |
| SearcherThread | searcher |
| Search engine thread. | |
| bool | stopSearchFlag |
| Flag signalling the search to stop. | |
| bool | finishedFlag |
| Flag signalling that Gist is ready to be closed. | |
| Node::NodeAllocator * | na |
| Allocator for nodes. | |
| VisualNode * | root |
| The root node of the tree. | |
| BestNode * | curBest |
| The currently best solution (for branch-and-bound). | |
| VisualNode * | currentNode |
| The currently selected node. | |
| VisualNode * | pathHead |
| The head of the currently selected path. | |
| QVector< QPair< Inspector *, bool > > | doubleClickInspectors |
| The registered click inspectors, and whether they are active. | |
| QVector< QPair< Inspector *, bool > > | solutionInspectors |
| The registered solution inspectors, and whether they are active. | |
| QVector< QPair< Inspector *, bool > > | moveInspectors |
| The registered move inspectors, and whether they are active. | |
| QVector< QPair< Comparator *, bool > > | comparators |
| The registered comparators, and whether they are active. | |
| QVector< VisualNode * > | bookmarks |
| The bookmarks map. | |
| bool | compareNodes |
| Whether node comparison action is running. | |
| bool | compareNodesBeforeFP |
| Whether node comparison action computes fixpoint. | |
| QSlider * | scaleBar |
| The scale bar. | |
| Statistics | stats |
| Statistics about the search tree. | |
| double | scale |
| Current scale factor. | |
| int | xtrans |
| Offset on the x axis so that the tree is centered. | |
| bool | autoHideFailed |
| Whether to hide failed subtrees automatically. | |
| bool | autoZoom |
| Whether to zoom automatically. | |
| bool | showCopies |
| Whether to show copies in the tree. | |
| int | refresh |
| Refresh rate. | |
| int | refreshPause |
| Time (in msec) to pause after each refresh. | |
| bool | smoothScrollAndZoom |
| Whether to use smooth scrolling and zooming. | |
| bool | moveDuringSearch |
| Whether to move cursor during search. | |
| int | c_d |
| The recomputation distance. | |
| int | a_d |
| The adaptive recomputation distance. | |
| QTimeLine | zoomTimeLine |
| Timer for smooth zooming. | |
| QTimeLine | scrollTimeLine |
| Timer for smooth scrolling. | |
| int | targetX |
| Target x coordinate after smooth scrolling. | |
| int | sourceX |
| Source x coordinate after smooth scrolling. | |
| int | targetY |
| Target y coordinate after smooth scrolling. | |
| int | sourceY |
| Target y coordinate after smooth scrolling. | |
| int | targetW |
| Target width after layout. | |
| int | targetH |
| Target height after layout. | |
| int | targetScale |
| Target scale after layout. | |
| int | layoutDoneTimerId |
| Timer id for delaying the update. |
Detailed Description
A canvas that displays the search tree.
Definition at line 87 of file treecanvas.hh.
Constructor & Destructor Documentation
| Gecode::Gist::TreeCanvas::TreeCanvas | ( | Space * | rootSpace, | |
| bool | bab, | |||
| QWidget * | parent, | |||
| const Options & | opt | |||
| ) |
Constructor.
Definition at line 52 of file treecanvas.cpp.
| Gecode::Gist::TreeCanvas::~TreeCanvas | ( | void | ) |
Destructor.
Definition at line 127 of file treecanvas.cpp.
Member Function Documentation
| void Gecode::Gist::TreeCanvas::addDoubleClickInspector | ( | Inspector * | i | ) |
Add inspector i.
Definition at line 136 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::activateDoubleClickInspector | ( | int | i, | |
| bool | active | |||
| ) |
Set active inspector.
Definition at line 141 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::addSolutionInspector | ( | Inspector * | i | ) |
Add inspector i.
Definition at line 147 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::activateSolutionInspector | ( | int | i, | |
| bool | active | |||
| ) |
Set active inspector.
Definition at line 152 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::addMoveInspector | ( | Inspector * | i | ) |
Add inspector i.
Definition at line 158 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::activateMoveInspector | ( | int | i, | |
| bool | active | |||
| ) |
Set active inspector.
Definition at line 163 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::addComparator | ( | Comparator * | c | ) |
Add comparator c.
Definition at line 169 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::activateComparator | ( | int | i, | |
| bool | active | |||
| ) |
Set active comparator.
Definition at line 174 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::scaleTree | ( | int | scale0, | |
| int | zoomx = -1 , |
|||
| int | zoomy = -1 | |||
| ) | [slot] |
Set scale factor to scale0.
Definition at line 180 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::searchAll | ( | void | ) | [slot] |
Explore complete subtree of selected node.
Definition at line 449 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::searchOne | ( | void | ) | [slot] |
Find next solution below selected node.
Definition at line 455 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::toggleHidden | ( | void | ) | [slot] |
Toggle hidden state of selected node.
Definition at line 461 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::hideFailed | ( | void | ) | [slot] |
Hide failed subtrees of selected node.
Definition at line 470 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::unhideAll | ( | void | ) | [slot] |
Unhide all nodes below selected node.
Definition at line 479 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::toggleStop | ( | void | ) | [slot] |
Do not stop at selected stop node.
Definition at line 489 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::unstopAll | ( | void | ) | [slot] |
Do not stop at any stop node.
Definition at line 498 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::exportPDF | ( | void | ) | [slot] |
Export pdf of the current subtree.
Definition at line 1064 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::exportWholeTreePDF | ( | void | ) | [slot] |
Export pdf of the whole tree.
Definition at line 1057 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::print | ( | void | ) | [slot] |
Print the tree.
Definition at line 1071 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::zoomToFit | ( | void | ) | [slot] |
Zoom the canvas so that the whole tree fits.
Definition at line 528 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::centerCurrentNode | ( | void | ) | [slot] |
Center the view on the currently selected node.
Definition at line 564 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::inspectCurrentNode | ( | bool | fix = true , |
|
| int | inspectorNo = -1 | |||
| ) | [slot] |
Call the double click inspector for the currently selected node.
If fix is true, then the node is inspected after fixpoint computation, otherwise its status after branching but before fixpoint computation is inspected.
Definition at line 618 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::inspectBeforeFP | ( | void | ) | [slot] |
Calls inspectCurrentNode(false).
Definition at line 754 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::labelBranches | ( | void | ) | [slot] |
Label all branches in subtree under current node.
Definition at line 759 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::labelPath | ( | void | ) | [slot] |
Label all branches on path to root node.
Definition at line 767 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::stopSearch | ( | void | ) | [slot] |
Stop current search.
Definition at line 810 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::reset | ( | void | ) | [slot] |
Reset.
Definition at line 816 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::navUp | ( | void | ) | [slot] |
Move selection to the parent of the selected node.
Definition at line 925 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::navDown | ( | void | ) | [slot] |
Move selection to the first child of the selected node.
Definition at line 938 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::navLeft | ( | void | ) | [slot] |
Move selection to the left sibling of the selected node.
Definition at line 961 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::navRight | ( | void | ) | [slot] |
Move selection to the right sibling of the selected node.
Definition at line 975 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::navRoot | ( | void | ) | [slot] |
Move selection to the root node.
Definition at line 989 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::navNextSol | ( | bool | back = false |
) | [slot] |
Move selection to next solution (in DFS order).
Definition at line 996 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::navPrevSol | ( | void | ) | [slot] |
Move selection to previous solution (in DFS order).
Definition at line 1009 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::bookmarkNode | ( | void | ) | [slot] |
Bookmark current node.
Definition at line 849 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::setPath | ( | void | ) | [slot] |
Set the current node to be the head of the path.
Definition at line 874 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::inspectPath | ( | void | ) | [slot] |
Call the double click inspector for all nodes on the path from root to head of the path.
Definition at line 888 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::startCompareNodes | ( | void | ) | [slot] |
Wait for click on node to compare with current node.
Definition at line 904 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::startCompareNodesBeforeFP | ( | void | ) | [slot] |
Wait for click on node to compare with current node before fixpoint.
Definition at line 912 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::emitStatusChanged | ( | void | ) | [slot] |
Re-emit status change information for current node.
Definition at line 920 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::setRecompDistances | ( | int | c_d, | |
| int | a_d | |||
| ) | [slot] |
Set recomputation distances.
Definition at line 1387 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::setAutoHideFailed | ( | bool | b | ) | [slot] |
Set preference whether to automatically hide failed subtrees.
Definition at line 1392 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::setAutoZoom | ( | bool | b | ) | [slot] |
Set preference whether to automatically zoom to fit.
Definition at line 1397 of file treecanvas.cpp.
| bool Gecode::Gist::TreeCanvas::getAutoHideFailed | ( | void | ) | [slot] |
Return preference whether to automatically hide failed subtrees.
Definition at line 1416 of file treecanvas.cpp.
| bool Gecode::Gist::TreeCanvas::getAutoZoom | ( | void | ) | [slot] |
Return preference whether to automatically zoom to fit.
Definition at line 1421 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::setShowCopies | ( | bool | b | ) | [slot] |
Set preference whether to show copies in the tree.
Definition at line 1407 of file treecanvas.cpp.
| bool Gecode::Gist::TreeCanvas::getShowCopies | ( | void | ) | [slot] |
Return preference whether to show copies in the tree.
Definition at line 1411 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::setRefresh | ( | int | i | ) | [slot] |
Set refresh rate.
Definition at line 1426 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::setRefreshPause | ( | int | i | ) | [slot] |
Set refresh pause in msec.
Definition at line 1431 of file treecanvas.cpp.
| bool Gecode::Gist::TreeCanvas::getSmoothScrollAndZoom | ( | void | ) | [slot] |
Return preference whether to use smooth scrolling and zooming.
Definition at line 1438 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::setSmoothScrollAndZoom | ( | bool | b | ) | [slot] |
Set preference whether to use smooth scrolling and zooming.
Definition at line 1443 of file treecanvas.cpp.
| bool Gecode::Gist::TreeCanvas::getMoveDuringSearch | ( | void | ) | [slot] |
Return preference whether to move cursor during search.
Definition at line 1448 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::setMoveDuringSearch | ( | bool | b | ) | [slot] |
Set preference whether to move cursor during search.
Definition at line 1453 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::resizeToOuter | ( | void | ) | [slot] |
Resize to the outer widget size if auto zoom is enabled.
Definition at line 1172 of file treecanvas.cpp.
| bool Gecode::Gist::TreeCanvas::finish | ( | void | ) | [slot] |
Stop search and wait for it to finish.
Definition at line 1276 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::scaleChanged | ( | int | ) | [signal] |
The scale factor has changed.
| void Gecode::Gist::TreeCanvas::autoZoomChanged | ( | bool | ) | [signal] |
The auto-zoom state was changed.
| void Gecode::Gist::TreeCanvas::contextMenu | ( | QContextMenuEvent * | ) | [signal] |
Context menu triggered.
| void Gecode::Gist::TreeCanvas::statusChanged | ( | VisualNode * | , | |
| const Statistics & | , | |||
| bool | ||||
| ) | [signal] |
Status bar update.
| void Gecode::Gist::TreeCanvas::solution | ( | const Space * | ) | [signal] |
Signals that a solution has been found.
| void Gecode::Gist::TreeCanvas::searchFinished | ( | void | ) | [signal] |
Signals that Gist is finished.
| void Gecode::Gist::TreeCanvas::addedBookmark | ( | const QString & | id | ) | [signal] |
Signals that a bookmark has been added.
| void Gecode::Gist::TreeCanvas::removedBookmark | ( | int | idx | ) | [signal] |
Signals that a bookmark has been removed.
| VisualNode * Gecode::Gist::TreeCanvas::eventNode | ( | QEvent * | event | ) | [protected] |
Return the node corresponding to the event position.
Definition at line 1103 of file treecanvas.cpp.
| bool Gecode::Gist::TreeCanvas::event | ( | QEvent * | event | ) | [protected] |
General event handler, used for displaying tool tips.
Definition at line 1153 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::paintEvent | ( | QPaintEvent * | event | ) | [protected] |
Paint the tree.
Definition at line 1178 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::mousePressEvent | ( | QMouseEvent * | event | ) | [protected] |
Handle mouse press event.
Definition at line 1328 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::mouseDoubleClickEvent | ( | QMouseEvent * | event | ) | [protected] |
Handle mouse double click event.
Definition at line 1217 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::contextMenuEvent | ( | QContextMenuEvent * | event | ) | [protected] |
Handle context menu event.
Definition at line 1234 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::resizeEvent | ( | QResizeEvent * | event | ) | [protected] |
Handle resize event.
Definition at line 1250 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::wheelEvent | ( | QWheelEvent * | event | ) | [protected] |
Handle mouse wheel events.
Definition at line 1264 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::timerEvent | ( | QTimerEvent * | e | ) | [protected, virtual] |
Timer invoked for smooth zooming and scrolling.
Definition at line 508 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::update | ( | void | ) | [slot] |
Update display.
Definition at line 224 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::scroll | ( | void | ) | [slot] |
React to scroll events.
Definition at line 254 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::layoutDone | ( | int | w, | |
| int | h, | |||
| int | scale0 | |||
| ) | [slot] |
Layout done.
Definition at line 259 of file treecanvas.cpp.
| void Gecode::Gist::TreeCanvas::setCurrentNode | ( | VisualNode * | n, | |
| bool | finished = true , |
|||
| bool | update = true | |||
| ) | [slot] |
Set the selected node to n.
Definition at line 1293 of file treecanvas.cpp.
Member Data Documentation
QMutex Gecode::Gist::TreeCanvas::mutex [protected] |
Mutex for synchronizing acccess to the tree.
Definition at line 246 of file treecanvas.hh.
QMutex Gecode::Gist::TreeCanvas::layoutMutex [protected] |
Mutex for synchronizing layout and drawing.
Definition at line 248 of file treecanvas.hh.
SearcherThread Gecode::Gist::TreeCanvas::searcher [protected] |
Search engine thread.
Definition at line 250 of file treecanvas.hh.
bool Gecode::Gist::TreeCanvas::stopSearchFlag [protected] |
Flag signalling the search to stop.
Definition at line 252 of file treecanvas.hh.
bool Gecode::Gist::TreeCanvas::finishedFlag [protected] |
Flag signalling that Gist is ready to be closed.
Definition at line 254 of file treecanvas.hh.
Node::NodeAllocator* Gecode::Gist::TreeCanvas::na [protected] |
Allocator for nodes.
Definition at line 256 of file treecanvas.hh.
VisualNode* Gecode::Gist::TreeCanvas::root [protected] |
The root node of the tree.
Definition at line 258 of file treecanvas.hh.
BestNode* Gecode::Gist::TreeCanvas::curBest [protected] |
The currently best solution (for branch-and-bound).
Definition at line 260 of file treecanvas.hh.
VisualNode* Gecode::Gist::TreeCanvas::currentNode [protected] |
The currently selected node.
Definition at line 262 of file treecanvas.hh.
VisualNode* Gecode::Gist::TreeCanvas::pathHead [protected] |
The head of the currently selected path.
Definition at line 264 of file treecanvas.hh.
QVector<QPair<Inspector*,bool> > Gecode::Gist::TreeCanvas::doubleClickInspectors [protected] |
The registered click inspectors, and whether they are active.
Definition at line 266 of file treecanvas.hh.
QVector<QPair<Inspector*,bool> > Gecode::Gist::TreeCanvas::solutionInspectors [protected] |
The registered solution inspectors, and whether they are active.
Definition at line 268 of file treecanvas.hh.
QVector<QPair<Inspector*,bool> > Gecode::Gist::TreeCanvas::moveInspectors [protected] |
The registered move inspectors, and whether they are active.
Definition at line 270 of file treecanvas.hh.
QVector<QPair<Comparator*,bool> > Gecode::Gist::TreeCanvas::comparators [protected] |
The registered comparators, and whether they are active.
Definition at line 272 of file treecanvas.hh.
QVector<VisualNode*> Gecode::Gist::TreeCanvas::bookmarks [protected] |
The bookmarks map.
Definition at line 275 of file treecanvas.hh.
bool Gecode::Gist::TreeCanvas::compareNodes [protected] |
Whether node comparison action is running.
Definition at line 278 of file treecanvas.hh.
bool Gecode::Gist::TreeCanvas::compareNodesBeforeFP [protected] |
Whether node comparison action computes fixpoint.
Definition at line 280 of file treecanvas.hh.
QSlider* Gecode::Gist::TreeCanvas::scaleBar [protected] |
The scale bar.
Definition at line 283 of file treecanvas.hh.
Statistics Gecode::Gist::TreeCanvas::stats [protected] |
Statistics about the search tree.
Definition at line 286 of file treecanvas.hh.
double Gecode::Gist::TreeCanvas::scale [protected] |
Current scale factor.
Definition at line 289 of file treecanvas.hh.
int Gecode::Gist::TreeCanvas::xtrans [protected] |
Offset on the x axis so that the tree is centered.
Definition at line 291 of file treecanvas.hh.
bool Gecode::Gist::TreeCanvas::autoHideFailed [protected] |
Whether to hide failed subtrees automatically.
Definition at line 294 of file treecanvas.hh.
bool Gecode::Gist::TreeCanvas::autoZoom [protected] |
Whether to zoom automatically.
Definition at line 296 of file treecanvas.hh.
bool Gecode::Gist::TreeCanvas::showCopies [protected] |
Whether to show copies in the tree.
Definition at line 298 of file treecanvas.hh.
int Gecode::Gist::TreeCanvas::refresh [protected] |
Refresh rate.
Definition at line 300 of file treecanvas.hh.
int Gecode::Gist::TreeCanvas::refreshPause [protected] |
Time (in msec) to pause after each refresh.
Definition at line 302 of file treecanvas.hh.
bool Gecode::Gist::TreeCanvas::smoothScrollAndZoom [protected] |
Whether to use smooth scrolling and zooming.
Definition at line 304 of file treecanvas.hh.
bool Gecode::Gist::TreeCanvas::moveDuringSearch [protected] |
Whether to move cursor during search.
Definition at line 306 of file treecanvas.hh.
int Gecode::Gist::TreeCanvas::c_d [protected] |
The recomputation distance.
Definition at line 309 of file treecanvas.hh.
int Gecode::Gist::TreeCanvas::a_d [protected] |
The adaptive recomputation distance.
Definition at line 311 of file treecanvas.hh.
QTimeLine Gecode::Gist::TreeCanvas::zoomTimeLine [protected] |
Timer for smooth zooming.
Definition at line 331 of file treecanvas.hh.
QTimeLine Gecode::Gist::TreeCanvas::scrollTimeLine [protected] |
Timer for smooth scrolling.
Definition at line 333 of file treecanvas.hh.
int Gecode::Gist::TreeCanvas::targetX [protected] |
Target x coordinate after smooth scrolling.
Definition at line 335 of file treecanvas.hh.
int Gecode::Gist::TreeCanvas::sourceX [protected] |
Source x coordinate after smooth scrolling.
Definition at line 337 of file treecanvas.hh.
int Gecode::Gist::TreeCanvas::targetY [protected] |
Target y coordinate after smooth scrolling.
Definition at line 339 of file treecanvas.hh.
int Gecode::Gist::TreeCanvas::sourceY [protected] |
Target y coordinate after smooth scrolling.
Definition at line 341 of file treecanvas.hh.
int Gecode::Gist::TreeCanvas::targetW [protected] |
Target width after layout.
Definition at line 344 of file treecanvas.hh.
int Gecode::Gist::TreeCanvas::targetH [protected] |
Target height after layout.
Definition at line 346 of file treecanvas.hh.
int Gecode::Gist::TreeCanvas::targetScale [protected] |
Target scale after layout.
Definition at line 348 of file treecanvas.hh.
int Gecode::Gist::TreeCanvas::layoutDoneTimerId [protected] |
Timer id for delaying the update.
Definition at line 350 of file treecanvas.hh.
The documentation for this class was generated from the following files:
- gecode/gist/treecanvas.hh
- gecode/gist/treecanvas.cpp


{% extends 'common.html' %} {% block main %}
If you entered a web address please check it was correct.


Login
Login
Logout
Force Login
Force Logout
{{vm.authInfo|json}}
Identity UI
User Avatar
Default Avatar
Override Avatar Colors
Override Avatar Size
User Card
Not available:
You must login to see the user card.
Create a custom Collab with
clb-automator
Collab Configuration:
An error occured:
{{vm.error | json}}
Create Collab
Alert box
Hello World
Collab Storage Browser
You have to be logged in to access the collab storage
Select a collab:
{{c.title}}
No storage available for the selected collab. Please select another one.


16
Messages (12)
Alerts (4)
Form Validation
Full Name
Email
*
Birth Date
Gender
Male
Female
Hobbies (2 minimum):
Writing
Gymming
Eating
Sleeping
Reading
Coding
Heard us by*
Choose..
Press
Internet
Word of mouth
Other..
Message (20 chars min, 100 max)
Submit


It is quite a while since anything has been heard from the poet Gervase Beerpint, author of Homage To Neurasthenia and Do You Know The Way To Sin, José?*, so it is with something akin to breathless overexcitement that his publishers announce a forthcoming volume, his first since the cataclysmic events of Bastardgate engulfed John Major's Conservative administration of 1990 to 1997.
Provocatively entitled A Slim Volume Of Twee Verse, Beerpint's latest is a huge slab of a book. Truman Capote said of Kerouac's On The Road that “it's not writing, it's typing”, and one feels that were Mr C still with us, he would make the same waspish remark about the torrent of verbiage spewed across these pages. It is difficult to know what to make of a work that steadfastly refuses to engage the reader in any way. At times it reads like an ironmongery catalogue for upwards of a hundred pages, then without warning the poet launches into his own (incompetent) Tagalog translation of the Book of Isaiah. Some of the old standby Beerpint motifs are here—popinjays, choc ices, and dust—but as a whole the work is baffling, perhaps even rubbish.
We rang the poet to ask some pertinent questions, but all that could be heard from his end of the line was this.
* NOTE : Copyright on this title is, of course, held in perpetuity by Max Décharné.


Bayelsa election result: APC leads in 4 of 6LGAs
by Agency ReportThe Independent National Electoral Commission has announced results of the Saturday governorship poll from the six Local government areas out of eight in the state.
Two local government areas yet to be announced are: Southern-Ijaw and Ekeremor.
News Agency of Nigeria reports that the All Progressive Congress has so far won in the four local government areas, while the Peoples Democratic Party won in two.
Announcing the results by the Returning Officer for the election, Prof. Faraday Orumwense, Vice-chancellor, University of Benin, said in Ogbia, that APC pulled 58, 016 votes to beat PDP that got 13, 763 votes in the local government.
According to Orumwense, APC also wins in Brass, Nembe and Yenagoa local government areas.
PDP leads in Sagbama and Kolokumo/Opokuma local government areas.
Mr Keme Jude, a resident, told NAN that the results so far announced was commendable, noting that with APC, a new Bayelsa would emerge.
“You see, people are already jubilating even when the total result has not been released.
”I know that our people already know that with the results so far announced, we are heading to a new Bayelsa.
NAN reports that six out of the eight local government areas had so far been announced by INEC; APC won in four while PDP won in two.
(NAN)


Postdoctoral Research Fellow
This position is with the QUT Centre for Robotics (QCR) and will work closely with me in the Visual Learning and Understanding research program.
I am looking to fill this position immediately (from May 2023). Please contact me if you are interested.
About the Position
We are looking for a creative and enthusiastic Research Fellow to contribute decisively to our Visual Learning and Understanding research program. You will be a key member of the QUT Centre for Robotics and will work closely with academics, other research fellows, engineers, and our PhD students.
You should be excited to do pioneering research in Robotic Learning and Robotic Scene Understanding
You are driven to investigate how robots can understand and represent the geometry, semantics, and functionality of their surroundings and the task-relevant objects therein; and how robots can use this internal representation and learn to decide or plan their next actions in order to accomplish a useful task in a safe way.
You are excited to investigate:
- the potentials and limitations of new foundation models, large language models and vision-language models in the context of reliable robot learning and understanding
- new representations for a scene (ranging from individual objects to large-scale environments) including implicit representations and scene graphs, that support robotic planning, navigation, and manipulation
- robot learning combining natural language instructions, human demonstrations, and prior knowledge with the semantic representations of the scene
You are willing to explore the applicability of your research in a variety of robotic application domains including service robotics, healthcare, environmental, retail, logistics, autonomous driving, agriculture, but also in adjacent domains such as augmented/mixed reality.
During your previous roles as researcher and PhD student, you have demonstrated expertise and understanding of the foundations of robotics, such as coordinate frames and transforms, navigation, localisation, mapping, SLAM, kinematics, motion models, and control. You are familiar with the mathematical concepts underpinning those foundations, including statistics and probabilistic methods.
You have deep knowledge in computer vision and machine learning, as well as a good understanding of robot learning approaches comprising reinforcement learning and imitation learning. You understand the mathematical and statistical foundations of deep learning. You are driven and excited to constantly learn to understand new techniques and keep up with a quickly evolving field.
You are a prolific user of Python and deep learning frameworks such as PyTorch, and regularly work and develop in Linux. Ideally, you have a working knowledge of ROS.
You should have published in the leading conferences in robotics, computer vision, or machine learning.
About Us
The QUT Centre for Robotics (QCR) conducts at-scale world-leading research in intelligent robotics; translates fundamental research into commercial and societal outcomes; is a leader in education, training and development of talent to meet growing demands for expertise in robotics and autonomous systems; and provides leadership in technological policy development and societal debate. Established in 2020, the Centre has been built on the momentum of a decade’s investment in robotic research and translation at QUT which has been funded by QUT, ARC, Queensland Government, CRCs and Industry. QCR comprises over 100 researchers and engineers.
QCR researchers collaborate with industry and universities around the world, including MIT, Harvard and Oxford universities, Boeing, Thales, DST, Airservices Australia, CASA, JARUS, TRAFI, Google Deepmind, Google AI, Amazon Robotics, Caterpillar, Rheinmetall, US Air Force, and NASA’s Jet Propulsion Laboratory.
We are proud of our beautiful and big modern lab space and research environment. We have a fantastic collection of equipment to support your research, including many mobile robot platforms and robotic arms.
The Centre supports a flexible working environment. We support a diverse and inclusive atmosphere and encourage applications from women, Aboriginal Australians and Torres Strait Islander people.
About the Visual Learning and Understanding Program
The Research Fellow will be a key member of QCR’s Visual Learning and Understanding Program.
This program investigates the fundamental problem of how a robot can learn to reliably interpret its environment, and build an internal representation of its surroundings in order to decide on its actions. The program addresses research questions such as how machine learning for visual perception can be made safe, trustworthy, and reliable; how robots can understand and represent the geometry, semantics, and functionality of their surroundings and the task-relevant objects therein; and how robots can use this internal representation and learn to decide or plan their next actions in order to accomplish a useful task in a safe way.
Key Responsibilities
Key responsibilities include:
- Contribute to the research in QCR’s Visual Learning and Understanding Program
- Work closely with a team of academics, research fellow, engineers, PhD students and undergraduates
- Co-supervise PhD students and undergraduate students
- Publish in high-quality conferences and journals in robotics, computer vision, machine learning
- Actively participate and contribute to our collaborative culture within the Centre, including visits to Centre partners and joint publications
- Implementing and administering University policy within the Faculty with respect to equitable access to education and workplace health and safety
Selection Criteria
- Completion of a doctoral qualification in engineering, computer science, or related discipline.
- A well-formulated research agenda and the willingness or demonstrated capability to independently conduct high-quality research.
- Demonstrated ability to publish research outcomes in top conferences or journals in robotics, computer vision, or machine learning.
- Demonstrated knowledge and expertise in the foundations of robotics, computer vision, machine learning. Demonstrated proficiency in Python and experience with ROS, deep learning frameworks such as PyTorch, Linux.
- Excellent communiation skills.
Type of Appointment
This appointment will be offered on a fixed term, full-time basis for 12 months with a potential option for extension.
Remuneration and Benefits
This Research Fellow position is classified as Academic Level B (LEVB) which has an annual salary of $104,290 AUD to $123,858 AUD, plus 17% superannuation.
QUT is a high quality and flexible organisation that is proud of its excellent employment conditions which include but are not limited to:
- Reduced working year scheme
- Parental leave provisions
- Study support encompassing leave and financial assistance
- Comprehensive professional development
- Salary Packaging
Location
Queensland University of Technology (QUT), Gardens Point campus, Brisbane, Australia. We are located on a beautiful campus next to the Brisbane City Botanic Gardens, just a few minutes on foot from the Brisbane CBD and the bustling Southbank cultural precinct with many fantastic restaurants and bars. QUT has excellent connections to public transport, including our CityCat river ferry, trains, and bus lines. A bike path along the river connects QUT with the nearby suburbs.
Brisbane is a very liveable sub-tropical city of 2.3M people and offers great opportunities for recreational activities ranging from hiking in the many nearby national parks, rock climbing (the Kangaroo Point crag is just across the river, and there are many of well-maintained sport crags in a 1-2 hour radius around Brisbane, as well as a selection of climbing and bouldering gyms in the city), surfing (the famous Gold Coast is just over one hour away), and all things beach and ocean related.


What is Product Sans ?
Product Sans is the font developed for
The new Google logo and identity system was developed to respond and grow with the changing needs of our users. It is a system that takes into account scale, interaction, and legibility, giving users a consistent and beautiful experience of the Google brand, wherever they encounter it.
To fully execute the brand system, we took the design a step further, by creating a custom, geometric sans serif called Product Sans. Simple, humble, and approachable, Product Sans was created from scratch to pair seamlessly with our logo in a variety of contexts and product lockups without overshadowing it. Additionally, it complements the new identity by introducing a primary branding typeface that is different in style and character from other interface text elements used in Material Design. With its careful weaving of form and function, it is an appropriate and essential component to the Google brand system.
Try it Out!
Font Size Control:
Product Sans Webfont
If you are a web developer, most likely you are already in love with this font. Well good news for you! You can use this font in your next project!
Before you use this font, please read the license
You can refer the font in many different methods, choose the one thats comfortable for you.
| Class | Id | Element |
|---|---|---|
Product Sans Downloadable Font
Not a web developer? Or just want it on your device? You may install them in any format you like! (Woff2 format is not compatible for Mac Os users).
But before you install any of the following, please read the license.
Syntax Specials
It's not over yet! There are specials characters you can enter, to create special icons and shapes!


GODialogSys
core.dm.dialogue_system.GODialogSys(act_set=None, slot_set=None, agt_feasible_actions=None, params=None)
The GO Dialogue System mediates the interaction between the environment and the agent.
Class members:
- agent : the type of conversational agent. Default is None (temporarily).
- environment : the environment with which the agent and user interact. Default is None (temporarily).
-
act_set : static set of all dialogue acts (intents) used in the dialogue. This set includes the following:
- request : the dialogue turn is requesting a value for some slots
- inform : the dialogue turn is providing values (constraints) for some values
- confirm_question :
- confirm_answer :
- greeting : the turn does not provide any info else than a greeting
- closing : the turn
- multiple_choice : when the turn includes
- thanks : the turn does not provide any info else than a thanks words
- welcome : the turn does not provide any info else than a welcoming words
- deny :
- not_sure :
- slot_set : the set of all slots used in the dialogue.
- kb_path : path to any knowledge base
- agt_feasible_actions : list of templates described as dictionaries, corresponding to each action the agent might take (dict to be specified)
- max_nb_turns : the maximal number of dialogue turns


mitmproxy is an interactive, SSL-capable man-in-the-middle proxy for HTTP
with a console interface.
mitmdump is the command-line version of mitmproxy. Think tcpdump for HTTP.
libmproxy is the library that mitmproxy and mitmdump are built on.
Documentation, tutorials and distribution packages can be found on the
mitmproxy.org website:
mitmproxy.org.
Features
- Intercept HTTP requests and responses and modify them on the fly.
- Save complete HTTP conversations for later replay and analysis.
- Replay the client-side of an HTTP conversations.
- Replay HTTP responses of a previously recorded server.
- Reverse proxy mode to forward traffic to a specified server.
- Transparent proxy mode on OSX and Linux.
- Make scripted changes to HTTP traffic using Python.
- SSL certificates for interception are generated on the fly.
- And much, much more.


| ZotWeb | chapter | |
| Src Url | [[Bevilacqua]], [[Zamborlin]], [[Sypniewski]], [[Schnell]], [[Guédy]], [[Rasamimanana]] (2010) | |
We present a HMM based system for real-time gesture analysis. The system outputs continuously parameters relative to the gesture time progression and its likelihood. These parameters are computed by comparing the performed gesture with stored reference gestures. The method relies on a detailed modeling of multidimensional temporal curves. Compared to standard HMM systems, the learning procedure is simpliﬁed using prior knowledge allowing the system to use a single example for each class. Several applications have been developed using this system in the context of music education, music and dance performances and interactive installation. Typically, the estimation of the time progression allows for the synchronization of physical gestures to sound ﬁles by time stretching/compressing audio buﬀers or videos.
Continuous Realtime Gesture Following and Recognition
Key words:
gesture recognition
[[GestureRecognition]]
gesture following
[[GestureFollowing]]
interactive systems
[[InteractiveSystems]]
Citer: (Bevilacqua et al., 2010)
FTag: Bevilacqua-et-al-2010
APA7: Bevilacqua, F., Zamborlin, B., Sypniewski, A., Schnell, N., Guédy, F., & Rasamimanana, N. (2010). Continuous Realtime Gesture Following and Recognition. In S. Kopp & I. Wachsmuth (Eds.), Gesture in Embodied Communication and Human-Computer Interaction (Vol. 5934, pp. 73–84). Springer Berlin Heidelberg. https://doi.org/10.1007/978-3-642-12553-9_7
Polar


{% extends 'homevisit/base.html' %} {% block title %}Frequently Asked Questions{% endblock %} {% block content %} {% for faq in object_list %}
No FAQs yet.