|
Excimontec
v1.0.0
An open-source KMC simulation software package for modeling the optoelectronic processes in organic semiconductor materials and devices, such as OPVs, OLEDs, and more.
|
Classes | |
| struct | Coords |
| This simple struct contains Cartesian coordinates specified by integers x,y,z. More... | |
| class | Event |
| This base class contains the basic properties of a KMC simulation event and the functions needed to interact with it. More... | |
| class | Lattice |
| This class contains the properties of a three-dimensional lattice and the functions needed to interact with it. More... | |
| class | Object |
| This base class contains the basic properties of a KMC simulation object and the functions needed to interact with it. More... | |
| class | Parameters_Lattice |
| This class contains all of the main input parameters needed by the Lattice class. More... | |
| class | Parameters_Simulation |
| This class contains all of the main input parameters needed by the Simulation class. More... | |
| class | Simulation |
| This abstract base class contains the basic properties of a KMC simulation and the functions needed to interact with it. More... | |
| class | Site |
| This base class contains the basic properties of a lattice site and the functions needed to interact with it. More... | |
| class | Version |
| This class contains the current version information and version comparison operators. More... | |
Functions | |
| std::vector< std::pair< double, double > > | calculateCumulativeHist (const std::vector< std::pair< double, double >> &hist) |
| Calculates the cumulative histogram from the input probability histogram data. More... | |
| std::vector< std::pair< double, double > > | calculateDensityHist (const std::vector< std::pair< double, double >> &hist) |
| Calculates the density histogram from the input probability histogram. More... | |
| std::vector< std::pair< double, int > > | calculateHist (const std::vector< int > &data, int bin_size) |
| Calculates the histogram for the input integer data vector using the input bin size. More... | |
| std::vector< std::pair< double, double > > | calculateProbabilityHist (const std::vector< std::pair< double, int >> hist) |
| Calculates the probability histogram for the input histogram data vector. The function outputs bin-centered x values and probability y values in a x-y pair vector. More... | |
| std::vector< std::pair< double, double > > | calculateProbabilityHist (const std::vector< int > &data, int bin_size) |
| Calculates the probability histogram for the input integer data vector using the input bin size. More... | |
| std::vector< std::pair< double, double > > | calculateProbabilityHist (const std::vector< double > &data, int num_bins) |
| Calculates the probability histogram for the input double data vector using the input number of bins. More... | |
| std::vector< std::pair< double, double > > | calculateProbabilityHist (const std::vector< float > &data, int num_bins) |
| Calculates the probability histogram for the input float data vector using the input number of bins. More... | |
| std::vector< std::pair< double, double > > | calculateProbabilityHist (const std::vector< double > &data, double bin_size) |
| Calculates the probability histogram for the input double data vector using the input bin size. More... | |
| std::vector< std::pair< double, double > > | calculateProbabilityHist (const std::vector< float > &data, double bin_size) |
| Calculates the probability histogram for the input float data vector using the input bin size. More... | |
| std::vector< std::pair< double, double > > | calculateProbabilityHist (const std::vector< double > &data, const double bin_size, const int num_bins) |
| Calculates the probability histogram for the input double data vector using the input bin size and input number of bins. More... | |
| std::vector< std::pair< double, double > > | calculateProbabilityHist (const std::vector< float > &data, const double bin_size, const int num_bins) |
| Calculates the probability histogram for the input float data vector using the input bin size and input number of bins. More... | |
| void | createExponentialDOSVector (std::vector< double > &data, const double mode, const double urbach_energy, std::mt19937_64 &gen) |
| Creates a vector of doubles that has a custom asymmetric distribution with an exponential tail. More... | |
| void | createExponentialDOSVector (std::vector< float > &data, const double mode, const double urbach_energy, std::mt19937_64 &gen) |
| Creates a vector of floats that has a custom asymmetric distribution with an exponential tail. More... | |
| void | createGaussianDOSVector (std::vector< double > &data, const double mean, const double stdev, std::mt19937_64 &gen) |
| Creates a vector of doubles that has a Gaussian distribution. More... | |
| void | createGaussianDOSVector (std::vector< float > &data, const double mean, const double stdev, std::mt19937_64 &gen) |
| Creates a vector of floats that has a Gaussian distribution. More... | |
| double | integrateData (const std::vector< std::pair< double, double >> &data) |
| Numerically integrates a vector of x-y data using the trapezoid rule. More... | |
| double | interpolateData (const std::vector< std::pair< double, double >> &data, const double x_val) |
| Linearly interpolates an x-y data set to determine the interpolated y-value corresponding to an input x-value. More... | |
| std::vector< std::pair< double, double > > | MPI_calculatePairVectorAvg (const std::vector< std::pair< double, double >> &input_vector) |
| Uses MPI to calculate the average pair vector distribution from separate pair vectors coming from different processors. More... | |
| std::vector< std::pair< double, double > > | MPI_calculateProbHistAvg (const std::vector< std::pair< double, int >> &input_hist) |
| Uses MPI to calculate the average probability histogram from separate histograms coming from different processors. More... | |
| std::vector< double > | MPI_calculateVectorAvg (const std::vector< double > &input_vector) |
| Uses MPI to calculate the element-wise average vector from separate vectors coming from different processors. More... | |
| std::vector< double > | MPI_calculateVectorSum (const std::vector< double > &input_vector) |
| Uses MPI to calculate the element-wise sum vector from separate equally sized vectors coming from different processors. More... | |
| std::vector< int > | MPI_calculateVectorSum (const std::vector< int > &input_vector) |
| Uses MPI to calculate the element-wise sum vector from separate vectors coming from different processors. More... | |
| std::vector< int > | MPI_gatherValues (const int input_val) |
| Uses MPI to gather integer values from separate processors to build one vector containing all of the data. More... | |
| std::vector< double > | MPI_gatherValues (const double input_val) |
| Uses MPI to gather double values from separate processors to build one vector containing all of the data. More... | |
| std::vector< double > | MPI_gatherVectors (const std::vector< double > &input_vector) |
| Uses MPI to gather vectors from separate processors to build one big vector containing all of the data. More... | |
| std::vector< int > | MPI_gatherVectors (const std::vector< int > &input_vector) |
| Uses MPI to gather vectors from separate processors to build one big vector containing all of the data. More... | |
| std::string | removeWhitespace (const std::string &str) |
| Removes all spaces and tab characters in a string. More... | |
| int | round_int (const double num) |
| Rounds the input double value to the nearest integer value. More... | |
| bool | str2bool (const std::string &input) |
| Extracts a boolean value from a string containing "true" or "false". Throws an invalid_argument exception if the input string is not "true" or "false". More... | |
| template<typename T > | |
| double | array_avg (const T data[], const int array_size) |
| This template function calculates and returns the average value in double format when given an array of numerical datatypes. More... | |
| template<typename T > | |
| T | array_median (const T data[], const int array_size) |
| This template function calculates and returns the median value when given an array of numerical datatypes. More... | |
| template<typename T > | |
| double | array_stdev (const T data[], const int array_size) |
| This template function calculates and returns the standard deviation in double format when given an array of numerical datatypes. More... | |
| template<typename T > | |
| int | array_which_median (const T data[], const int array_size) |
| This template function determines which element in the data array has the median value of the dataset. More... | |
| template<typename T > | |
| double | intpow (const T base, const int exponent) |
| This template function calculates and returns the results of an integer power operation on a base numerical datatype. More... | |
| template<typename T > | |
| void | outputVectorToFile (std::vector< T > &vec, std::string filename) |
| This template function outputs the input data vector to a file with the specified filename. More... | |
| template<typename T > | |
| void | outputVectorToFile (std::vector< std::pair< T, T >> &vec, std::string filename) |
| This template function outputs the input data pair vector to a file with the specified filename. More... | |
| template<typename T > | |
| void | removeDuplicates (std::vector< T > &vec) |
| This template function efficiently removes the duplicate entries from an input vector. More... | |
| template<typename T , typename A > | |
| double | vector_avg (const std::vector< T, A > &data) |
| This template function calculates and returns the average value in double format when given a vector of numerical datatypes. More... | |
| template<typename T , typename A > | |
| double | vector_median (std::vector< T, A > data) |
| This template function calculates and returns the median value when given a vector of numerical datatypes. More... | |
| template<typename T , typename A > | |
| double | vector_stdev (const std::vector< T, A > &data) |
| This template function calculates and returns the standard deviation in double format when given a vector of numerical datatypes. More... | |
| template<typename T , typename A > | |
| int | vector_which_median (const std::vector< T, A > &data) |
| This template function determines which element in the data vector is closest to the median value of the dataset. More... | |
| std::ostream & | operator<< (std::ostream &stream, const Version &input) |
Variables | |
| Version | Current_version ("2.1.0-beta.1") |
| double KMC_Lattice::array_avg | ( | const T | data[], |
| const int | array_size | ||
| ) |
This template function calculates and returns the average value in double format when given an array of numerical datatypes.
| data | is the array of numerical data. |
| array_size | is the size of the input data array. |
| T KMC_Lattice::array_median | ( | const T | data[], |
| const int | array_size | ||
| ) |
This template function calculates and returns the median value when given an array of numerical datatypes.
| data | is the array of numerical data. |
| array_size | is the size of the input data array. |
| double KMC_Lattice::array_stdev | ( | const T | data[], |
| const int | array_size | ||
| ) |
This template function calculates and returns the standard deviation in double format when given an array of numerical datatypes.
| data | is the input array of numerical data. |
| array_size | is the size of the input data array. |
| int KMC_Lattice::array_which_median | ( | const T | data[], |
| const int | array_size | ||
| ) |
This template function determines which element in the data array has the median value of the dataset.
| data | is the input array of numerical data. |
| array_size | is the size of the input data array. |
| std::vector< std::pair< double, double > > KMC_Lattice::calculateCumulativeHist | ( | const std::vector< std::pair< double, double >> & | hist | ) |
Calculates the cumulative histogram from the input probability histogram data.
| hist | is the input probability histogram which is a vector of x-y pairs consisting of bin-centered x values and probability y values. |
| std::vector< std::pair< double, double > > KMC_Lattice::calculateDensityHist | ( | const std::vector< std::pair< double, double >> & | hist | ) |
Calculates the density histogram from the input probability histogram.
| hist | is the input probability histogram which is a vector of x-y pairs consisting of bin-centered x values and probability y values. |
| std::vector< std::pair< double, int > > KMC_Lattice::calculateHist | ( | const std::vector< int > & | data, |
| int | bin_size | ||
| ) |
Calculates the histogram for the input integer data vector using the input bin size.
Linearly spaced bins are automatically created from the minimum value to the maximum value of the data set with the specified bin size. The function outputs bin-centered x values and counts y values in a x-y pair vector.
| data | is the input integer data vector. |
| bin_size | is the specified bin size |
| std::vector< std::pair< double, double > > KMC_Lattice::calculateProbabilityHist | ( | const std::vector< std::pair< double, int >> | hist | ) |
Calculates the probability histogram for the input histogram data vector. The function outputs bin-centered x values and probability y values in a x-y pair vector.
| hist | is the input histogram data vector. |
| std::vector< std::pair< double, double > > KMC_Lattice::calculateProbabilityHist | ( | const std::vector< int > & | data, |
| int | bin_size | ||
| ) |
Calculates the probability histogram for the input integer data vector using the input bin size.
Linearly spaced bins are automatically created from the minimum value to the maximum value of the data set with the specified bin size. The function outputs bin-centered x values and probability y values in a x-y pair vector.
| data | is the input integer data vector. |
| bin_size | is the specified bin size |
| std::vector< std::pair< double, double > > KMC_Lattice::calculateProbabilityHist | ( | const std::vector< double > & | data, |
| int | num_bins | ||
| ) |
Calculates the probability histogram for the input double data vector using the input number of bins.
Linearly spaced bins are automatically created from the minimum value to the maximum value of the data set. The function outputs bin-centered x values and probability y values in a x-y pair vector.
| data | is the input data vector. |
| num_bins | is the desired number of bins. |
| std::vector< std::pair< double, double > > KMC_Lattice::calculateProbabilityHist | ( | const std::vector< float > & | data, |
| int | num_bins | ||
| ) |
Calculates the probability histogram for the input float data vector using the input number of bins.
Linearly spaced bins are automatically created from the minimum value to the maximum value of the data set. The function outputs bin-centered x values and probability y values in a x-y pair vector.
| data | is the input data vector. |
| num_bins | is the desired number of bins. |
| std::vector< std::pair< double, double > > KMC_Lattice::calculateProbabilityHist | ( | const std::vector< double > & | data, |
| double | bin_size | ||
| ) |
Calculates the probability histogram for the input double data vector using the input bin size.
Linearly spaced bins are automatically created from the minimum value to the maximum value of the data set. with the specified bin spacing. The function outputs bin-centered x values and probability y values in a x-y pair vector.
| data | is the input data vector. |
| bin_size | is the desired bin size. |
| std::vector< std::pair< double, double > > KMC_Lattice::calculateProbabilityHist | ( | const std::vector< float > & | data, |
| double | bin_size | ||
| ) |
Calculates the probability histogram for the input float data vector using the input bin size.
Linearly spaced bins are automatically created from the minimum value to the maximum value of the data set. with the specified bin spacing. The function outputs bin-centered x values and probability y values in a x-y pair vector.
| data | is the input data vector. |
| bin_size | is the desired bin size. |
| std::vector< std::pair< double, double > > KMC_Lattice::calculateProbabilityHist | ( | const std::vector< double > & | data, |
| const double | bin_size, | ||
| const int | num_bins | ||
| ) |
Calculates the probability histogram for the input double data vector using the input bin size and input number of bins.
Linearly spaced bins are automatically created starting from the minimum value of the data set. The function outputs bin-centered x values and probability y values in a x-y pair vector.
| data | is the input data vector. |
| num_bins | is the number of bins that will be created. |
| bin_size | is the input bin size. |
| std::vector< std::pair< double, double > > KMC_Lattice::calculateProbabilityHist | ( | const std::vector< float > & | data, |
| const double | bin_size, | ||
| const int | num_bins | ||
| ) |
Calculates the probability histogram for the input float data vector using the input bin size and input number of bins.
Linearly spaced bins are automatically created starting from the minimum value of the data set. The function outputs bin-centered x values and probability y values in a x-y pair vector.
| data | is the input data vector. |
| num_bins | is the number of bins that will be created. |
| bin_size | is the input bin size. |
| void KMC_Lattice::createExponentialDOSVector | ( | std::vector< double > & | data, |
| const double | mode, | ||
| const double | urbach_energy, | ||
| std::mt19937_64 & | gen | ||
| ) |
Creates a vector of doubles that has a custom asymmetric distribution with an exponential tail.
The created distribution is Gaussian in the positive direction relative to the mode and exponential in the negative direction. On the Gaussian side, the standard deviation is calculated relative to the Urbach energy chosen for the exponential side, so that the distribution function is continuous.
| data | is the data vector where the random numbers will be placed, which must be preallocated to the desired size. |
| mode | is the value of the peak of the distribution. |
| urbach_energy | is the parameter that determines the shape of the exponential tail side of the distribution. |
| gen | is a Mersenne twister random number generator used to randomly draw numbers from the distribution. |
| void KMC_Lattice::createExponentialDOSVector | ( | std::vector< float > & | data, |
| const double | mode, | ||
| const double | urbach_energy, | ||
| std::mt19937_64 & | gen | ||
| ) |
Creates a vector of floats that has a custom asymmetric distribution with an exponential tail.
The created distribution is Gaussian in the positive direction relative to the mode and exponential in the negative direction. On the Gaussian side, the standard deviation is calculated relative to the Urbach energy chosen for the exponential side, so that the distribution function is continuous.
| data | is the data vector where the random numbers will be placed, which must be preallocated to the desired size. |
| mode | is the value of the peak of the distribution. |
| urbach_energy | is the parameter that determines the shape of the exponential tail side of the distribution. |
| gen | is a Mersenne twister random number generator used to randomly draw numbers from the distribution. |
| void KMC_Lattice::createGaussianDOSVector | ( | std::vector< double > & | data, |
| const double | mean, | ||
| const double | stdev, | ||
| std::mt19937_64 & | gen | ||
| ) |
Creates a vector of doubles that has a Gaussian distribution.
| data | is the data vector where the numbers will be placed, which must be preallocated to the desired size. |
| mean | is the position of the peak and center of the distribution. |
| stdev | is the standard deviation of the distribution, which defines the width of the peak. |
| gen | is a Mersenne twister random number generator used to randomly draw numbers from the distribution. |
| void KMC_Lattice::createGaussianDOSVector | ( | std::vector< float > & | data, |
| const double | mean, | ||
| const double | stdev, | ||
| std::mt19937_64 & | gen | ||
| ) |
Creates a vector of floats that has a Gaussian distribution.
| data | is the data vector where the numbers will be placed, which must be preallocated to the desired size. |
| mean | is the position of the peak and center of the distribution. |
| stdev | is the standard deviation of the distribution, which defines the width of the peak. |
| gen | is a Mersenne twister random number generator used to randomly draw numbers from the distribution. |
| double KMC_Lattice::integrateData | ( | const std::vector< std::pair< double, double >> & | data | ) |
Numerically integrates a vector of x-y data using the trapezoid rule.
| data | is the data vector containing x-y data pairs. |
| double KMC_Lattice::interpolateData | ( | const std::vector< std::pair< double, double >> & | data, |
| const double | x_val | ||
| ) |
Linearly interpolates an x-y data set to determine the interpolated y-value corresponding to an input x-value.
| data | is the data vector containing x-y data pairs. |
| x_val | is the x-value that will be interpolated to. |
| double KMC_Lattice::intpow | ( | const T | base, |
| const int | exponent | ||
| ) |
This template function calculates and returns the results of an integer power operation on a base numerical datatype.
| base | is the base of the integer power operation and can be any numerical type. |
| exponent | is the integer exponent for the integer power operation. |
| std::vector< std::pair< double, double > > KMC_Lattice::MPI_calculatePairVectorAvg | ( | const std::vector< std::pair< double, double >> & | input_vector | ) |
Uses MPI to calculate the average pair vector distribution from separate pair vectors coming from different processors.
Each processor calls this function and sends an input pair vector distribution. Each pair vector entry represents an x-y data pair, where x is the centered bin position and y is the distribution value for that bin. Each input pair vector distribution can have a different range, but they must have the same bin size. Beyond the range of the input pair vector, the y distribution values are assumed to be zero. Upon function return, processor 0 receives the average pair vector and all of the other processors receive an empty pair vector. The range of the final pair vector is automatically sized to contain the data from of all input pair vectors.
| input_vector | is the input pair vector data from the processor calling the function. |
| std::vector< std::pair< double, double > > KMC_Lattice::MPI_calculateProbHistAvg | ( | const std::vector< std::pair< double, int >> & | input_hist | ) |
Uses MPI to calculate the average probability histogram from separate histograms coming from different processors.
Each processor calls this function and sends an input histogram. Each input histogram must have the same bin size.
Upon function return, processor 0 receives the average probability histogram and all of the other processors receive an empty probability histogram. The range of the final pair vector is automatically sized to contain the data from of all input pair vectors.
| input_hist | is the input histogram data from the processor calling the function. |
| std::vector< double > KMC_Lattice::MPI_calculateVectorAvg | ( | const std::vector< double > & | input_vector | ) |
Uses MPI to calculate the element-wise average vector from separate vectors coming from different processors.
Each processor calls this function and sends an input vector. If vectors are different sizes, the function uses trailing zeroes to make all vectors the same size before averaging. Upon function return, processor 0 receives the average vector and all of the other processors receive an empty vector.
| input_vector | is the input data from the processor calling the function. |
| std::vector< double > KMC_Lattice::MPI_calculateVectorSum | ( | const std::vector< double > & | input_vector | ) |
Uses MPI to calculate the element-wise sum vector from separate equally sized vectors coming from different processors.
Each processor calls this function and sends an input vector. Upon function return, processor 0 receives the sum vector and all of the other processors receive an empty vector.
| input_vector | is the input data from the processor calling the function. |
| std::vector< int > KMC_Lattice::MPI_calculateVectorSum | ( | const std::vector< int > & | input_vector | ) |
Uses MPI to calculate the element-wise sum vector from separate vectors coming from different processors.
Each processor calls this function and sends an input vector. Upon function return, processor 0 receives the sum vector and all of the other processors receive an empty vector.
| input_vector | is the input data from the processor calling the function. |
| std::vector< int > KMC_Lattice::MPI_gatherValues | ( | const int | input_val | ) |
Uses MPI to gather integer values from separate processors to build one vector containing all of the data.
Each processor calls this function and sends an input value. Upon function return, processor 0 receives the data vector and all of the other processors receive an empty vector.
| input_val | is the input integer data value from the processor calling the function. |
| std::vector< double > KMC_Lattice::MPI_gatherValues | ( | const double | input_val | ) |
Uses MPI to gather double values from separate processors to build one vector containing all of the data.
Each processor calls this function and sends an input value. Upon function return, processor 0 receives the data vector and all of the other processors receive an empty vector.
| input_val | is the input double data value from the processor calling the function. |
| std::vector< double > KMC_Lattice::MPI_gatherVectors | ( | const std::vector< double > & | input_vector | ) |
Uses MPI to gather vectors from separate processors to build one big vector containing all of the data.
Each processor calls this function and sends an input vector. Upon function return, processor 0 receives the large data vector and all of the other processors receive an empty vector.
| input_vector | is the input data from the processor calling the function. |
| std::vector< int > KMC_Lattice::MPI_gatherVectors | ( | const std::vector< int > & | input_vector | ) |
Uses MPI to gather vectors from separate processors to build one big vector containing all of the data.
Each processor calls this function and sends an input vector. Upon function return, processor 0 receives the large data vector and all of the other processors receive an empty vector.
| input_vector | is the input data from the processor calling the function. |
| std::ostream& KMC_Lattice::operator<< | ( | std::ostream & | stream, |
| const Version & | input | ||
| ) |
| void KMC_Lattice::outputVectorToFile | ( | std::vector< T > & | vec, |
| std::string | filename | ||
| ) |
This template function outputs the input data vector to a file with the specified filename.
| vec | is the input data vector. |
| filename | is the input file name. |
| void KMC_Lattice::outputVectorToFile | ( | std::vector< std::pair< T, T >> & | vec, |
| std::string | filename | ||
| ) |
This template function outputs the input data pair vector to a file with the specified filename.
| vec | is the input data pair vector. |
| filename | is the input file name. |
| void KMC_Lattice::removeDuplicates | ( | std::vector< T > & | vec | ) |
This template function efficiently removes the duplicate entries from an input vector.
This algorithm allow efficient removal of duplicate vector objects when > or < comparison operators do not exist.
| vec | is the input vector to be operated on. |
| std::string KMC_Lattice::removeWhitespace | ( | const std::string & | str | ) |
Removes all spaces and tab characters in a string.
| str | is the input string |
| int KMC_Lattice::round_int | ( | const double | num | ) |
Rounds the input double value to the nearest integer value.
| num | is the input double value. |
| bool KMC_Lattice::str2bool | ( | const std::string & | input | ) |
Extracts a boolean value from a string containing "true" or "false". Throws an invalid_argument exception if the input string is not "true" or "false".
| input | is the input string. |
| double KMC_Lattice::vector_avg | ( | const std::vector< T, A > & | data | ) |
This template function calculates and returns the average value in double format when given a vector of numerical datatypes.
| data | is the vector of numerical data. |
| double KMC_Lattice::vector_median | ( | std::vector< T, A > | data | ) |
This template function calculates and returns the median value when given a vector of numerical datatypes.
| data | is the vector of numerical data. |
| double KMC_Lattice::vector_stdev | ( | const std::vector< T, A > & | data | ) |
This template function calculates and returns the standard deviation in double format when given a vector of numerical datatypes.
| data | is the vector of numerical data. |
| int KMC_Lattice::vector_which_median | ( | const std::vector< T, A > & | data | ) |
This template function determines which element in the data vector is closest to the median value of the dataset.
if multiple values are equally close, the first one in the vector is selected.
| data | is the input vector of numerical data. |
| Version KMC_Lattice::Current_version |


