text:
%% This BibTeX bibliography file was created using BibDesk.
%% http://bibdesk.sourceforge.net/

%% Created for Gerhard Kraetzschmar at 2013-12-06 16:20:46 +0100

%% Saved with string encoding Unicode (UTF-8)

@electronic{wiki:illuminance,
	Author = {Anonymous},
	Date-Added = {2013-12-06 15:17:22 +0000},
	Date-Modified = {2013-12-06 15:19:53 +0000},
	Keywords = {illuminance},
	Title = {Illuminance},
	Url = {www.wikipedia.org/illuminance},
	Urldate = {Last accessed November 20, 2013}}

@electronic{gkk:redwoodRobotics,
	Author = {Evan Ackerman},
	Date-Added = {2013-07-19 19:50:30 +0000},
	Date-Modified = {2013-07-19 19:51:55 +0000},
	Title = {Redwood Robotics Brings Big Names to Next Gen Robot Arms},
	Url = {http://spectrum.ieee.org/automaton/robotics/industrial-robots/redwood-robotics-brings-big-names-to-next-gen-robot-arms},
	Urldate = {Posted May 7, 2012},
	Bdsk-Url-1 = {http://spectrum.ieee.org/automaton/robotics/industrial-robots/redwood-robotics-brings-big-names-to-next-gen-robot-arms}}

@techreport{gkk:rockin-D-1.1:2013,
	Author = {Aamir Ahmad and Iman Awaad and Francesco Amigoni and Jakob Berghofer and Rainer Bischoff and Andrea Bonarini and Rhama Dwiputra and Giulio Fontana and Frederik Hegger and Nico Hochgeschwender and Luca Iocchi and Gerhard Kraetzschmar and Pedro Lima and Matteo Matteucci and Daniele Nardi and Viola Schaffionati and Sven Schneider},
	Institution = {The RoCKIn Project (FP7-ICT-601012 grant agreement number 601012)},
	Timestamp = {2013.09.19},
	Title = {D1.1 - Specification of General Features of Scenarios and Robots for Benchmarking Through Competitions},
	Type = {Public Deliverable},
	Year = {2013}}

@article{gkk:Anderson++:2011,
	Author = {Monica Anderson and Odest Chadwick Jenkins and Sarah Osentoski},
	Date-Added = {2013-07-21 16:20:48 +0000},
	Date-Modified = {2013-07-21 16:26:10 +0000},
	Journal = {Robotics Automation Magazine, IEEE},
	Month = {June},
	Number = {2},
	Pages = {10--11},
	Title = {Recasting Robotics Challenges as Experiments},
	Volume = {18},
	Year = {2011}}

@electronic{gkk:CIG,
	Author = {anonymous},
	Date-Added = {2013-07-14 22:11:25 +0000},
	Date-Modified = {2013-07-21 09:36:16 +0000},
	Keywords = {CIG},
	Lastchecked = {July 14, 2013},
	Title = {IEEE Conference on Computational Intelligence in Games (CIG): Competitions},
	Url = {http://geneura.ugr.es/cig2012/competitions.html},
	Urldate = {http://geneura.ugr.es/cig2012/competitions.html},
	Bdsk-Url-1 = {http://geneura.ugr.es/cig2012/competitions.html}}

@electronic{gkk:ICAPScompetitions,
	Author = {anonymous},
	Date-Added = {2013-07-14 21:51:32 +0000},
	Date-Modified = {2013-07-21 09:36:48 +0000},
	Lastchecked = {July 14, 2013},
	Title = {ICAPS Competitions},
	Url = {http://www.icaps-conference.org/index.php/Main/Competitions},
	Urldate = {http://www.icaps-conference.org/index.php/Main/Competitions},
	Bdsk-Url-1 = {http://www.icaps-conference.org/index.php/Main/Competitions}}

@electronic{gkk:indianChefsUkReuters,
	Author = {anonymous},
	Date-Added = {2013-07-20 09:34:55 +0000},
	Date-Modified = {2013-07-20 09:35:56 +0000},
	Title = {Chef shortage heats up UK curry crisis},
	Url = {http://www.reuters.com/video/2013/06/03/chef-shortage-heats-up-uk-curry-crisis?videoId=243112928},
	Urldate = {Last accessed July 20, 2013},
	Bdsk-Url-1 = {http://www.reuters.com/video/2013/06/03/chef-shortage-heats-up-uk-curry-crisis?videoId=243112928}}

@electronic{gkk:PETS:2012,
	Author = {anonymous},
	Date-Added = {2013-07-14 22:19:45 +0000},
	Date-Modified = {2013-07-21 09:38:29 +0000},
	Keywords = {PETS},
	Lastchecked = {July 14, 2013},
	Title = {Fourteenth IEEE International Workshop on Performance Evaluation of Tracking and Surveillance},
	Url = {http://pets2012.net},
	Urldate = {http://pets2012.net},
	Bdsk-Url-1 = {http://pets2012.net}}

@electronic{gkk:PowerTAC,
	Author = {anonymous},
	Date-Added = {2013-07-14 21:24:40 +0000},
	Date-Modified = {2013-07-21 09:38:40 +0000},
	Keywords = {PowerTAC},
	Lastchecked = {July 14, 2013},
	Title = {Power Agent Trading Competition},
	Url = {http://www.powertac.org/node/4},
	Urldate = {http://www.powertac.org/node/4},
	Bdsk-Url-1 = {http://www.powertac.org/node/4}}

@electronic{gkk:TAC,
	Author = {anonymous},
	Date-Added = {2013-07-14 19:50:55 +0000},
	Date-Modified = {2013-07-21 09:39:05 +0000},
	Keywords = {TAC},
	Lastchecked = {July 14, 2013},
	Title = {Trading Agent Competition},
	Url = {http://tac.sics.se/page.php?id=2},
	Urldate = {http://tac.sics.se/page.php?id=2},
	Bdsk-Url-1 = {http://tac.sics.se/page.php?id=2}}

@electronic{gkk:TAC:2013,
	Author = {anonymous},
	Date-Added = {2013-07-14 18:06:18 +0000},
	Date-Modified = {2013-07-21 09:39:18 +0000},
	Keywords = {TAC},
	Lastchecked = {July 14, 2013},
	Title = {Yearly Archives 2013},
	Url = {http://tradingagents.eecs.umich.edu/2013/},
	Urldate = {http://tradingagents.eecs.umich.edu/2013/},
	Bdsk-Url-1 = {http://tradingagents.eecs.umich.edu/2013/}}

@electronic{gkk:TunedItOrg,
	Author = {anonymous},
	Date-Added = {2013-07-14 22:30:35 +0000},
	Date-Modified = {2013-07-21 09:39:49 +0000},
	Keywords = {ML benchmark},
	Lastchecked = {July 14, 2013},
	Title = {Machine Learning and Data Mining Algorithms: Automated Tests, Repeatable Experiments, Meaningful Results},
	Url = {http://tunedit.org},
	Urldate = {http://tunedit.org},
	Bdsk-Url-1 = {http://tunedit.org}}

@electronic{gkk:wiki:FigureSkating,
	Author = {anonymous},
	Date-Added = {2013-07-16 15:32:24 +0000},
	Date-Modified = {2013-07-21 09:40:42 +0000},
	Keywords = {Figure Skating},
	Lastchecked = {July 16, 2013},
	Title = {Figure Skating},
	Url = {http://en.wikipedia.org/wiki/Figure_Skating},
	Urldate = {http://en.wikipedia.org/wiki/Figure_Skating},
	Bdsk-Url-1 = {http://en.wikipedia.org/wiki/Figure_Skating}}

@techreport{gkk:COLLADA,
	Author = {Mark Barnes and Ellen Levy Finch},
	Date-Added = {2013-07-23 21:44:56 +0000},
	Date-Modified = {2013-07-23 21:48:19 +0000},
	Institution = {Sony Computer Entertainment Inc., Tokyo, Japan},
	Month = {April},
	Title = {{COLLADA} -- Digital Asset Schema Release 1.5.0},
	Type = {Specification},
	Url = {http://www.khronos.org/files/collada_spec_1_5.pdf},
	Year = {2008},
	Bdsk-Url-1 = {http://www.khronos.org/files/collada_spec_1_5.pdf}}

@phdthesis{gkk:Bienia:2011,
	Author = {Christian Bienia},
	Date-Added = {2013-07-14 17:15:51 +0000},
	Date-Modified = {2013-07-14 17:17:01 +0000},
	Keywords = {PARSEC},
	Month = {January},
	School = {Princeton University},
	Title = {Benchmarking Modern Multiprocessors},
	Year = {2011}}

@article{gkk:Cohn++:2011,
	Author = {Anthony G. Cohn and Rina Dechter and Gerhard Lakemeyer},
	Date-Added = {2013-07-21 15:54:11 +0000},
	Date-Modified = {2013-07-21 15:58:59 +0000},
	Doi = {http://dx.doi.org/10.1016/S0004-3702(11)00060-9},
	Journal = {Artificial Intelligence},
	Number = {9--10},
	Title = {The Competition Section: A New Paper Category},
	Url = {http://www.sciencedirect.com/science/article/pii/S0004370211000609},
	Volume = {175},
	Year = {2011},
	Bdsk-Url-1 = {http://www.sciencedirect.com/science/article/pii/S0004370211000609},
	Bdsk-Url-2 = {http://dx.doi.org/10.1016/S0004-3702(11)00060-9}}

@electronic{gkk:CoremarkOrg:2013,
	Author = {EEMBC Embedded Microprocessor Benchmark Consortium},
	Date-Added = {2013-07-14 17:33:53 +0000},
	Date-Modified = {2013-07-21 09:36:32 +0000},
	Keywords = {Coremark},
	Lastchecked = {July 14, 2013},
	Title = {Coremark},
	Url = {http://coremark.org},
	Urldate = {http://coremark.org},
	Bdsk-Url-1 = {http://coremark.org}}

@electronic{gkk:SPECorg:2013,
	Author = {Standard Performance Evaluation Corporation},
	Date-Added = {2013-07-14 17:29:09 +0000},
	Date-Modified = {2013-07-21 09:38:53 +0000},
	Keywords = {SPEC},
	Lastchecked = {July 14, 2013},
	Title = {SPEC's Benchmarks and Published Results},
	Url = {http://www.spec.org/benchmarks.html},
	Urldate = {http://www.spec.org/benchmarks.html},
	Bdsk-Url-1 = {http://www.spec.org/benchmarks.html}}

@article{gkk:Cumow+Wichman:76,
	Author = {Cumow, H.J. and Wichman, B.A.},
	Date-Added = {2013-07-14 16:22:18 +0000},
	Date-Modified = {2013-07-14 16:24:43 +0000},
	Journal = {Computer Journal},
	Keywords = {Whetstone},
	Number = {1},
	Pages = {43--49},
	Title = {A Synthetic Benchmark},
	Volume = {19},
	Year = {1976}}

@electronic{gkk:BioRob,
	Author = {Bionic Robotics GmbH},
	Date-Added = {2013-07-19 19:52:18 +0000},
	Date-Modified = {2013-07-19 19:54:52 +0000},
	Title = {BioRob Arm},
	Url = {http://www.bionic-robotics.de/en/company/biorob-arm.html},
	Urldate = {Last accessed July19, 2013},
	Bdsk-Url-1 = {http://www.bionic-robotics.de/en/company/biorob-arm.html}}

@electronic{gkk:indianChefsCrisisUk,
	Author = {PRI Public Radio International},
	Date-Added = {2013-07-20 09:40:38 +0000},
	Date-Modified = {2013-07-20 09:42:11 +0000},
	Title = {British cry foul over shortage of trained curry chefs in the U.K.},
	Url = {http://www.pri.org/stories/politics-society/british-cry-foul-over-shortage-of-trained-curry-chefs-in-the-u-k-7298.html},
	Urldate = {Last accessed July 20},
	Bdsk-Url-1 = {http://www.pri.org/stories/politics-society/british-cry-foul-over-shortage-of-trained-curry-chefs-in-the-u-k-7298.html}}

@electronic{gkk:NetperfOrg:2013,
	Author = {Rick Jones},
	Date-Added = {2013-07-14 17:50:23 +0000},
	Date-Modified = {2013-07-21 09:37:30 +0000},
	Keywords = {NetPerf},
	Lastchecked = {July 14, 2013},
	Title = {Netperf Homepage},
	Url = {http://www.netperf.org/netperf/},
	Urldate = {http://www.netperf.org/netperf/},
	Bdsk-Url-1 = {http://www.netperf.org/netperf/}}

@electronic{gkk:Netspec:2013,
	Author = {Roel Jonkman},
	Date-Added = {2013-07-14 17:52:04 +0000},
	Date-Modified = {2013-07-21 09:38:07 +0000},
	Keywords = {NetSpec},
	Lastchecked = {July 14, 2013},
	Title = {NetSpec: A Tool for Network Experimentation and Measurement},
	Url = {http://compnetworking.about.com/gi/o.htm?zi=1/XJ&zTi=1&sdn=compnetworking&cdn=compute&tm=469&f=00&tt=14&bt=8&bts=8&zu=http%3A//www.ittc.ku.edu/netspec/},
	Urldate = {http://compnetworking.about.com/gi/o.htm?zi=1/XJ&zTi=1&sdn=compnetworking&cdn=compute&tm=469&f=00&tt=14&bt=8&bts=8&zu=http%3A//www.ittc.ku.edu/netspec/},
	Bdsk-Url-1 = {http://compnetworking.about.com/gi/o.htm?zi=1/XJ&zTi=1&sdn=compnetworking&cdn=compute&tm=469&f=00&tt=14&bt=8&bts=8&zu=http%3A//www.ittc.ku.edu/netspec/}}

@book{gkk:Kant:92,
	Author = {Kant, K.},
	Date-Added = {2013-07-14 17:27:39 +0000},
	Date-Modified = {2013-07-14 17:28:28 +0000},
	Isbn = {9780070335868},
	Keywords = {SPEC},
	Lccn = {lc91021266},
	Publisher = {McGraw-Hill},
	Series = {McGraw-Hill computer science series},
	Title = {Introduction to computer system performance evaluation},
	Url = {http://books.google.de/books?id=Ht5QAAAAMAAJ},
	Year = {1992},
	Bdsk-Url-1 = {http://books.google.de/books?id=Ht5QAAAAMAAJ}}

@techreport{gkk:Ketter++:2011,
	Author = {Wolfgang Ketter and John Collins and Prashant P. Reddy and Christoph M. Flath},
	Date-Added = {2013-07-14 21:29:09 +0000},
	Date-Modified = {2013-07-14 21:32:39 +0000},
	Institution = {Soial Science Research Report},
	Keywords = {http://ssrn.com/abstract=1839139},
	Month = {May 17},
	Number = {Ref No ERS-2011-011-US},
	Title = {The Power Trading Agent Competition},
	Type = {ERIm Report Series},
	Year = {2011}}

@electronic{gkk:Matlis:2005,
	Author = {Jan Matlis},
	Date-Added = {2013-07-14 17:21:17 +0000},
	Date-Modified = {2013-07-21 09:37:19 +0000},
	Journal = {Computer World},
	Keywords = {LINPACK},
	Lastchecked = {July 14, 2013},
	Month = {May 30},
	Title = {Sidebar: The Linpack Benchmark},
	Url = {http://www.computerworld.com/s/article/102050/Sidebar_The_Linpack_Benchmark},
	Urldate = {http://www.computerworld.com/s/article/102050/Sidebar_The_Linpack_Benchmark},
	Year = {2005},
	Bdsk-Url-1 = {http://www.computerworld.com/s/article/102050/Sidebar_The_Linpack_Benchmark}}

@electronic{gkk:top-500-computers:2013,
	Author = {Hans Meuer and Erich Strohmaier and Jack Dongarra and Horst Simon},
	Date-Added = {2013-07-14 16:58:19 +0000},
	Date-Modified = {2013-07-21 09:39:28 +0000},
	Lastchecked = {July 14, 2013},
	Title = {Top 500 Supercomputer Sites, June 2013},
	Url = {http://www.top500.org/lists/2013/06/},
	Urldate = {http://www.top500.org/lists/2013/06/},
	Bdsk-Url-1 = {http://www.top500.org/lists/2013/06/}}

@electronic{gkk:TREC,
	Author = {NIST},
	Date-Added = {2013-07-14 22:07:56 +0000},
	Date-Modified = {2013-07-21 09:39:39 +0000},
	Keywords = {TREC},
	Lastchecked = {July 14, 2013},
	Title = {Text Retrieval Conference (TREC)},
	Url = {http://trec.nist.gov},
	Urldate = {http://trec.nist.gov},
	Bdsk-Url-1 = {http://trec.nist.gov}}

@electronic{gkk:baxter,
	Author = {Rethink Robotics},
	Date-Added = {2013-07-21 09:53:07 +0000},
	Date-Modified = {2013-07-21 09:54:33 +0000},
	Keywords = {Baxter},
	Title = {Meet your new lab partner},
	Url = {http://www.rethinkrobotics.com/files/8713/6694/8748/BRR_004.20.13.pdf},
	Urldate = {Last accessed July 21, 2013},
	Bdsk-Url-1 = {http://www.rethinkrobotics.com/files/8713/6694/8748/BRR_004.20.13.pdf}}

@electronic{gkk:UniversalRobots,
	Author = {Universal Robots},
	Date-Added = {2013-07-19 20:04:58 +0000},
	Date-Modified = {2013-07-19 20:08:04 +0000},
	Title = {Collaborative Robot Solutions},
	Url = {http://www.universal-robots.com/GB/Products.aspx},
	Urldate = {Last accessed July19},
	Bdsk-Url-1 = {http://www.universal-robots.com/GB/Products.aspx}}

@electronic{gkk:Passmark:2013,
	Author = {Passmark Software},
	Date-Added = {2013-07-14 17:56:42 +0000},
	Date-Modified = {2013-07-21 09:38:18 +0000},
	Keywords = {Passmark},
	Lastchecked = {July 14, 2013},
	Title = {Network benchmark - test your network speed},
	Url = {http://www.passmark.com/products/pt_advnet.htm},
	Urldate = {http://www.passmark.com/products/pt_advnet.htm},
	Bdsk-Url-1 = {http://www.passmark.com/products/pt_advnet.htm}}

@misc{gkk:KIVAsystems,
	Author = {Kiva Systems},
	Date-Added = {2013-07-24 00:25:29 +0000},
	Date-Modified = {2013-07-24 00:28:50 +0000},
	Howpublished = {http://www.kivasystems.com/industries/ecommerce},
	Title = {eCommerce},
	Url = {http://www.kivasystems.com},
	Urldate = {Last accessed July 20},
	Year = {2013},
	Bdsk-Url-1 = {http://www.kivasystems.com}}

@article{gkk:Thrun:2006,
	Author = {S. Thrun and M. Montemerlo and H. Dahlkamp and D. Stavens and A. Aron and J. Diebel and P. Fong and J. Gale and M. Halpenny and G. Hoffmann and K. Lau and C. Oakley and M. Palatucci and V. Pratt and P. Stang and S. Strohband and C. Dupont and L.-E. Jendrossek and C. Koelen and C. Markey and C. Rummel and J. van Niekerk and E. Jensen and P. Alessandrini and G. Bradski and B. Davies and S. Ettinger and A. Kaehler and A. Nefian and P. Mahoney},
	Date-Added = {2013-07-21 10:10:55 +0000},
	Date-Modified = {2013-07-21 10:11:07 +0000},
	Journal = {Journal of Field Robotics},
	Note = {accepted for publication},
	Title = {Winning the DARPA Grand Challenge},
	Year = {2006}}

@electronic{gkk:ISUrules,
	Author = {International Skating Union},
	Date-Added = {2013-07-16 15:29:57 +0000},
	Date-Modified = {2013-07-21 09:36:58 +0000},
	Lastchecked = {July 16, 2013},
	Title = {Summary of ISU Judging System},
	Url = {http://www.isu.org/vsite/vcontent/page/custom/0,8510,4844-152094-169310-31825-132302-custom-item,00.html},
	Urldate = {http://www.isu.org/vsite/vcontent/page/custom/0,8510,4844-152094-169310-31825-132302-custom-item,00.html},
	Bdsk-Url-1 = {http://www.isu.org/vsite/vcontent/page/custom/0,8510,4844-152094-169310-31825-132302-custom-item,00.html}}

@electronic{gkk:wiki:PARSEC,
	Author = {Princeton University},
	Date-Added = {2013-07-14 17:12:33 +0000},
	Date-Modified = {2013-07-21 09:35:36 +0000},
	Keywords = {PARSEC},
	Lastchecked = {July 14, 2013},
	Title = {PARSEC: A unit of measure},
	Url = {http://parsec.cs.princeton.edu},
	Urldate = {http://parsec.cs.princeton.edu},
	Bdsk-Url-1 = {http://parsec.cs.princeton.edu}}

@misc{gkk:Veloso+Stone:IROSvideo:2012,
	Abstract = { This video documents technical progress in four RoboCup soccer leagues
	from 1997 until 2011. The leagues represented are the small size
	league, the middle size league, the standard platform leage, and
	the humanoid league. },
	Author = {Manuela Veloso and Peter Stone},
	Booktitle = {Proceedings of IROS 2012-IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS)},
	Date-Added = {2013-07-24 01:01:08 +0000},
	Date-Modified = {2013-07-24 01:01:40 +0000},
	Month = {October},
	Note = {Available from \url{http://www.robocup.org/2012/10/robocup-video-finalist-for-best-video-award-at-iros-2012/}},
	Title = {Video: RoboCup Robot Soccer History 1997 -- 2011},
	Wwwnote = {http://www.robocup.org/2012/10/robocup-video-finalist-for-best-video-award-at-iros-2012/},
	Year = {2012}}

@article{gkk:Weicker:84,
	Author = {Reinhold Weicker},
	Date-Added = {2013-07-14 17:03:54 +0000},
	Date-Modified = {2013-07-14 17:05:39 +0000},
	Journal = {Communications of the ACM},
	Keywords = {doi:10.1145/358274.358283},
	Number = {10},
	Pages = {1013--1030},
	Title = {Dhrystone: A Synthetic Systems Programming Benchmark},
	Volume = {27},
	Year = {1984}}

@electronic{gkk:wiki:Coremark,
	Author = {Wikipedia},
	Date-Added = {2013-07-14 17:11:00 +0000},
	Date-Modified = {2013-07-21 09:40:00 +0000},
	Keywords = {Coremark},
	Lastchecked = {July 14, 2013},
	Title = {Coremark},
	Url = {http://en.wikipedia.org/wiki/Coremark},
	Urldate = {http://en.wikipedia.org/wiki/Coremark},
	Bdsk-Url-1 = {http://en.wikipedia.org/wiki/Coremark}}

@electronic{gkk:wiki:CTF,
	Author = {Wikipedia},
	Date-Added = {2013-07-14 22:02:39 +0000},
	Date-Modified = {2013-07-21 09:40:11 +0000},
	Lastchecked = {July 14, 2013},
	Title = {Capture the Flag},
	Url = {https://en.wikipedia.org/wiki/Capture_the_flag},
	Urldate = {https://en.wikipedia.org/wiki/Capture_the_flag},
	Bdsk-Url-1 = {https://en.wikipedia.org/wiki/Capture_the_flag}}

@electronic{gkk:wiki:DEFCON,
	Author = {Wikipedia},
	Date-Added = {2013-07-14 22:00:39 +0000},
	Date-Modified = {2013-07-21 09:40:21 +0000},
	Keywords = {DEF CON CTF},
	Lastchecked = {July 14, 2013},
	Title = {DEF CON},
	Url = {https://en.wikipedia.org/wiki/DEF_CON_(convention)},
	Urldate = {https://en.wikipedia.org/wiki/DEF_CON_(convention)},
	Bdsk-Url-1 = {https://en.wikipedia.org/wiki/DEF_CON_(convention)}}

@electronic{gkk:wiki:dhrystone,
	Author = {Wikipedia},
	Date-Added = {2013-07-14 17:02:22 +0000},
	Date-Modified = {2013-07-21 09:40:33 +0000},
	Keywords = {Dhrystone},
	Lastchecked = {July 14, 2014},
	Title = {Dhrystone},
	Url = {http://en.wikipedia.org/wiki/Dhrystone},
	Urldate = {http://en.wikipedia.org/wiki/Dhrystone},
	Bdsk-Url-1 = {http://en.wikipedia.org/wiki/Dhrystone}}

@electronic{gkk:wiki:LINPACK,
	Author = {Wikipedia},
	Date-Added = {2013-07-14 17:11:44 +0000},
	Date-Modified = {2013-07-21 09:40:59 +0000},
	Keywords = {LINPACK},
	Lastchecked = {July 14, 2013},
	Title = {LINPACK},
	Url = {http://en.wikipedia.org/wiki/Linpack},
	Urldate = {http://en.wikipedia.org/wiki/Linpack},
	Bdsk-Url-1 = {http://en.wikipedia.org/wiki/Linpack}}

@electronic{gkk:wiki:Netperf,
	Author = {Wikipedia},
	Date-Added = {2013-07-14 17:49:20 +0000},
	Date-Modified = {2013-07-21 09:41:10 +0000},
	Keywords = {NetPerf},
	Lastchecked = {July 14, 2013},
	Title = {Netperf},
	Url = {http://en.wikipedia.org/wiki/Netperf},
	Urldate = {http://en.wikipedia.org/wiki/Netperf},
	Bdsk-Url-1 = {http://en.wikipedia.org/wiki/Netperf}}

@electronic{gkk:wiki:SPEC,
	Author = {Wikipedia},
	Date-Added = {2013-07-14 17:09:32 +0000},
	Date-Modified = {2013-07-21 09:35:09 +0000},
	Keywords = {SPEC},
	Lastchecked = {July 14, 2013},
	Title = {Standard Performance Evaluation Corporation},
	Url = {http://en.wikipedia.org/wiki/Standard_Performance_Evaluation_Corporation},
	Urldate = {http://en.wikipedia.org/wiki/Standard_Performance_Evaluation_Corporation},
	Bdsk-Url-1 = {http://en.wikipedia.org/wiki/Standard_Performance_Evaluation_Corporation}}

@electronic{gkk:wiki:whetstone,
	Author = {Wikipedia},
	Date-Added = {2013-07-14 16:51:29 +0000},
	Date-Modified = {2013-07-21 09:35:22 +0000},
	Keywords = {Whetstone},
	Lastchecked = {July 14, 2013},
	Title = {Whetstone (benchmark)},
	Url = {http://en.wikipedia.org/wiki/Whetstone_(benchmark)},
	Urldate = {http://en.wikipedia.org/wiki/Whetstone_(benchmark)},
	Bdsk-Url-1 = {http://en.wikipedia.org/wiki/Whetstone_(benchmark)}}


text:
@Comment{jabref-meta: databaseType:bibtex;}

@Comment{jabref-meta: saveActions:enabled;
date[normalize_date]
editor[unicode_to_latex]
pages[normalize_page_numbers]
journal[unicode_to_latex]
month[normalize_month]
author[unicode_to_latex]
all-text-fields[ordinals_to_superscript]
title[html_to_latex,unicode_to_latex]
booktitle[unicode_to_latex]
;}

@Comment{jabref-meta: saveOrderConfig:specified;bibtexkey;false;author;false;abstract;false;}

license: MIT

repository: FlamingTempura/bibtex-tidy

license_type: permissive

repo_name: FlamingTempura/bibtex-tidy

branch_name: refs/heads/master

gha_license_id: MIT

gha_language: TeX

extension: bib


text:
package credits

import (
	"bytes"
	"image/color"
	"log"

	"github.com/EngoEngine/ecs"
	"github.com/EngoEngine/engo"
	"github.com/EngoEngine/engo/common"

	"github.com/Noofbiz/hypnic/assets"
	"github.com/Noofbiz/hypnic/options"
	"github.com/Noofbiz/hypnic/systems/creditroll"
	"github.com/Noofbiz/hypnic/systems/endcredits"
)

type Scene struct {
	fnt, dfnt *common.Font
	curPos    float32
	w         *ecs.World
}

func (s *Scene) Type() string {
	return "CreditsScene"
}

func (s *Scene) Preload() {
	filelist := []string{
		"bg.png",
		"bgm.mp3",
		"Gaegu-Regular.ttf",
		"kenpixel_square.ttf",
	}
	for _, url := range filelist {
		d, err := assets.Asset(url)
		if err != nil {
			log.Println("Couldn't load " + url)
		}
		engo.Files.LoadReaderData(url, bytes.NewReader(d))
	}
}

func (s *Scene) Setup(u engo.Updater) {
	w, _ := u.(*ecs.World)
	s.w = w
	common.SetBackground(color.Black)

	// Add Render System
	var renderable *common.Renderable
	var notrenderable *common.NotRenderable
	s.w.AddSystemInterface(&common.RenderSystem{}, renderable, notrenderable)

	// add audio system
	var audioable *common.Audioable
	var notaudioable *common.NotAudioable
	s.w.AddSystemInterface(&common.AudioSystem{}, audioable, notaudioable)

	// add credit roll system
	var creditrollable *creditroll.Able
	s.w.AddSystemInterface(&creditroll.System{}, creditrollable, nil)

	// add end credit system
	s.w.AddSystem(&endcredits.System{})

	//add background
	bgs, _ := common.LoadedSprite("bg.png")
	bg := sprite{
		BasicEntity: ecs.NewBasic(),
		SpaceComponent: common.SpaceComponent{
			Position: engo.Point{
				X: 0 + options.XOffset,
				Y: 0 + options.YOffset,
			},
			Width:  320,
			Height: 480,
		},
		RenderComponent: common.RenderComponent{
			Drawable: bgs,
		},
	}
	s.w.AddEntity(&bg)

	// background music
	bgmp, _ := common.LoadedPlayer("bgm.mp3")
	bgmp.SetVolume(options.TheOptions.BGMLevel)
	b := bgm{BasicEntity: ecs.NewBasic()}
	b.AudioComponent = common.AudioComponent{
		Player: bgmp,
	}
	b.AudioComponent.Player.Repeat = true
	if options.TheOptions.BGM {
		b.AudioComponent.Player.Play()
	}
	s.w.AddEntity(&b)

	s.curPos = 320 + options.YOffset

	//up font
	s.fnt = &common.Font{
		URL:  "Gaegu-Regular.ttf",
		FG:   color.White,
		Size: 32,
	}
	s.fnt.CreatePreloaded()

	//down font
	s.dfnt = &common.Font{
		URL:  "kenpixel_square.ttf",
		FG:   color.White,
		Size: 24,
	}
	s.dfnt.CreatePreloaded()

	//Title
	s.createLines("hypnic")

	//me
	s.createLines("A Game By", "Jerry Caligiure", "noofbiz.github.io")

	// sprites
	s.createLines("sprites")
	// background
	s.createLines("Background", "Robin Caligiure")

	// bullet
	s.createLines("Statue Bullets", "Kenney", "kenney.nl")

	// main menu buttons
	s.createLines("Main Menu Buttons", "Under the moon", "opengameart.org/users/under-the-moon")

	// health bars
	s.createLines("Health Bars", "Scrittl", "opengameart.org/users/scrittl")

	// mage player
	s.createLines("Player Mage", "Sollision", "opengameart.org/user/30796",
		"Jordan Irwin", "opengameart.org/users/antumdeluge")

	// mage statue
	s.createLines("Mage Statue", "Johann C", "opengameart.org/users/johann-c")

	// gem
	s.createLines("Gem", "Code Inferno Games", "codeinferno.com")

	// walls
	s.createLines("Walls", "Blarget2", "opengameart.org/users/blarget2")

	// potion
	s.createLines("Potion", "Bonsaiheldin", "bonsaiheld.org")

	// scroll background
	s.createLines("Paper", "darkwood67", "deviantart.com/darkwood67/")

	// sound
	s.createLines("sounds")
	// menu bgm
	s.createLines("Menu BGM", "HorrorPen", "opengameart.org/users/horrorpen")

	// game bgm
	s.createLines("Game BGM", "xXUnderTowerXx", "opengameart.org/users/xxundertowerxx")

	// potion pickup
	s.createLines("Potion Sound", "Bart Kelsey", "opengameart.org/users/bart")

	// hit
	s.createLines("On Hit", "wobbleboxx", "wobbleboxx.com")

	// gem
	s.createLines("Gem Sound", "wobbleboxx", "wobbleboxx.com")

	// statue fire
	s.createLines("Statue Fire", "dklon", "opengameart.org/users/dklon")

	// button press
	s.createLines("Button Press", "copyc4t", "opengameart.org/users/copyc4t")

	// font
	s.createLines("fonts")
	// kenpixel
	s.createLines("Square Pixel", "Kenney", "kenney.nl")

	// Gaegu
	s.createLines("Gaegu", "JIKJI SOFT", "fonts.google.com/specimen/Gaegu")

	// Made in
	s.createLines("Made in", "engo", "engoengine.github.io")
}

func (s *Scene) createLines(lines ...string) {
	for i, line := range lines {
		l := mobilesprite{BasicEntity: ecs.NewBasic()}
		if i%2 == 1 {
			l.RenderComponent.Drawable = s.dfnt.Render(line)
			l.RenderComponent.Scale = engo.Point{
				X: 1,
				Y: 1,
			}
		} else if i == 0 {
			l.RenderComponent.Drawable = s.fnt.Render(line)
			l.RenderComponent.Scale = engo.Point{
				X: 1,
				Y: 1,
			}
		} else if i%2 == 0 {
			l.RenderComponent.Drawable = s.fnt.Render(line)
			l.RenderComponent.Scale = engo.Point{
				X: 0.5,
				Y: 0.5,
			}
		}
		l.RenderComponent.SetZIndex(2)
		l.SpaceComponent.Width = l.RenderComponent.Drawable.Width() * l.RenderComponent.Scale.X
		l.SpaceComponent.Height = l.RenderComponent.Drawable.Height() * l.RenderComponent.Scale.Y
		l.SpaceComponent.Position = engo.Point{
			X: (320-l.SpaceComponent.Width)/2 + options.XOffset,
			Y: s.curPos,
		}
		s.w.AddEntity(&l)
		s.curPos += 28
	}
	s.curPos += 30
}

repository: Noofbiz/hypnic

repo_name: Noofbiz/hypnic

extension: go


text:
Automatically generated by Mendeley Desktop 1.19.4
Any changes to this file will be lost if it is regenerated by Mendeley.

BibTeX export options can be customized via Preferences -> BibTeX in Mendeley Desktop

@article{Han2015c,
abstract = {Neural networks are both computationally intensive and memory intensive, making them difficult to deploy on embedded systems with limited hardware resources. To address this limitation, we introduce "deep compression", a three stage pipeline: pruning, trained quantization and Huffman coding, that work together to reduce the storage requirement of neural networks by 35x to 49x without affecting their accuracy. Our method first prunes the network by learning only the important connections. Next, we quantize the weights to enforce weight sharing, finally, we apply Huffman coding. After the first two steps we retrain the network to fine tune the remaining connections and the quantized centroids. Pruning, reduces the number of connections by 9x to 13x; Quantization then reduces the number of bits that represent each connection from 32 to 5. On the ImageNet dataset, our method reduced the storage required by AlexNet by 35x, from 240MB to 6.9MB, without loss of accuracy. Our method reduced the size of VGG-16 by 49x from 552MB to 11.3MB, again with no loss of accuracy. This allows fitting the model into on-chip SRAM cache rather than off-chip DRAM memory. Our compression method also facilitates the use of complex neural networks in mobile applications where application size and download bandwidth are constrained. Benchmarked on CPU, GPU and mobile GPU, compressed network has 3x to 4x layerwise speedup and 3x to 7x better energy efficiency.},
archivePrefix = {arXiv},
arxivId = {1510.00149},
author = {Han, Song and Mao, Huizi and Dally, William J.},
doi = {abs/1510.00149/1510.00149},
eprint = {1510.00149},
file = {:Users/sepmein/Qsync/Papers/Han, Mao, Dally{\_}2015{\_}Deep Compression Compressing Deep Neural Networks with Pruning, Trained Quantization and Huffman Coding.pdf:pdf},
pages = {1--14},
title = {{Deep Compression: Compressing Deep Neural Networks with Pruning, Trained Quantization and Huffman Coding}},
url = {http://arxiv.org/abs/1510.00149},
year = {2015}
}

license: Unlicense

repository: sepmein/references

repo_name: sepmein/references


text:
// 19. Remove Nth Node From End of List

// Given a linked list, remove the n-th node from the end of list and return its head.

// Example:
// Given linked list: 1->2->3->4->5, and n = 2.
// After removing the second node from the end, the linked list becomes 1->2->3->5.

// Note:
// Given n will always be valid.

// Follow up:
// Could you do this in one pass?

package leetcode

// ListNode is a node of a linked list.
type ListNode struct {
	Val  int
	Next *ListNode
}

func removeNthFromEnd(head *ListNode, n int) *ListNode {
	l := &ListNode{Next: head}
	for i := 0; i < n; i++ {
		head = head.Next
	}

	prev := l
	for head != nil {
		prev = prev.Next
		head = head.Next
	}
	prev.Next = prev.Next.Next
	return l.Next
}

repository: invzhi/LeetCode

repo_name: invzhi/LeetCode


text:
package database

import (
	"fmt"
	"github.com/spf13/cast"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"gorm.io/gorm/schema"
	"os"
	"sync"
	"time"
)

var db *gorm.DB

var mysqlOnce sync.Once

func connect() {

	var err error

	dsn := os.Getenv("DB_USERNAME") + ":" + os.Getenv("DB_PASSWORD") + "@tcp(" + os.Getenv("DB_HOST") + ":" + os.Getenv("DB_PORT") + ")/" + os.Getenv("DB_DATABASE") + "?charset=utf8mb4&parseTime=True&loc=Local"
	//mysql.Open
	db, err = gorm.Open(mysql.Open(dsn), &gorm.Config{
		NamingStrategy: schema.NamingStrategy{
			SingularTable: true,
		},
	})

	if err != nil {

		//panic(err)
		fmt.Println(err)

	}

	//db.L

	s, _ := db.DB()

	//fmt.Println("数据库连接成功。。。")

	//连接池打开最大连接数
	s.SetMaxOpenConns(cast.ToInt(os.Getenv("DB_MAX_OPEN_CONNS")))

	//连接池最大空闲连接数
	s.SetMaxIdleConns(cast.ToInt(os.Getenv("DB_MAX_IDLE_CONNS")))

	//设置连接过期时间
	s.SetConnMaxLifetime(1 * time.Minute)

}

func GetDb() *gorm.DB {

	//数据库连接单例
	mysqlOnce.Do(func() {

		//fmt.Println("数据库开始连接。。。")

		connect()

	})

	return db

}


text:
package bitbot

import (
	"fmt"
	"strings"
	"time"

	"github.com/whyrusleeping/hellabot"
)

// WorldClockTrigger sends back the time in a specified timezone.
var WorldClockTrigger = NamedTrigger{ //nolint:gochecknoglobals,golint
	ID:   "worldClock",
	Help: "Returns the local time in a given time zone from the IANA Time Zone database. Usage: !time [TZ]. Returns time in UTC when used with no args.",
	Condition: func(irc *hbot.Bot, m *hbot.Message) bool {
		return m.Command == "PRIVMSG" && strings.HasPrefix(m.Content, "!time")
	},
	Action: func(irc *hbot.Bot, m *hbot.Message) bool {
		tz := "UTC"
		if len(strings.Split(m.Content, " ")) > 1 {
			tz = strings.Split(m.Content, " ")[1]
		}

		t, err := getLocalTime(tz)
		if err != nil {
			irc.Reply(m,
				"Unknown TZ, assuming UTC. Please use a time zone from the IANA Time Zone Database: https://gist.github.com/aviflax/a4093965be1cd008f172")
		}

		irc.Reply(m, fmt.Sprintf("Time: %s", t.Format("02 Jan 06 15:04 MST")))
		return true
	},
}

func getLocalTime(name string) (time.Time, error) {
	now := time.Now()
	loc, err := time.LoadLocation(name)
	if err != nil {
		err = fmt.Errorf("unknown time zone: %w", err)
		loc, _ = time.LoadLocation("UTC")
	}
	return now.In(loc), err
}

repository: bbriggs/bitbot

repo_name: bbriggs/bitbot

branch_name: refs/heads/dev

gha_language: Go


text:
package binding_test

type EmptyStruct struct {
	Empty struct{} `json:"empty"`
}

func (s EmptyStruct) Get() EmptyStruct {
	return s
}

var EmptyStructTest = BindingTest{
	name: "EmptyStruct",
	structs: []interface{}{
		&EmptyStruct{},
	},
	exemptions:  nil,
	shouldError: false,
	want: `
export namespace binding_test {
	export class EmptyStruct {
		// Go type: struct {}

		empty: any;

		static createFrom(source: any = {}) {
			return new EmptyStruct(source);
		}
		constructor(source: any = {}) {
			if ('string' === typeof source) source = JSON.parse(source);
			this.empty = this.convertValues(source["empty"], Object);
		}
		convertValues(a: any, classs: any, asMap: boolean = false): any {
			if (!a) {
				return a;
			}

			if (a.slice) {
				return (a as any[]).map(elem => this.convertValues(elem, classs));
			} else if ("object" === typeof a) {
				if (asMap) {
					for (const key of Object.keys(a)) {
						a[key] = new classs(a[key]);
					}
					return a;
				}
				return new classs(a);
			}
			return a;
		}
	}
}
`,
}

repository: wailsapp/wails

repo_name: wailsapp/wails

gha_language: MDX


text:
DESCRIPTION = "rambus Security-IP-150 DDK"
LICENSE = "CLOSED"

PV = "1.0"
PR = "r0"

COMPATIBLE_MACHINE = "light-fm"
SRCREV="${AUTOREV}"

SRC_URI = " \
            git://git@gitlab.alibaba-inc.com/thead-linux/light-libs.git;branch=master;protocol=ssh \
          "

S = "${WORKDIR}/git/rambus_sec_lib"

export PROJECT_DIR?="${COREBASE}/.."
export BUILD_ROOT?="${PROJECT_DIR}/thead-build/light-fm"
export KERNEL_VERSION="$(cat ${BUILD_ROOT}/tmp-glibc/pkgdata/light-fm/kernel-depmod/kernel-abiversion)"

do_install() {
    install -d ${D}${base_libdir}/modules/${KERNEL_VERSION}/extra
    install -d ${D}${base_libdir}/firmware
    install -d ${D}${libdir}
    install -d ${D}${libdir}/engines-1.1
    install -d ${D}${libdir}/pkgconfig
    install -d ${D}${includedir}/openssl
    install -d ${D}${datadir}/rambus-IP-150
    install -d ${D}${datadir}/rambus-IP-150/bin
    install -d ${D}${datadir}/rambus-IP-150/ssl

    install -m 0755 ${S}/lib/firmware/firmware_eip28.bin ${D}${base_libdir}/firmware/firmware_eip28.bin
    install -m 0755 ${S}/lib/modules/extra/*.ko ${D}${base_libdir}/modules/${KERNEL_VERSION}/extra
    install -m 0755 ${S}/lib/*.so* ${D}${libdir}/engines-1.1
    install -m 0755 ${S}/lib/*.a* ${D}${libdir}/engines-1.1
    install -m 0755 ${S}/lib/engines-1.1/* ${D}${libdir}/engines-1.1
    install -m 0755 ${S}/lib/pkgconfig/* ${D}${libdir}/pkgconfig
    install -m 0755 ${S}/include/openssl/* ${D}${includedir}/openssl
    cp ${S}/bin/* ${D}${datadir}/rambus-IP-150/bin/ -rf
    install -m 0755 ${S}/ssl/*.cnf ${D}${datadir}/rambus-IP-150/ssl
    install -m 0755 ${S}/ssl/*.dist ${D}${datadir}/rambus-IP-150/ssl
}

FILES_${PN} += " ${base_libdir} "
FILES_${PN} += " ${libdir} "
FILES_${PN} += " ${includedir} "
FILES_${PN} += " ${datadir} "

PACKAGES = "${PN}"
INSANE_SKIP_${PN} += " staticdev debug-files already-stripped dev-deps file-rdeps "

repository: heysion/xuantie-yocto

repo_name: heysion/xuantie-yocto

extension: bb


text:
SUMMARY = "A Qt5 library with input/output helpers"

LICENSE = "GPL-2.0-only"
LIC_FILES_CHKSUM = "file://LICENSE;md5=bd7b2c994af21d318bd2cd3b3f80c2d5"

inherit cmake_qt5

SRC_URI = "git://github.com/ZeraGmbH/qtiohelper.git;protocol=https;branch=master"

DEPENDS += "qtbase qtserialport"

PV = "0.4.0+git${SRCPV}"
SRCREV = "5c28d4765ce7de57702f4f529fed7da80b82e8d8"

S="${WORKDIR}/git"


text:
@article{DBLP:journals/corr/abs-1906-00391,
 author = {Zhengxiao Du and
Xiaowei Wang and
Hongxia Yang and
Jingren Zhou and
Jie Tang},
 booktitle = {KDD 2019},
 title = {Sequential Scenario-Specific Meta Learner for Online Recommendation},
 year = {2019}
}


text:
@Article{AbdellatifHei2009,
  author    = {Abdellatif, Houssem and Heimann, Bodo},
  title     = {\textit{Computational efficient inverse dynamics of {6-DOF} fully parallel manipulators by using the {L}agrangian formalism}},
  journal   = {Mechanism and Machine Theory},
  year      = {2009},
  volume    = {44},
  number    = {1},
  pages     = {192--207},
  doi       = {10.1016/j.mechmachtheory.2008.02.003},
  publisher = {Elsevier},
}

@InProceedings{DoThanhKotHeiOrt2009b,
  author       = {Do Thanh, Trung and Kotlarski, Jens and Heimann, Bodo and Ortmaier, Tobias},
  title        = {\textit{On the inverse dynamics problem of general parallel robots}},
  booktitle    = {IEEE International Conference on Mechatronics 2009},
  doi          = {10.1109/ICMECH.2009.4957202},
  year         = {2009},
  isbn         = {978-1-4244-4194-5},
  location     = {Malaga/Spain},
  pages        = {1--6},
}

@Book{Gogu2008,
  author    = {Gogu, Grigore},
  title     = {\textit{Structural synthesis of parallel robots, part 1: methodology}},
  year      = {2008},
  publisher = {Springer Netherlands},
  volume    = {866},
  series    = {Solid Mechanics and Its Applications},
  doi       = {10.1007/978-1-4020-5710-6},
}

@Book{KongGos2007,
  author    = {Kong, Xianwen and Gosselin, Clément M.},
  title     = {\textit{Type synthesis of parallel mechanisms}},
  year      = {2007},
  publisher = {Springer Berlin Heidelberg},
  doi       = {10.1007/978-3-540-71990-8},
}

@Article{SchapplerTapOrt2019c,
  author    = {Schappler, Moritz and Tappe, Svenja and Ortmaier, Tobias},
  title     = {\textit{Modeling parallel robot kinematics for {3T2R} and {3T3R} tasks using reciprocal sets of {Euler} angles}},
  journal   = {MDPI Robotics},
  year      = {2019},
  volume    = {8},
  number    = {3},
  issue     = {Special Issue "Kinematics and Robot Design II"},
  issn      = {2218-6581},
  doi       = {10.3390/robotics8030068},
  publisher = {Multidisciplinary Digital Publishing Institute},
}

@Article{KhalilGue2004,
  author    = {Khalil, Wisama and Guegan, Sylvain},
  title     = {\textit{Inverse and direct dynamic modeling of {Gough-Stewart} robots}},
  journal   = {IEEE Transactions on Robotics},
  year      = {2004},
  volume    = {20},
  number    = {4},
  pages     = {754--761},
  doi       = {10.1109/TRO.2004.829473},
  publisher = {IEEE},
}

@Article{JamwalHusXie2015,
  author    = {P. K. Jamwal and S. Hussain and S. Q. Xie},
  title     = {\textit{Three-stage design analysis and multicriteria optimization of a parallel ankle rehabilitation robot using genetic algorithm}},
  journal   = {IEEE Transactions on Automation Science and Engineering},
  year      = {2015},
  volume    = {12},
  number    = {4},
  pages     = {1433--1446},
  month     = {oct},
  issn      = {1558-3783},
  doi       = {10.1109/TASE.2014.2331241},
}

@PhdThesis{Krefft2006,
  author    = {Krefft, M.},
  title     = {\textit{Aufgabenangepasste Optimierung von Parallelstrukturen für Maschinen in der Produktionstechnik}},
  year      = {2006},
  school    = {Technische Universität Braunschweig},
}

@Article{CarboneOttCec2007,
  author    = {Carbone, G. and Ottaviano, E. and Ceccarelli, M.},
  title     = {\textit{An optimum design procedure for both serial and parallel manipulators}},
  journal   = {Proceedings of the Institution of Mechanical Engineers Part C Journal of Mechanical Engineering Science},
  year      = {2007},
  volume    = {221},
  number    = {7},
  pages     = {529-843},
  doi       = {10.1243/0954406JMES367},
}

@Article{ZhouBaiHan2011,
  author    = {Zhou, Lelai and Bai, Shaoping and Hansen, Michael Rygaard},
  title     = {\textit{Design optimization on the drive train of a light-weight robotic arm}},
  journal   = {Mechatronics},
  year      = {2011},
  volume    = {21},
  number    = {3},
  pages     = {560--569},
  publisher = {Elsevier},
  doi       = {10.1016/j.mechatronics.2011.02.004},
}

@Book{BriotKha2015,
  title     = {\textit{Dynamics of parallel robots}},
  publisher = {Springer},
  year      = {2015},
  author    = {Briot, Sébastien and Khalil, Wisama},
  volume    = {35},
  series    = {Mechan. Machine Science},
  doi       = {10.1007/978-3-319-19788-3},
}

@InCollection{FrindtKreHes2010,
  author    = {Frindt, Matthias and Krefft, Mathias and Hesselbach, Jürgen},
  title     = {\textit{Structure and type synthesis of parallel manipulators}},
  booktitle = {Robotic Systems for Handling and Assembly},
  publisher = {Springer},
  year      = {2010},
  pages     = {17ff.},
  doi       = {10.1007/978-3-642-16785-0\_2},
}

@Book{Merlet2006,
  title     = {\textit{Parallel robots}},
  publisher = {Springer Science \& Business Media},
  year      = {2006},
  author    = {Merlet, Jean-Pierre},
  volume    = {128},
  series    = {Solid Mechanics and Its Applications},
  edition   = {2nd},
  doi       = {10.1007/1-4020-4133-0},
}

@Article{Jordehi2015,
  author    = {Jordehi, A Rezaee},
  title     = {\textit{A review on constraint handling strategies in particle swarm optimisation}},
  journal   = {Neural Computing and Applications},
  year      = {2015},
  volume    = {26},
  number    = {6},
  pages     = {1265--1275},
  doi       = {10.1007/s00521-014-1808-5},
  publisher = {Springer},
}

@PhdThesis{Ramirez2018,
  author      = {Daniel Andres Ramirez},
  title       = {\textit{Automatic generation of task-specific serial mechanisms using combined structural and dimensional synthesis}},
  school      = {Gottfried Wilhelm Leibniz Universität Hannover},
  year        = {2018},
  doi         = {10.15488/4571},
}

@Article{KelaiaiaComZaa2012,
  author    = {Kelaiaia, R. and Company, O. and Zaatri, A.},
  title     = {\textit{Multiobjective optimization of a linear Delta parallel robot}},
  journal   = {Mechanism and Machine Theory},
  year      = {2012},
  volume    = {50},
  number    = {0},
  pages     = {159--178},
  doi       = {10.1016/j.mechmachtheory.2011.11.004},
}

@Article{ZhouBai2015,
  author    = {Zhou, Lelai and Bai, Shaoping},
  title     = {\textit{A new approach to design of a lightweight anthropomorphic arm for service applications}},
  journal   = {Journal of Mechanisms and Robotics},
  year      = {2015},
  volume    = {7},
  number    = {3},
  pages     = {031001},
  publisher = {American Society of Mechanical Engineers},
  doi       = {10.1115/1.4028292},
}

@Article{MbarekNefCor2005,
  author       = {Taoufik Mbarek and Marwene Nefzi and Burkhard Corves},
  title        = {\textit{Prototypische {E}ntwicklung und {K}onstruktion eines neuartigen {P}arallelmanipulators mit dem {F}reiheitsgrad fünf}},
  journal      = {VDI-Berichte},
  journaltitle = {VDI-Berichte Nr. 15},
  year         = {2005},
}

@Electronic{MatlabPSO,
  author = {{The MathWorks, Inc.}},
  title  = {\textit{Particle swarm}},
  url    = {https://de.mathworks.com/help/gads/particle-swarm.html},
  note   = {accessed 11.02.2020},
}

@Electronic{GitHubThisPaper,
  author = {Moritz Schappler},
  title  = {\textit{Material für IFToMM DACH 2020}},
  url    = {https://github.com/SchapplM/robsynth-paper\_iftommdach2020},
}

@Book{KhalilDom2002,
  author    = {W. Khalil and E. Dombre},
  title     = {\textit{Modeling, identification and control of robots}},
  year      = {2002},
  publisher = {Hermes Penton Science},
  doi       = {10.1016/B978-1-903996-66-9.X5000-3},
}

@Article{StockMil2003,
  author        = {Stock, Michael and Miller, Karol},
  title         = {\textit{Optimal kinematic design of spatial parallel manipulators: application to linear delta robot}},
  journal       = {J. Mech. Des.},
  year          = {2003},
  volume        = {125},
  number        = {2},
  pages         = {292--301},
  doi           = {10.1115/1.1563632},
}

@Book{SaminFis2013,
  author    = {Samin, Jean-Claude and Fisette, Paul},
  title     = {\textit{Symbolic modeling of multibody systems}},
  year      = {2013},
  volume    = {112},
  series    = {Solid Mechanics and Its Applications},
  publisher = {Springer Science \& Business Media},
  doi       = {10.1007/978-94-017-0287-4},
}

@PhdThesis{Frindt2001,
  title     = {\textit{Modulbasierte Synthese von Parallelstrukturen für Maschinen in der Produktionstechnik}},
  publisher = {Vulkan-Verlag},
  year      = {2001},
  author    = {Frindt, Matthias},
  school    = {TU Braunschweig},
}


text:
SUMMARY = "Lightweight robotics middleware for Linux/Unix systems"
HOMEPAGE = "http://pixhawk.ethz.ch/wiki/software/middleware/"

LICENSE = "GPLv3"
LIC_FILES_CHKSUM = "file://CMakeLists.txt;beginline=15;endline=30;md5=64c970c4052930910793b7ecf09cfdc7"

DEPENDS = "glib-2.0 glibmm opencv libgtop mavlink gsl zlib lcm boost"
#roscpp

PV = "0.0+git${SRCPV}"
SRCREV_mavconn = "7475d7fe71c0c205cfc4a5a76062db2dbe07ada5"
SRC_URI = "git://github.com/pixhawk/mavconn.git;name=mavconn \
           file://0001-Remove-Bluefox-libs-from-INSTALL-it-s-an-x86-binary-.patch \
           file://baf4a55d4f4c7351897912f70148a14d5e587608.patch \
          "

S = "${WORKDIR}/git"

inherit cmake pythonnative
OECMAKE_SOURCEPATH = "${S}"
OECMAKE_BUILDPATH = "${S}/build-${TARGET_ARCH}-${PV}"

EXTRA_OECMAKE = " \
                 -DMAVLINK_IncludeSearchPaths=${STAGING_INCDIR}/mavlink/v1.0 \
                 -DMAVLINK_INCLUDE_DIR=${STAGING_INCDIR}/mavlink/v1.0 \
                 -DMAVLINK_TYPES_INCLUDE_DIR=${STAGING_INCDIR}/mavlink/v1.0 \
                "

# Shared libs don't have versioning :(
FILES_${PN} += "${libdir}/*${SOLIBSDEV}"
FILES_${PN}-dev = "${includedir}"
INSANE_SKIP = "dev-so"

repository: koenkooi/meta-uav

repo_name: koenkooi/meta-uav


text:
@misc{acro,
    author = "{Niederberger, Clemens}",
    title = "Acro package bitbucket repository",
    howpublished = "\url{https://bitbucket.org/cgnieder/acro}",
    note = "[Online; accessed 7-August-2019]"
}

repository: ssavvides/latex-acronyms

repo_name: ssavvides/latex-acronyms


text:
DESCRIPTION = "Program that allows you to set the CCCR registers on PXA Zauruses."
SECTION = "opie/settings"
PRIORITY = "optional"
LICENSE = "GPL"
AUTHOR = "piro <piro400@occn.zaq.ne.jp>"
HOMEPAGE = "http://piro.sytes.net/~piro/zaurus/"
APPTYPE="binary"
PR = "r0"

SRC_URI = "http://piro.sytes.net/~piro/zaurus/etc/qclockchange-${PV}.tar.gz \
	   file://qclockchange.png \
	   file://qclockchange.desktop "

inherit palmtop

do_install() {
	install -d ${D}${palmtopdir}/bin/ \
               ${D}${palmtopdir}/pics \
               ${D}${palmtopdir}/apps/Settings

	install -m 0755 bin/qclockchange ${D}${palmtopdir}/bin/qclockchange
	install -m 0644 ${WORKDIR}/qclockchange.png ${D}${palmtopdir}/pics/qclockchange.png
	install -m 0644 ${WORKDIR}/qclockchange.desktop ${D}${palmtopdir}/apps/Settings/qclockchange.desktop
}

SRC_URI[md5sum] = "4131497c414c7fedae1df58cab2ddfa3"
SRC_URI[sha256sum] = "8cb7000f55ab124d5fe928960c3c9a059faf4f374981b88e74ac0cdb7904c98a"

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
DESCRIPTION = "Command line utility for maXTouch devices"
SECTION = "tools"
HOMEPAGE = "https://github.com/atmel-maxtouch/obp-utils"
LICENSE = "ATMEL_LLA"
LIC_FILES_CHKSUM = "file://LICENSE;md5=8b6acde4490765c7b838377ac61e2d2d"

DEPENDS = "libusb1"

PR = "r0"

inherit autotools

SRCREV="6c0bd1941fbe66a13ff066cac8ec5d1b5f8931a7"
SRC_URI = "git://github.com/atmel-maxtouch/obp-utils.git;protocol=git \
           file://0001-Allow-building-out-of-tree.patch"

S = "${WORKDIR}/git"

repository: rzr/meta-atmel

repo_name: rzr/meta-atmel

gha_language: BitBake


text:
package inspectr_resolvers

import (
	"encoding/json"
	"time"

	graphql "github.com/graph-gophers/graphql-go"
	"github.com/jinzhu/gorm"
	"github.com/jinzhu/gorm/dialects/postgres"
)

// Trail
type Trail struct {
	Model `json:",inline"`
	// Timestamp
	Timestamp int64 `json:"timestamp" gorm:"type:integer"`
	// Event
	Event string `json:"event" gorm:"type:varchar(100)"`
	// EventMetadata
	EventMetadata postgres.Jsonb `json:"eventMetadata" gorm:"type:jsonb;"`
	// Actor
	Actor string `json:"actor"`
	// ActorMetadata
	ActorMetadata postgres.Jsonb `json:"actorMetadata" gorm:"type:jsonb;"`
	// Target
	Target string `json:"target"`
	// TargetMetadata
	TargetMetadata postgres.Jsonb `json:"targetMetadata" gorm:"type:jsonb;"`
	// Origin
	Origin string `json:"origin"`
	// OriginMetadata
	OriginMetadata postgres.Jsonb `json:"originMetadata" gorm:"type:jsonb;"`
}

// TrailResolver resolver for Trail
type TrailResolver struct {
	Trail
	DB *gorm.DB
}

// ID
func (r *TrailResolver) ID() graphql.ID {
	return graphql.ID(r.Trail.Model.ID.String())
}

// Timestamp
func (r *TrailResolver) Timestamp() int64 {
	return r.Trail.Timestamp
}

// Event
func (r *TrailResolver) Event() string {
	return r.Trail.Event
}

// EventMetadata
func (r *TrailResolver) EventMetadata() JSON {
	return JSON{r.Trail.EventMetadata.RawMessage}
}

// Actor
func (r *TrailResolver) Actor() string {
	return r.Trail.Actor
}

// ActorMetadata
func (r *TrailResolver) ActorMetadata() JSON {
	return JSON{r.Trail.ActorMetadata.RawMessage}
}

// Target
func (r *TrailResolver) Target() string {
	return r.Trail.Target
}

// TargetMetadata
func (r *TrailResolver) TargetMetadata() JSON {
	return JSON{r.Trail.TargetMetadata.RawMessage}
}

// Origin
func (r *TrailResolver) Origin() string {
	return r.Trail.Origin
}

// OriginMetadata
func (r *TrailResolver) OriginMetadata() JSON {
	return JSON{r.Trail.OriginMetadata.RawMessage}
}

// Created
func (r *TrailResolver) Created() graphql.Time {
	tm := time.Unix(r.Trail.Timestamp, 0)
	return graphql.Time{Time: tm}
}

func (r *TrailResolver) MarshalJSON() ([]byte, error) {
	return json.Marshal(&r.Trail)
}

func (r *TrailResolver) UnmarshalJSON(data []byte) error {
	return json.Unmarshal(data, &r.Trail)
}

repository: inspectr/backend

repo_name: inspectr/backend


text:
package fsm

import (
	"encoding/json"
	"fmt"

	"github.com/hashicorp/raft"
)

// snapshot is used to provide a snapshot of the current
// state in a way that can be accessed concurrently with operations
// that may modify the live state.
type snapshot struct {
	state *HostMembership
}

// Persist saves the FSM snapshot out to the given sink.
func (s *snapshot) Persist(sink raft.SnapshotSink) error {
	fmt.Println("Persist data")
	data, err := json.Marshal(s.state)
	if err != nil {
		sink.Cancel()
		return err
	}

	if _, err := sink.Write(data); err != nil {
		sink.Cancel()
		return err
	}

	return sink.Close()
}

func (s *snapshot) Release() {

}

repository: youngbupark/raft-membership

repo_name: youngbupark/raft-membership


text:
package main

import (
	"errors"
	"fmt"
	"io/ioutil"
	"os"
	"os/exec"
	"path/filepath"
	"strconv"
	"syscall"
	"time"

	gokeeper "github.com/huajiao-tv/gokeeper/client"
	"github.com/huajiao-tv/gokeeper/model"
)

//
var (
	DatetimeFormat = "20060102150405"
	ErrEventData   = errors.New("event data invalid")
	ErrPidEmpty    = errors.New("pid file empty")
)

func init() {
	gokeeper.EventCallback.RegisterCallFunc(model.EventCmdStop, serviceStop)
	gokeeper.EventCallback.RegisterCallFunc(model.EventCmdStart, serviceStart)
	gokeeper.EventCallback.RegisterCallFunc(model.EventCmdRestart, serviceRestart)
}

func serviceStart(c *gokeeper.Client, evt model.Event) error {
	var err error
	node, ok := (evt.Data).(model.NodeInfo)
	if !ok {
		Logex.Error("serviceStart", "evtData invalid", fmt.Sprintf("%#v", evt))
		return ErrEventData
	}

	Logex.Trace("serviceStart", "receive start event", node.GetComponent())

	stdoutFile := fmt.Sprintf("%s/panic-%s-%s.log", filepath.Join(ComponentLogPath), node.GetComponent(), node.GetID())
	stderrFile := stdoutFile

	// backup old file
	os.Rename(stdoutFile, fmt.Sprintf("%s.%s", stdoutFile, time.Now().Format(DatetimeFormat)))
	os.Rename(stderrFile, fmt.Sprintf("%s.%s", stderrFile, time.Now().Format(DatetimeFormat)))

	stdout, err := os.OpenFile(stdoutFile, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0755)
	if err != nil {
		Logex.Error("serviceStart", "OpenFile", node.GetComponent(), stdoutFile, err.Error())
		return err
	}
	stderr, err := os.OpenFile(stderrFile, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0755)
	if err != nil {
		Logex.Error("serviceStart", "OpenFile", node.GetComponent(), stdoutFile, err.Error())
		return err
	}

	command := fmt.Sprintf("%s/%s -d=%s -k=%s -n=%s", filepath.Join(ComponentBinPath), node.GetComponent(), node.GetDomain(), node.GetKeeperAddr(), node.GetID())
	cmd := exec.Command(os.Getenv("SHELL"), "-c", command)
	cmd.Stdout = stdout
	cmd.Stderr = stderr

	Logex.Trace("serviceStart", "command", node.GetComponent(), command, "stdout>"+stdoutFile, "stderr>"+stderrFile)

	if err := cmd.Start(); err != nil {
		Logex.Error("serviceStart", "cmd.Start", node.GetComponent(), command, err.Error())
		return fmt.Errorf("%s: %s", err.Error(), command)
	}

	go func(node model.NodeInfo) {
		cmd.Wait()
		stdout.Close()
		stderr.Close()

		Logex.Trace("serviceStart", "component has exited", node.GetComponent())
	}(node)

	err = saveComponentPid(node.GetComponent(), node.GetID(), strconv.Itoa(cmd.Process.Pid))
	if err != nil {
		Logex.Error("serviceStart", "saveComponentPid", node.GetComponent(), err.Error())
		return err
	}

	Logex.Trace("serviceStart", "component has been started", "pid="+strconv.Itoa(cmd.Process.Pid))

	return nil
}

func serviceRestart(c *gokeeper.Client, evt model.Event) error {
	Logex.Trace("serviceRestart", "receive restart event")

	serviceStop(c, evt)
	time.Sleep(1 * time.Second)
	if err := serviceStart(c, evt); err != nil {
		return err
	}
	return nil
}

func serviceStop(c *gokeeper.Client, evt model.Event) error {
	node, ok := (evt.Data).(model.NodeInfo)
	if !ok {
		return ErrEventData
	}

	Logex.Trace("serviceStop", "receive stop event", node.GetComponent())

	pidStr, err := getComponentPid(node.GetComponent(), node.GetID())
	if err != nil {
		Logex.Error("serviceStop", "getComponentPid", node.GetComponent(), err.Error())
		return err
	}
	pid, err := strconv.Atoi(pidStr)
	if err != nil {
		Logex.Error("serviceStop", "pid invalid", node.GetComponent(), "pid="+pidStr, err.Error())
		return err
	}
	process, err := os.FindProcess(pid)
	if err != nil {
		Logex.Error("serviceStop", "FindProcess", node.GetComponent(), pid, err.Error())
		return err
	}

	process.Signal(syscall.SIGTERM)
	if err := process.Signal(syscall.SIGUSR1); err != nil {
		Logex.Error("serviceStop", "Signal", node.GetComponent(), err.Error())
		return err
	}

	Logex.Trace("serviceStop", "component should have stopped", node.GetComponent(), pid)

	return nil
}

func getComponentPid(component, nodeID string) (string, error) {
	pidFile := getComponentPidFile(component, nodeID)
	pid, err := ioutil.ReadFile(pidFile)
	if err != nil {
		return "", err
	}
	if len(pid) == 0 {
		return "", ErrPidEmpty
	}
	return string(pid), nil
}

func saveComponentPid(component, nodeID, pid string) error {
	pidFile := getComponentPidFile(component, nodeID)
	err := ioutil.WriteFile(pidFile, []byte(pid), 0744)
	return err
}

func getComponentPidFile(component, nodeID string) string {
	filename := fmt.Sprintf("%s-%s.pid", component, nodeID)
	pidFile := filepath.Join(ComponentPidPath, filename)
	return pidFile
}


text:
@Article{Grasser_2012,
  doi = {10.1186/1746-4269-8-31},
  url = {https://doi.org/10.1186/1746-4269-8-31},
  year = {2012},
  publisher = {Springer Nature},
  volume = {8},
  number = {1},
  pages = {31},
  author = {Susanne Grasser and Christoph Schunko and Christian R Vogl},
  title = {Gathering {\textquotedblleft}tea{\textquotedblright} {\textendash} from necessity to connectedness with nature. Local knowledge about wild plant gathering in the Biosphere Reserve Grosses Walsertal (Austria)},
  journal = {J Ethnobiology Ethnomedicine},
}

@Article{Groom_2012,
  doi = {10.1016/j.biocon.2012.03.002},
  url = {https://doi.org/10.1016/j.biocon.2012.03.002},
  year = {2012},
  month = {oct},
  publisher = {Elsevier {BV}},
  volume = {154},
  pages = {42--52},
  author = {Ben Groom and Charles Palmer},
  title = {{REDD}$\mathplus$ and rural livelihoods},
  journal = {Biological Conservation},
}

@Article{Heyman_2012,
  doi = {10.1016/j.fishres.2012.02.016},
  url = {https://doi.org/10.1016/j.fishres.2012.02.016},
  year = {2012},
  month = {aug},
  publisher = {Elsevier {BV}},
  volume = {125-126},
  pages = {129--148},
  author = {William D. Heyman and Pablo Granados-Dieseldorff},
  title = {The voice of the fishermen of the Gulf of Honduras: Improving regional fisheries management through fisher participation},
  journal = {Fisheries Research},
}

@Misc{Yap,
  doi = {10.3410/f.718205978.793488603},
  url = {https://doi.org/10.3410/f.718205978.793488603},
  publisher = {Faculty of 1000, Ltd.},
  author = {Helen Yap},
  title = {Faculty of 1000 evaluation for Community Markets for Conservation ({COMACO}) links biodiversity conservation with sustainable improvements in livelihoods and food production.},
}

@Article{Mfunda_2011,
  doi = {10.1080/21513732.2011.602028},
  url = {https://doi.org/10.1080/21513732.2011.602028},
  year = {2011},
  month = {mar},
  publisher = {Informa {UK} Limited},
  volume = {7},
  number = {1},
  pages = {39--49},
  author = {Iddi M. Mfunda and Eivin R{\o}skaft},
  title = {Wildlife or crop production: the dilemma of conservation and human livelihoods in Serengeti, Tanzania},
  journal = {International Journal of Biodiversity Science, Ecosystem Services {\&} Management},
}

@Article{Farley_2009,
  doi = {10.1007/s00267-009-9379-4},
  url = {https://doi.org/10.1007/s00267-009-9379-4},
  year = {2009},
  month = {oct},
  publisher = {Springer Science $\mathplus$ Business Media},
  volume = {45},
  number = {1},
  pages = {39--51},
  author = {Joshua Farley and David Batker and Isabel {de la Torre} and Tom Hudspeth},
  title = {Conserving Mangrove Ecosystems in the Philippines: Transcending Disciplinary and Institutional Borders},
  journal = {Environmental Management},
}

@Article{Wells_2010,
  doi = {10.1016/j.ocecoaman.2010.01.007},
  url = {https://doi.org/10.1016/j.ocecoaman.2010.01.007},
  year = {2010},
  month = {apr},
  publisher = {Elsevier {BV}},
  volume = {53},
  number = {4},
  pages = {161--168},
  author = {Sue Wells and Melita Samoilys and Solomon Makoloweka and Hassan Kalombo},
  title = {Lessons learnt from a collaborative management programme in coastal Tanzania},
  journal = {Ocean {\&} Coastal Management},
}

@Article{GUBBI_2008,
  doi = {10.1017/s0376892908005225},
  url = {https://doi.org/10.1017/s0376892908005225},
  year = {2008},
  month = {dec},
  publisher = {Cambridge University Press ({CUP})},
  volume = {35},
  number = {04},
  pages = {331},
  author = {SANJAY GUBBI and MATTHEW LINKIE and NIGEL LEADER-WILLIAMS},
  title = {Evaluating the legacy of an integrated conservation and development project around a tiger reserve in India},
  journal = {Envir. Conserv.},
}

repository: marty-downs/evidence-based-heatmap

repo_name: marty-downs/evidence-based-heatmap


text:
DESCRIPTION = "Sol3 (sol2 v3.0) - a C++ <-> Lua API wrapper with advanced features and top notch performance - is here, and it's great!"
LICENSE = "MIT"
HOMEPAGE = "https://github.com/ThePhD/sol2"
LIC_FILES_CHKSUM = "file://LICENSE.txt;md5=ce04e78f0c06a8a22851d023215d658a"

DEPENDS += "lua-native lua"

SRC_URI = "git://github.com/ThePhD/sol2.git;branch=develop"

SRCREV = "e09d2ffef8f4edb1e67aef881c6ad3c58a30c5d6"
S = "${WORKDIR}/git"
LUA_VERSION = "5.3"

inherit pkgconfig cmake


text:
// This package defines the Store interfaces for reading and writing bundles
// (or any artifact data) to some underlying system, and Store implementations.
package store

import (
	"io"
	"time"

	"github.com/twitter/scoot/common/stats"
)

var DefaultTTL time.Duration = time.Hour * 24 * 180 //180 days. If zero, no ttl will be applied by default.
const (
	// DefaultTTLKey is primarily used for communicating ttl(RFC1123) over http.
	DefaultTTLKey string = "x-scoot-expires"
	// DefaultTTLFormat is to specify the format for parsing ttl(RFC1123).
	DefaultTTLFormat string = time.RFC1123
)

// Stores should generally support TTL, at this time httpStore and groupcacheStore implement it.
type TTLValue struct {
	TTL    time.Time
	TTLKey string
}

// TTLConfig configures defaults for stores.
type TTLConfig struct {
	TTL       time.Duration
	TTLKey    string
	TTLFormat string
}

// Gets a TTLValue based on Now given a TTLConfig, or nil
func GetTTLValue(c *TTLConfig) *TTLValue {
	if c != nil {
		return &TTLValue{TTL: time.Now().Add(c.TTL), TTLKey: c.TTLKey}
	}
	return nil
}

// Return a time.Duration based on Now given a TTLValue specifying a fixed time.
// Returns a zero duration if TTLValue is nil or if duration would be negative.
func GetDurationTTL(t *TTLValue) time.Duration {
	var d time.Duration
	if t != nil {
		d = t.TTL.Sub(time.Now())
	}
	if d < 0 {
		d = 0
	}
	return d
}

// Resource encapsulates a Store resource and embeds an io.ReadCloser around the data
// Length: length in bytes of data to be read or written
// TTLValue: TTL value for the resource, or nil if not supporting TTL
type Resource struct {
	io.ReadCloser
	Length   int64
	TTLValue *TTLValue
}

// NewResource constructs a new resource.
func NewResource(rc io.ReadCloser, l int64, ttlv *TTLValue) *Resource {
	return &Resource{ReadCloser: rc, Length: l, TTLValue: ttlv}
}

// Read-only operations on store, limited for now to a couple essential functions.
type StoreRead interface {
	// Check if the bundle exists. Not guaranteed to be any cheaper than actually reading the bundle.
	Exists(name string) (bool, error)

	// Open the bundle for streaming read. It is the caller's responsibility to call Close().
	OpenForRead(name string) (*Resource, error)

	// Get the base location, like a directory or base URI that the Store writes to
	Root() string
}

// Write operations on store, limited to a one-shot writing operation since bundles are immutable.
// If ttl config is nil then the store will use its defaults.
type StoreWrite interface {
	// Does a streaming write of the given bundle. There is no concept of partial writes (partial=failed).
	Write(name string, resource *Resource) error
}

// Combines read and write operations on store. This is what most of the code will use.
type Store interface {
	StoreRead
	StoreWrite
}

// Encapsulating struct for instances of Stores and accompanying configurations
type StoreConfig struct {
	Store  Store
	TTLCfg *TTLConfig
	Stat   stats.StatsReceiver
}

repository: twitter/scoot

repo_name: twitter/scoot


text:
SUMMARY = "A Simple Server with Python Flask"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"
PV = "1.0"
PR = "r1"

SRC_URI = "\
	file://Dockerfile \
	file://requirements.txt \
"

fetch_rdepends_debs[depends] = "\
	simple-server-python:do_package_write_deb \
"
addtask fetch_rdepends_debs after do_fetch before do_compile
do_fetch_rdepends_debs() {
	install -d "${S}/install-debs/"
	install --target-directory "${S}/install-debs/" \
		${DEPLOY_DIR_DEB}/${PACKAGE_ARCH}/simple-server-python_*.deb
}

do_install() {
	install -d \
		"${D}/${datadir}/${PN}" \
		"${D}/${datadir}/${PN}/install-debs"

	install --target-directory "${D}/${datadir}/${PN}" \
		"${WORKDIR}/Dockerfile" \
		"${WORKDIR}/requirements.txt"

	install --target-directory "${D}/${datadir}/${PN}/install-debs" \
		${S}/install-debs/*
}
FILES_${PN} = "${datadir}/${PN}"

repository: NGenetzky/meta-ngenetzky

repo_name: NGenetzky/meta-ngenetzky


text:
package main

import "testing"

func Benchmark_1(b *testing.B) {
	nums := []int{0, 0, 1, 1, 1, 2, 2, 3, 3, 4, 5, 5, 5, 5, 10, 10, 11}
	for i := 0; i < b.N; i++ {
		removeDuplicates(nums)
	}
}

func Benchmark_2(b *testing.B) {
	nums := []int{0, 0, 1, 1, 1, 2, 2, 3, 3, 4, 5, 5, 5, 5, 10, 10, 11}
	for i := 0; i < b.N; i++ {
		removeDuplicates2(nums)
	}
}
func Benchmark_3(b *testing.B) {
	nums := []int{0, 0, 1, 1, 1, 2, 2, 3, 3, 4, 5, 5, 5, 5, 10, 10, 11}
	for i := 0; i < b.N; i++ {
		removeDuplicates3(nums)
	}
}

repository: wangxianzhuo/leetcode-practises

repo_name: wangxianzhuo/leetcode-practises


text:
DESCRIPTION = "An extremely memory-efficient hash_map implementation."
SECTION = ""
PRIORITY = "optional"
DEPENDS = ""
LICENSE = "BSD"
LIC_FILES_CHKSUM="file://COPYING;md5=762732742c73dc6c7fbe8632f06c059a"
PR = "r0"

SRC_URI="http://google-sparsehash.googlecode.com/files/sparsehash-1.11.tar.gz"

inherit autotools pkgconfig

SRC_URI[md5sum] = "53a9bb4b3fb11fc6fca9bf938c1b1ce9"
SRC_URI[sha256sum] = "1934d7b0ae76d24518c1520fc1cc424eb4788f9bd4618a8e9b0f19a9f8489cd4"

repository: mkatic/meta-zos

repo_name: mkatic/meta-zos


text:
SUMMARY = "A set of utilities to help QCA driver development."
HOMEPAGE = "https://github.com/qca/qca-swiss-army-knife"
SECTION = "devel"

LICENSE = "ISC"
LIC_FILES_CHKSUM = "file://LICENSE;md5=884c3f3a874b2a0cfa283c7db0e5d604"

SRCREV = "5ede3cc07e9a52f115101c28f833242b772eeaab"
SRC_URI = " \
	git://github.com/qca/${BPN}.git;branch=master;protocol=https \
	file://0001-ath10k-bdencoder-Switch-to-python3.patch \
	file://0002-ath10k-bdencoder-Add-option-to-switch-to-ath11k-mode.patch \
	file://0001-read-powers-port-to-python3.patch \
	file://0002-ath10k-fwencoder-port-to-python3.patch \
	file://0003-scripts-port-to-python3.patch \
	file://ath10k-generate-board-2_json.sh \
	file://ath10k-generate-pci-board-2_json.sh \
	file://ath11k-generate-board-2_json.sh \
"

PV = "0.0+${SRCPV}"
S = "${WORKDIR}/git"

do_install () {
	install -d ${D}/${bindir}
	install -m 0755 tools/scripts/*/* ${D}/${bindir}
	install -m 0755 ${WORKDIR}/ath10k-generate-board-2_json.sh ${D}/${bindir}
	install -m 0755 ${WORKDIR}/ath10k-generate-pci-board-2_json.sh ${D}/${bindir}
	install -m 0755 ${WORKDIR}/ath11k-generate-board-2_json.sh ${D}/${bindir}
}

BBCLASSEXTEND = "native nativesdk"

RDEPENDS:${PN} += "perl python3-core"

repository: vchong/meta-qcom

repo_name: vchong/meta-qcom


text:
package testing

import (
	"fmt"
	"net/http"
	"testing"

	"github.com/chnsz/golangsdk"
	"github.com/chnsz/golangsdk/openstack/dli/v2/batches"
	th "github.com/chnsz/golangsdk/testhelper"
	"github.com/chnsz/golangsdk/testhelper/client"
)

const (
	expectedCreateResponse = `
{
	"cluster_name": "driver_behavior",
	"create_time": 1634285547245,
	"id": "6145a791-81a4-4edb-b2d2-ea599caf6550",
	"name": "terraform_spark_job",
	"owner": "terraform",
	"queue": "terraform_test",
	"sc_type": "CUSTOMIZED",
	"state": "starting",
	"update_time": 1634285547245
}`

	expectedGetStateResponse = `
{
	"id": "6145a791-81a4-4edb-b2d2-ea599caf6550",
	"state": "starting"
}`
)

var (
	createOpts = batches.CreateOpts{
		ClassName: golangsdk.MaybeString("driver_behavior"),
		Queue:     "terraform_test",
		Name:      "terraform_spark_job",
		Configurations: map[string]interface{}{
			"spark.dli.metaAccess.enable": "true",
		},
		File: "driver_package/driver_behavior.jar",
		Jars: []string{"jar_package/jackson-core-2.13.0-javadoc.jar"},
		Groups: []batches.Group{
			{
				Name: "driver_package",
			},
		},
		MaxRetryTimes:  20,
		Specification:  "A",
		DriverMemory:   "5G",
		DriverCores:    2,
		ExecutorMemory: "8G",
		ExecutorCores:  2,
		NumExecutors:   12,
	}

	expectedCreateResponseData = &batches.CreateResp{
		ClusterName: "driver_behavior",
		ID:          "6145a791-81a4-4edb-b2d2-ea599caf6550",
		Name:        "terraform_spark_job",
		Owner:       "terraform",
		Queue:       "terraform_test",
		ScType:      "CUSTOMIZED",
		State:       "starting",
		CreateTime:  1634285547245,
		UpdateTime:  1634285547245,
	}

	expectedGetStateResponseData = &batches.StateResp{
		ID:    "6145a791-81a4-4edb-b2d2-ea599caf6550",
		State: "starting",
	}
)

func handleV2SparkJobCreate(t *testing.T) {
	th.Mux.HandleFunc("/batches", func(w http.ResponseWriter, r *http.Request) {
		th.TestMethod(t, r, "POST")
		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
		w.Header().Add("Content-Type", "application/json")
		w.WriteHeader(http.StatusOK)
		_, _ = fmt.Fprint(w, expectedCreateResponse)
	})
}

func handleV2SparkJobGet(t *testing.T) {
	th.Mux.HandleFunc("/batches/6145a791-81a4-4edb-b2d2-ea599caf6550", func(w http.ResponseWriter, r *http.Request) {
		th.TestMethod(t, r, "GET")
		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
		w.Header().Add("Content-Type", "application/json")
		w.WriteHeader(http.StatusOK)
		_, _ = fmt.Fprint(w, expectedCreateResponse)
	})
}

func handleV2SparkJobGetState(t *testing.T) {
	th.Mux.HandleFunc("/batches/6145a791-81a4-4edb-b2d2-ea599caf6550/state",
		func(w http.ResponseWriter, r *http.Request) {
			th.TestMethod(t, r, "GET")
			th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
			w.Header().Add("Content-Type", "application/json")
			w.WriteHeader(http.StatusOK)
			_, _ = fmt.Fprint(w, expectedGetStateResponse)
		})
}

func handleV2SparkJobDelete(t *testing.T) {
	th.Mux.HandleFunc("/batches/6145a791-81a4-4edb-b2d2-ea599caf6550", func(w http.ResponseWriter, r *http.Request) {
		th.TestMethod(t, r, "DELETE")
		th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
		w.Header().Add("Content-Type", "application/json")
		w.WriteHeader(http.StatusOK)
	})
}

repository: niuzhenguo/golangsdk

repo_name: niuzhenguo/golangsdk

gha_license_id: NOASSERTION


text:
// Copyright 2016-2019 The Libsacloud Authors
//
// 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.

package sacloud

import (
	"encoding/json"
	"testing"

	"github.com/stretchr/testify/assert"
)

var testZoneJSON = `
{
	"ID": 31002,
	"DisplayOrder": 20031002,
	"Name": "is1b",
	"Description": "\u77f3\u72e9\u7b2c2\u30be\u30fc\u30f3",
	"IsDummy": false,
	"VNCProxy": {
	    "HostName": "sac-is1b-ssl.sakura.ad.jp",
	    "IPAddress": "133.242.239.244"
	},
	"FTPServer": {
	    "HostName": "sac-is1b-ssl.sakura.ad.jp",
	    "IPAddress": "133.242.239.244"
	},
	"Settings": {
	    "Subnet": {
		"Plan": {
		    "Member": [28,27,26],
		    "Staff": [28,27,26,25,24]
		}
	    }
	},
	"Region": ` + testRegionJSON + `
}
`

func TestMarshalZoneJSON(t *testing.T) {
	var zone Zone
	err := json.Unmarshal([]byte(testZoneJSON), &zone)

	assert.NoError(t, err)
	assert.NotEmpty(t, zone)

	assert.NotEmpty(t, zone.ID)
	assert.NotEmpty(t, zone.VNCProxy.HostName)
	assert.NotEmpty(t, zone.FTPServer.HostName)
	assert.NotEmpty(t, zone.Region.ID)
	assert.NotEmpty(t, zone.Region.NameServers)
}

repository: smlrepo/libsacloud

repo_name: smlrepo/libsacloud


text:
SUMMARY  = "Xilinx dfx-mgr libraries"
DESCRIPTION = "Xilinx Runtime User Space Libraries and Binaries"

LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://LICENSE;md5=d67bcef754e935bf77b6d7051bd62b5e"

REPO ?= "git://github.com/Xilinx/dfx-mgr.git;protocol=https"
BRANCHARG = "${@['nobranch=1', 'branch=${BRANCH}'][d.getVar('BRANCH', True) != '']}"
SRC_URI = "${REPO};${BRANCHARG}"

BRANCH = "master"
SRCREV = "9989200612b149d926077c5c8096f95b9a74e5ff"

S = "${WORKDIR}/git"

inherit cmake update-rc.d

DEPENDS += " libwebsockets inotify-tools libdfx zocl libdrm"
EXTRA_OECMAKE += " \
		-DCMAKE_INCLUDE_PATH=${S}/include \
		"
INITSCRIPT_NAME = "dfx-mgr.sh"
INITSCRIPT_PARAMS = "start 99 S ."

do_install(){
	install -d ${D}${bindir}
	install -d ${D}${sysconfdir}/init.d/
	install -d ${D}${base_libdir}/firmware/xilinx
	install -d ${D}/etc/dfx-mgrd

	cp ${B}/example/sys/linux/dfx-mgrd-static ${D}${bindir}/dfx-mgrd
	cp ${B}/example/sys/linux/dfx-mgr-client-static ${D}${bindir}/dfx-mgr-client
	chrpath -d ${D}${bindir}/dfx-mgrd
	chrpath -d ${D}${bindir}/dfx-mgr-client
	install -m 0755 ${S}/src/dfx-mgr.sh ${D}${sysconfdir}/init.d/
	install -m 0755 ${S}/src/daemon.conf ${D}/etc/dfx-mgrd/
}

FILES_${PN} += "${base_libdir}/firmware/xilinx"

repository: ansar-rasool/meta-xilinx-tools

repo_name: ansar-rasool/meta-xilinx-tools


text:
include(RunCMake)

run_cmake(ParentScope)
run_cmake(ParentPulling)
run_cmake(ParentPullingRecursive)
run_cmake(UnknownCacheType)

repository: jschultz/CMake

repo_name: jschultz/CMake

extension: cmake


text:
package actuator_test

import (
	"testing"

	"github.com/ninech/actuator/actuator"
	"github.com/ninech/actuator/github"

	"github.com/stretchr/testify/assert"
)

func TestPingEventHandler(t *testing.T) {
	t.Run("GetEventResponse", func(t *testing.T) {
		handler := actuator.NewPingEventHandler()
		response := handler.GetEventResponse(&github.Event{})

		assert.Equal(t, "Request received. Thank you.", response.Message)
	})

	t.Run("HandleEvent", func(t *testing.T) {
		handler := actuator.NewGenericEventHandler()
		handler.HandleEvent(&github.Event{})
	})
}

repository: ninech/actuator

repo_name: ninech/actuator


text:
@inproceedings{kuwahara_erlang-delayed_2011,
 abstract = {Stochastic chemical kinetics (SCK) has become an important formalism for modeling and analysis of complex biological systems as it can capture the discreteness and the randomness of underlying biochemical reactions. One of the assumptions made by SCK is that each reaction be an elementary step which cannot be broken down into smaller steps. As such, transition events of the SCK model occur spontaneously in that there is no time lag between the reaction initiation and completion. In practice, however, it is very difficult to experimentally determine if an observed state change is a result of an elementary reaction or a sequence of several reaction steps. To test various hypotheses on such time-delays through the use of the SCK, all of the intermediate reactions and species need to be explicitly specified, which can quickly become cumbersome. To more efficiently model and analyze potential effects of such intermediate reaction steps, this paper proposes a new formalism for higher-level discrete-stochastic treatment of biological systems with reaction delays. Our new formalism can represent a time delay caused by intermediate reaction steps as an Erlang random variable, allowing a model's size to be reduced substantially. This paper illustrates an application of this formalism for analysis of the effect of different transcription elongation steps and rates on the distribution of RNA molecules.},
 author = {Kuwahara, Hiroyuki and Myers, Chris},
 booktitle = {Proceedings of the 2nd ACM Conference on Bioinformatics, Computational Biology and Biomedicine},
 date = {2011-08-01},
 doi = {10.1145/2147805.2147863},
 file = {Kuwahara_Myers-2011-Erlang-delayed stochastic chemical kinetic formalism for efficient analysis of.pdf:/Users/lukas/Lab/Zotero/storage/5PGKGC9A/Kuwahara_Myers-2011-Erlang-delayed stochastic chemical kinetic formalism for efficient analysis of.pdf:application/pdf},
 isbn = {978-1-4503-0796-3},
 keywords = {stochastic logic},
 location = {New York, NY, USA},
 note = {00000},
 pages = {425--429},
 publisher = {Association for Computing Machinery},
 series = {BCB '11},
 title = {Erlang-delayed stochastic chemical kinetic formalism for efficient analysis of biological systems with non-elementary reaction effects},
 url = {http://doi.org/10.1145/2147805.2147863},
 urldate = {2020-09-18}
}


text:
DESCRIPTION = "GNU dbm is a set of database routines that use extensible hashing."
HOMEPAGE = "http://www.gnu.org/software/gdbm/gdbm.html"
SECTION = "libs"
PRIORITY = "optional"
LICENSE = "GPL"

PR = "r5"

SRC_URI = "${GNU_MIRROR}/gdbm/gdbm-${PV}.tar.gz \
	   file://makefile.patch \
           file://libtool-mode.patch \
           file://chmod.patch"

inherit autotools

TARGET_CC_ARCH += "${LDFLAGS}"

SRC_URI[md5sum] = "1d1b1d5c0245b1c00aff92da751e9aa1"
SRC_URI[sha256sum] = "cc340338a2e28b40058ab9eb5354a21d53f88a1582ea21ba0bb185c37a281dc9"

BBCLASSEXTEND = "native"


text:
package settings

import (
	"encoding/json"
	"hash/fnv"
	"log"
	"math/rand"
	"os"
	"sort"
	"strings"
)

// Settings holds every setting we want to randomize, along with their possible
// values, cost, and a probability weight.
// The cost is an arbitrary cost out of a budget of an arbitrary number of
// points, the idea is to avoid having too much chaos-inducing settings applied
// at the same time.
// The probability is there to ensure some values are scarcely or never used.
// It is an integer that only has meaning relative to the sum of all
// probabilities.
type Settings map[string]Setting // name (json key) => possible values

// Load loads shuffled settings parameters from file.
func Load(path string) (Settings, error) {
	var ret Settings
	f, err := os.Open(path)
	if err != nil {
		return nil, err
	}
	defer f.Close()

	dec := json.NewDecoder(f)
	if err := dec.Decode(&ret); err != nil {
		return nil, err
	}

	return ret, nil
}

func (s Settings) weightSum() float64 {
	var weightSum float64
	for k := range s {
		for i := range s[k] {
			weightSum += s[k][i].Weight
		}
	}

	return weightSum
}

func abs(v int) int {
	if v < 0 {
		return -v
	}
	return v
}

func int64SeedFromString(str string) int64 {
	h := fnv.New64a()
	if _, err := h.Write([]byte(str)); err != nil {
		panic(err)
	}

	return int64(h.Sum64())
}

// Shuffle is a probably broken adaptation of M. T. Chao "general purpose
// unequal probability sampling plan" algorithm.
// Biometrika Vol. 69, No. 3 (Dec., 1982), pp. 653-656
// DOI: 10.2307/2336002
// There is an hardcoded maximum iterations count to avoid inifite loops, and
// and a tolerance for going under or over the cost budget if we reach enough
// iterations.
func (s Settings) Shuffle(seedStr string, costMax int) map[string]interface{} { // nolint:funlen
	r := rand.New(rand.NewSource(int64SeedFromString(seedStr))) // nolint:gosec

	var costSum, iterations, tolerance int
	weightSum := s.weightSum()
	maxIterations := 1000 // arbitrary
	ret := map[string]interface{}{}

	// Make map iteration deterministic
	keys := make([]string, 0, len(s))
	for k := range s {
		keys = append(keys, k)
	}
	sort.Strings(keys)

	// iterate until we matched our budget or we failed to match it
	for abs(costMax-costSum) > tolerance && iterations < maxIterations {
		// Shuffle before each step to ensure first items are not picked more than the rest.
		r.Shuffle(len(keys), func(i, j int) {
			keys[i], keys[j] = keys[j], keys[i]
		})

		for _, k := range keys { // iterate over all settings
			// Already decided on a value for this setting on a previous iteration.
			if _, ok := ret[k]; ok {
				continue
			}

			for i := range s[k] { // iterate over all possible values
				if s[k][i].Weight <= 0 {
					continue
				}

				p := s[k][i].Weight / weightSum
				if r.Float64() > p { // not selected, ignore
					continue
				}

				// Over cost budget, ignore
				newCost := costSum + s[k][i].Cost
				if newCost > (costMax - tolerance) {
					continue
				}

				// Selected, set value and update cost.
				costSum = newCost
				ret[k] = s[k][i].Value

				// Avoid conflicting settings
				for impliedKey, impliedValue := range s[k][i].Implies {
					ret[impliedKey] = impliedValue
				}

				// Disable other bridge settings if we picked one.
				handleBridgeSettings(k, s[k][i].Value, ret)

				break
			}
		}

		tolerance = iterations / 100
		iterations++
	}

	return ret
}

// handleBridgeSettings is a magic/auto Implies statement to disable all other
// bridge settings once one has been picked.
func handleBridgeSettings(name string, value interface{}, ret map[string]interface{}) {
	if !strings.HasPrefix(name, "bridge") {
		return
	}

	// If we manually set bridge, ensure we're not picking any other bridge setting.
	if name == "bridge" {
		vStr, ok := value.(string)
		if !ok {
			log.Printf("error: 'bridge' set with non-string value '%v'", value)
			return
		}
		if vStr != "open" && vStr != "vanilla" {
			log.Printf("error: 'bridge' can only be set to 'open' or 'vanilla', '%s' provided", vStr)
			return
		}
		ret["bridge_tokens"] = 0
		ret["bridge_stones"] = 0
		ret["bridge_rewards"] = 0
		ret["bridge_medallions"] = 0
		return
	}

	typ := strings.Split(name, "_")[1] // will panic on bad value, 'tis ok.
	if typ == "rewards" {
		ret["bridge"] = "dungeons" // OOTR and consistency…
	} else {
		ret["bridge"] = typ
	}

	// Set all other settings to 0 to ensure they cannot be picked later.
	for _, v := range []string{"stones", "medallions", "rewards", "tokens"} {
		if v != typ {
			ret["bridge_"+v] = 0
		}
	}
}

// A Setting is a collection of values that can be given to a setting key.
type Setting []PossibleSettingValue

// A PossibleSettingValue has a cost that represents its impact on routing, a
// weight to make it appear less or more often, and a list of implied settings
// k/v to avoid impossible settings combo or force interesting combinations.
type PossibleSettingValue struct {
	Value   interface{}
	Cost    int
	Weight  float64
	Implies map[string]interface{}
}

repository: mracsys/kaepora

repo_name: mracsys/kaepora


text:
@article{melymcb-0143,
 author = {Pugnaloni, L.A. and Vericat, F.},
 document_type = {Article},
 journal = {Physical Review E - Statistical Physics, Plasmas, Fluids, and Related Interdisciplinary Topics},
 note = {cited By 7},
 number = {6 B},
 pages = {R6067-R6070},
 source = {Scopus},
 title = {Density expansion for particle-particle correlations in time-dependent physical clusters},
 url = {https://www.scopus.com/inward/record.uri?eid=2-s2.0-0034207194&partnerID=40&md5=62f664bf4dd0e75e9fcdb0b64570a751},
 volume = {61},
 year = {2000}
}


text:
X. Chen, J. Peng, J. Zhou, Y. Chen, M. Y. Wang and Z. Wang, "A robotic manipulator design with novel soft actuators," 2017 IEEE International Conference on Robotics and Automation (ICRA), Singapore, 2017, pp. 1878-1884.

@inproceedings{Chen2017g,
abstract = {Soft robots are inherently compliant and adaptive, therefore they are promising candidates for interacting with humans. However robotic manipulators utilizing soft actuators are often constrained by a series of actuator performance limitations. In this work we design a novel linear soft robotic actuator with significantly improved performances over the existing products, achieving 300{\%} deformation ratio, quasi-constant output force over a wide motion range, while maintain-ing passive compliance and adaptability. Moreover, the novel actuator is less prone to friction, and could be fabricated using inject molding and 3D printing, hence having high repeata-bility at very low cost. An analytical model was developed to characterize the actuator behavior and provide a guideline for actuator design according to performance specifications. A 6 DOF soft manipulator was designed and fabricated utilizing the novel soft actuator. The manipulator arm had a serial kinematic structure with a biomimetic wrist and was driven by 12 soft actuators mounted onto the arm links. With 1.2m workspace radius and 1kg payload, the working air pressure could be as low as 1bar. Preliminary results have shown the validity of the novel soft actuator and manipulator designs, as well as the strong potential of soft robots in human-oriented applications.},
author = {Chen, Xiaojiao and Peng, Jing and Zhou, Jianshu and Chen, Yonghua and Wang, Michael Yu and Wang, Zheng},
booktitle = {2017 IEEE International Conference on Robotics and Automation (ICRA)},
doi = {10.1109/ICRA.2017.7989220},
isbn = {978-1-5090-4633-1},
issn = {10504729},
mendeley-groups = {OurLab},
month = {may},
pages = {1878--1884},
publisher = {IEEE},
title = {{A robotic manipulator design with novel soft actuators}},
url = {http://ieeexplore.ieee.org/document/7989220/},
year = {2017}
}

url: https://raw.githubusercontent.com/XiaojiaoChen/academic-MyWebsite/c9bc75343b7f234b1d94495441d92ad6e521157f/content/publication/conference-paper/A robotic manipulator design with novel soft actuators/cite.bib

repository: XiaojiaoChen/academic-MyWebsite

repo_name: XiaojiaoChen/academic-MyWebsite


text:
package golinks

import (
	"fmt"
	"net/http"
)

func getErrorJSON(status int) string {
	return fmt.Sprintf(`{
	"status": %d,
	"message": "error",
	"type": "error"
}`, status)
}

func addHeader(w http.ResponseWriter) {
	w.Header().Add(rateLimitRemainingHeader, "99")
	w.Header().Add(rateLimitLimitHeader, "1000")
	w.Header().Add(rateLimitResetHeader, "1598795193")
}

repository: kekelinks/go-golinks

repo_name: kekelinks/go-golinks


text:
package main

import (
	"reflect"
	"testing"
)

func TestSilver(t *testing.T) {
	value := PartOne("example")
	expected := "13"

	if value != expected {
		t.Error("Got " + value + " expected " + expected)
	}
}

func TestGold(t *testing.T) {
	value := PartTwo("example")
	expected := ""

	if value != expected {
		t.Error("Got " + value + " expected " + expected)
	}
}

func TestSplitLineIntoLists(t *testing.T) {
	type args struct {
		line string
	}
	tests := []struct {
		name string
		args args
		want []string
	}{
		{
			name: "basic",
			args: args{"[1,2,3,4]"},
			want: []string{"1", "2", "3", "4"},
		},
		{
			name: "One nested Left",
			args: args{"[[1],[2,3,4]]"},
			want: []string{"[1]", "[2,3,4]"},
		},
		{
			name: "One nested right",
			args: args{"[1,[2,[3,[4,[5,6,7]]]],8,9]"},
			want: []string{"1", "[2,[3,[4,[5,6,7]]]]", "8", "9"},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := SplitLineIntoLists(tt.args.line); !reflect.DeepEqual(got, &tt.want) {
				t.Errorf("SplitLineIntoLists() = %v, want %v", got, tt.want)
			}
		})
	}
}

repository: hamzah-hayat/adventofcode

repo_name: hamzah-hayat/adventofcode


text:
package main

import (
	"fmt"

	"github.com/pkg/profile"
)

func fib(n int) int {
	if n < 2 {
		return n
	}
	return fib(n-1) + fib(n-2)
}

func main() {
	defer profile.Start().Stop()

	fmt.Println("start")
	for i := 0; i < 1000; i++ {
		fib(30)
	}
}


text:
package forest

import (
	"math"
	"testing"
)

func TestIrisFitPredict(t *testing.T) {
	clf := NewClassifier(NumTrees(10))

	clf.Fit(X, Y)

	pred := clf.Predict(X)

	correctFrac := 0.0
	contrib := 1.0 / float64(len(pred))
	for i := range Y {
		if Y[i] == clf.Classes[pred[i]] {
			correctFrac += contrib
		}
	}

	if correctFrac < 0.98 {
		t.Errorf("expected accuracy on iris data to be at least 0.98, got: %f", correctFrac)
	}
}

func TestIrisVariableImportance(t *testing.T) {
	clf := NewClassifier(NumTrees(10))
	clf.Fit(X, Y)

	sum := 0.0
	for _, val := range clf.VarImp() {
		sum += val
	}

	if math.Abs(sum-1.0) > 1e-7 {
		t.Error("expected variable importance to sum to 1, got:", sum)
	}
}

func TestIrisOOBError(t *testing.T) {
	clf := NewClassifier(NumTrees(10), ComputeOOB)

	clf.Fit(X, Y)

	// check oob accuracy
	if clf.Accuracy < 0.90 {
		t.Errorf("expected oob accuracy to be at least 0.90, got: %f", clf.Accuracy)
	}

	// check confusion matrix
	for i := range clf.ConfusionMatrix {
		if clf.ConfusionMatrix[i][i] < 40 || clf.ConfusionMatrix[i][i] > 50 {
			t.Errorf("expected confusion matrix entry to be at least 45 and less than 50, got: %d", clf.ConfusionMatrix[i][i])
		}
	}
}

func BenchmarkIrisFit(b *testing.B) {
	for i := 0; i < b.N; i++ {
		clf := NewClassifier(NumTrees(10))

		clf.Fit(X, Y)
	}
}

func BenchmarkIrisPredict(b *testing.B) {
	clf := NewClassifier(NumTrees(10))
	clf.Fit(X, Y)

	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		_ = clf.Predict(X)
	}
}

var X = [][]float64{
	[]float64{3.5, 1.4, 5.1, 0.2},
	[]float64{3.0, 1.4, 4.9, 0.2},
	[]float64{3.2, 1.3, 4.7, 0.2},
	[]float64{3.1, 1.5, 4.6, 0.2},
	[]float64{3.6, 1.4, 5.0, 0.2},
	[]float64{3.9, 1.7, 5.4, 0.4},
	[]float64{3.4, 1.4, 4.6, 0.3},
	[]float64{3.4, 1.5, 5.0, 0.2},
	[]float64{2.9, 1.4, 4.4, 0.2},
	[]float64{3.1, 1.5, 4.9, 0.1},
	[]float64{3.7, 1.5, 5.4, 0.2},
	[]float64{3.4, 1.6, 4.8, 0.2},
	[]float64{3.0, 1.4, 4.8, 0.1},
	[]float64{3.0, 1.1, 4.3, 0.1},
	[]float64{4.0, 1.2, 5.8, 0.2},
	[]float64{4.4, 1.5, 5.7, 0.4},
	[]float64{3.9, 1.3, 5.4, 0.4},
	[]float64{3.5, 1.4, 5.1, 0.3},
	[]float64{3.8, 1.7, 5.7, 0.3},
	[]float64{3.8, 1.5, 5.1, 0.3},
	[]float64{3.4, 1.7, 5.4, 0.2},
	[]float64{3.7, 1.5, 5.1, 0.4},
	[]float64{3.6, 1.0, 4.6, 0.2},
	[]float64{3.3, 1.7, 5.1, 0.5},
	[]float64{3.4, 1.9, 4.8, 0.2},
	[]float64{3.0, 1.6, 5.0, 0.2},
	[]float64{3.4, 1.6, 5.0, 0.4},
	[]float64{3.5, 1.5, 5.2, 0.2},
	[]float64{3.4, 1.4, 5.2, 0.2},
	[]float64{3.2, 1.6, 4.7, 0.2},
	[]float64{3.1, 1.6, 4.8, 0.2},
	[]float64{3.4, 1.5, 5.4, 0.4},
	[]float64{4.1, 1.5, 5.2, 0.1},
	[]float64{4.2, 1.4, 5.5, 0.2},
	[]float64{3.1, 1.5, 4.9, 0.2},
	[]float64{3.2, 1.2, 5.0, 0.2},
	[]float64{3.5, 1.3, 5.5, 0.2},
	[]float64{3.6, 1.4, 4.9, 0.1},
	[]float64{3.0, 1.3, 4.4, 0.2},
	[]float64{3.4, 1.5, 5.1, 0.2},
	[]float64{3.5, 1.3, 5.0, 0.3},
	[]float64{2.3, 1.3, 4.5, 0.3},
	[]float64{3.2, 1.3, 4.4, 0.2},
	[]float64{3.5, 1.6, 5.0, 0.6},
	[]float64{3.8, 1.9, 5.1, 0.4},
	[]float64{3.0, 1.4, 4.8, 0.3},
	[]float64{3.8, 1.6, 5.1, 0.2},
	[]float64{3.2, 1.4, 4.6, 0.2},
	[]float64{3.7, 1.5, 5.3, 0.2},
	[]float64{3.3, 1.4, 5.0, 0.2},
	[]float64{3.2, 4.7, 7.0, 1.4},
	[]float64{3.2, 4.5, 6.4, 1.5},
	[]float64{3.1, 4.9, 6.9, 1.5},
	[]float64{2.3, 4.0, 5.5, 1.3},
	[]float64{2.8, 4.6, 6.5, 1.5},
	[]float64{2.8, 4.5, 5.7, 1.3},
	[]float64{3.3, 4.7, 6.3, 1.6},
	[]float64{2.4, 3.3, 4.9, 1.0},
	[]float64{2.9, 4.6, 6.6, 1.3},
	[]float64{2.7, 3.9, 5.2, 1.4},
	[]float64{2.0, 3.5, 5.0, 1.0},
	[]float64{3.0, 4.2, 5.9, 1.5},
	[]float64{2.2, 4.0, 6.0, 1.0},
	[]float64{2.9, 4.7, 6.1, 1.4},
	[]float64{2.9, 3.6, 5.6, 1.3},
	[]float64{3.1, 4.4, 6.7, 1.4},
	[]float64{3.0, 4.5, 5.6, 1.5},
	[]float64{2.7, 4.1, 5.8, 1.0},
	[]float64{2.2, 4.5, 6.2, 1.5},
	[]float64{2.5, 3.9, 5.6, 1.1},
	[]float64{3.2, 4.8, 5.9, 1.8},
	[]float64{2.8, 4.0, 6.1, 1.3},
	[]float64{2.5, 4.9, 6.3, 1.5},
	[]float64{2.8, 4.7, 6.1, 1.2},
	[]float64{2.9, 4.3, 6.4, 1.3},
	[]float64{3.0, 4.4, 6.6, 1.4},
	[]float64{2.8, 4.8, 6.8, 1.4},
	[]float64{3.0, 5.0, 6.7, 1.7},
	[]float64{2.9, 4.5, 6.0, 1.5},
	[]float64{2.6, 3.5, 5.7, 1.0},
	[]float64{2.4, 3.8, 5.5, 1.1},
	[]float64{2.4, 3.7, 5.5, 1.0},
	[]float64{2.7, 3.9, 5.8, 1.2},
	[]float64{2.7, 5.1, 6.0, 1.6},
	[]float64{3.0, 4.5, 5.4, 1.5},
	[]float64{3.4, 4.5, 6.0, 1.6},
	[]float64{3.1, 4.7, 6.7, 1.5},
	[]float64{2.3, 4.4, 6.3, 1.3},
	[]float64{3.0, 4.1, 5.6, 1.3},
	[]float64{2.5, 4.0, 5.5, 1.3},
	[]float64{2.6, 4.4, 5.5, 1.2},
	[]float64{3.0, 4.6, 6.1, 1.4},
	[]float64{2.6, 4.0, 5.8, 1.2},
	[]float64{2.3, 3.3, 5.0, 1.0},
	[]float64{2.7, 4.2, 5.6, 1.3},
	[]float64{3.0, 4.2, 5.7, 1.2},
	[]float64{2.9, 4.2, 5.7, 1.3},
	[]float64{2.9, 4.3, 6.2, 1.3},
	[]float64{2.5, 3.0, 5.1, 1.1},
	[]float64{2.8, 4.1, 5.7, 1.3},
	[]float64{3.3, 6.0, 6.3, 2.5},
	[]float64{2.7, 5.1, 5.8, 1.9},
	[]float64{3.0, 5.9, 7.1, 2.1},
	[]float64{2.9, 5.6, 6.3, 1.8},
	[]float64{3.0, 5.8, 6.5, 2.2},
	[]float64{3.0, 6.6, 7.6, 2.1},
	[]float64{2.5, 4.5, 4.9, 1.7},
	[]float64{2.9, 6.3, 7.3, 1.8},
	[]float64{2.5, 5.8, 6.7, 1.8},
	[]float64{3.6, 6.1, 7.2, 2.5},
	[]float64{3.2, 5.1, 6.5, 2.0},
	[]float64{2.7, 5.3, 6.4, 1.9},
	[]float64{3.0, 5.5, 6.8, 2.1},
	[]float64{2.5, 5.0, 5.7, 2.0},
	[]float64{2.8, 5.1, 5.8, 2.4},
	[]float64{3.2, 5.3, 6.4, 2.3},
	[]float64{3.0, 5.5, 6.5, 1.8},
	[]float64{3.8, 6.7, 7.7, 2.2},
	[]float64{2.6, 6.9, 7.7, 2.3},
	[]float64{2.2, 5.0, 6.0, 1.5},
	[]float64{3.2, 5.7, 6.9, 2.3},
	[]float64{2.8, 4.9, 5.6, 2.0},
	[]float64{2.8, 6.7, 7.7, 2.0},
	[]float64{2.7, 4.9, 6.3, 1.8},
	[]float64{3.3, 5.7, 6.7, 2.1},
	[]float64{3.2, 6.0, 7.2, 1.8},
	[]float64{2.8, 4.8, 6.2, 1.8},
	[]float64{3.0, 4.9, 6.1, 1.8},
	[]float64{2.8, 5.6, 6.4, 2.1},
	[]float64{3.0, 5.8, 7.2, 1.6},
	[]float64{2.8, 6.1, 7.4, 1.9},
	[]float64{3.8, 6.4, 7.9, 2.0},
	[]float64{2.8, 5.6, 6.4, 2.2},
	[]float64{2.8, 5.1, 6.3, 1.5},
	[]float64{2.6, 5.6, 6.1, 1.4},
	[]float64{3.0, 6.1, 7.7, 2.3},
	[]float64{3.4, 5.6, 6.3, 2.4},
	[]float64{3.1, 5.5, 6.4, 1.8},
	[]float64{3.0, 4.8, 6.0, 1.8},
	[]float64{3.1, 5.4, 6.9, 2.1},
	[]float64{3.1, 5.6, 6.7, 2.4},
	[]float64{3.1, 5.1, 6.9, 2.3},
	[]float64{2.7, 5.1, 5.8, 1.9},
	[]float64{3.2, 5.9, 6.8, 2.3},
	[]float64{3.3, 5.7, 6.7, 2.5},
	[]float64{3.0, 5.2, 6.7, 2.3},
	[]float64{2.5, 5.0, 6.3, 1.9},
	[]float64{3.0, 5.2, 6.5, 2.0},
	[]float64{3.4, 5.4, 6.2, 2.3},
	[]float64{3.0, 5.1, 5.9, 1.8},
}

var XNames = []string{"Sepal.Width", "Petal.Length", "Sepal.Length", "Petal.Width"}

var Y = []string{
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"setosa",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"versicolor",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
	"virginica",
}

repository: wlattner/rf

repo_name: wlattner/rf


text:
// Copyright Fuzamei Corp. 2018 All Rights Reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package executor

import (
	"github.com/33cn/chain33/types"
	gt "github.com/33cn/plugin/plugin/dapp/blackwhite/types"
)

// Exec_Create 创建游戏
func (c *Blackwhite) Exec_Create(payload *gt.BlackwhiteCreate, tx *types.Transaction, index int) (*types.Receipt, error) {
	action := newAction(c, tx, int32(index))
	return action.Create(payload)
}

// Exec_Play 参与游戏
func (c *Blackwhite) Exec_Play(payload *gt.BlackwhitePlay, tx *types.Transaction, index int) (*types.Receipt, error) {
	action := newAction(c, tx, int32(index))
	return action.Play(payload)
}

// Exec_Show 出示密钥
func (c *Blackwhite) Exec_Show(payload *gt.BlackwhiteShow, tx *types.Transaction, index int) (*types.Receipt, error) {
	action := newAction(c, tx, int32(index))
	return action.Show(payload)
}

// Exec_TimeoutDone 超时处理
func (c *Blackwhite) Exec_TimeoutDone(payload *gt.BlackwhiteTimeoutDone, tx *types.Transaction, index int) (*types.Receipt, error) {
	action := newAction(c, tx, int32(index))
	return action.TimeoutDone(payload)
}


text:
SUMMARY = "Strict separation of settings from code."
HOMEPAGE = "https://github.com/henriquebastos/python-decouple/"
SECTION = "devel/python"
LICENSE = "MIT"
LIC_FILES_CHKSUM = "file://LICENSE;md5=a46375b26bb7d7603565d829a2a51782"

SRC_URI[sha256sum] = "ba6e2657d4f376ecc46f77a3a615e058d93ba5e465c01bbe57289bfb7cce680f"

PYPI_PACKAGE = "python-decouple"

inherit pypi setuptools3

RDEPENDS:${PN} += " \
    python3-shell \
    python3-stringold \
"

repository: openembedded/meta-openembedded

repo_name: openembedded/meta-openembedded


text:
package sqli

import (
	"database/sql"
	"fmt"
	"regexp"
	"strconv"
	"time"
)

type tracedTx struct {
	tx  txer
	log string
}

func (tx *tracedTx) Query(query string, args ...interface{}) (*sql.Rows, error) {
	defer tx.trace(query, args...)()
	return tx.tx.Query(query, args...)
}

func (tx *tracedTx) QueryRow(query string, args ...interface{}) *sql.Row {
	defer tx.trace(query, args...)()
	return tx.tx.QueryRow(query, args...)
}

func (tx *tracedTx) Exec(query string, args ...interface{}) (sql.Result, error) {
	defer tx.trace(query, args...)()
	return tx.tx.Exec(query, args...)
}

func (tx *tracedTx) Commit() error {
	defer tx.trace("commit")()
	return tx.tx.Commit()
}

func (tx *tracedTx) Rollback() error {
	return tx.tx.Rollback()
}

var traceSpaceRE = regexp.MustCompile(`\s+`)
var traceParamsRE = regexp.MustCompile(`\$([0-9]+)`)

func (tx *tracedTx) trace(query string, args ...interface{}) func() {

	if tx.log == "" {
		var id string
		tx.tx.QueryRow("select txid_current()").Scan(&id)
		tx.log = fmt.Sprintf("tx=%s\n", id)
	}

	query = traceSpaceRE.ReplaceAllString(query, " ")
	query = traceParamsRE.ReplaceAllStringFunc(query, func(m string) string {
		i, _ := strconv.Atoi(m[1:])
		if i > 0 && i <= len(args) {
			a := args[i-1]
			if b, ok := a.([]byte); ok {
				a = string(b)
			}
			return fmt.Sprintf("%s:%#v", m, a)
		}
		return m
	})
	start := time.Now()
	return func() {
		took := int64(time.Since(start).Truncate(time.Microsecond) / time.Microsecond)
		tx.log += fmt.Sprintf("%8dµs %s\n", took, query)
	}
}

func (tx *tracedTx) stats() string {
	return tx.log
}

repository: EmielM/sqli

repo_name: EmielM/sqli


text:
@misc{gaskey19,
  author = {Gaskey, O.},
  title = {Extended Kalman Filter},
  year = {2019},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {\url{https://github.com/OanaGaskey/Extended-Kalman-Filter}}
}

@misc{gordon20,
  author = {Gordon, N., Grimaldi, E., and Gupta, S.},
  title = {{EECE5644} Kalman Filters},
  year = {2020},
  publisher = {GitHub},
  journal = {GitHub repository},
  howpublished = {\url{https://github.com/gordonng123/EECE5644\_Kalman\_Filters}}
}

branch_name: refs/heads/main