public final class ClassFactory
extends java.lang.Object
| Modifier and Type | Class and Description |
|---|---|
static class |
ClassFactory.SENSOR_FLAVOR
An enumeration of the various sensor manufacturers we are involved with
|
| Modifier and Type | Method and Description |
|---|---|
static IBNO055IMU |
createAdaFruitBNO055IMU(com.qualcomm.robotcore.hardware.I2cDevice i2cDevice,
IBNO055IMU.Parameters parameters)
Instantiates a driver object for an AdaFruit BNO055 sensor which resides at the indicated I2cDevice using
the provided configuration parameters.
|
static IBNO055IMU |
createAdaFruitBNO055IMU(com.qualcomm.robotcore.eventloop.opmode.OpMode opmodeContext,
com.qualcomm.robotcore.hardware.I2cDevice i2cDevice)
Instantiates a driver object for a AdaFruit BNO055 sensor which resides at the indicated I2cDevice using
default values for configuration parameters.
|
static IBNO055IMU |
createAdaFruitBNO055IMU(com.qualcomm.robotcore.eventloop.opmode.OpMode opmodeContext,
com.qualcomm.robotcore.hardware.I2cDevice i2cDevice,
IBNO055IMU.Parameters parameters)
Instantiates a driver object for an AdaFruit BNO055 sensor which resides at the indicated I2cDevice using
the provided configuration parameters.
|
static void |
createEasyLegacyMotorController(com.qualcomm.robotcore.eventloop.opmode.OpMode opmodeContext,
com.qualcomm.robotcore.hardware.DcMotor motor1,
com.qualcomm.robotcore.hardware.DcMotor motor2)
Deprecated.
Deprecated because of a poor choice of API name: insufficiently general.
|
static com.qualcomm.robotcore.hardware.DcMotorController |
createEasyMotorController(com.qualcomm.robotcore.eventloop.opmode.OpMode opmodeContext,
com.qualcomm.robotcore.hardware.DcMotor motor1,
com.qualcomm.robotcore.hardware.DcMotor motor2)
Deprecated.
This functionality is now included in the core SDK; the implementation of this
method is now effectively a nop.
If the provided motors are using a legacy motor controller, createEasyMotorController swaps
that controller out and installs an alternate 'EasyLegacyMotorController' DCMotorController
implementation for the duration of the OpMode. If the motors are using a modern motor controller,
an analogous swap to an 'EasyModernMotorController' is made. If a matrix motor controller is in
use, this function has no effect. The APIs to easy legacy and modern motor controllers
are identical, which helps simplify programming.
EasyLegacyMotorController is implemented on top of an The improvements in EasyModernMotorController are less dramatic, but still significant. Of particular note is that write operations, including motor mode and power changes, happen immediately rather than being deferred to the end of a loop() cycle. This significantly simplifies the steps that are necessary to create code that uses a modern motor controller reliably. Easy motor controllers are not tied to SynchronousOpMode or any other particular
OpMode. They can be used, for example, from LinearOpModes. In SynchronousOpMode,
easy motor controllers are used automatically; in other OpModes, you'll have to manually
call |
static com.qualcomm.robotcore.hardware.ServoController |
createEasyServoController(com.qualcomm.robotcore.eventloop.opmode.OpMode opmodeContext,
java.util.Collection<com.qualcomm.robotcore.hardware.Servo> servos)
Deprecated.
This functionality is now included in the core SDK; the implementation of this
method is now effectively a nop.
Creates an alternate 'easy' implementation of the controller for the indicated collection
of servos, which must all share the same controller, and must be all the servos
which are found on that controller.
A notable feature of the easy servo controller implementation is that position change
requests and other servo writes are issued immediately instead of being deferred to the
end of the next loop() cycle, which simplifies programming. This is similar to the
enhancements found in the easy motor controller. Some small bugs are also fixed.
|
static com.qualcomm.robotcore.hardware.I2cDevice |
createI2cDevice(com.qualcomm.robotcore.hardware.I2cController i2cController,
int port)
Creates an I2Device instance on a specific port on an I2cDeviceController
|
static com.qualcomm.robotcore.hardware.I2cDevice |
createI2cDevice(com.qualcomm.robotcore.hardware.I2cDevice i2cDevice)
Deprecated.
I2cDevice, as defined in the SDK, is now an interface, not an implementation, so
this API is no longer necessary.
|
static com.qualcomm.robotcore.hardware.I2cDeviceSynch |
createI2cDeviceClient(com.qualcomm.robotcore.eventloop.opmode.OpMode opmodeContext,
com.qualcomm.robotcore.hardware.I2cDevice i2cDevice,
int i2cAddr8Bit,
boolean closeOnOpModeStop)
Deprecated.
The creation API has been renamed to match changes in interface nomenclature.
Use
createI2cDeviceSynch() instead. |
static com.qualcomm.robotcore.hardware.I2cDeviceSynch |
createI2cDeviceSynch(com.qualcomm.robotcore.hardware.I2cDevice i2cDevice,
int i2cAddr8Bit)
Create a new I2cDeviceSynch on an I2cDevice instance.
|
static IOpModeLoopCounter |
createLoopCounter(com.qualcomm.robotcore.eventloop.opmode.OpMode opMode)
Creates an object that can report the number of times loop() has been called in both
Synchronous and Linear OpModes.
|
static com.qualcomm.robotcore.hardware.ColorSensor |
createSwerveColorSensor(com.qualcomm.robotcore.eventloop.opmode.OpMode opmodeContext,
com.qualcomm.robotcore.hardware.ColorSensor target)
Creates an alternate implementation of the target color sensor.
|
static com.qualcomm.robotcore.hardware.ColorSensor |
createSwerveColorSensor(com.qualcomm.robotcore.eventloop.opmode.OpMode opmodeContext,
com.qualcomm.robotcore.hardware.I2cController controller,
int port,
int i2cAddr8Bit,
ClassFactory.SENSOR_FLAVOR flavor)
Creates a implementation of a color sensor from the provided information.
|
@Deprecated public static com.qualcomm.robotcore.hardware.DcMotorController createEasyMotorController(com.qualcomm.robotcore.eventloop.opmode.OpMode opmodeContext, com.qualcomm.robotcore.hardware.DcMotor motor1, com.qualcomm.robotcore.hardware.DcMotor motor2)
EasyLegacyMotorController is implemented on top of an I2cDeviceSynch
instance
which completely handles all the complexities of read vs write mode switching and the
like, allowing the logic inside the controller itself to be extraordinarily simple.
In particular, the manual mode switching and loop() counting necessary with the stock
controller implementation is not needed. Just call the motor getPosition() or setPower()
methods or what have you, and the necessary bookkeeping details will be taken care of.
The improvements in EasyModernMotorController are less dramatic, but still significant. Of particular note is that write operations, including motor mode and power changes, happen immediately rather than being deferred to the end of a loop() cycle. This significantly simplifies the steps that are necessary to create code that uses a modern motor controller reliably.
Easy motor controllers are not tied to SynchronousOpMode or any other particular
OpMode. They can be used, for example, from LinearOpModes. In SynchronousOpMode,
easy motor controllers are used automatically; in other OpModes, you'll have to manually
call createEasyMotorController(com.qualcomm.robotcore.eventloop.opmode.OpMode, com.qualcomm.robotcore.hardware.DcMotor, com.qualcomm.robotcore.hardware.DcMotor)
yourself.
opmodeContext
- the OpMode within which this creation is occurringmotor1
- one of the up-to-two motor controllers which share a legacy motor controller. May be null.motor2
- the possibly other motor controller on the same controller. May be null.SynchMotorLoopPerf
@Deprecated public static void createEasyLegacyMotorController(com.qualcomm.robotcore.eventloop.opmode.OpMode opmodeContext, com.qualcomm.robotcore.hardware.DcMotor motor1, com.qualcomm.robotcore.hardware.DcMotor motor2)
@Deprecated public static com.qualcomm.robotcore.hardware.ServoController createEasyServoController(com.qualcomm.robotcore.eventloop.opmode.OpMode opmodeContext, java.util.Collection<com.qualcomm.robotcore.hardware.Servo> servos)
opmodeContext
- the OpMode within which the creation is occurringservos
- the list of servos whose controller implementation we are to change.
May not be null or empty.createEasyMotorController(OpMode, DcMotor, DcMotor)
public static IBNO055IMU createAdaFruitBNO055IMU(com.qualcomm.robotcore.eventloop.opmode.OpMode opmodeContext, com.qualcomm.robotcore.hardware.I2cDevice i2cDevice)
opmodeContext
- the OpMode within which this creation is taking placei2cDevice
- the robot controller runtime object representing the sensorcreateAdaFruitBNO055IMU(OpMode, I2cDevice, IBNO055IMU.Parameters)
public static IBNO055IMU createAdaFruitBNO055IMU(com.qualcomm.robotcore.hardware.I2cDevice i2cDevice, IBNO055IMU.Parameters parameters)
i2cDevice
- the robot controller runtime object representing the sensorparameters
- the parameters with which the sensor should be initializedcreateAdaFruitBNO055IMU(OpMode, I2cDevice, IBNO055IMU.Parameters)
public static IBNO055IMU createAdaFruitBNO055IMU(com.qualcomm.robotcore.eventloop.opmode.OpMode opmodeContext, com.qualcomm.robotcore.hardware.I2cDevice i2cDevice, IBNO055IMU.Parameters parameters)
Features of this sensor include a gyro that does rate integration in hardware to provide robust and accurate angular position indications, and a separation of the output of the accelerometer into gravity and linear-motion-induced components.
The driver builds on the linear-acceleration information to provide linear velocity
and position measurements using integration in software. That said, the built-in accelerometer
integration algorithm is quite naive. For a real robot, you'll want to do some investigation
and reading and make a better one, whose use you can indicate using
parameters.accelerationIntegrationAlgorithm
.
Also, while the out-of-box sensor BNO055 works remarkably well, Bosch
describes
a one-time calibration process that will make it even better (see Section 3.11).
Perform this calibration process in the lab. Once you've got the sensor fully
calibrated (or at least the gyro and the accelerometer), extract the configuration
state with IBNO055IMU.readCalibrationData()
. We suggest that you then incorporate
the results as constants in your code, and provide them during OpMode startup in
parameters.calibrationData
where they will automatically be applied.
opmodeContext
- the OpMode within which this creation is taking placei2cDevice
- the robot controller runtime object representing the sensorparameters
- the parameters with which the sensor should be initializedcreateAdaFruitBNO055IMU(OpMode, I2cDevice)
public static com.qualcomm.robotcore.hardware.ColorSensor createSwerveColorSensor(com.qualcomm.robotcore.eventloop.opmode.OpMode opmodeContext, com.qualcomm.robotcore.hardware.ColorSensor target)
opmodeContext
- the OpMode within which this sensor is to be usedtarget
- the sensor whose implementation we are to replacecreateSwerveColorSensor(OpMode, I2cController, int, int, SENSOR_FLAVOR)
,
LinearColorDemo
,
SynchColorDemo
public static com.qualcomm.robotcore.hardware.ColorSensor createSwerveColorSensor(com.qualcomm.robotcore.eventloop.opmode.OpMode opmodeContext, com.qualcomm.robotcore.hardware.I2cController controller, int port, int i2cAddr8Bit, ClassFactory.SENSOR_FLAVOR flavor)
opmodeContext
- the OpMode within which this sensor is to be usedcontroller
- the controller on which the sensor residesport
- the port on the controller at which it so residesi2cAddr8Bit
- the I2C address of the sensorflavor
- the flavor of color sensor that resides therecreateSwerveColorSensor(OpMode, ColorSensor)
,
LinearColorDemo
,
SynchColorDemo
@Deprecated public static com.qualcomm.robotcore.hardware.I2cDevice createI2cDevice(com.qualcomm.robotcore.hardware.I2cDevice i2cDevice)
i2cDevice
- the device to wrappublic static com.qualcomm.robotcore.hardware.I2cDevice createI2cDevice(com.qualcomm.robotcore.hardware.I2cController i2cController, int port)
i2cController
- the controller on which to create the deviceport
- the port on the controller to usepublic static com.qualcomm.robotcore.hardware.I2cDeviceSynch createI2cDeviceSynch(com.qualcomm.robotcore.hardware.I2cDevice i2cDevice, int i2cAddr8Bit)
i2cDevice
- the II2cDevice to wrapi2cAddr8Bit
- the I2C address at which the client is to communicateEngagable.engage()
@Deprecated public static com.qualcomm.robotcore.hardware.I2cDeviceSynch createI2cDeviceClient(com.qualcomm.robotcore.eventloop.opmode.OpMode opmodeContext, com.qualcomm.robotcore.hardware.I2cDevice i2cDevice, int i2cAddr8Bit, boolean closeOnOpModeStop)
createI2cDeviceSynch()
instead.createI2cDeviceSynch(I2cDevice, int)
public static IOpModeLoopCounter createLoopCounter(com.qualcomm.robotcore.eventloop.opmode.OpMode opMode)
opMode
- the OpMode in which this loop counter is to report