The entire solution consists of the following projects:
| Canvas | Graphical library |
| Controls | Definition of controls |
| Core | Basic blocks and other base classes |
| CSharp_Editor | Stefan's C# Editor (functionality and UI in one project) |
| HTMLEditor | Martin, Thomas and Christian's HTML Editor |
| CSharpBlocks | Test C# Editor functionality |
| CSharpEditor | Test C# Editor UI |
| XmlBlocks | Test XML Editor functionality |
| XmlEditorTest | Test XML Editor UI |
C# and XML test projects have functionality separated from the UI, but it isn't very important. We could also put them in one project as well.
Canvas is a graphical library.
Functionality:
Depends on: Canvas
A library of visual (interactive) controls that can be drawn on Canvas, such as TextBox, List, Label, Button, Scrollbar, Picture etc.
Depends on: Canvas, Controls
Core defines base classes to model an editor:
Blocks and controls form a foundation of each editor. Each block is represented by a corresponding control.
Depends on: Canvas, Controls, Core (as .dll)
Stefan's C# Editor: functionality and UI client in the same assembly.
Depends on: Canvas, Controls, Core
Blocks and controls definition and user interface of an HTML editor.
Start goal of the HTML editor is to be able to edit and save HTML files, supported tags like in this documentation.
Depends on: Canvas, Controls, Core
Classes that define an editor for C#
Depends on: Canvas, Controls, Core, CSharpBlocks
UI Client for the C# editor (Windows Forms)
Depends on: Canvas, Controls, Core
Definition of blocks and controls to edit an XML document hierarchy (DOM).
Depends on: Canvas, Controls, Core, XmlBlocks
Simple UI for the XmlBlocks, mainly a single form with a ViewWindow, which displays an XmlRootBlock.