About
Music
Portfolio
Contact
Produced, Engineered & Mixed by Phatt Pratt
Produced, Engineered & Mixed by Phatt Pratt
Produced, Engineered & Mixed by Phatt Pratt
phatpratt905@gmail.com


ARCOS-advanced.Rmd
library(ARCOS)
#> Warning: replacing previous import 'data.table::melt' by 'reshape2::melt' when
#> loading 'ARCOS'
library(data.table)
At its core, the tracking algorithm starts with spatial clustering in the first frame with objects using dbscan
algorithm. Objects from subsequent frames are added to existing clusters based on their threshold distance. Objects that cannot be added to any of the existing clusters are again spatially clustered and form potential seeds of new clusters. The entire procedure is repeated.
The application of this clustering procedure to collective activation events in biological systems requires identification of active objects, i.e. objects that will be passed to the clustering algorithm. In practice the single-cell activity over time needs to be thresholded and binarised. ARCOS offers several approaches to perform such approaches that will be covered below.
In this example 4 distinct objects are moving in 1 dimension over 5 time points. We aim to identify clusters of objects moving close to each other.
The minimal data in the long format consists of 3 columns:
frame
with the frame number that corresponds to the time point,objid
with the unique identifier of every object,x
with the position of the object.
dts = data.table(frame = c(1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 5, 5),
objid = c(1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 4, 1, 4),
x = c(1, 3, 1.2, 2.5, 3.5, 0.9, 2.6, 2.9, 3.2, 1.1, 2.8, 3.1, 1, 3))
knitr::kable(dts)
| frame | objid | x |
|---|---|---|
| 1 | 1 | 1.0 |
| 1 | 2 | 3.0 |
| 2 | 1 | 1.2 |
| 2 | 2 | 2.5 |
| 2 | 3 | 3.5 |
| 3 | 1 | 0.9 |
| 3 | 2 | 2.6 |
| 3 | 3 | 2.9 |
| 3 | 4 | 3.2 |
| 4 | 1 | 1.1 |
| 4 | 2 | 2.8 |
| 4 | 4 | 3.1 |
| 5 | 1 | 1.0 |
| 5 | 4 | 3.0 |
Initiate an arcosTS
object. Specify the names of frame, object id, and positions columns. The function simply adds attributes to the existing data.table object.
library(ARCOS)
ARCOS::arcosTS(dt = dts,
colPos = "x",
col = list(Frame = "frame",
RT = NULL,
IDobj = "objid",
IDcoll = NULL),
interVal = 1,
interType = "f")
Plot the time series. Each object has a distinct identifier represented by a different colour in the plot:
In this step 3 objects on the top are grouped into a single collective event that spans 5 frames. A single object on the bottom forms a single-object event.
The most important parameter of the trackColl
function is the search radius eps
, which sets the distance for:
dbscan
spatial clustering in a single time frame,The minimum size of the spatial cluster is set using the minClSz
parameter, which is also passed to dbscan
. The parameter nPrev
determines the number of previous frames that are searched for collective events in order to match them to objects in the current frame.
dcoll = ARCOS::trackColl(dts)
The output contains 3 columns with the frame number, object identifier, and the calculated identifier of the collective event:
| frame | objid | collid.frame | collid | x |
|---|---|---|---|---|
| 1 | 1 | 1 | 1 | 1.0 |
| 1 | 2 | 2 | 2 | 3.0 |
| 2 | 1 | 3 | 1 | 1.2 |
| 2 | 2 | 4 | 2 | 2.5 |
| 2 | 3 | 4 | 2 | 3.5 |
| 3 | 1 | 5 | 1 | 0.9 |
| 3 | 2 | 6 | 2 | 2.6 |
| 3 | 3 | 6 | 2 | 2.9 |
| 3 | 4 | 6 | 2 | 3.2 |
| 4 | 1 | 7 | 1 | 1.1 |
| 4 | 2 | 8 | 2 | 2.8 |
| 4 | 4 | 8 | 2 | 3.1 |
| 5 | 1 | 9 | 1 | 1.0 |
| 5 | 4 | 10 | 2 | 3.0 |
Plot:
Each trace is assigned an identifier of the collective event, which is represented by the shape of the point in the plot:
The algorithm with the default search radius eps=1.0
has identified two collective events. One is an event with only a single object, the latter is an event that consists of 1 to 3 objects at different points in time.


Learn More About All This Stuff
Always Improving
Cactus is an always-improving toolchain that gains new features every month. Our world-class engineering team constantly iterates upon every facet of the Cactus stack. And from Cactus Pay to Cactus ID, building on Cactus means you get early access to the latest technologies.
Learn More Here →Global Scale
Cactus is an always-improving toolchain that gains new features every month. Our world-class engineering team constantly iterates upon every facet of the Cactus stack. And from Cactus Pay to Cactus ID, building on Cactus means you get early access to the latest technologies.
Keep Reading Here →


ranking list
result
Total
| rank | department | username | japanese score | english score | total score | |||
|---|---|---|---|---|---|---|---|---|
| 0 | 0 | user | 0 | 0 | 0 |
Japanese
| rank | department | username | score | ||
|---|---|---|---|---|---|
| 0 | 0 | user | 0 |
English
| rank | department | username | score | ||
|---|---|---|---|---|---|
| 0 | 0 | user | 0 |
result
| rank | department | username | japanese score | english score | total score | |||
|---|---|---|---|---|---|---|---|---|
| 0 | 0 | user | 0 | 0 | 0 |
| rank | department | username | score | ||
|---|---|---|---|---|---|
| 0 | 0 | user | 0 |
| rank | department | username | score | ||
|---|---|---|---|---|---|
| 0 | 0 | user | 0 |


 I vaguely remember the discussions .. about how they should be given a chance and all that shit
[dscrd-prt] <mrlynch> well, we did the right thing
[dscrd-prt] <LocoMB> ... ?
[dscrd-prt] <LocoMB> paying 2.5 BTC for getting listed on a scam exchange that exit scams 3 weeks later?
[dscrd-prt] <mrlynch> as in, not given them a chance once we found out what they were doing
[dscrd-prt] <mrlynch> we got listed in march iirc so, probably before they had the exit in mind
[dscrd-prt] <LocoMB> was that in March? maybe I am confusing some things here, bcs I remember the listing fee discussion some time in October/ or so
[dscrd-prt] <LocoMB> but good that the damage was contained somewhat
[dscrd-prt] <mrlynch> you have a different event in mind
[dscrd-prt] <LocoMB> :rum:
(edited)
[dscrd-prt] <mrlynch> i guess now that they're closing down i can release some details that will showcase their incompetence
for entertainment purposes of course :troll:
[dscrd-prt] <LocoMB> ah sure- now I remember, the CB thing was when 1.8 million ARRR got snarfed there, and then dumped
[dscrd-prt] <LocoMB> yes please do! always fun!
[dscrd-prt] <LocoMB> a little bit like cryptsy in small
[dscrd-prt] <mrlynch> it wasn't 1.8M arrr that was snarfed, but more like 2 M bridge.arrr (their token)
[dscrd-prt] <mrlynch> they only had around 140k arrr in their accounts when i discovered what they were doing, but a liability towards their users of 1.8M
(edited)
[dscrd-prt] <LocoMB> I shamelessly admit: I bought 300,000 ARR @ 400Sat after that- so either I will look very stupid or like an investment genius eventually
[dscrd-prt] <LocoMB> interesting thing to do, sleuthing such amateur incompetence/ shenanigans
[dscrd-prt] <mrlynch> what happened was that a few users discovered the bug and simply ripped them off.. they created bridge.arrr tokens out of thin air, withdrawed as much arrr as they could (when you withdrew arrr from crypto-bridge, you essentially burned bridge.arrr tokens 1:1 with how much arrr you wanted)
[dscrd-prt] <mrlynch> when they could withdraw no more they simply dumped for btc and withdrew that thus shifting the liability of unbacked bridge.arrr to other users
[dscrd-prt] <LocoMB> sounds a bit like what went down in cryptsy, only smaller
[dscrd-prt] <mrlynch> and the handling of the situation was just appaling.. i told them half-heartedly what the issue might be (after exhausting all other possible logical explanations) and it took them a week to come clean
[dscrd-prt] <mrlynch> 1 week in which users continued to be ripped off
[dscrd-prt] <mrlynch> and months before that when they simply refused to stop trading until we figured out what was going on
[dscrd-prt] <mrlynch> trading fees must go on
[dscrd-prt] <LocoMB> Karpeles syndrome: half-assed amateurs in the deep, way over their heads..
[dscrd-prt] <mrlynch> all the while stating in public that the pirate daemon is faulty
[dscrd-prt] <LocoMB> seems they now demand KYCed stool samples from the remaining depositors in the hope that they can keep a few coins
[dscrd-prt] <mrlynch> sounds a bit like what went down in cryptsy, only smaller not really.. cb did it over a lengthy period of time
rvn had this 3 times, denarius at least once, i think they did it with vrsc as well
[dscrd-prt] <mrlynch> yes and that claim of theirs that under eu law all withdraws need kyc is false
under eu law you only need to kyc if you handle fiat, or if withdraws are higher than 5-10k eur / day / user
(edited)
[dscrd-prt] <mrlynch> depending on the country
[dscrd-prt] <mrlynch> so it is just an attempt at holding on to coins and potentially get some money out of kyc profiles (selling data is a thing)
[dscrd-prt] <Diablo_> under eu law you only need to kyc if you handle fiat, or if withdraws are higher than 5-10k eur / day
That's not quite true
[dscrd-prt] <mrlynch> oh really?
[dscrd-prt] <LocoMB> dunno- we have been waiting for AtomicDex for a long time now- and ARRR on ATomicDex will take some more tweaking as I understand - but ultimately, there seems no other robust option
[dscrd-prt] <mrlynch> where are they incorporated?
[dscrd-prt] <Diablo_> denmark
[dscrd-prt] <LocoMB> ARRR! ... loool!
[dscrd-prt] <LocoMB> of all places
[dscrd-prt] <mrlynch> aml5 is not in effect yet
[dscrd-prt] <mrlynch> and under aml4 there are no overly dramatic provisions for kyc.. yes you need to do it as an exchange but only after certain limits or if you handle fiat
[dscrd-prt] <Diablo_> AML5 is in effect in most countries already
[dscrd-prt] <Diablo_> and mandatory for all countries by jan 2020
[dscrd-prt] <mrlynch> even if you handle fiat there is a limit after which kyc is mandatory
[dscrd-prt] <mrlynch> but you can still get away with few hundred eur without
[dscrd-prt] <Diablo_> AMLD5 requires KYC and AML counter measures for custodian wallet providers even
[dscrd-prt] <mrlynch> it does, trying to find if denmark adopted it or not
[dscrd-prt] <mrlynch> amld5 - another tool of opression btw
[dscrd-prt] <Diablo_> afaik denmark was called out by the eu comission already for being late with AMLD5 implementation
[dscrd-prt] <Diablo_> that's likely also the reason why CB made it without any phasing time
[dscrd-prt] <LocoMB>  Cheers guys! I'll chill
[dscrd-prt] <mrlynch> europe doesn't seem to be a good place anymore
[dscrd-prt] <Diablo_> the good places become rarer and rarer
[dscrd-prt] <mrlynch> a place with no eu and us influence? where some form of liberty exists?!
[dscrd-prt] <LocoMB> I have been looking at Paraguay
[dscrd-prt] <Diablo_> CHINA! :troll:
[dscrd-prt] <mrlynch> i said liberty
[dscrd-prt] <LocoMB> South America certainly has its peculiarities, but I am looking at getting me a residence there
[dscrd-prt] <LocoMB> may be a pipe dream, but won't know w/o looking closely
[dscrd-prt] <Diablo_> idk if many south american countries qualify as good places to live
[dscrd-prt] <LocoMB> me neither, but it SA is a big place with big differences
[dscrd-prt] <Diablo_> sure
[dscrd-prt] <LocoMB> there are certainly many places with a well earned bad reputation, but also some quiet ones that usually don't get that much attention
[dscrd-prt] <LocoMB> Paraguay for example, or Uruguay / Monte Video
[dscrd-prt] <Diablo_> I fear it won't be easy to find a place with low criminality, good economy, good health system, good education system, no opression, no corruption etc.
[dscrd-prt] <LocoMB> thats a tall wish list, will rply need to make some amends on few ot those
[dscrd-prt] <mrlynch> I fear it won't be easy to find a place with low criminality, good economy, good health system, good education system, no opression, no corruption etc. if you have enough $$ you could get all private no?
[dscrd-prt] <Diablo_> but yea, of course people have different needs/wishes. Maybe someone enjoys a small village as long as it is peaceful
[dscrd-prt] <mrlynch> what about Panama?
[dscrd-prt] <LocoMB> that could be cool also.. sec...
[dscrd-prt] <Diablo_> maybe luxembourg or swiss
(edited)
[dscrd-prt] <LocoMB> I have been followong this project for almost 10 years now
[dscrd-prt] <LocoMB> Swiss is difficult, you need a lot of money there
[dscrd-prt] <LocoMB> and they can be very difficult with foreigners
[dscrd-prt] <mrlynch> luxembourg no, switzerland yes
[dscrd-prt] <mrlynch> and they can be very difficult with foreigners i've heard otherwise as of late
[dscrd-prt] <Diablo_> well salaries are also very high in switzerland