2 Kings 3:8
And he said, Which way shall we go up? And he answered, The way through the wilderness of Edom.


Expand Side Panel
Sidebar
Main Menu
Collapse Side Panel
Home
Services
About
Work
Settings
Contact
Projects
Search


Warning! {{ hostUrl }} is a test website. orcid.org is the official website. Sandbox only sends email messages to mailinator.com email addresses, see Sandbox FAQ for more information


Projects
project 1
This is the first project
This is the first project
This is the first project
This is the first project
This is the first project
This is the first project
This is the first project
This is the first project


L.A. STORY A film review by Steve Rhodes Copyright 1997 Steve Rhodes
RATING (0 TO ****): *** 1/2
L.A. STORY (1991), a beautiful parody and homage written by and starring Steve Martin, opens to a carefully choreographed water ballet of lawn sprinklers.
As L.A. wakes for another morning of glorious California sun, the image is subtitled "Los Angeles, California, Temperature 72 degrees." We see Los Angelenos going about their morning routines, switching from one sleepy guy in shorts busily dragging his Christmas tree to the curb to a suit who chats away on his cell phone as the stretched limo he is riding in is being towed.
"I live in Los Angeles, and I've had 7 heart attacks -- all imagined," explains meteorologist Harris K. Telemacher (Steve Martin). "That is to say, I was deeply unhappy, but I didn't know it because I was happy all the time."
"When the weather dropped to 58 degrees this weekend, how did you cope?" asks Harris in a man-on-the-street interview. As a wacky television weatherman, he fits right in with the area's "culture." Even so, he is almost fired by the show's producer, played devilishly by a candy sucking and Hawaiian shirt wearing Woody Harrelson, when the producer claims Harris was doing some intellectual thing during another of his slapstickish weather reports.
In a film so rich that it would take at least three viewings to sift through all of the humor and subtleties, the show's subtext is highly romantic and poignant. The humor is presented with such delicious seriousness that it becomes almost an anthropological exploration of West Coast tribes. ("Hi, my name is Bob," chirps Dennis Dragon as a saccharinely polite thief. "I'll be your robber.") The resulting film by director Mick Jackson is so funny that I could not control myself at times -- one belly laugh would not subside before another began.
In a completely plastic city, where Harris drives a hundred yards to his next door neighbor's house, he meets his would-be wife, Sara McDowel (Victoria Tennant), who has just arrived from her home in London. She shocks the locals by saying exactly what is on her mind.
When not attempting to date someone his own age, Harris goes out with Sandy, who, after all, is just "4 years shy of 27." Although the credits list her as "Sandy," she carefully writes her name for Harris as "SanDeE" with a star at the end and a heart encasing the name. Sarah Jessica Parker, who has been too often miscast as she was in THE SUBSTANCE OF FIRE, plays free spirit SanDeE with perfection. The woman is incapable of standing still and constantly dances and twirls, while throwing her long, curly hair about. Having not a care in the world and not burdened with excessive brain power, she lives an experiential lifestyle.
An electronic highway sign plays perhaps the sweetest, and certainly the most unusual character in the story. The sign gives Harris prescient advice and even speaks in riddles -- unscramble "How Daddy is Doing," commands the sign.
The show is full of well chosen cameos by known actors playing against type. Rick Moranis, in a Hamlet take-off, appears as a gravedigger with a thick English accent. Best is Patrick Stewart as the maitre d' of a restaurant so exclusive that Harris has to accompany him to the maitre d's bank (Fourth Reich of Hamburg) to review Harris's financial statement before he can get a reservation. And since his is deemed deficient in several areas, he can order only a limited number of items on the menu, and certainly not the duck.
Thanks to the sparkling and romantic cinematography by Andrew Dunn, the picture has a magical sense of wonderment about life. Amidst all the humor is a sensitive story about a man in search of meaning for his life. And in a quest for love. ("Forget for this moment the smog and the cars and the restaurant and the skating and remember only this. A kiss may not be the truth, but it is what we wish were true.")
"Wow, that was something!" says Harris as the show draws to its delightful conclusion. "That was really something!" As my newfound friends faded away, I thought, "My sentiments exactly!"
L.A. STORY runs a fast 1:35. It is rated PG-13 for very brief nudity and a little profanity. The show has so much mature humor that I think kids would need to be nine or ten to appreciate it. I strongly recommend this gem to you and give it *** 1/2.
**** = A must see film. *** = Excellent show. Look for it. ** = Average movie. Kind of enjoyable. * = Poor show. Don't waste your money. 0 = Totally and painfully unbearable picture.
REVIEW WRITTEN ON: July 5, 1997
Opinions expressed are mine and not meant to reflect my employer's.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


--- title: Home Page layout: default body_class: home-template --- {% include material-cover.html %}
{{post.description}} …


Using TensorFlowSharp in Unity (Experimental)
ML-Agents allows you to use pre-trained TensorFlow graphs inside your Unity games. This support is possible thanks to the TensorFlowSharp project. The primary purpose for this support is to use the TensorFlow models produced by the ML-Agents own training programs, but a side benefit is that you can use any TensorFlow model.
Notice: This feature is still experimental. While it is possible to embed trained models into Unity games, Unity Technologies does not officially support this use-case for production games at this time. As such, no guarantees are provided regarding the quality of experience. If you encounter issues regarding battery life, or general performance (especially on mobile), please let us know.
Supported devices :
- Linux 64 bits
- Mac OS X 64 bits
- Windows 64 bits
- iOS (Requires additional steps)
- Android
Requirements
- Unity 2017.1 or above
- Unity TensorFlow Plugin (Download here)
Using TensorFlowSharp with ML-Agents
Go to Edit
-> Player Settings
and add ENABLE_TENSORFLOW
to the Scripting Define Symbols
for each type of device you want to use (PC, Mac and Linux Standalone
, iOS
or Android
).
Set the Brain you used for training to Internal
. Drag your_name_graph.bytes
into Unity and then drag it into The Graph Model
field in the Brain.
Using your own trained graphs
The TensorFlow data graphs produced by the ML-Agents training programs work without any additional settings.
In order to use a TensorFlow data graph in Unity, make sure the nodes of your graph have appropriate names. You can assign names to nodes in TensorFlow :
variable= tf.identity(variable, name="variable_name")
We recommend using the following naming conventions:
- Name the batch size input placeholder
batch_size
- Name the input vector observation placeholder
state
- Name the output node
action
- Name the recurrent vector (memory) input placeholder
recurrent_in
(if any) - Name the recurrent vector (memory) output node
recurrent_out
(if any) - Name the observations placeholders input placeholders
visual_observation_i
wherei
is the index of the observation (starting at 0)
You can have additional placeholders for float or integers but they must be placed in placeholders of dimension 1 and size 1. (Be sure to name them.)
It is important that the inputs and outputs of the graph are exactly the ones you receive and return when training your model with an External
brain. This means you cannot have any operations such as reshaping outside of the graph.
The object you get by calling step
or reset
has fields vector_observations
, visual_observations
and memories
which must correspond to the placeholders of your graph. Similarly, the arguments action
and memory
you pass to step
must correspond to the output nodes of your graph.
While training your Agent using the Python API, you can save your graph at any point of the training. Note that the argument output_node_names
must be the name of the tensor your graph outputs (separated by a coma if using multiple outputs). In this case, it will be either action
or action,recurrent_out
if you have recurrent outputs.
from tensorflow.python.tools import freeze_graph
freeze_graph.freeze_graph(input_graph = model_path +'/raw_graph_def.pb',
input_binary = True,
input_checkpoint = last_checkpoint,
output_node_names = "action",
output_graph = model_path +'/your_name_graph.bytes' ,
clear_devices = True, initializer_nodes = "",input_saver = "",
restore_op_name = "save/restore_all", filename_tensor_name = "save/Const:0")
Your model will be saved with the name your_name_graph.bytes
and will contain both the graph and associated weights. Note that you must save your graph as a .bytes file so Unity can load it.
In the Unity Editor, you must specify the names of the nodes used by your graph in the Internal brain Inspector window. If you used a scope when defining your graph, specify it in the Graph Scope
field.
See Internal Brain for more information about using Internal Brains.
If you followed these instructions well, the agents in your environment that use this brain will use your fully trained network to make decisions.
iOS additional instructions for building
- Once you build for iOS in the editor, Xcode will launch.
- In
General
->Linked Frameworks and Libraries
:- Add a framework called
Accelerate.framework
- Remove the library
libtensorflow-core.a
- Add a framework called
- In
Build Settings
->Linking
->Other Linker Flags
:- Double click on the flag list to expand the list
- Add
-force_load
- Drag the library
libtensorflow-core.a
from theProject Navigator
on the left underLibraries/ML-Agents/Plugins/iOS
into the flag list, after-force_load
.
Using TensorFlowSharp without ML-Agents
Beyond controlling an in-game agent, you can also use TensorFlowSharp for more general computation. The following instructions describe how to generally embed TensorFlow models without using the ML-Agents framework.
You must have a TensorFlow graph, such as your_name_graph.bytes
, made using TensorFlow's freeze_graph.py
. The process to create such graph is explained in the Using your own trained graphs section.
Inside of Unity
To load and use a TensorFlow data graph in Unity:
Put the file,
your_name_graph.bytes
, into Resources.At the top off your C# script, add the line:
using TensorFlow;
- If you will be building for android, you must add this block at the start of your code :
#if UNITY_ANDROID
TensorFlowSharp.Android.NativeBinding.Init();
#endif
- Load your graph as a text asset into a variable, such as
graphModel
:
TextAsset graphModel = Resources.Load (your_name_graph) as TextAsset;
- You then must instantiate the graph in Unity by adding the code :
graph = new TFGraph ();
graph.Import (graphModel.bytes);
session = new TFSession (graph);
- Assign the input tensors for the graph. For example, the following code assigns a one dimensional input tensor of size 2:
var runner = session.GetRunner ();
runner.AddInput (graph ["input_placeholder_name"] [0], new float[]{ placeholder_value1, placeholder_value2 });
You must provide all required inputs to the graph. Supply one input per TensorFlow placeholder.
- To calculate and access the output of your graph, run the following code.
runner.Fetch (graph["output_placeholder_name"][0]);
float[,] recurrent_tensor = runner.Run () [0].GetValue () as float[,];
Note that this example assumes the output array is a two-dimensional tensor of floats. Cast to a long array if your outputs are integers.


{% extends "../customer.layout.html" %} {% block content %}
Take the time to write a personalized email to this customer.


--- layout: post title: 4 Big Data Stories You May Have Missed This Week date: '2012-03-04T11:57:09-08:00' tags: tumblr_url: http://alexhwilliams.tumblr.com/post/18743281467/4-big-data-stories-you-may-have-missed-this-week ---
http://bit.ly/zFbeP4


Text Field
Read Only Field
Disabled Field
Password Field
Text Area
Examples of the types of text input supported.


One of formats of data that Spry accepts is XML. The Spry XML Data set was the first type of data that Spry used when it was released. This document will present an overview of setting up XML for use with Spry. It will have tips and tricks for generating proper XML from the start.
The important points of this document:
XML stands for eXtensible Markup Language. This is a flexible yet strict method of storing and transmitting data. Flexible in that the user can create the format and node names in any way they please; strict in the sense that XML has a strict set of rules for structure: required closing tags and case sensitivity for instance.
XML is a tree structure of nodes and nested nodes of information, with the user defining the names of the nodes.
A basic XML file looks like this:
<?xml version="1.0" encoding="utf-8"?> <employees xmlns="http://www.foo.com/employees"> <employee id="120585"> <lastname>Jones</lastname> <firstname>John</firstname> <phone>(415) 333-9345 </phone> <username>jjones</username> </employee> <employee id="127493"> <lastname>Brown</lastname> <firstname>Joe</firstname> <phone>(415) 333-5938 </phone> <username>jbrown</username> </employee> </employees>
Line 1 is the XML declaration. It specifies the version of the XML and the encoding of the document. The encoding tells the browser which language is being used in the XML. Using UTF-8 is a good choice unless you have specific language needs.
"Employees" is the top level node. This defines the start of the user specified content. All top level node tags must have a closing tag. Notice that the last line of the XML file is the closing </employees> tag.
Within the <employees> block is the repeating <employee> node. This is where the bulk of the actual data is kept. The user defines the actual names of the nodes. Important: Node names are case sensitive. This is important to keep in mind when using Spry data references. If the node is <employee>, the data reference needs to be {employee}. If the node was <Employee>, the data reference needs to be {Employee}. If the node was uppercase and the data reference was lowercase, it will fail.
Notice there are 2 places to put data:
This node/value structure works well for simple data. If the data is more complex, meaning it has many special characters or perhaps HTML markup, then these nodes need to be wrapped in a CDATA container or be entity encoded. For example, if the value of a node was: ' 6 > 5 and 5 < 6', the XML parser (the browser or Spry) will get confused since it would think that the '><' characters are opening or closing tags. This would cause a parsing error and the XML is therefore invalid.
There are two ways to handle this.
The first is to entity encode the special characters. Each special character has its own character pattern that is used to display the character in the browser. For instance. the '<' character can also be written as < or <. This way the above sample can be written '6 > 5 and 5 < 6'. This should be parsed correctly.
The second way is to wrap the value in CDATA. This is done like <formula><![CDATA[ 6 > 5 and 5 < 6]]></formula>. CDATA tells the parser to ignore everything within the CDATA tag. This way, you can have HTML markup and any number of special characters within the value of the node.
Note the structure of the CDATA tag: < ! [ CDATA [ your code ] ] >
Frequently, users will want to generate XML using information from a database. This is useful when the data changes frequently. Spry can take data from an XML page or any page that can generate valid XML. This can be done, for instance, with ASP, PHP or Coldfusion application servers. We have a series of code samples that show how to convert database queries into XML.
Using server side functionality brings up an important web concept: that of 'content-type'. Content type is a message to the browser that tells it what kind of content is on the page. By default, the content type is 'text/plain'. This tells the browser that it is plain text that requires no special processing. Most web pages have a content type of 'text/html'. This tells the browser that the content is HTML code and the browser knows how to handle it.
Browser also have default content types determined by the file extension. These are MIME types. So a browser will know that a PHP page is serving HTML content. When serving up XML content via these server side technologies, it is vital that you tell the browser that the content is actually XML. To do this, we need to send a header that says that the content type is XML. Notice in the file linked above that each code sample has a content type header that is sent along.
This will ensure that the browser will parse the content as valid XML. Otherwise, it will be seen as plain text and may not work properly. When making a dynamic source for Spry, it's a good idea to simply view the page in a browser. It will be obvious when a XML file is being parsed correctly. If it works in the browser, it should work in Spry.
One other concern with dynamic feeds is making sure that the browser (or server) does not cache the data. Browser or server caching will prevent the latest data from reaching Spry. To prevent this, set the headers for:
Check the Query to XML sample for examples.
http://juicystudio.com/article/content-negotiation.php is a good article that further explains content type.
For further information about XML, check out http://www.xmlfiles.com/xml/
Copyright © 2007. Adobe Systems Incorporated.
All rights reserved.