About Us
Consulting
Training
Contact
Get in Touch
Need Ember.js consulting? A training to schedule? Just want to say hullo? We're listening!
How Can We Help?


Playing with objects in Javascript
You can check the console.
In your console (in the browser), enter these commands one after another:
person.name;
person.name[0];
person.age;
person.interests[1];
person.bio();
person.greeting();


---
layout: post
title: 'Unconstrain #Revit Walls with #DynamoBIM'
date: '2016-06-22T14:45:00.000-07:00'
author: JohnP
tags:
modified_time: '2016-06-22T14:46:38.466-07:00'
blogger_id: tag:blogger.com,1999:blog-8275462422374771907.post-4674483516193923469
blogger_orig_url: http://sixtysecondrevit.blogspot.com/2016/06/unconstrain-revit-walls-with-dynamobim.html
---
A coworker of mine recently had a need to unconstrain a lot of walls in his Revit model. Naturally, we turn to Dynamo to get this done. Initially we thought it would be as easy as assigning "Top Constraint" as nothing or unconstrained. Wrong! It turns out, if you want to unconstrain a wall's top, you simply set the value to the wall element. Check it out in the video below!
First I demonstrate what I tried at first, then I show the solution. Have fun and be in awe of the mysteries of Dynamo!


Use the form below to sign up for my coffee newsletter.
Be sure to select “Coffee Training” as an interest if you want to be notified of upcoming classes, as I send early notice to that list.


{% extends "base.html" %} {% block title %} Databases {% endblock %} {% block content %}
Federal law requires facilities that use large amounts of extremely hazardous substances to file Risk Management Plans with the EPA. This data is intended to save lives, protect property and prevent pollution. You can identify facilities in your area by using the RMP search tool.
The Biennial Reporting System (BRS) is one of the Environmental Protection Agency’s primary tools for tracking the generation, shipment and receipt of hazardous waste. It contains information from Hazardous Waste Reports that must be filed every two years under the Resource Conservation and Recovery Act, which is the federal law that regulates the generation, treatment, storage, disposal or recycling of solid and hazardous waste.
This database includes information from companies that generate, transport, treat, store and dispose of hazardous waste, which are required to report certain activities to state-level regulators. These regulators pass on the information to the EPA. Data includes permit status, compliance and violation information, and cleanup activities. The information is mandated by the Resource Conservation and Recovery Act (RCRA), as amended in 1984.
This inventory is a database of information about releases and transfers of toxic chemicals from facilities in certain industrial sectors, including manufacturing, waste handling, mining and electricity generation. Facilities also must report the total amount of toxic chemicals in waste they produce.


Java Web Start is a helper application that gets associated with a Web browser. When a user clicks on a link that points to a special launch file (JNLP file), it causes the browser to launch Java Web Start, which then automatically downloads, caches, and runs the given Java Technology-based application. The entire process is typically completed without requiring any user interaction, except for the initial single click.
From a technology standpoint, Java Web Start has a number of key benefits that make it an attractive platform to use for deploying applications:
The technology underlying Java Web Start is the Java TM Network Launching Protocol & API (JNLP). This technology was developed via the Java Community Process (JCP). Java Web Start is the reference implementation (RI) for the JNLP specification. The JNLP technology defines, among other things, a standard file format that describes how to launch an application called a JNLP file.
An application can request unrestricted access to your system. In this case, Java Web Start will display a Security Warning dialog when the application is launched for the first time. The security warning will show information about the vendor who developed the application. If you choose to trust the vendor, then the application will be launched. The information about the origin of the application is based on digital code signing.
Java Web Start is included in the Java Runtime Environment available at http://java.sun.com. The JNLP specification can be found at JSR 56: Java Network Launching Protocol and API.
Java Web Start allows you to launch Java-technology-based applications directly from the Web. An application can be launched in three different ways:
Regardless of which way is used, Java Web Start will connect back to the Web server each time an application is launched to check whether an updated version of the application is available.
Point your web browser to a page with a link to a jnlp application, and click on that link.
Some applications require extra privileges, such as access to your local hard disk. For these applications, a security dialog will pop up with information about the origin of the application based on who digitally signed the code. The application will run only if you decide to trust the vendor.
That is really all there is to using Java Web Start, but how does it work? The HTML links that launch the applications are, in fact, standard HTML links. However, instead of pointing to another Web page, they link to a special configuration file called a JNLP file. The Web browser examines the file extension and/or the MIME type of the file, and sees that it belongs to Java Web Start. It then launches Java Web Start with the downloaded JNLP file as an argument. Java Web Start proceeds with downloading, caching, and running the application as directed by the JNLP file.
Java Web Start technology can automatically create shortcuts for your application on the desktop and in the Start Menu for Web-deployed applications developed with Java technology. You can use the Java Control Panel to control the shortcut settings. Shortcuts can also be added and removed by using the Java Web Start Cache Viewer, using the install/remove shortcut menu item.
Java Web Start software must be configured with the correct proxy settings in order to launch applications from outside your firewall. Java Web Start software will automatically try to detect the proxy settings from the default browser on your system (Internet Explorer or NetscapeTM browsers on Microsoft Windows, and Netscape browsers on the Solaris Operating Environment and Linux). Java Web Start technology supports most web proxy auto-configuration scripts. It can detect proxy settings in almost all environments.
You can also use the Java Web Start Control Panel to view or edit the proxy configuration. Refer to the Java Control Panel for more details.
The client machine requires support for the Java Runtime Environment (JRE), version 1.2.2 or later. Java Web Start is available for Windows 98/NT/2000/ME/XP, the Solaris Operating Environment, and Linux.
Applications can be deployed from any standard Web server. In order to use Java Web Start, the Web server must be configured with support for a new MIME type. See Setting Up the Web Site.


---
layout: post
title: "October, 01 2019 Meeting"
subtitle: "Team Meeting"
date: 2019-10-01 23:45:13 -0400
background: '/img/posts/03.jpg'
categories: Meeting Logs
---
Meeting Logs
Attendees: JoCee, Donovan
Progress Made this Week
JoCee
- Updated Database to return weights
Zane
Donovan
- UART progress
- FPGA Design
- Starting to put ML on the board
Mohitt
- Began frontend work
- 2 additional algorithms
Donovan
- Keep working on UART + FPGA
JoCee
- Database information to show buys and portfolio worth
- Connect api to alpaca
Zane
Mohit


Index
All Classes|All Packages
S
- Serialization - Class in <Unnamed>
- setArtist(String) - Method in class Album
-
Setter of artist (Album).
- setArtist(String) - Method in class Song
-
Setter of Song artist
- setAuthor(String) - Method in class AudioBook
-
Setter of author (AudioBook).
- setCategory(Category) - Method in class AudioBook
-
Setter of Category (AudioBook).
- setContent(String) - Method in class Album
-
Setter of Content (Album). the content is the path of your Album file.
- setContent(String) - Method in class MusicalElement
-
Setter of MusicalElement content
- setDuration(int) - Method in class MusicalElement
-
Setter of MusicalElement duration (second)
- setGenre(Genre) - Method in class Song
-
Setter of Song genre
- setId(int) - Method in class Album
-
Setter of id (Album).
- setId(int) - Method in class MusicalElement
-
Setter of MusicalElement id
- setId(int) - Method in class Playlist
-
Setter of id (Playlist).
- setLanguage(Language) - Method in class AudioBook
-
Setter of Language (AudioBook).
- setListAlbums(ArrayList<Album>) - Method in class ListAlbum
-
Setter of ListAlbum Albums.
- setMusicalElements(ArrayList<MusicalElement>) - Method in class ListMusicalElement
-
Setter of ListMusicalElement MusicalElements
- setMusicalElements(ArrayList<MusicalElement>) - Method in class Playlist
-
Setter of Playlist MusicalElement allow us to modify our current Song list
- setName(String) - Method in class Playlist
-
Setter of Name's Playlist.
- setPlaylists(ArrayList<Playlist>) - Method in class ListPlaylist
-
Setter of ListPlaylist Playlists
- setRelease(Date) - Method in class Album
-
Setter of release (Album).
- setSongs(ArrayList<Song>) - Method in class Album
-
Setter of Album Songs allow us to modify our current Song list
- setTitle(String) - Method in class Album
-
Setter of title (Album).
- setTitle(String) - Method in class MusicalElement
-
Setter of MusicalElement title
- Song - Class in <Unnamed>
- Song() - Constructor for class Song
-
Constructor Song
- storeListAlbum(ArrayList<Album>, String) - Method in class ListAlbum
-
Store JAVA objects inside XML file
- storeListPlaylist(ArrayList<Playlist>, String) - Method in class ListPlaylist
-
Encode and store data from XML file
- storeMusicalElement(ArrayList<MusicalElement>, String) - Method in class ListMusicalElement
-
Encode and store data from XML file
All Classes|All Packages