Comments
-
lRem
At the same time it works flawless in MacVim.
-
Greg Hurrell
This will happen whenever you build Command-T and link it against one version of Ruby, and then run a Vim which links against a different version of Ruby.
You haven't provided the Command-T build transcript, but I imagine what is happening is that it is linking against the system Ruby, which is what MacVim links against and which is why it works fine with MacVim. On the other hand, when you try to run it against a MacPorts version of Vim you're crashing because that Vim links against its own, different version of Ruby.
So if you want it to work in both MacPorts Vim and MacVim you'll need to build everything (Command-T, Vim, and MacVim) linking against the MacPorts version of Ruby.
A simpler solution, however, would be just to use MacVim (note that it comes with a command-line version for use in the terminal —
/Applications/MacVim.app/Contents/MacOS/vim
— which you can use by setting yourPATH
appropriately, or making an alias, or setting yourEDITOR
environment variable accordingly etc) and build Command-T using the system Ruby. If you want a custom build of Vim that's easily doable too, as MacVim is quite straightforward to build from source. -
Greg Hurrell
In the absence of a reply I assume you've got this one sorted out, so I'm going to mark the ticket as closed. Feel free to comment again if you want me to re-open it.
-
Greg Hurrell
Status changed:
- From: new
- To: closed
Add a comment
Comments are now closed for this issue.


432k
Customers
18k
Happy Clients
160k
Reviewed Clients
1236k
Cup of Coffee
10k
Milestone Clients
We are a trendy cafe that offer a basket of exquisitely crafted desserts. With our coffees, thousands celebrate themselves with their selfies, lovers express their profound affection for each other, old pals chat over their nostalgia, strangers strike memorable conversations & colleagues at work brainstorm creative solutions.
One of the most awesome things about coffee is how well its complex flavor combines with other foods and drinks. The flavor of coffee has been added to all sorts of foods and drinks including sweets, cake, ice cream and chocolates.
Personal hygiene and machine cleanliness will not only ensure that your cafe is socially acceptable and medically safe but your coffee will taste better too.
Have you think about a great cup of coffee in a very cheap rate, yes you heard it right! We at pic give you great discount for your desired cup of coffee.
How about having coffee late night, early morning or whenever you want. Your pic is open 24x7 for you. We are please to serve our customer.
A very attractive part of our cafe is that we behave very sweetly with our customers. Services by our cafe is overwhelming.
Cold Coffee
Churros
Shake
Wafflles