Got a lot of good things on sale, stranger
See a design that you really love? We have a range of merchandise prints and tees on our Etsy shop. Select a product below to view and purchase on Etsy.
If you'd like one of our other designs as a print, bag or as clothing, get in touch.
-
{% assign products = site.products | sort: 'order' %}
{% for product in products %}
-
{% comment %} include product-styles.html product=product {% endcomment %}
{{ product.name }} {{ product.product-type}}
{{ product.description_markdown | truncate: 45 | markdownify }}£{{ product.price }}
{% endfor %}


“We are lonely but fearful of intimacy. Digital connection and sociable robots may offer the illusion of companionship without the demand of friendship” Sherry Turkle_
Robots are the most sophisticated breed of tools that human can make use of. They are both a cognitive and a physical aid that in some aspects can outperform our skills. What becomes then the very deep meaning of companionship with technological devices and the digital world in general? About us is a human-robot ritual of a typical day routine.
robotic companionship
During my studies at the Bartlett School of Architecture, I particularly focused on
that take active part in our every day lives. We are sourrounded by technological devices and digital networks, yet .Is there a way to give technological devices
? Is there a need for such a thing? Would that make us feel better? With these never answered question I turned to in order to better comprehend the topic of agency.I envisioned a single ritual that was fascinating to me if explored on a human-robot level:
. Four tools were needed: .The robotic arm UR-10 was equipped with magnets to
during the ritual. It could then become a , in which the robot became a conversational piece.What is the role of
in designing human-robot systems? Going beyond paradigms of antromorphism, how does the aesthetics of robots ?So I crafte different tools, choosing a language that was against the usual design choices in consumer electronics and robotics. I used .About us is definitively a
project, where I let myself free to explore and pursue bold ideas. Theatre blends with design and with robotics in a . Many have associated the result with Chaplins' Modern Times scene of the corn eating machine, which I take as a true compliment.how did I get there?
I built
where I tried to replicate human behaviours, with the use of puppetry. The studies involved designing and programming small robots showing and more. One quick example is below.The following sketch shows a
- using a fake robot with familiar utensils: a spoon, a tissue and a glass. It basically is the analog veresion of the final result.That's how I graduated from the Bartlett School of Architecture
.Behind the scenes
developed individually at Interactive Architecture Lab, Bartlett School of Architecture, London pretty much all - from concepting, to programming robots, to sculpting wood, to video editing Ruairi Glynn, Yuri Suzuki Luca Giacolini, Bartlett School of Architecture Chalevet Visner, Adi Meyer, Arianna di Pasquale


MoodleVersion
A class for parsing and representing version information for the Moodle VLE.
The class can parse both the human-friendly Moodle release strings like
3.3.6 (Build: 20180517)
, and the underlying raw version numbers like
2017051506
.
Note that this class only reliably understands version information from Moodle 2.2 up. The reason for this limitation is that this is the first Moodle version which uses the now standard versioning conventions.
Static Member Summary
| Static Public Members | ||
| public static get |
A regular expression for matching human-friendly Moodle release strings. |
|
| public static get |
A regular expression for matching under-the-hood version numbers like
|
|
| public static get |
A regular expression for matching short version strings like |
Static Method Summary
| Static Public Methods | ||
| public static |
Convert a branch number into a branch string, i.e. |
|
| public static |
Convert a branching date number to a branch, e.g. |
|
| public static |
Convert a branch string into a branch number, i.e. |
|
| public static |
Convert a branching date number to a branch number, e.g. |
|
| public static |
Convert a branch to a branching date number, e.g. |
|
| public static |
Convert a branch number to a branching date number, e.g. |
|
| public static |
Compare two values to see if they represent the same version, a greater version, or a lesser version. |
|
| public static |
dateFromDateNumber(dn: DateNumber): Date Convert a date number to a date object. |
|
| public static |
Convert a date object to a date number. |
|
| public static |
fromObject(obj: Object): * A factory method for producing a Moodle Version object given all its properties. |
|
| public static |
fromString(verStr: string): MoodleVersion Build a version object from a version string. |
|
| public static |
Test if a given value is a branch string, e.g. |
|
| public static |
isBranchNumber(val: *, strictTypeCheck: boolean): boolean Test if a given value is a branch number, e.g. |
|
| public static |
isDateNumber(val: *, strictTypeCheck: boolean): boolean Test if a given value is a date number, i.e. |
|
| public static |
isReleaseNumber(val: *, strictTypeCheck: boolean): boolean Test if a given value is a release number. |
|
| public static |
isReleaseSuffix(val: *): boolean Test if a given value is a valid release suffix. |
|
| public static |
isReleaseType(val: *): boolean Test if a given value is a valid release type. |
|
| public static |
numberFromReleaseType(rt: *): number Convert a release type to a number. |
|
| public static |
Convert a release type to a release suffix, e.g. |
|
| public static |
Convert a relase suffix to a release type, e.g. |
Constructor Summary
| Public Constructor | ||
| public |
constructor(versionInfo: string | Object) By default version objects contain no information. |
Member Summary
| Public Members | ||
| public get |
The major version part of the version number, officially known as the branch. |
|
| public set |
The branch (AKA major version) must be a string consisting of two digits separated by a period, e.g. |
|
| public get |
The version's branch number, if known. This is the two-digit number used internally within the Moodle code to identify a branch, or major release. For example, all Moodle 3.5.* releases will have the branch number |
|
| public set |
The branch number must be a two-digit integer between 10 and 99. |
|
| public get |
The known mappings between branching date numbers and Moodle branch numbers. |
|
| public get |
The known mappings between branching date numbers and Moodle branches. |
|
| public get |
The branching date as a date object. |
|
| public set |
Setting the branching date will update the branch to match. |
|
| public get |
The branching date as a DateNumber. |
|
| public set |
Setting the branching date will update the branch to match. |
|
| public get |
The known mappings between Moodle braches and branching date numbers. |
|
| public get |
The known mappings between Moodle brache numberss and branching date numbers. |
|
| public get |
The build number. |
|
| public set |
Build numbers must be valid date numbers, i.e. |
|
| public get |
The long human-friendly form of the version information. |
|
| public get |
The release number part of the version number. |
|
| public set |
The release number must be an integer greater than or equal to zero. |
|
| public get |
The release suffix for the release's type, e.g. |
|
| public set |
The release suffix must be one of |
|
| public get |
The release's type, e.g. |
|
| public set |
The release type must be one of |
|
| public get |
The short human-friendly form of the version number. |
|
| public get |
The under-the-hood form of the version number. |
Method Summary
| Public Methods | ||
| public |
atLeast(mv: MoodleVersion): boolean | undefined Determine whether this version is greater than or equal to the given version. |
|
| public |
Create a new Moodle version object representing the same version information. |
|
| public |
compareTo(mv: MoodleVersion): number Compare this version to another. |
|
| public |
Test if a given value is a Moodle Version object representing the same version. |
|
| public |
greaterThan(mv: MoodleVersion): boolean | undefined Determine whether this version is greater than a given version. |
|
| public |
Is this version on a branch the library knows about? |
|
| public |
Determine whether or not this is version is on a long-term support branch. |
|
| public |
Is this a stable release? I.e. |
|
| public |
lessThan(mv: MoodleVersion): boolean | undefined Determine whether this version is less than a given version. |
|
| public |
sameBranch(mv: MoodleVersion): boolean | undefined Determine whether this versions is on the same branch as a given version. |
|
| public |
The version as a plain object indexed by zero or more of: |
|
| public |
toSemVerArray(): Array<number> An array containing a SemVer (Semantic Versioning) representation of the version information. |
|
| public |
toSemVerObject(): {major: number, minor: number, patch: number} An object containing a SemVer (Semantic Versioning) representation of the version information. |
|
| public |
Return a string representation of the version. |
Static Public Members
public static get releaseRE: RegExp source
A regular expression for matching human-friendly Moodle release strings. This RE is case-insensitive and will allow for the optional pre-fixing of the word Moodle with or whithout a separating space.
See:
public static get versionNumberRE: RegExp source
A regular expression for matching under-the-hood version numbers like
'2017051506'
or '2017051506.00'
.
See:
Static Public Methods
public static branchFromBranchNumber(bn: BranchNumber): BranchString | undefined source
Convert a branch number into a branch string, i.e. 35
to '3.5'
and
310
to '3.10'
.
Params:
| Name | Type | Attribute | Description |
| bn | BranchNumber |
Return:
| BranchString | undefined | If the passed value can't be converted
to a branch |
public static branchFromBranchingDateNumber(bdn: DateNumber): BranchString | undefined source
Convert a branching date number to a branch, e.g. 20180517
to
'3.5'
.
Params:
| Name | Type | Attribute | Description |
| bdn | DateNumber |
public static branchNumberFromBranch(b: BranchString): number | undefined source
Convert a branch string into a branch number, i.e. '3.5'
to 35
.
Params:
| Name | Type | Attribute | Description |
| b | BranchString |
public static branchNumberFromBranchingDateNumber(bdn: DateNumber): number | undefined source
Convert a branching date number to a branch number, e.g. 20180517
to
35
.
Params:
| Name | Type | Attribute | Description |
| bdn | DateNumber |
public static branchingDateNumberFromBranch(b: BranchString): number | undefined source
Convert a branch to a branching date number, e.g. '3.5'
to 20180517
.
Params:
| Name | Type | Attribute | Description |
| b | BranchString |
public static branchingDateNumberFromBranchNumber(bn: BranchNumber): number | undefined source
Convert a branch number to a branching date number, e.g. 35
to 20180517
.
Params:
| Name | Type | Attribute | Description |
| bn | BranchNumber |
public static compare(val1: *, val2: *): number source
Compare two values to see if they represent the same version, a greater version, or a lesser version.
When ranking versions, the branch is given the highest weight, then the
release number, then the release type,
and finally the build number. When comparing release types,
'development'
is considered earlier 'official'
, which is considered
earlier than 'weekly'
.
Params:
| Name | Type | Attribute | Description |
| val1 | * | ||
| val2 | * |
Return:
| number | Unless both values are moodle vesion objects, |
public static dateFromDateNumber(dn: DateNumber): Date source
Convert a date number to a date object. The date object will represent midnight UTC on the given date.
Params:
| Name | Type | Attribute | Description |
| dn | DateNumber |
Throw:
public static dateNumberFromDate(d: Date): DateNumber source
Convert a date object to a date number. The date will be interpreted as UTC.
Params:
| Name | Type | Attribute | Description |
| d | Date |
Throw:
public static fromObject(obj: Object): * source
A factory method for producing a Moodle Version object given all its properties.
If only one of the branch and branching date are passed, and if a known mapping exists, the other is auto-completed.
This function can be used to create version objects which contain unknown mappings between Moodle branches and branching dates.
Params:
| Name | Type | Attribute | Description |
| obj | Object | an object defining zero or more of the following keys:
|
Return:
| * |
Throw:
A type error is thrown if an object is not passed, or, if any of the keys within that object map to an invalid value. |
public static fromString(verStr: string): MoodleVersion source
Build a version object from a version string. The vesion string can be in one of the following formats:
- A human-friendly full release string (ReleaseString), e.g.
'Moodle 3.5+ (Build: 20180614)'
(will be accepted with or without the'Moodle'
prefix). - A human-friendly short version string (VersionString), e.g.
'Moodle 3.3.6+'
(will be accepted with or without the'Moodle'
prefix). - An under-the-hood version number (VersionNumber), e.g.
'2017051506'
or'2017051506.00'
.- A string as returned by calling
.toString()
on an instance of this class.
Params:
| Name | Type | Attribute | Description |
| verStr | string | the version string to parse. |
Throw:
public static isBranch(val: *): boolean source
Test if a given value is a branch string, e.g. '3.5'
or '3.10'
.
Params:
| Name | Type | Attribute | Description |
| val | * | the value to test. |
public static isBranchNumber(val: *, strictTypeCheck: boolean): boolean source
Test if a given value is a branch number, e.g. 35
, '35'
, 310
or
`'310'.
Params:
| Name | Type | Attribute | Description |
| val | * | the value to test. |
|
| strictTypeCheck | boolean |
|
whether or not to enable
strict type checking. With strict type cheking enabled, string
representation of otherwise valid values will return |
public static isDateNumber(val: *, strictTypeCheck: boolean): boolean source
Test if a given value is a date number, i.e. an 8-digit number of the
form YYYYMMDD
.
Params:
| Name | Type | Attribute | Description |
| val | * | the value to test. |
|
| strictTypeCheck | boolean |
|
whether or not to enable
strict type checking. With strict type cheking enabled, string
representation of otherwise valid values will return |
public static isReleaseNumber(val: *, strictTypeCheck: boolean): boolean source
Test if a given value is a release number.
Note that if strict type checking is not enabled, the empty string is considered a valid release number, being synonymous with zero in Moodle release strings.
Params:
| Name | Type | Attribute | Description |
| val | * | the value to test. |
|
| strictTypeCheck | boolean |
|
whether or not to enable
strict type checking. With strict type cheking enabled, string
representation of otherwise valid values will return |
public static isReleaseSuffix(val: *): boolean source
Test if a given value is a valid release suffix.
Params:
| Name | Type | Attribute | Description |
| val | * | the value to test. |
See:
public static isReleaseType(val: *): boolean source
Test if a given value is a valid release type.
Params:
| Name | Type | Attribute | Description |
| val | * | the value to test. |
See:
public static numberFromReleaseType(rt: *): number source
Convert a release type to a number. Useful for version comparisons.
All invalid values convert to 0
, 'development'
to 1
, 'official'
to 2
, and 'weekly'
to 3.
Params:
| Name | Type | Attribute | Description |
| rt | * |
public static releaseSuffixFromReleaseType(rt: ReleaseType): ReleaseSuffix | undefined source
Convert a release type to a release suffix, e.g. 'weekly'
to '+'
.
Params:
| Name | Type | Attribute | Description |
| rt | ReleaseType |
public static releaseTypeFromReleaseSuffix(rs: ReleaseSuffix): ReleaseType | undefined source
Convert a relase suffix to a release type, e.g. '+'
to 'weekly'
.
Params:
| Name | Type | Attribute | Description |
| rs | ReleaseSuffix |
Public Constructors
public constructor(versionInfo: string | Object) source
By default version objects contain no information.
If a string is passed, the object is initialised using MoodleVersion.fromString, and if an object is passed then MoodleVersion.fromObject is used instead.
Throw:
* |
TypeError |
* |
RangeError |
Public Members
public get branch: BranchString | undefined source
The major version part of the version number, officially known as the branch.
For example, the branch for each of the 3.4, 3.4+, 3.4.1, and 3.4.1+
releases is '3.4'
.
public set branch: BranchString source
The branch (AKA major version) must be a string consisting of two
digits separated by a period, e.g. '3.5'
.
Setting the branch will also update the branching date to match.
To create an object with an un-known combination of branch and branching date, use the MoodleVersion.fromObject factory method.
Throw:
A range error is thrown if the branch does not have a known mapping to a branching date. |
public get branchNumber: number | undefined source
The version's branch number, if known. This is the two-digit number used internally within the Moodle code to identify a branch, or major release.
For example, all Moodle 3.5.* releases will have the branch number 35
.
public set branchNumber: BranchNumber | undefined source
The branch number must be a two-digit integer between 10 and 99.
Setting the branch number will also update the branching date to match.
To create an object with an un-known combination of branch and branching date, use the MoodleVersion.fromObject factory method.
Throw:
A range error is thrown if the branch does not have a known mapping to a branching date. |
public get brancheNumbersByBranchingDateNumber: * source
The known mappings between branching date numbers and Moodle branch numbers.
@type{Map<DateNumber, BranchNumber>}
public get branchesByBranchingDateNumber: * source
The known mappings between branching date numbers and Moodle branches.
@type{Map<DateNumber, Branch>}
public set branchingDate source
Setting the branching date will update the branch to match.
To create an object with an un-known combination of branch and branching date, use the MoodleVersion.fromObject factory method.
@type{Date|undefined}
Throw:
A range error is thrown if the branching date does not have a known mapping to a branch. |
public set branchingDateNumber source
Setting the branching date will update the branch to match.
To create an object with an un-known combination of branch and branching date, use the MoodleVersion.fromObject factory method.
@type{DateNumber|undefined}
Throw:
A range error is thrown if the branching date does not have a known mapping to a branch. |
public get branchingDateNumbersByBranch: * source
The known mappings between Moodle braches and branching date numbers.
@type{Map<Branch, DateNumber>}
public get branchingDateNumbersByBranchNumber: * source
The known mappings between Moodle brache numberss and branching date numbers.
@type{Map<BranchNumber, DateNumber>}
public set buildNumber: ReleaseSuffix | undefined source
Build numbers must be valid date numbers, i.e. of the form YYYYMMDD
.
Throw:
public get release: ReleaseString source
The long human-friendly form of the version information.
In keeping with how Moodle presents version strings, release numbers of
zero are omitted. If the release type is unknown no suffix is appended.
If the branch is unknown it is represented as '??.??'
, if the
release number is unknown it's represented as '.??'
, and if the build
number is unknown it's represented as '????????'
.
public get releaseNumber: ReleaseNumber | undefined source
The release number part of the version number.
public set releaseNumber: ReleaseNumber | undefined source
The release number must be an integer greater than or equal to zero.
Throw:
public get releaseSuffix: ReleaseSuffix | undefined source
The release suffix for the release's type, e.g. '+'
for weekly
updates to the official releases.
public set releaseSuffix: ReleaseSuffix | undefined source
The release suffix must be one of 'dev'
, an empty string, or '+'
. The
value will get automatically cast to lower case before validation is
applied.
Throw:
public set releaseType: ReleaseType | undefined source
The release type must be one of 'development'
, 'official'
, or
'weekly'
. The value will get automatically cast to lower case before
validation is applied.
Throw:
public get version: VersionString source
The short human-friendly form of the version number.
In keeping with how Moodle presents version strings, release numbers of
zero are omitted. If the release type is unknown no suffix is appended.
If the branch is unknown it is represented as '??.??'
, and if the
release number is unknown it's represented as '.??'
.
public get versionNumber: VersionNumber source
The under-the-hood form of the version number.
If the branch is unknown its replaced with eight question marks, and if the release number is unknown it's replaced with two.
Public Methods
public atLeast(mv: MoodleVersion): boolean | undefined source
Determine whether this version is greater than or equal to the given version.
Params:
| Name | Type | Attribute | Description |
| mv | MoodleVersion |
public clone(): MoodleVersion source
Create a new Moodle version object representing the same version information.
public compareTo(mv: MoodleVersion): number source
Compare this version to another.
Params:
| Name | Type | Attribute | Description |
| mv | MoodleVersion |
Return:
| number |
|
public equals(val: *): boolean source
Test if a given value is a Moodle Version object representing the same version.
Params:
| Name | Type | Attribute | Description |
| val | * |
public greaterThan(mv: MoodleVersion): boolean | undefined source
Determine whether this version is greater than a given version.
Params:
| Name | Type | Attribute | Description |
| mv | MoodleVersion |
public isLTS(): boolean | undefined source
Determine whether or not this is version is on a long-term support
branch. If the branch is not defined or unknown, undefined
is returned.
public isStable(): boolean | undefined source
Is this a stable release? I.e. is the release type official
or
weekly
?
public lessThan(mv: MoodleVersion): boolean | undefined source
Determine whether this version is less than a given version.
Params:
| Name | Type | Attribute | Description |
| mv | MoodleVersion |
public sameBranch(mv: MoodleVersion): boolean | undefined source
Determine whether this versions is on the same branch as a given version.
Params:
| Name | Type | Attribute | Description |
| mv | MoodleVersion |
public toObject(): Object source
The version as a plain object indexed by zero or more of:
version
versionNumber
release
branch
branchNumber
branchingDateNumber
branchingDate
releaseNumber
releaseType
releaseSuffix
buildNumber
public toSemVerArray(): Array<number> source
An array containing a SemVer (Semantic Versioning) representation of the version information. The first element will be the major version number, the second the minor, and the third the patch.
public toSemVerObject(): {major: number, minor: number, patch: number} source
An object containing a SemVer (Semantic Versioning) representation of the version information.


Toggle navigation
Frog Cam
Rongie-san
Mar-san
Louie-san
Dinn-san
login
Yazaki Hearthrobs
Meet the Kwanggols
Rongie Andrade
Will Catch Your Eye
Hi I'm Ronggie-san, blablabla
Joseph Leomar Senanin
Is Pretty Cool Too.

Camille Louie Olarte
Too Good To Be True, Can't Take My Eyes Off Of You.
MEET YOUR MAKER
Dinn Kevin Noel
Will Seal the Deal.
Im Hotter than a Lava
Not seeing a
Scroll to Top Button
? Go to our FAQ page for more info.


Mysterious Wizard:
I can't tell you, but you may find out soon.
Come on, show the doll to the priest at the temple of the Rune Township. Ask him about
the one who hides behind the truth
.


SmartCart
ETH
Enter the product details
Product Name
Product Description
Price
Product Image
Submit Product


turn deadlines in challenge array into date objects
finish adding notes to site
Planning Page
Python Coder (Splash/About)
Describes purpose of page
Should be a very beautiful and simple page
Dashboad
Page Elements
This will have dynamically generated content based on available exercies, their due dates, and their completion status
Reminder about upcoming challenges. If an assinment is due within 1 day it should have an orange warning icon. If it's due within 6 hours it should have a red icon. Maybe use a glyphicon clock as icon.
It would be nice to have a button that would add challenge deadlines to their Google Calendar
Code History; Organzie by challenge; ennumerate and list in a drop down under each challenge;
or show all submissions for an challenge in one text file
Questions
Q: Will teachers have a dashboard? What will be covered on it that would be covered on their students/classes pages?
Profile
Work on this after dashboard
Add change password feature
Challenges (student-side)
Show challenges as list in left panel of workspace; maybe make collapsable later.
name, deadlines
Reminder about upcoming challenges. If an assinment is due within 1 day it should have an orange warning icon. If it's due within 6 hours it should have a red icon (like on dash)
(?) add request extension button?
In the workspace add a rubber ducky notepad
Instructor dashboard
Page Elements
Challenges (teacher-side)
Allows instructor to see and edit challenges
Toggle whether the challenge is live/available
Challenge Form
add text input for starting code
add input for test cases to form
Add input for hints for test cases to form
Students (teacher-side)
How should we represent student progress? "5/6 challenges complete; 1 missed."; "5/6 challenges complete; 1 extension requested." Or just use little colored squares. Filled square = complete; empty = not complete; x in square = missed.


Computer Science student at UCSD
Aiming to explore various computer science fields,
with vim in my left hand and coffee in my right
Eager to learn more! Currently taking CSE 12 Basic Data Structures at UCSD and plan on taking CSE 30 Computer Organization and Systems Programming and CSE 21 Mathematics for Algorithms and System Analysis next quarter!
Started December 2018
Created using Javascript with JSON
Created a discord bot using the discord.js library with 9 commands so far
For instance:
!help to obtain information about the other commands and usage.
!build [string] to add words to a string that is stored as a JSON object, which
everyone can build on.
!buildClear to clear the sequence of strings and start from fresh
!joinedAt to see the date a user has joined said server
!odds @User [numberOutOf] based off of What are the Odds;
have the bot message both users for a number and compare it,
What it does Impulse uses Google's gmail API to authenticate with a person's email and it tracks which emails are from internship applications. It then loads these emails into a database where it shows information on each email, including company name, logo, status, content of the email, and the time line. Additionally, if a company sends another email, it overwrites the existing entry in the database to accurately reflect the new email and showcases the time line changes. Link to DEVPOST Writeup!!
Close Project
BitPic is designed to allow people to take a photo while traveling and
to send it to others in the form of a Bitmoji sticker using their
avatar with a simplistic UI
Created in 36 Hours at SB Hacks 2019
Mobile App created in Java using Android Studio
Utilizes Google Cloud Platform, mainly uses Cloud Vision API
to process images and query for objects.
Also makes use of SnapKit: LoginKit to connect user to the app,
BitmojiKit to use the Bitmoji sticker UI, and CreativeKit
to be able to click on a bitmoji and send it to another.
Premise is to take a photo or choose from a gallery, process the photo,
then show popular word choices based on what
the Vision API believes to be in the picture, and then the user
taps on a word and it will search through all Bitmoji stickers
and return relevant stickers that can be then shared to other apps.
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Mollitia neque assumenda ipsam nihil, molestias magnam, recusandae quos quis inventore quisquam velit asperiores, vitae? Reprehenderit soluta, eos quod consequuntur itaque. Nam.
Close ProjectLorem ipsum dolor sit amet, consectetur adipisicing elit. Mollitia neque assumenda ipsam nihil, molestias magnam, recusandae quos quis inventore quisquam velit asperiores, vitae? Reprehenderit soluta, eos quod consequuntur itaque. Nam.
Close ProjectLorem ipsum dolor sit amet, consectetur adipisicing elit. Mollitia neque assumenda ipsam nihil, molestias magnam, recusandae quos quis inventore quisquam velit asperiores, vitae? Reprehenderit soluta, eos quod consequuntur itaque. Nam.
Close Project


There are new updates. Do you want to refresh?
auto update
or
Refresh
Admin
Search User
Signaling-Server ( users:
0
, rooms:
0
)
Scalable-Broadcast ( users:
0
)
Error Logs
Logs Viewer
×
Get User Information
×
Enter User ID:
Alert
×
Please Confirm
×
Admin Credentials
×
Enter Admin UserName:
Enter Admin Password:
#
Room ID
Owner ID
Identifier
socketMessageEvent
Session
Extra
Participants
Delete
No active room found on this server.
#
User ID
Room ID
Session
Extra
streams
mediaConstraints
sdpConstraints
connectedWith
Delete
No active users found on this server.


select a subset of a dimension by dragging over the portion of the coordinate you wish to keep; de-select by single-clicking anywhere else on the coordinate
reorder the dimensions by dragging one coordinate
invert a dimensions by double-clicking on its header
color by a (numeric) dimension by clicking on its header
Thanks to...


In this project, you'll define and train a DCGAN on a dataset of faces. Your goal is to get a generator network to generate new images of faces that look as realistic as possible!
The project will be broken down into a series of tasks from loading in data to defining and training adversarial networks.
You'll be using the CelebFaces Attributes Dataset (CelebA) to train your adversarial networks.
This dataset is more complex than the number datasets (like MNIST or SVHN) you've been working with, and so, you should prepare to define deeper networks and train them for a longer time to get good results. It is suggested that you utilize a GPU for training.
Since the project's main focus is on building the GANs, we've done some of the pre-processing for you. Each of the CelebA images has been cropped to remove parts of the image that don't include a face, then resized down to 64x64x3 NumPy images. Some sample data is show below.
If you are working locally, you can download this data by clicking here
This is a zip file that you'll need to extract in the home directory of this notebook for further loading and processing. After extracting the data, you should be left with a directory of data processed_celeba_small/
# can comment out after executing
#!unzip processed_celeba_small.zip
data_dir = 'processed_celeba_small/'
"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
import pickle as pkl
import matplotlib.pyplot as plt
import numpy as np
import problem_unittests as tests
#import helper
%matplotlib inline
The CelebA dataset contains over 200,000 celebrity images with annotations. Since you're going to be generating faces, you won't need the annotations, you'll only need the images. Note that these are color images with 3 color channels (RGB)#RGB_Images) each.
Since the project's main focus is on building the GANs, we've done some of the pre-processing for you. Each of the CelebA images has been cropped to remove parts of the image that don't include a face, then resized down to 64x64x3 NumPy images. This pre-processed dataset is a smaller subset of the very large CelebA data.
There are a few other steps that you'll need to transform this data and create a DataLoader.
get_dataloader
function, such that it satisfies these requirements:¶image_size x image_size
in the x and y dimension.To create a dataset given a directory of images, it's recommended that you use PyTorch's ImageFolder wrapper, with a root directory processed_celeba_small/
and data transformation passed in.
# necessary imports
import torch
from torchvision import datasets
from torchvision import transforms
def get_dataloader(batch_size, image_size, data_dir='processed_celeba_small/'):
"""
Batch the neural network data using DataLoader
:param batch_size: The size of each batch; the number of images in a batch
:param img_size: The square size of the image data (x, y)
:param data_dir: Directory where image data is located
:return: DataLoader with batched data
"""
# TODO: Implement function and return a dataloader
dtransform = transforms.Compose([ transforms.Resize(image_size),
transforms.ToTensor()])
dset = datasets.ImageFolder(data_dir, transform=dtransform)
dloader = torch.utils.data.DataLoader(dset, batch_size=batch_size, drop_last=True, shuffle=True)
return dloader
celeba_train_loader
with appropriate hyperparameters.¶Call the above function and create a dataloader to view images.
batch_size
parameterimage_size
must be 32
. Resizing the data to a smaller size will make for faster training, while still creating convincing images of faces!#  You should seen square images of somewhat-centered faces.
Note: You'll need to convert the Tensor images into a NumPy type and transpose the dimensions to correctly display an image, suggested imshow
code is below, but it may not be perfect.
# helper display function
def imshow(img):
npimg = img.numpy()
plt.imshow(np.transpose(npimg, (1, 2, 0)))
"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
# obtain one batch of training images
dataiter = iter(celeba_train_loader)
images, _ = dataiter.next() # _ for no labels
# plot the images in the batch, along with the corresponding labels
fig = plt.figure(figsize=(20, 4))
plot_size=20
for idx in np.arange(plot_size):
ax = fig.add_subplot(2, plot_size/2, idx+1, xticks=[], yticks=[])
imshow(images[idx])
You need to do a bit of pre-processing; you know that the output of a tanh
activated generator will contain pixel values in a range from -1 to 1, and so, we need to rescale our training images to a range of -1 to 1. (Right now, they are in a range from 0-1.)
# TODO: Complete the scale function
def scale(x, feature_range=(-1, 1)):
''' Scale takes in an image x and returns that image, scaled
with a feature_range of pixel values from -1 to 1.
This function assumes that the input x is already scaled from 0-1.'''
# assume x is scaled to (0, 1)
# scale to feature_range and return scaled x
val_min, val_max = feature_range # explode tuple
scale = val_max-val_min # calc the new feature range scale
center = (val_max+val_min)/2 # calc the new feature range center
x = x-0.5 # recenter the source (scale is already 1)
x = x*scale+center # translate in the new range
return x
"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
# check scaled range
# should be close to -1 to 1
img = images[0]
scaled_img = scale(img)
print('Min: ', scaled_img.min())
print('Max: ', scaled_img.max())
A GAN is comprised of two adversarial networks, a discriminator and a generator.
Your first task will be to define the discriminator. This is a convolutional classifier like you've built before, only without any maxpooling layers. To deal with this complex data, it's suggested you use a deep network with normalization. You are also allowed to create any helper functions that may be useful.
import torch.nn as nn
import torch.nn.functional as F
# helper conv function
def conv(in_channels, out_channels, kernel_size, stride=2, padding=1, batch_norm=True):
"""Creates a convolutional layer, with optional batch normalization.
"""
layers = []
conv_layer = nn.Conv2d(in_channels, out_channels,
kernel_size, stride, padding, bias=False)
# append conv layer
layers.append(conv_layer)
if batch_norm:
# append batchnorm layer
layers.append(nn.BatchNorm2d(out_channels))
# using Sequential container
return nn.Sequential(*layers)
class Discriminator(nn.Module):
def __init__(self, conv_dim):
"""
Initialize the Discriminator Module
:param conv_dim: The depth of the first convolutional layer
"""
super(Discriminator, self).__init__()
# complete init function
self.conv_dim = conv_dim
# 32x32 x 3
self.conv1 = conv(3, conv_dim, 4, batch_norm=False) # 16x16 x conv_dim
self.conv2 = conv(conv_dim, conv_dim*2, 3, stride=1) # 16x16 x 2 conv_dim
self.conv3 = conv(conv_dim*2, conv_dim*2, 4) # 8x 8 x 2 conv_dim
self.conv4 = conv(conv_dim*2, conv_dim*4, 3, stride=1) # 8x 8 x 4 conv_dim
self.conv5 = conv(conv_dim*4, conv_dim*4, 4) # 4x 4 x 4 conv_dim
self.fc1 = nn.Linear(conv_dim*4*4*4, conv_dim*4)
self.fc2 = nn.Linear(conv_dim*4, 1)
self.leaky_relu = nn.LeakyReLU(negative_slope=0.2)
self.sigmoid = nn.Sigmoid()
self.dropout = nn.Dropout(p=0.38)
def forward(self, x):
"""
Forward propagation of the neural network
:param x: The input to the neural network
:return: Discriminator logits; the output of the neural network
"""
# define feedforward behavior
#
x = self.conv1(x)
x = self.leaky_relu(x)
x = self.conv2(x)
x = self.leaky_relu(x)
x = self.conv3(x)
x = self.leaky_relu(x)
x = self.conv4(x)
x = self.leaky_relu(x)
x = self.conv5(x)
x = self.leaky_relu(x)
# flatten
x = x.view(-1, self.conv_dim*4*4*4)
x = self.fc1(x)
x = self.leaky_relu(x)
x = self.dropout(x)
x = self.fc2(x)
x = self.sigmoid(x)
return x
"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
tests.test_discriminator(Discriminator)
The generator should upsample an input and generate a new image of the same size as our training data 32x32x3
. This should be mostly transpose convolutional layers with normalization applied to the outputs.
z_size
32x32x3
# helper deconv function
def deconv(in_channels, out_channels, kernel_size, stride=2, padding=1, batch_norm=True):
"""Creates a transposed-convolutional layer, with optional batch normalization.
"""
## TODO: Complete this function
## create a sequence of transpose + optional batch norm layers
layers = []
conv_layer =nn.ConvTranspose2d(in_channels, out_channels,
kernel_size, stride, padding, bias=False)
# append conv layer
layers.append(conv_layer)
if batch_norm:
# append batchnorm layer
layers.append(nn.BatchNorm2d(out_channels))
# using Sequential container
return nn.Sequential(*layers)
class Generator(nn.Module):
def __init__(self, z_size, conv_dim):
"""
Initialize the Generator Module
:param z_size: The length of the input latent vector, z
:param conv_dim: The depth of the inputs to the *last* transpose convolutional layer
"""
super(Generator, self).__init__()
self.conv_dim = conv_dim
self.fc = nn.Linear(z_size, conv_dim*4*4*4)
# 4x 4 x 4 conv_dim
self.deconv1 = deconv(conv_dim*4, conv_dim*2, 4) # 8x 8 x 2 conv_dim
self.deconv2 = deconv(conv_dim*2, conv_dim, 4) # 16x16 x conv_dim
self.deconv3 = deconv(conv_dim, conv_dim, 4) # 32x32 x conv_dim
self.deconv4 = deconv(conv_dim, conv_dim, 4) # 64x64 x conv_dim
self.conv = conv(conv_dim, 3, 4, batch_norm=False) # 32x32 x conv_dim
self.relu = nn.ReLU()
self.tanh = nn.Tanh()
self.dropout = nn.Dropout(p=0.38)
def forward(self, x):
"""
Forward propagation of the neural network
:param x: The input to the neural network
:return: A 32x32x3 Tensor image as output
"""
# define feedforward behavior
x = self.fc(x)
x = self.dropout(x)
x = x.view(-1, self.conv_dim*4, 4, 4)
x = self.deconv1(x)
x = self.relu(x)
x = self.deconv2(x)
x = self.relu(x)
x = self.deconv3(x)
x = self.relu(x)
x = self.deconv4(x)
x = self.relu(x)
x = self.conv(x)
x = self.tanh(x)
return x
"""
DON'T MODIFY ANYTHING IN THIS CELL THAT IS BELOW THIS LINE
"""
tests.test_generator(Generator)
To help your models converge, you should initialize the weights of the convolutional and linear layers in your model. From reading the original DCGAN paper, they say:
All weights were initialized from a zero-centered Normal distribution with standard deviation 0.02.
So, your next task will be to define a weight initialization function that does just this!
You can refer back to the lesson on weight initialization or even consult existing model code, such as that from the networks.py
file in CycleGAN Github repository to help you complete this function.
def weights_init_normal(m):
"""
Applies initial weights to certain layers in a model .
The weights are taken from a normal distribution
with mean = 0, std dev = 0.02.
:param m: A module or layer in a network
"""
# classname will be something like:
# `Conv`, `BatchNorm2d`, `Linear`, etc.
classname = m.__class__.__name__
# TODO: Apply initial weights to convolutional and linear layers
classname_init_list = ["Conv2d","ConvTranspose2d","Linear"]
if classname in classname_init_list:
if hasattr(m, 'weight'):
nn.init.normal_(m.weight.data, mean=0.0, std=0.02)
Define your models' hyperparameters and instantiate the discriminator and generator from the classes defined above. Make sure you've passed in the correct input arguments.
 Here, we'll set this as a boolean variable train_on_gpu
. Later, you'll be responsible for making sure that
- Models,
- Model inputs, and
- Loss function arguments
Are moved to GPU, where appropriate.
"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
import torch
# Check for a GPU
train_on_gpu = torch.cuda.is_available()
if not train_on_gpu:
print('No GPU found. Please use a GPU to train your neural network.')
else:
print('Training on GPU!')
Now we need to calculate the losses for both types of adversarial networks.
- For the discriminator, the total loss is the sum of the losses for real and fake images,
d_loss = d_real_loss + d_fake_loss
.- Remember that we want the discriminator to output 1 for real images and 0 for fake images, so we need to set up the losses to reflect that.
The generator loss will look similar only with flipped labels. The generator's goal is to get the discriminator to think its generated images are real.
labels
You may choose to use either cross entropy or a least squares error loss to complete the following real_loss
and fake_loss
functions.
def calc_loss(D_out, labels):
# move labels to GPU if needed
if train_on_gpu:
labels = labels.cuda()
criterion = nn.BCELoss()
# calculate loss
loss = criterion(D_out, labels)
return loss
def real_loss(D_out):
'''Calculates how close discriminator outputs are to being real.
param, D_out: discriminator logits
return: real loss'''
batch_size = D_out.size(0)
labels = torch.ones(batch_size).unsqueeze(1) # real labels = 1
return calc_loss(D_out, labels)
def fake_loss(D_out):
'''Calculates how close discriminator outputs are to being fake.
param, D_out: discriminator logits
return: fake loss'''
batch_size = D_out.size(0)
labels = torch.zeros(batch_size).unsqueeze(1) # fake labels = 0
return calc_loss(D_out, labels)
import torch.optim as optim
# params
lr = 0.0002
beta1=0.5
beta2=0.999
# Create optimizers for the discriminator and generator
d_optimizer = optim.Adam(D.parameters(), lr, [beta1, beta2])
g_optimizer = optim.Adam(G.parameters(), lr, [beta1, beta2])
Training will involve alternating between training the discriminator and the generator. You'll use your functions real_loss
and fake_loss
to help you calculate the discriminator losses.
You've been given some code to print out some loss statistics and save some generated "fake" samples.
Keep in mind that, if you've moved your models to GPU, you'll also have to move any model inputs to GPU.
def train(D, G, n_epochs, print_every=50):
'''Trains adversarial networks for some number of epochs
param, D: the discriminator network
param, G: the generator network
param, n_epochs: number of epochs to train for
param, print_every: when to print and record the models' losses
return: D and G losses'''
# move models to GPU
if train_on_gpu:
D.cuda()
G.cuda()
# keep track of loss and generated, "fake" samples
samples = []
losses = []
# Get some fixed data for sampling. These are images that are held
# constant throughout training, and allow us to inspect the model's performance
sample_size=16
fixed_z = np.random.uniform(-1, 1, size=(sample_size, z_size))
fixed_z = torch.from_numpy(fixed_z).float()
# move z to GPU if available
if train_on_gpu:
fixed_z = fixed_z.cuda()
# epoch training loop
for epoch in range(n_epochs):
# batch training loop
for batch_i, (real_images, _) in enumerate(celeba_train_loader):
batch_size = real_images.size(0)
real_images = scale(real_images)
# ===============================================
# YOUR CODE HERE: TRAIN THE NETWORKS
# ===============================================
D.train()
G.train()
# 1.  Train the generator with an adversarial loss
g_optimizer.zero_grad()
# 1.1 generate images
z = np.random.uniform(-1, 1, size=(batch_size, z_size))
z = torch.from_numpy(z).float()
if train_on_gpu:
z = z.cuda()
gen_images = G(z)
# 1.2 pass generated images to the discriminator to score them as real
D_gen = D(gen_images)
g_loss = real_loss(D_gen)
nn.utils.clip_grad_norm_(G.parameters(), 5)
g_loss.backward()
g_optimizer.step()
# ===============================================
# END OF YOUR CODE
# ===============================================
# Print some loss stats
if batch_i % print_every == 0:
# append discriminator loss and generator loss
losses.append((d_loss.item(), g_loss.item()))
# print discriminator and generator loss
print('Epoch [{:5d}/{:5d}] | d_loss: {:6.4f} ({:6.4f}+{:6.4f}) | g_loss: {:6.4f}'.format(
epoch+1, n_epochs, d_loss.item(), d_real_loss.item(), d_fake_loss.item(), g_loss.item()))
## AFTER EACH EPOCH##
# this code assumes your generator is named G, feel free to change the name
# generate and save sample, fake images
G.eval() # for generating samples
with torch.no_grad():
samples_z = G(fixed_z)
samples_z = samples_z.detach().cpu()
samples.append(samples_z)
G.train() # back to training mode
# Save training generator samples
with open('train_samples.pkl', 'wb') as f:
pkl.dump(samples, f)
# finally return losses
return losses
Set your number of training epochs and train your GAN!
# set number of epochs
n_epochs = 88
"""
DON'T MODIFY ANYTHING IN THIS CELL
"""
# call training function
losses = train(D, G, n_epochs=n_epochs,print_every=192)
Plot the training losses for the generator and discriminator, recorded after each epoch.
fig, ax = plt.subplots()
losses = np.array(losses)
plt.plot(losses.T[0], label='Discriminator', alpha=0.5)
plt.plot(losses.T[1], label='Generator', alpha=0.5)
plt.title("Training Losses")
plt.legend()
View samples of images from the generator, and answer a question about the strengths and weaknesses of your trained models.
# helper function for viewing a list of passed in sample images
def view_samples(epoch, samples):
fig, axes = plt.subplots(figsize=(16,4), nrows=2, ncols=8, sharey=True, sharex=True)
for ax, img in zip(axes.flatten(), samples[epoch]):
img = img.detach().cpu().numpy()
img = np.transpose(img, (1, 2, 0))
img = ((img + 1)*255 / (2)).astype(np.uint8)
ax.xaxis.set_visible(False)
ax.yaxis.set_visible(False)
im = ax.imshow(img.reshape((32,32,3)))
# Load samples from generator, taken while training
with open('train_samples.pkl', 'rb') as f:
samples = pkl.load(f)
_ = view_samples(-76, samples)
_ = view_samples(-61, samples)
_ = view_samples(-46, samples)
_ = view_samples(-31, samples)
_ = view_samples(-16, samples)
_ = view_samples(-1, samples)
When you answer this question, consider the following factors:
Answer: (Write your answer in this cell)
When submitting this project, make sure to run all the cells before saving the notebook. Save the notebook file as "dlnd_face_generation.ipynb" and save it as a HTML file under "File" -> "Download as". Include the "problem_unittests.py" files in your submission.


Expermiental implementation for meteo-parapente usable on a mobile phone. See https://meteo-parapente
This is a experiment and works as long as meteo-parapente is providing its data free and in the same format.
Subtract glider descent rate to get average vario reading for cloudless thermals.
Updraft strengths will be stronger than this forecast if convective clouds are present, since cloud condensation adds buoyancy aloft (i.e. this neglects cloudsuck).
W* depends upon both the surface heating and the BL depth
If convective clouds are present, the actual B/S ratio will be larger than calculated here due to the neglect of 'cloudsuck'.
This prediction can be misleading if there is a large change in wind direction through the BL (for a complex wind profile, no single number is an adequate descriptor!).
Note that this represents vertical wind shear and does not indicate so-called 'shear lines' (which are horizontal changes of wind speed/direction).
Positive convergence is associated with local small-scale convergence lines (often called 'shear lines' by pilots, which are horizontal changes of wind speed/direction) - however, the actual size of such features is much smaller than can be resolved by the model so only stronger ones will be forecast and their predictions are subject to much error. If CAPE is also large, thunderstorms can be triggered.
Negative convergence (divergence) produces subsiding vertical motion, creating low-level inversions which limit thermalling heights. This parameter can be noisy, so users should be wary.
This parameter can be useful in determining which flight direction allows better thermalling conditions when average surface elevations vary greatly in differing directions. (But the same cautions mentioned under Height of BL Top also apply.) It is also an important determinant of thermals strength (as is the Surface Heating)
Over flat terrain, maximum thermalling heights will be lower due to the glider descent rate and other factors. In the presence of clouds (which release additional buoyancy aloft, creating cloudsuck) the updraft top will be above this forecast, but the maximum thermalling height will then be limited by the cloud base. Further, when the mixing results from shear turbulence rather than thermal mixing this parameter is not useful for glider flying. NB: this BL Top is not the height where the Thermal Index (TI) is zero, which is a criteria used by many simple determinations of the BL top - instead, the RASP BL Top uses a more sophisticated BL Top criteria based on turbulent fluxes


Default core controller of giuseppe. Contains the routes and generates them on "configureRouter()" of giuseppe.
GiuseppeApiController
{ControllerDefinition}
GiuseppeRoute[]
Default core controller of giuseppe. Contains the routes and generates them on "configureRouter()" of giuseppe.
GiuseppeApiController
{ControllerDefinition}


- Tabs: import TabsModule from 'ngx-bootstrap';
- service for boat: using constant data from './boat-mock-data';
- service for others: using api from REST
import Injectable from '@angular/core'; for @Injectable()
import Headers, Http, Response from '@angular/http';
- alert ng-template;
alertMe
alertMe tab: with ng-template tabHeading, class=badge badge-secondary


About Us
VICKY RESTAURANT
It has survived not only five centuries.
It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.
It is a long established fact that a reader will be distracted by the readable content of a page when looking at its layout.


PART I. SHORT TITLE; PURPOSE; DEFINITIONS
[§190D-1] Short title. This chapter shall be known as the Hawaii Ocean and Submerged Lands Leasing Act. [L 1986, c 91, pt of §1]


I am a long-distance runner, and I have the same work values of preparation, practice and endurance. Full-stack Developer and competitive programmer. My role is to write and style the front-end and back-end components that meet the requirements of our mocks and fulfil our user stories.
I also monitor and process pull requests for production deployments. Technologies used: React❤, Django💙,MongoDB😍, JavaScript🤩, Node.js etc.
I love ❤ to talk on new technology and recite 😍 the poem in the fron of people💙.
A man who dares to waste one hour of time has not discovered the value of life
CONTACT ME


Add your name, school, date, title, etc. on the custom properties of the document and start working right away. The main title will appear on top of every page. You may even use this data on your document.
The table of contents will build itself from the custom APA style headers. No need to keep track of the page number yourself. You can alter the entire structure of the document and you only need to refresh the table of contents to see the changes.
Create a bibliography database and use it to keep your APA style references in order. It's more work at the beginning but it pays in the long run, specially when you have a long document with hundreds of references.
Creating a title page is simple, just add data to the custom fields and see how it works for you. You may use the custom fields on your document. The table of contents will create itself if you use the custom APA style headers.
Creating a bibliography database is helpful for future reference and will bring you easy acces to such sources in the future. just like the table of contents, you only need to refresh the bibliography to see the changes.


Javasript Calculator
Created By Khalil Saboor
MUST CLEAR AFTER EACH CALCULATIONS!!!
0
AC
CE
/
*
7
8
9
-
4
5
6
+
1
2
3
.
0
=


4 references to VMConnectionInfo
System.Management.Automation (4)
engine\remoting\commands\newrunspacecommand.cs (1)
964
connectionInfo = new
VMConnectionInfo
(this.Credential, this.VMId[index], this.VMName[index], this.ConfigurationName);
engine\remoting\commands\PSRemotingCmdlet.cs (1)
1756
connectionInfo = new
VMConnectionInfo
(this.Credential, this.VMId[index], this.VMName[index], this.ConfigurationName);
engine\remoting\commands\PushRunspaceCommand.cs (1)
1023
connectionInfo = new
VMConnectionInfo
(this.Credential, this.VMId, this.VMName, this.ConfigurationName);
engine\remoting\common\RunspaceConnectionInfo.cs (1)
2895
VMConnectionInfo result = new
VMConnectionInfo
(Credential, VMGuid, ComputerName, ConfigurationName);


To overcome the randomness of the draw, you need cards to help you find your Pokémon, energy, and other trainer and supporter cards. These don't replace general draw support but can help you conserve resources by finding exactly what you want or need.
All decks need to get their Pokémon out of the deck and into the playing field. Nearly all decks use four {{ 'B01EU45830'|affiliate_link('Ultra Ball', page='detail') }} to find any Pokémon you need. {{ 'B06X15X345'|affiliate_link('Nest Ball', page='detail') }} can search out any basic but it plays them right to the bench which won't activate abilities like those on {{ 'B00WTGHDGW'|affiliate_link('Shaymin-EX', page='detail') }} and {{ 'B017AHK5O6'|affiliate_link('Hoopa-EX', page='detail') }}. {{ 'B0128VBENK'|affiliate_link('Level Ball', page='detail') }} is a staple in evolution based decks since it can search out any Pokémon with 90 HP or less. {{ 'B06X8WWHCQ'|affiliate_link('Timer Ball', page='detail') }} can help search our higher evolutions but does rely on coin flips. Specificly for water decks, {{ 'B00S5LN0PS'|affiliate_link('Dive Ball', page='detail') }} is great because it can search out any water Pokémon without requiring a discard like Ultra Ball.
{% set examples = [ ('B01EU45830', 'Ultra Ball'), ('B06X15X345', 'Nest Ball'), ('B0128VBENK', 'Level Ball'), ('B06X8WWHCQ', 'Timer Ball'), ('B00S5LN0PS', 'Dive Ball'), ] %} {{ display_examples(examples) }}There are a few supports which can help search out Pokémon as well. {{ 'B016VKBT98'|affiliate_link('Brigette', page='detail') }} works like Nest Ball putting three basic Pokémon directly to the bench (or a single EX basic). {{ 'B01EU44WSM'|affiliate_link('Pokémon Fan Club', page='detail') }} can find two basic Pokémon and put them in your hand. {{ 'B00WTGLEDA'|affiliate_link('Winona', page='detail') }} can search out three colorless Pokémon of any evolution stage and put them in your hand. {{ 'B00WTGKYS6'|affiliate_link('Wally', page='detail') }} searches out non-EX evolution Pokémon and allows you to evolve on the same turn. While these cards can be helpful, you generally aren't going to include more than one or two of them in a deck since you can play multiple Poké ball cards in a turn but you can only play a single supporter for your turn.
{% set examples = [ ('B016VKBT98', 'Brigette'), ('B01EU44WSM', 'Pokemon Fan Club'), ('B00WTGLEDA', 'Winona'), ('B00WTGKYS6', 'Wally'), ] %} {{ display_examples(examples) }}There aren't a lot of cards which can search out energy, particularly special engery. {{ 'B016VKCBD6'|affiliate_link('Professor\'s Letter', page='detail') }} can search out two basic energy but it does not see a lot of usage outside of theme decks. {{ 'B00S5LNGZM'|affiliate_link('Teammates', page='detail') }} can be used to search out any two cards in your deck, including special energy, but it can only be played the turn after your opponent has knocked out one of your Pokémon so it more of a recovery card than a general search card. {{ 'B01B3LFAZY'|affiliate_link('Misty\'s Determination', page='detail') }} can let you search the top eight cards in your deck for the cost of discarding one to help you look for energy or any other card you might need there. Overall there aren't a lot of great options for energy search in Standard so you are generally relying on a sufficiently high energy count (8-12 basic energy) and enough general draw support to find them each turn. If your deck is running into problems finding energy, a combination of a single Professor's Letter and a single {{ 'B016VKCEAG'|affiliate_link('Skyla', page='detail') }} and be a combo to help you always find the basic energy you need.
{% set examples = [ ('B016VKCBD6', 'Letter'), ('B00S5LNGZM', 'Teammates'), ('B01B3LFAZY', 'Misty'), ('B016VKCEAG', 'Skyla'), ] %} {{ display_examples(examples) }}As previously mentioned, {{ 'B016VKCEAG'|affiliate_link('Skyla', page='detail') }} is a handy, often single count, supporter which can find any other trainer card in your deck. When combined with the ball search cards, it can be used to search out Pokémon if needed or combined with Professor's Letter then Skyla can find energy. Also handy for finding stadiums when needed or switching cards.
{{ 'B00WTGJMY8'|affiliate_link('Trainer\'s Mail', page='detail') }} is a popular search/consitency card which let's you select a trainer card from the top 4 of your deck. {{ 'B00S5LMUUO'|affiliate_link('Acro Bike', page='detail') }} let's you look at the top two cards, selecting one for your hand and discarding the other. Both of these cards can help you thin your deck of cards so that you'll draw into cards you want later in the game.
{% set examples = [ ('B00WTGJMY8', 'Mail'), ('B00S5LMUUO', 'Acro'), ] %} {{ display_examples(examples) }}Pokémon search is a key component of every deck and nearly every deck will benefit from using four Ultra Balls. Other ball search cards can be helpful depending on the type of Pokémon you need to find. Skyla is a useful multi-purpose search card though it does use your supporter for your turn. Generally if you can search out the Pokémon you need early and have sufficient draw support then you can find the cards you need to carry out your game.


Enter a video url to download the video to the server. Url can be to YouTube or any other supported site. The server will automatically download the highest quality version available.
youtube-dl you-get
Start


Home
About
Virtualization
Containerization
Comparison
Webserver with Docker
Docker Login and Linux commands
Docker with Pycharm


NZ_Do_We_Deliver_To_You_EspotNew customer?
Enter your postcode to check we deliver in your area.
Important Information
Alcohol promotions available to online customers serviced from our Scottish stores may differ from those shown when browsing our site. Please log in to see the full range of promotions available to you.


A container for the element that describes the location of the file containing the global APIs.
The <cxxFileAPIItemLocation> element is contained within the element <cxxFile>. The child element <cxxFileDeclarationFile> describes the location of the file containing the global data, functions, and other constructs.
<cxxFileAPIItemLocation> <cxxFileDeclarationFile name="filePath" value="C:/src/include/cfshared.h"/> </cxxFileAPIItemLocation>


Primarily this site is a tool to help you price and purchase deck lists for the Pokémon Trading Card Game. If you don't have a list of your own then this guide can help you put one together or find one online.
Our deck price calculator supports lists generated in the export format from Pokémon TCG Online (PTCGO). You do not need to own the cards online to add them to a list and export them. Since it's an easy way to generate a list, many players will use this same format when sharing a list on their website, YouTube channel, or forum. Some places we recommend checking out are the OmniPoke YouTube channel, the Pokebeach Deck Garage, and the decklists on The Charizard Lounge.
If you are looking for a deck for competitive play, you can find the lists used by the top 8 Junior, Senior, and Master players at the Regional and Championship tournaments published by Play Pokémon. Following the link, you choose a recent event, select a division, and then a player from the dropdown menu. Each list has a "Copy Deck List" button which uses the PTCGO format.
Pokémon TCG Online (PTCGO) is an easy and free/cheap way to try out a deck before buying it. To get the cards you need you'll have to earn coins for packs or win tournaments for tradeable packs to trade for the cards you want. To accelerate this process you can also purchase codes to unlock tradeable booster packs online. These are significantly less expensive than the real life booster packs.
For testing in real life, you can print proxy versions of the cards. While these proxies won't be legal for tournament play, they can be perfect for your play testing. For generating proxies, we recommend Proxycroak which supports the same PTCGO list format.
The pricing calculator expects the cards to be listed roughly in the format provided by Pokémon TCG Online (PTCGO). The PTCGO format has each card on its own line and has the format:
{quantity} {card name} {set code} {card number}
such as "2 Shaymin-EX ROS 77". Since cards from the same name might appear in different sets it's important that the set code is included. Likewise the card number makes it clear exactly which card it is from the set. There have been sets which have multiple cards with the same name such as Mewtwo-EX from Breakthrough (61 and 62)
{{ 'B016VKC02S'|affiliate_link }} {{ 'B016VKC0V4'|affiliate_link }}
Most of the prices for cards used in competitive play should be available. The prices come from Amazon.com and we've tried our best to match up the cards with their listings and we work constantly to keep them up to date. However, there might be cards which could not be matched to any item available for sale. If you'd like to report a card which wasn't match please drop us an<EMAIL_ADDRESS>Ciards come in different rarities. Many popular card have both regular art and full art prints. Some also have secret rare versions which have golden borders. For instance here are the regular art and full art versions of the popular supporter Professor Sycamore.
{{ 'B00ICALRM0'|affiliate_link }} {{ 'B01IUAGJDI'|affiliate_link }}
The full art version can often be more than twice as expensive as the regular art version. For the purpose of competitive play, these are the same card. We're working on ways to identify these and suggest cheaper options but for now that's something that you would need to adjust on your own.