The architecture of AlexNet, as shown in the original paper.
Deep convolutional networks can be both simple and quite convoluted. However, in our final project of the semester, we make attempts to demystify what goes into a convolutional network and try to understand how it works. In order to do this, we utilized TensorFlow and AlexNet, as implemented here in this repository.
If you would like to see our (George and Yan's) repository, then please refer to the link here. We forked and adapted the code from kratzert's repository based on our needs and requirements. Overall, this was a fun, quick project to do in order to understand how convolutional networks function!
Yan led the research and drafting process for this project report; the configuration of cloned code, creation of supplementary code, and training of the CNN were George's primary responsibilities. Facebook messenger was used to facilitate a mutual understanding of AlexNet and the cloned repository, while Git served as a tool to work on the same codebase in parallel. This report is a synthesis of our findings and understanding of the material.
Additional roles that we undertook throughout this project will be discussed throughout the report.
Deep convolutional neural networks (CNNs) simulate neuronal-based learning through the use of a multi-layered processing architecture. CNNs have grown in popularity thanks to their proficiency in tasks that have often proved challenging to solve by computer, such as object recognition and complex scene description. For this project, we used AlexNet, an image recognition CNN originally created in 2012. Alexnet contains eight learning layers: five convolutional layers and three "fully-connected" layers. See the above image to understand how data
is processed throuhgout the system. CNNs share weights in convolutional layers, which means that the same filter is used in each field and improves performance overall.
All of the processes should ideally happen on the GPU, as it is faster, but in some cases will need to be done on the CPU depending on the OS of the system being used
(in our case, our processing happened on the CPU). If the dataset is small enough, the time it takes to run on the CPU is negilible. However, bigger datasets will require more machinepower.
AlexNet in particular is supervised deep learning, meaning that we are providing the network a training dataset, a validation dataset, and a testing dataset (70-15-15 breakup, if possible).
The network takes the training dataset, processes it, and validates it against the validation set. The testing set should be images that the network has never seen before in order to properly test
the network. For our particular setup, we have a pretrained network that already has weights associated with it. We will now discuss finetuning AlexNet to our new datasets from the Professor (dog vs hotdog)
and from ImageNet. Note that, in order to observe the tuned results of this neural network, training information must first be generated; the training data used for the tuned implementations discussed has not been included in this repository due to size limitations. This can be done by running hd_tuner.py
and ob_tuner.py
, respectively.
Finetuning AlexNet, thankfully, was not a challenge but did require some work in modifying the code to suit our needs, especially with the first set of images being only 58 images total.
The small batch required us to consider parts of the code as George attempted to run parts of it. We had to adjust the learning params
in finetune.py
. We adjusted our batch_size
as 8 to avoid hitting division by zero errors. We also took away one of the train_layers
that we wanted to look at and focused primarily on the last two, fc8 and fc7. We kept the rest of the code the same
and then made our .txt
files to include the paths to our training and validation images, respectively. We classified dogs as 0s and hot dogs (and food related items) as 1s. There were several images
provided to us where the dogs were also in hot dog costumes.
Our results were tested on 9 images! Not so surprisingly, AlexNet was able to identify the images accurately for 5/9 images (3 true positives, 2 false positives), as seen below, where food is labelled appropriately and dogs are labelled appropriately. The algorithm failed to notice the Corgi in the hot dog costume as well as the Dachscund in the hot dog costume. It also miscategorized the very left image as a dog, when it's actually hot dogs. For the most part, though, the algorithm did a good job in identifying the images, likely because of the fact that AlexNet was already pretrained on images of dogs and hotdogs, but it was likely just introduced to dogs in costumes. Perhaps with a larger dataset to train AlexNet on, we could arrive to be more reliant results, but a success rate of a little over 50% is not bad for the given dataset.
After finetuning AlexNet to our dog/hotdog dataset, we were required to train the neural network on another set of data. We chose the dataset called Caltech101, which is linked below in the results (if you'd like
to learn more about the contents of the dataset). This was significantly smaller than the dataset that we were linked to (CIFAR) and, given our computational power and prowess in writing scripts that would automate the .txt
file creation, it was in our favor to pick a smaller dataset. Nonetheless, Caltech 101 consists of 101 classes with approximately 50 or so images per class, at variable resolution. Some classes have more images than others, airplanes,
for example, have over 700. This dataset was created by Fei Fei Li. Furthermore, CIFAR was stored in a format that was unfamiliar with both of us and would require more time than we could afford in order to tackle the problem. Combined with
the breadth of the dataset and the datatype, it was better to go with Caltech 101. As the algorithm that we are using requires a .txt
file, George wrote a script that would automate the process and would give us two files to work with in the end
with the proper labels. What this entails is parsing through the files to find the filepaths and to match the images accordingly based on the parsing to have a file containing training images and validation images.
See below for the script that George wrote to obtain the path to the file and the appropriate labels.
import os
def list_files(dir):
r = []
i = 0
dir_list = [x[0] for x in os.walk(dir)]
dir_list = sorted(dir_list, key=str.lower)
dir_list.pop(0)
for subdir in dir_list:
folder_list = []
files = os.walk(subdir).next()[2]
if (len(files) > 0):
for file in files:
folder_list.append(subdir + '/' + file + ' ' + str(i))
i += 1
r.append(folder_list)
return r
# Create master file list
master_list = list_files('data/101_obj')
# Create sublists
tr_list = []
va_list = []
te_list = []
for sublist in master_list:
# Training List
tr_portion = sublist[:int(len(sublist)*.7)]
for item in tr_portion:
tr_list.append(item)
# Validation List
va_portion = sublist[int(len(sublist)*.7):int(len(sublist)*.85)]
for item in va_portion:
va_list.append(item)
for sublist in master_list:
# Test List
for item in sublist:
if not item in tr_list and not item in va_list:
te_list.append(item)
# Print file lists
# print master_list
# print tr_list
# print va_list
# Create new text files
tr_text = open("@tr_list.txt","w+")
va_text = open("@va_list.txt","w+")
te_text = open("@te_list.txt","w+")
# Write to file lists
for item in tr_list:
tr_text.write('%s\n' % (item))
for item in va_list:
va_text.write('%s\n' % (item))
for item in te_list:
te_text.write('%s\n' % (item))
# Close text files
tr_text.close()
va_text.close()
te_text.close()
Like before, there was an observation of increasing validation accuracy as AlexNet is trained on the given dataset that was provided. AlexNet may or may not have already been trained on these images, but it would be interesting to see what comes out of it after splitting the files in relatively the same distribution as we did for the hot dogs vs dogs.
And check out those results! These images were randomly picked from the testing pool and evaluated. We can see that AlexNet had 6/9, or 2/3. There were six true positives and 3 false positives. That is incredibly good in terms of the return rate, which is to be expected from AlexNet! Furthermore, it's interesting that the first image in the first row was determined as pizza with half confidence. This is likely due to the red lining and the greenness of the image, along with the shape of the brain closely resembling a triangular slice of pizza. The last image in the final row is a silver dragonfly pendant, and the fossil that it refers to looks incredibly like it (plus, 30% confidence also indicates that the algorithm was also unclear). Overall, the algorithm did a phenomenal job with identifying the objects in the images.
For a final project, this was interesting! We were able to properly problem solve our way through understanding and using the repository that was provided to us. We were also able to effectively use git and GitHub as a means of collaboration and used Facebook in order to communicate when we made changes so that we could pull said changes down from GitHub. For the future, it would be nice to dive deeper into convlutional networks and in understanding the algorithm in-depth, and perhaps that can be done through an artifiical intelligence class. Nonetheless, it is quite impressive that AlexNet was able to analyze images the way that it did and with fairly impressive accuracy.


This happened about the second week of January 2003. I remember because it was that Friday after all of my mid term exams were done. anyways, I go to military school, their policy on drugs is you get caught using them, you're out. I've used dxm many times and got away with it, but this night was an extreme last warning.
I've used Benadryl many times in the past. taking about 25 pills. I call these 'pinkies', because they're small and have a pink-tic-tac look to them. My friend John and I went AWOL (Absent without leave) Friday night. We went to a drug store and bought some benadryl. He took 25 and so did I. We finally got back to school and back into barracks without getting caught. It started to kick in about 3:30 am, we left my room and went to the TV room. I noticed the hallucinations like before and was enjoying my trip. I noticed that my friend John said earlier 'My legs feel numb.' He stood up from the couch to my right and walked over to the couch on the left side of the room.
A few minutes later he says 'I need to piss' he stands up and his legs must've buckled. He fell and his head came crashing down onto the corner of the TV stand. I didn't notice he hit his head until he rolled over and started convulsing uncontrollably. He was gasping for air and looked like something out of a horror movie. Considering I was tripping, I remembered from my first aid class that when someone's having a seizure is to get something for them to bite on. To my luck there was nothing.  He finally stopped shaking and breathed really really hard. There was blood and foam all over his mouth. I was scared out of my mind. He didn't respond to me.  I couldn't concentrate because I was tripping myself. My adrenaline rush killed the high.
 I wanted to bring him up to the health center but I couldn't lift him up. He was all dead weight. I managed to lift him up onto the couch, getting blood all over my sweatshirt. He immediately leaned over and puked a little bit, but not enough to make a mess. I still couldn't make sensible decisions, leading myself not to wake anyone up to get help. I put his arm around my neck and started walking to his room. He was so out of it that if I let him go he'd fall over again. He couldn't put in his door code and I couldn't get his roommate to wake up.
My roommate was on a weekend leave. So I brought him to my room. Getting him on the top bunk was near impossible but I managed to get his heavy-dead weight body into the top bunk. I sat there and thoughts were racing through my mind. He layed there and was still breathing. So I decided to go to sleep. He started talking gibberish like I used to when I would trip. OK now I have an idea that he'll be ok. The next morning I wake up an hour past reveille. I immediately jump out of bed and look at the top bunk. John was still breathing and sleeping soundly.  What happened to my face?'
After all of that I go to sleep each night thanking god that John's still alive and that no one found out. John is still fine today, no noticeable side effects. Since then I'm cautious about doing benadryl or any other Diphenhydramine drug. Please Please Please, be careful if you're to do this drug in the future. I'm lucky that I'm still here today with John. This was the most traumatic thing I've ever experienced, and it's hard to let go. I'm not telling any of you not to do any drugs but this one you should avoid for your own safety.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


texinfo - software documentation system
Texinfo is a documentation system that uses a single source file to produce both
online information and printed output. It is primarily designed for writing
software manuals.
For a full description of the Texinfo language and associated
tools, please see the Texinfo manual (written in Texinfo itself). Most
likely, running this command from your shell:
info texinfo
or this key sequence from inside Emacs:
M-x info RET m texinfo RET
will get you there.
http://www.gnu.org/software/texinfo/
or any GNU mirror site.
Please send bug reports to<EMAIL_ADDRESS>general questions and discussion
to<EMAIL_ADDRESS>info(1), install-info(1), makeinfo(1), texi2dvi(1), texindex(1).
emacs(1), tex(1).
info(5).


Last Name: First Name:
Gender:Male Female
My favorite Web Tech topics are Basic HTML CSS Tables FORMS
What grade do you expect to receive? A B C
Please add any comments you have.
SUBMIT CLEAR


Average
Compare
Correlation
Precision
Please choose a name for the average centrality map
Send
Abort
Please select a correlation coefficient
Pearson
Spearman
Kendall
Abort
Please select the ground-truth from the table.
How many of the top nodes should be considered?
Calculate
Abort
Select All
Deselect All
Remove Selected
Name
Graph
Creation Method
Execution Time (ms)
R


Who we are
The Group of Companies specializes in the construction and fit out of large projects.
We are confident that we
can meet the needs of any customer to the highest quality.The Jasaf Group is part of FAMCORP whic is a
holding company founded in 1975 that operates internationally.
The Group is made up of three main Companies : Jasaf Building Technology Company LLC,Jasaf Joinery
and Jasaf Electromechanical Company (JEMCO) LLC.


I have been trying to stick to an Engine for a while now. And everytime, I fallback on creating a new one because I didn't like the Old one, after a certain point. This is the same. It started out while I was reading a book, and following his examples. Halfway through it, I did not like where it was going. So, I scrapped it, and started new. This time, with the knowledge of what I needed to implement first.
This Engine is supposed to be an Engine for an RTS Game. Now, how it would turn out, is to be seen. But so, far, I'm satisfied with the results
I've decided to take elaborate notes and document the entire process a week after I started this Engine. So, I do not have the very start of the process.
Terrain Loader
I realized I wanted to start with loading a terrain. Load a heightmap file and create a terrain based on that. This way, I can create my own terrain in tools like Photoshop or Gimp without leaving the map upto chance, which is a huge deal when it comes to game balance. Note that it does however means that we need to create every map in the game ourselves.
Actual development of the Terrain was easy, however the whiteboarding process took a while. Right now, every scene has a Terrain. It could be a nullptr, but it exists. This is to make sure that all Scenes conform to a specific set of Rules.


In addition to awesome software, Cannlytics is a free software support business. If you need assistance or desire a fully-managed solution, then you can find a support option suited to you →


|
Dear Nasser,
I'm dealing with the same problems. And it seems, that noone
really knows something about the java heap memory. I never
got a clear response on this topic.
I found a small workaround to free some heap memory.
heapTotalMemory = java.lang.Runtime.getRuntime.totalMemory;
heapFreeMemory = java.lang.Runtime.getRuntime.freeMemory;
if(heapFreeMemory < (heapTotalMemory*0.01))
java.lang.Runtime.getRuntime.gc;
end
I'm calling the java garbace collector if the free memory
drops below a certain limit.
Maybe this helps.
Keep me up to date if you get any news according to the java
heap memory.
Best regards,
Stefan.
"Nasser Abbasi"<EMAIL_ADDRESS>wrote in message
<EMAIL_ADDRESS>> 2007a, student version on windoz XP SP2.
>
> I use GUIDE, and after sometime of using it, I notice it
gets sluggish in
> its response to editing and I see the following Java
errors on the console:
>
> "Exception in thread "AWT-EventQueue-0"
java.lang.OutOfMemoryError: Java
> heap space"
>
> I am not sure why it runs out of RAM so fast. as I have 4
GB of physical
> RAM.
>
> I did a google on the above and I see that others have
seen this.
>
> I wonder if there is any update on this problem that
someone from Mathworks
> or others can comment on.
>
> Is this still a problem in later Matlab releases?
>
> thanks,
> Nasser
>
>
|


To install this style in Mendeley Desktop 1.7 or above:
You can also use Mendeley's own version of this CSL Editor at http://csl.mendeley.com, where Mendeley will host your style, install it directly to your computer and help you share the style with other CSL users.
Click the "Download Style" button above to download your style. Then:
Drag the style file onto any open Firefox window.
Go to "Preferences...", "Cite", "Styles", click the "+" button and select the style file.
See also the official Zotero documentation.
For installing your style in Papers, click the "Download Style" button above to download your style, and then see the official instructions for Papers 3 for Mac or Papers 3 for Windows.
Click the "Download Style" button above to download your style. Then copy your style file into Docear4Word's style folder. This folder is usually located at "C:\ProgramData\Docear4Word\Styles\".
If the folder "C:\ProgramData\" isn't visible, you need to configure Windows to show invisible files. To do so, open the Windows Explorer, press Alt, select "Tools" -> "Folder Options..." -> "View" -> "Hidden files and folders" and select "Show hidden files, folders, and drives".
See also the official Docear4Word documentation.
Click the "Download Style" button above to download your style. Then:


Fast track your plans for the web
Businesses have had to put up with slow, poorly designed WinForms applications for years. We here at Velocity believe that the modern web offers an elegant, platform-independent solution for internal applications.
Enterprise should not mean ugly
No one should be subjected to ugly, grey forms day after day. While re-engineering your internal tools Velocity will make strides to improve the visual workflow and aesthetics of your applications.
Changing your perception of what the web feels like
Using the lastest cutting edge web technologies Velocity can make your web applications come alive! Bluring the lines between web page and native application, we create web applications indistinguishable from a native application running on your device.


UBERFITNESS |
Log your workouts with UberFitnessThe fastest, easiest to use workout loggerLog In |
UberFitness is designed to replace your paper workout journal. UberFitness was developed by two brothers who were disappointed with the selection of overly complicated workout tracking apps, so our solution was a simple, yet visually pleasing, and user-friendly workout logger that is quick and fast to use.
Other workout apps ????. Here at UberFitness we beieve that a workout tracker should do what just what it says: TRACK! By being simple, we allow users to log quickly and easily, avoiding logging to get in the way of your workout.


Events
The Midway
Sala de Puerto Rico • Open 5pm–9pm Friday
Visit the Midway! Send exactly two players who love carnival food and games. Please plan to arrive anytime between 5pm and 6pm; if you really love the Midway, you’re welcome to stay as long as it’s open, or send other teammates back to play!
Character Breakfast
Lobdell • 9am/11am Saturday
Do you enjoy gluten, eggs, dairy and making a mess? Then you are invited to attend the Character Breakfast! Send exactly two players to your reserved seating. Safety note: please do not send players who have had a contagious illness in the last 3 days.
Build-a-Wand Workshop
Twenty Chimneys • 1pm Saturday
Come along for your chance to build your very own magic wand and bring it home with you! You’ll have many styles and resources to choose from, but finding a combination that’s worth it might be a challenge. Send exactly two players who are ready to haggle.
Robot Parade
Infinite Corridor and Lobby 7 • 4pm Saturday
A few lucky park guests will make robot costumes and march in this fun parade down the Infinite Corridor. Come cheer them on and enjoy their robot antics! The parade is best viewed from Lobby 7, but is visible from parts of the Infinite Corridor as well. Safety note: viewers should not sit or block public walkways, please stand along the walls only.
Fireworks Show
Outside, between 56 and 66 • 7pm Saturday
Please bring headphones/earbuds — our silent fireworks display goes great with pop music that you provide! And best of all, you don’t have to go outside if it’s too cold. You can also stand at windows in the halls connecting building 56 and 66 to view this nighttime spectacle! Attending every event in Penny Park is something special, so don’t miss out! Safety note: viewers should not sit or block public walkways, please stand along the walls only.
Pay It Forward
Before 9pm Saturday
Help Penny Park give back to the local community! On Friday or Saturday, anyone can participate in the Pay It Forward Scavenger Hunt. Check The Tech for your first clue.


Welcome to Piano Chords!
Instructions:
Click a key on the piano or press the corresponding key on the keyboard to hear a note.
To start learning about chords, select Chord Mode, a Chord Type, and play the root (starting) note to hear the chord and see note names.
(For Major Triad, click/press C to hear a C Major Triad)
If you are a beginner, I would start with Major Triad, Minor Triad, Diminished Triad, and Augmented Triad, before moving on to Seventh Chords.


---
layout: post
authors: ["Steven Koenig"]
title: "Workshop at University of Southern Denmark, Odense"
date: 2014-04-18
time: "20:00:00"
tags: ["Bootcamps"]
---
The workshop at University of
Southern Denmark, Odense was my first workshop for Software Carpentry, the
same is true for Luis as well. We had taught before, Luis more than me, but it
was still exciting for me to see how this workshop would go given that we never
taught together before. While I taught bash, regular
expressions and Git, Luis taught
Python, unit testing and SQL.
Initially, make was also on that list, but due to time constraints was kicked
out to make room for a second Git lecture.
Around 30 persons attended the course, mostly from SDU and
the Max-Planck
Odense Center (MaxO). All in all, the workshop was well-received
and the attendees as well as the instructors were highly
motivated. But there is still lots of room for improvement:
- The shell lecture was way too slow, so
that I could not do any of the demos. This was bad for a couple of reasons,
but mainly because people did not know about even the most basic things which
were needed for the Git part.
- The regular expressions lecture should also increase in speed. Also, we (=
SWC instructors) must be aware that Apple ships old BSD
versions of the commonly used command line tools. These lack
essential features, so that grep output cannot be colored on OS
X!
- Git just cannot be taught in 1.5 h to people without any prior knowledge of
version control, at least not in a comprehensible way. Git is so incredibly
powerful and the concepts behind it are so intricate that it is easy to
cognitively overload people. Therefore, I dropped the make lecture and did a
’Git Double Feature‘ instead. Also, I noticed
that I am suffering from expert's blind spot: when asked
about where one can see the files of different branches on the computer, I
realized that this feature of Git was so obvious to me that I did not explain
that at all.
- Probably the most interesting/realistic way to show Git is to have a new
repository created before the workshop. That repository already contains some
linear commits with simple scripts. People will clone it during the workshop
and do some work in a new branch. While they are doing that new commits are
added to the master branch, which people should fetch/pull and see the
effect.
- Showroom: Now and then we need to be able to show people
what great things they can do with tools we teach. This would serve two
purposes:
- People would see right away the usefulness of what we are teaching.
This should boost motivation.
- People have a moment to relax.
The workshop was held on a Thursday and Friday and it was obvious that people,
especially after lunch break on Friday, were mentally quite exhausted already.
At that time I noticed just how much information (as measured in the
’unit‘ mind map connections) we conveyed during the two days. And
that is what the ’showroom‘ is thought to be for.
Big thanks go to Owen Jones from SDU for organizing, things really worked out
great.
PS: Danish pastry is as good as its reputation.


CANDIDATE INFORMATION
PHONE NUMBER
NAME
EMAIL
QUALIFICATION
<- select qualification-->
MCA
MBA
ME
MPHIL
SKILLS
EXPERIENCE
YEAR OF PASS OUT
<- select passout year -- >
2016
2015
2014
2013
2012
2011
2010
2009
2008
2007
2006
2005
2004
ADDRESS
PINCODE
NUMBER OF REAL TIME PROJECTS
NUMBER OF ACADEMIC PROJECTS
Phone Number :
Name :
Email :
Qualification :
skills :
Experience :
Year of Passout :
Address :
Pincode :
Real time Project :
Acedemic Project :


X Factor contestant Ariel Burdett reportedly dies aged 38
by Buzz ContributorX Factor contestant Ariel Burdett has passed away at the age of 38, according to reports.
The Daily Star report Ariel died earlier this month but a cause of death is yet to be revealed.
The singer was most famous for her audition on the 2008 series of X Factor, which saw Alexandra Burke win the series.
Former holistic vocal coach Ariel, originally called Amy Burdett, became famous during her audition as she performed a song which showed off her vocal range.
Starting off her audition by throwing her label on the floor and telling the judges she was "a human being , not a number."
The singer also told Cheryl she was "stupid" after being given four nos.
Tributes have been pouring in for the singer, who changed her name to Arabella Starchild after her infamous audition.
One wrote: "Ariel Burdett is gone. What a loss."
Another added: "Ariel Burdett is dead omg. Despite not getting through and whatnot, she was talked about more than most contestants and will forever be an x factor legend! RIP!"
A third chipped in: "I can't believe that she died... rest in peace, Ariel Burdett."
A fourth wrote: "OMG Ariel Burdett the holistic vocal coach has passed away."


--- layout: documentation title: EmailReceivedLineListType ---
The EmailReceivedLineListType captures a list of 'Received' lines in an email message header.
| Field Name | Type | Description |
|---|---|---|
| Received1..n | EmailReceivedLineType |
The Received field captures a single Received line in the list. |


Author : Melanie Rhianna Lewis
Input Type : TrianaPixelMap
Output Type : TrianaPixelMap
Date :
This makes a TrianaPixelMap more 'fuzzy'. It actually uses a general convolution to generate the result. See Convolve for details about general convolutions.


 The following pages are a useful first step to get on
your way writing programs with Python!
The Python Packing Index (PyPl) hosts thousands of third-party modules
for Python. Both Python's standard library and the community- contributed modules allow for endless
possibilities.


--- layout: pages options: full class: fill-light title: Mapbox GL JS Roadmap ---
The GL JS team is focused on making our priorities transparent and reliable. Below is a list of which major projects and features are currently in active development, upcoming, or we are thinking about long-term. Each item includes links to the relevant issues and pull requests on GitHub.
This roadmap is updated weekly on Tuesdays. The roadmap does not include bug fixes, and features that take less than a day to develop. Due to the pace at which GL JS is being developed, we are unable to confidently estimate which release version a feature will ship with.
#{{i}}
{% endfor %}{% endif %}
{% if item.project %}
project#{{item.project}}
{% endif %}


The final chapter of the book outlines my general observations about the nature of technological change, its impact on financial markets and the roots of speculative mania. I use a simple model to formalise the interaction between a new technology and the markets, and assess the Internet bubble and what has happened since against that framework. I conclude with some further thoughts about the short-, medium- and longer-term impact of recent developments.
I was fortunate in my early career in investment management to be able to spend time with Sir John Templeton, one of the greatest professional investors of the 20th century. A consistent theme from Sir John was that the study of past financial history can be a rich source of inspiration and guidance for investors. A historical perspective always underpinned his own impressive achievements as an investor. One of his famous quotes was that, “The four most expensive words in the English language are ‘This time it’s different’ ”. By definition, this means understanding what has gone before.
As Mark Twain said, history does not repeat itself exactly, but it rhymes. This book is an attempt to capture some of the lines that many investors have had to relearn for themselves over the years. It is fair to say that professional investors are often just as blameworthy as private investors for their failings during times of speculative mania. It is never too late to relearn the important lessons of the past.
dr sandy nairn
Investment Partner, CEO, Edinburgh Partners
Chairman, Templeton Global Equity Group
April 2018


[forumTopics forumNewPosts] topicPage = "forum/topic" listType = "new_posts" [forumTopics forumNewTopics] topicPage = "forum/topic" listType = "new_topics" ==


Apple Spinach
Homemade ice cream is a big production. You need to remember to freeze your ice cream maker, make a custard base, chill your custard base, churn the ice cream, then chill the ice cream (unless you're looking for soft serve consistency). Is it worth it? Yes, yes, yes, one thousand times. Every time we take a bite of ice cream made from scratch, we realize we' ve NEVER had anything as good come from a store-bought pint. Seriously. Homemade ice cream is a big production. You need to remember to freeze your ice cream maker, make a custard base, chill your custard base, churn the ice cream, then chill the ice cream (unless you're looking for soft serve consistency). Is it worth it? Yes, yes, yes, one thousand times. Every time we take a bite of ice cream made from scratch, we realize we' ve NEVER had anything as good come from a store-bought pint. Seriously. Homemade ice cream is a big production. You need to remember to freeze your ice cream maker, make a custard base, chill your custard base, churn the ice cream, then chill the ice cream (unless you're looking for soft serve consistency). Is it worth it? Yes, yes, yes, one thousand times. Every time we take a bite of ice cream made from scratch, we realize we' ve NEVER had anything as good come from a store-bought pint. Seriously. Homemade ice cream is a big production. You need to remember to freeze your ice cream maker, make a custard base, chill your custard base, churn the ice cream, then chill the ice cream (unless you're looking for soft serve consistency). Is it worth it? Yes, yes, yes, one thousand times. Every time we take a bite of ice cream made from scratch, we realize we' ve NEVER had anything as good come from a store-bought pint. Seriously.


|
Cell in column 1, row 1 |
Cell in column 2, row 1 |
|
Cell in column 1, row 2 |
Cell in column 2, row 2 |
|
Cell in column 1, row 1 |
Cell in column 2, row 1 |
|
Cell in column 1, row 1 |
Cell in column 2, row 1 |
|
Cell in column 1, row 1 |
Cell in column 2, row 1 |
|
Cell in column 1, row 1 |
Cell in column 2, row 1 |
|
Cell in column 1, row 1 |
Cell in column 2, row 1 |
|
Cell in column 1, row 1 |
Cell in column 2, row 1 |
|
Cell in column 1, row 1 |
Cell in column 2, row 1 |
| Name of Column 1 | Name of Column 2 |
|---|---|
|
Cell in column 1, row 1 |
Cell in column 2, row 1 |
|
Cell in column 1, row 2 |
Cell in column 2, row 2 |
|
Footer in column 1, row 3 |
Footer in column 2, row 3 |
|
Cell in column 1, row 1 |
Cell in column 2, row 1 |
|
Cell in column 1, row 2 |
Cell in column 2, row 2 |
|
Cell in column 1, row 1 |
Cell in column 2, row 1 |
Cell in column 3, row 1 |
|
Cell in column 1, row 1 |
Cell in column 2, row 1 |
Cell in column 3, row 1 |
|
Cell in column 1, row 1 |
Cell in column 2, row 1 |
Cell in column 3, row 1 |
|
|
Emphasized text |
Styled like a header |
Literal block |
|
Strong text |
Verse block
|
|---|
|
Single paragraph on row 1 |
|
First paragraph on row 2 Second paragraph on row 2 |
|
Cell in column 1, row 1 |
Cell in column 2, row 1 |
Cell in column 3, row 1 |
|
Content in a single cell that spans columns 1 and 3 |
Cell in column 3, row 1 |
|
Cell in column 1, row 1 |
Cell in column 2, row 1 |
Cell in column 3, row 1 |
|
Content in a single cell that spans rows 2 and 3 |
Cell in column 2, row 2 |
Cell in column 3, row 2 |
|
Cell in column 2, row 3 |
Cell in column 3, row 3 |
|
Prefix the {vbar} with {caret} to center content horizontally |
Prefix the {vbar} with < to align the content to the left horizontally |
Prefix the {vbar} with > to align the content to the right horizontally |
|
Prefix the {vbar} with a . and {caret} to center the content in the cell vertically |
Prefix the {vbar} with a . and < to align the content to the top of the cell |
Prefix the {vbar} with a . and > to align the content to the bottom of the cell |
|
This content spans three columns (3{plus}) and is centered horizontally ({caret}) and vertically (.{caret}) within the cell. |
|
|
|
|
This cell spans 3 rows. The content is centered horizontally, aligned to the bottom of the cell, and strong. |
This content is emphasized. |
This content is aligned to the top of the cell and literal. |
|
|
This cell contains a verse
that may one day expound on the
wonders of tables in an
epic sonnet.
|


sm
::
eod
::
io
::
ZLibDecoder
ZLibDecoder Class Reference
Inherits
ZLibCodec< sm::eod::io::SerializableCompressorDecoder >
.
List of all members.
Detailed Description
Definition at line
14
of file
zlibdecoder.h
.
Public Member Functions
void
decode
(const uint8 *data, std::size_t size)
DecoderData
getNextWithStatus
(
DeserializationStatusFlags
&status)
Generated on Fri Apr 1 15:36:51 2011 for Seeing Machines CoreData API by
1.5.0


High-Low Game
Start Game!
(click "Start Game!" button to restart)
Guess a whole number between 1 and 100 , then guess if your number is higher or lower than the dealer's number:
<
(If you try to put anything higher, the field will reset. Trust me...Thanos can't even do it)
High
Low


Liquidity: ETH Available: ETH Price: USD
Structured Ether is a new kind of financial product encpausalted in a Smart ContractOwnerless executable code on top of the Ethereum blockchain.. It allows you to buy and sellSell is always possible. Buy is subject to availability of deposited ethers. Ether according to the current fair global market priceAggregated market price from Coin Market Cap.. Furthermore you can stake your ethers, locking in their priceIf you stake 2 Ethers at a price of 1000USD per ether, you can later obtain them back always at this fixed price. and recieving a loan of Structured Ethers equal to the price of the amount staked. This way, you can either hedge agains Ether's price dorppingYou stake 1 ether at 1000 USD. If the price goes up, you redeem the stake. If the price goes down you purchase discounted Ethers with the loan money. or you can obtain up to 20x leverage on your EthersYou stake 1 ether and get a loan. With the loan you purchase more ether and stake it as well... and so on. , if you are very bullish on the price.
Liquidity: ETH Available: ETH Price: USD


{{>_header}}
Give your collection a short, descriptive title.
Describe what your collection contains.
This uses GitHub Flavoured Markdown for formatting. Use the preview tab to see how it looks.


Not all animals are wild. Some can be domesticated and be petted. Dogs, cats, bunnies, birds, iguanas, and many other more animals out there can be taught and befriended.
The Pet Stop have a variety of pets that will relieve you from stress. You can feed them and you can also play with them. Talk to them as much as you want. Sometimes animals are better listeners than humans.
Teach yourself to respect animals. Learn to appreciate them. Its not just dogs who can be man's bestfriend. There are many more out there. Love them and they will surely make you feel that you are loved.
The Pet Stop is open from Mondays to Saturdays. 8:00am until 5:00pm
Avoid bringing chocolates, avocado, alcoholic drinks, raisins, raw meat, energy drinks and dairy products. These foods are said to be unhealthy or toxic for pets. Thank you! Have a good day!


UTSL
`Prev `__
U
`Next `__
--------------
**UTSL**: //, n.
[Unix] On-line acronym for ‘Use the Source, Luke’ (a pun on Obi-Wan
Kenobi's “Use the Force, Luke!” in *Star Wars*) — analogous to
`*RTFS* <../R/RTFS.html>`__ (sense 1), but more polite. This is a common
way of suggesting that someone would be better off reading the source
code that supports whatever feature is causing confusion, rather than
making yet another futile pass through the manuals, or broadcasting
questions on Usenet that haven't attracted
`*wizard* <../W/wizard.html>`__\ s to answer them.
Once upon a time in `*elder days* <../E/elder-days.html>`__, everyone
running Unix had source. After 1978, AT&T's policy tightened up, so this
objurgation was in theory appropriately directed only at associates of
some outfit with a Unix source license. In practice, bootlegs of Unix
source code (made precisely for reference purposes) were so ubiquitous
that one could utter it at almost anyone on the network without concern.
Nowadays, free Unix clones have become widely enough distributed that
anyone can read source legally. The most widely distributed is certainly
Linux, with variants of the NET/2 and 4.4BSD distributions running
second. Cheap commercial Unixes with source such as BSD/OS are
accelerating this trend.
--------------
+--------------------------------+----------------------------+-------------------------+
| `Prev `__ | `Up <../U.html>`__ | `Next `__ |
+--------------------------------+----------------------------+-------------------------+
| Utah teapot, the | `Home <../index.html>`__ | UUOC |
+--------------------------------+----------------------------+-------------------------+


After starting to get my hands on learning javascript development, I decided to start this blog to track my learning progress. On a whim I registered a trendy .io
domain and set up Ghost with DigitalOcean. The setup was fairly painless and the blog engine was up and running in a minute.
However, I encountered some slight set-back when I tried to connect my custom domain. I edited the config.js
in Ghost with my domain url as directed, yet as I refreshed the page countless times the change still didn't take place. All my page links were still the default Ghost domain.
Turns out, the issue was that I needed to restart Ghost on the server. Lesson learned for next time.
I still have some customization to do, perhaps add a few such as extensions such as analytics. More to come.
Cover Image: Stacja Metra Dworzec Wileński, Warsaw, Poland


This field cannot be longer than 250 characters.
This field cannot be longer than 250 characters.
This field cannot be longer than 250 characters.
This field cannot be longer than 250 characters.
This field cannot be longer than 250 characters.
This field cannot be longer than 1250 characters.


|
Contiki 2.5
|
Representation of a uIP TCP connection. More...
#include </cygdrive/e/share/contiki/core/net/uip.h>
Data Fields | |
| uip_ipaddr_t | ripaddr |
| The IP address of the remote host. | |
| u16_t | lport |
| The local TCP port, in network byte order. | |
| u16_t | rport |
| The local remote TCP port, in network byte order. | |
| u8_t | rcv_nxt [4] |
| The sequence number that we expect to receive next. | |
| u8_t | snd_nxt [4] |
| The sequence number that was last sent by us. | |
| u16_t | len |
| Length of the data that was previously sent. | |
| u16_t | mss |
| Current maximum segment size for the connection. | |
| u16_t | initialmss |
| Initial maximum segment size for the connection. | |
| u8_t | sa |
| Retransmission time-out calculation state variable. | |
| u8_t | sv |
| Retransmission time-out calculation state variable. | |
| u8_t | rto |
| Retransmission time-out. | |
| u8_t | tcpstateflags |
| TCP state and flags. | |
| u8_t | timer |
| The retransmission timer. | |
| u8_t | nrtx |
| The number of retransmissions for the last segment sent. | |
| uip_tcp_appstate_t | appstate |
| The application state. |
Representation of a uIP TCP connection.
The uip_conn structure is used for identifying a connection. All but one field in the structure are to be considered read-only by an application. The only exception is the appstate field whose purpose is to let the application store application-specific state (e.g., file pointers) for the connection. The type of this field is configured in the "uipopt.h" header file.
Initial maximum segment size for the connection.
Definition at line 1305 of file uip.h.
Referenced by uip_process().
Length of the data that was previously sent.
Definition at line 1302 of file uip.h.
Referenced by uip_process().
The local TCP port, in network byte order.
Definition at line 1294 of file uip.h.
Referenced by uip_process().
Current maximum segment size for the connection.
Definition at line 1303 of file uip.h.
Referenced by uip_process().
The number of retransmissions for the last segment sent.
Definition at line 1314 of file uip.h.
Referenced by uip_process().
The sequence number that we expect to receive next.
Definition at line 1298 of file uip.h.
Referenced by uip_process().
The IP address of the remote host.
Definition at line 1292 of file uip.h.
Referenced by uip_process().
The local remote TCP port, in network byte order.
Definition at line 1295 of file uip.h.
Referenced by uip_process().
Retransmission time-out calculation state variable.
Definition at line 1307 of file uip.h.
Referenced by uip_process().
The sequence number that was last sent by us.
Definition at line 1300 of file uip.h.
Referenced by uip_process().
Retransmission time-out calculation state variable.
Definition at line 1309 of file uip.h.
Referenced by uip_process().
TCP state and flags.
Definition at line 1312 of file uip.h.
Referenced by uip_init(), and uip_process().


Driver name: {{ driver.driver_name }}
{% for route_segment in route_segments %}
{% if route_segment.driver == driver %}
{% include "RouteFinder/ExamineSegment.html" with route_segments=route_segment order1=forloop.parentloop.counter0 order2=forloop.counter0 %}
{% endif %}
{% endfor %}


Node's assert.deepEqual() algorithm
as a standalone module.
This module is around 5 times faster
than wrapping assert.deepEqual()
in a try/catch
.
var equal = require('deep-equal');
console.dir([
equal(
{ a : [ 2, 3 ], b : [ 4 ] },
{ a : [ 2, 3 ], b : [ 4 ] }
),
equal(
{ x : 5, y : [6] },
{ x : 5, y : 6 }
)
]);
var deepEqual = require('deep-equal')
Compare objects a
and b
, returning whether they are equal according to a
recursive equality algorithm.
If opts.strict
is true
, use strict equality (===
) to compare leaf nodes.
The default is to use coercive equality (==
) because that's how
assert.deepEqual()
works by default.
With npm do:
npm install deep-equal
With npm do:
npm test
MIT. Derived largely from node's assert module.


My name is Virginia Ndungu.
I am a Full Stack Developer, with a
customer-focussed approach to work
and strong drive to continually
increase and improve my technical skills.
I am fascinated by technology innovations,
product development and creating solutions
for communities and organizations.
“The more i learn, the more i realise
how much i don't know...”