| Modifier and Type | Method and Description |
|---|---|
static <T extends DifferentialFunction> |
RPUtils.getOp(String name,
INDArray x,
INDArray y,
INDArray result) |
| Modifier and Type | Method and Description |
|---|---|
static <T extends DifferentialFunction> |
RPUtils.getOp(String name,
INDArray x,
INDArray y,
INDArray result) |
| Modifier and Type | Method and Description |
|---|---|
DifferentialFunction |
DifferentialFunction.dup()
Duplicate this function
|
| Modifier and Type | Method and Description |
|---|---|
DifferentialFunction |
SameDiff.getOpById(@NonNull String id)
Get the function by the
DifferentialFunction#getOwnName() |
DifferentialFunction |
SameDiff.getVariableOutputOp(String variableName)
Get the differential function (if any) that this variable is the output for
|
DifferentialFunction[] |
SameDiff.ops()
Get an array of differential functions that have been defined for this SameDiff instance
|
| Modifier and Type | Method and Description |
|---|---|
void |
SameDiff.addArgsFor(SDVariable[] variables,
DifferentialFunction function)
Adds incoming arguments for the specified differential function to the graph
|
void |
SameDiff.addArgsFor(String[] variables,
DifferentialFunction function)
Adds incoming arguments for the specified differential function to the graph
|
void |
SameDiff.addOutgoingFor(SDVariable[] variables,
DifferentialFunction function)
Adds outgoing arguments to the graph for the specified DifferentialFunction
Also checks for input arguments and updates the graph adding an appropriate edge when the full graph is declared.
|
void |
SameDiff.addOutgoingFor(String[] varNames,
DifferentialFunction function)
Adds outgoing arguments to the graph for the specified DifferentialFunction
Also checks for input arguments and updates the graph adding an appropriate edge when the full graph is declared.
|
SDVariable[] |
SameDiff.generateOutputVariableForOp(DifferentialFunction function)
Generate the variables based on the given input op
and return the output variable names.
|
SDVariable[] |
SameDiff.generateOutputVariableForOp(DifferentialFunction function,
String baseName,
boolean isImport)
Generate the variables based on the given input op and return the output variable names.
|
String[] |
SameDiff.getInputsForOp(@NonNull DifferentialFunction function)
Returns the name(s) of the inputs for the given function
|
SDVariable[] |
SameDiff.getInputVariablesForOp(DifferentialFunction function)
Get the input variable(s) for the specified differential function
|
String[] |
SameDiff.getOutputsForOp(DifferentialFunction function)
Returns the name(s) of the outputs for the given function
|
SDVariable[] |
SameDiff.getOutputVariablesForOp(DifferentialFunction function)
Get the output variable(s) for the specified differential function
|
boolean |
SameDiff.hasArgs(DifferentialFunction function)
Returns true if this function already has defined arguments
|
void |
SameDiff.putOpForId(String id,
DifferentialFunction function)
Put the function for the given id
|
void |
SameDiff.removeArgFromOp(String varName,
DifferentialFunction function)
Remove an argument for a function.
|
void |
SameDiff.replaceArgFor(int i,
@NonNull SDVariable newArg,
@NonNull DifferentialFunction function)
Replaces the argument at i with newArg for function
Does not use (or remove) ArgumentInterceptor stuff
|
| Modifier and Type | Field and Description |
|---|---|
protected DifferentialFunction |
SameDiffOp.op |
| Modifier and Type | Method and Description |
|---|---|
INDArray[] |
InferenceSession.doExec(DifferentialFunction op,
OpContext opContext,
FrameIter outputFrameIter,
Set<AbstractSession.VarId> opInputs,
Set<AbstractSession.VarId> allIterInputs,
Set<String> constAndPhInputs) |
INDArray[] |
InferenceSession.getOutputsHelperTensorArrayOps(DifferentialFunction op,
FrameIter outputFrameIter,
Set<AbstractSession.VarId> opInputs,
Set<AbstractSession.VarId> allIterInputs)
Forward pass for TensorArray ops
|
| Modifier and Type | Method and Description |
|---|---|
static DifferentialFunction |
FlatBuffersMapper.cloneViaSerialize(SameDiff sd,
DifferentialFunction df) |
static DifferentialFunction |
FlatBuffersMapper.cloneViaSerialize(SameDiff sd,
DifferentialFunction df,
Map<String,Integer> nameToIdxMap) |
static DifferentialFunction |
FlatBuffersMapper.fromFlatNode(FlatNode fn) |
| Modifier and Type | Method and Description |
|---|---|
static int |
FlatBuffersMapper.asFlatNode(@NonNull SameDiff sameDiff,
@NonNull DifferentialFunction node,
@NonNull com.google.flatbuffers.FlatBufferBuilder bufferBuilder,
List<SDVariable> variables,
Map<String,Integer> reverseMap,
Map<String,Integer> forwardMap,
Map<String,Integer> framesMap,
AtomicInteger idCounter,
Integer id) |
static DifferentialFunction |
FlatBuffersMapper.cloneViaSerialize(SameDiff sd,
DifferentialFunction df) |
static DifferentialFunction |
FlatBuffersMapper.cloneViaSerialize(SameDiff sd,
DifferentialFunction df,
Map<String,Integer> nameToIdxMap) |
| Modifier and Type | Field and Description |
|---|---|
protected DifferentialFunction |
SubGraph.rootNode |
| Modifier and Type | Field and Description |
|---|---|
protected List<DifferentialFunction> |
SubGraph.childNodes |
| Modifier and Type | Method and Description |
|---|---|
List<DifferentialFunction> |
SubGraph.allFunctionsInSubgraph() |
| Modifier and Type | Method and Description |
|---|---|
SubGraph |
SubGraphPredicate.getSubGraph(SameDiff sd,
DifferentialFunction rootFn)
Get the SubGraph that matches the predicate
|
boolean |
SubGraph.inSubgraph(DifferentialFunction df) |
abstract boolean |
OpPredicate.matches(SameDiff sameDiff,
DifferentialFunction function) |
boolean |
SubGraphPredicate.matches(SameDiff sameDiff,
DifferentialFunction rootFn)
Determine if the subgraph, starting with the root function, matches the predicate
|
| Modifier and Type | Method and Description |
|---|---|
static void |
SameDiffUtils.validateDifferentialFunctionSameDiff(SameDiff sameDiff,
SDVariable function,
DifferentialFunction op) |
| Modifier and Type | Method and Description |
|---|---|
DifferentialFunction |
DifferentialFunctionClassHolder.getInstance(String name) |
DifferentialFunction |
DifferentialFunctionClassHolder.getOpWithOnnxName(String onnxName) |
DifferentialFunction |
DifferentialFunctionClassHolder.getOpWithTensorflowName(String tensorflowName)
Get the
|
| Modifier and Type | Method and Description |
|---|---|
static Map<String,DifferentialFunction> |
ImportClassMapping.getOnnxOpMappingFunctions() |
static Map<String,DifferentialFunction> |
ImportClassMapping.getOpNameMapping() |
Map<String,DifferentialFunction> |
DifferentialFunctionClassHolder.getTensorFlowNames() |
static Map<String,DifferentialFunction> |
ImportClassMapping.getTFOpMappingFunctions() |
| Modifier and Type | Method and Description |
|---|---|
Map<String,Field> |
DifferentialFunctionClassHolder.getFieldsForFunction(DifferentialFunction function)
Get the fields for a given
DifferentialFunction |
| Modifier and Type | Method and Description |
|---|---|
void |
AttributeAdapter.mapAttributeFor(Object inputAttributeValue,
Field fieldFor,
DifferentialFunction on)
Map the attribute using the specified field
on the specified function on
adapting the given input type to
the type of the field for the specified function.
|
| Modifier and Type | Method and Description |
|---|---|
void |
BooleanAdapter.mapAttributeFor(Object inputAttributeValue,
Field fieldFor,
DifferentialFunction on) |
void |
ConditionalFieldValueIntIndexArrayAdapter.mapAttributeFor(Object inputAttributeValue,
Field fieldFor,
DifferentialFunction on) |
void |
ConditionalFieldValueNDArrayShapeAdapter.mapAttributeFor(Object inputAttributeValue,
Field fieldFor,
DifferentialFunction on) |
void |
DataTypeAdapter.mapAttributeFor(Object inputAttributeValue,
Field fieldFor,
DifferentialFunction on) |
void |
IntArrayIntIndexAdpater.mapAttributeFor(Object inputAttributeValue,
Field fieldFor,
DifferentialFunction on) |
void |
NDArrayShapeAdapter.mapAttributeFor(Object inputAttributeValue,
Field fieldFor,
DifferentialFunction on) |
void |
SizeThresholdIntArrayIntIndexAdpater.mapAttributeFor(Object inputAttributeValue,
Field fieldFor,
DifferentialFunction on) |
void |
StringEqualsAdapter.mapAttributeFor(Object inputAttributeValue,
Field fieldFor,
DifferentialFunction on) |
void |
StringNotEqualsAdapter.mapAttributeFor(Object inputAttributeValue,
Field fieldFor,
DifferentialFunction on) |
| Modifier and Type | Method and Description |
|---|---|
static void |
TFGraphMapper.initFunctionFromProperties(String mappedTfName,
DifferentialFunction on,
Map<String,AttrValue> attributesForNode,
NodeDef node,
GraphDef graph)
Deprecated.
To be removed
|
| Modifier and Type | Class and Description |
|---|---|
class |
BaseBroadcastBoolOp |
class |
BaseBroadcastOp |
class |
BaseIndexAccumulation
Index based reduction algo
|
class |
BaseOp
Base op.
|
class |
BaseReduceBoolOp |
class |
BaseReduceFloatOp |
class |
BaseReduceLongOp |
class |
BaseReduceOp
Base class for accumulation, initiates the initial entry
with respect to the child class.
|
class |
BaseReduceSameOp |
class |
BaseScalarBoolOp
Base scalar boolean operation
|
class |
BaseScalarOp
Base scalar operation
|
class |
BaseTransformAnyOp |
class |
BaseTransformBoolOp |
class |
BaseTransformFloatOp |
class |
BaseTransformOp
A base op for basic getters and setters
|
class |
BaseTransformSameOp |
class |
BaseTransformStrictOp |
class |
DynamicCustomOp
Basic implementation for CustomOp
|
class |
NoOp |
| Modifier and Type | Class and Description |
|---|---|
class |
CompatSparseToDense
This is a wrapper for SparseToDense op that impelements corresponding TF operation
|
class |
CompatStringSplit
This is a wrapper for StringSplit op that impelements corresponding TF operation
|
| Modifier and Type | Class and Description |
|---|---|
class |
DecodeBitmap
Bitmap decoding op wrapper.
|
class |
DecodeThreshold
Sparse threshold decoding op wrapper.
|
class |
EncodeBitmap
Bitmap encoding op wrapper.
|
class |
EncodeThreshold
Sparse threshold encoding op wrapper.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AdjustContrast |
class |
AdjustContrastV2 |
class |
AdjustHue |
class |
AdjustSaturation |
class |
BarnesEdgeForces |
class |
BarnesHutGains
This op calculates gains - data used internally by Barnes-Hut-TSNE algorithm.
|
class |
BarnesHutSymmetrize |
class |
BaseAdjustContrast |
class |
BetaInc |
class |
BitCast |
class |
CompareAndBitpack |
class |
Digamma |
class |
DivideNoNan |
class |
DrawBoundingBoxes |
class |
FakeQuantWithMinMaxVarsPerChannel |
class |
Flatten
This op takes arbitrary number of arrays as input, and returns single "flattened" vector
|
class |
FusedBatchNorm |
class |
HsvToRgb |
class |
Igamma |
class |
Igammac |
class |
KnnMinDistance |
class |
Lgamma |
class |
LinearSolve |
class |
Logdet |
class |
Lstsq |
class |
Lu |
class |
MatrixBandPart |
class |
Polygamma |
class |
RandomCrop |
class |
RgbToGrayscale |
class |
RgbToHsv |
class |
RgbToYiq |
class |
RgbToYuv |
class |
Roll |
class |
SpTreeCell |
class |
ToggleBits |
class |
Tri |
class |
TriangularSolve |
class |
Triu |
class |
TriuBp |
class |
YiqToRgb |
class |
YuvToRgb |
| Modifier and Type | Class and Description |
|---|---|
class |
BiasAdd
Bias addition gradient operation.
|
class |
BiasAddGrad |
class |
BroadcastAddOp |
class |
BroadcastAMax
Broadcast Abs Max comparison op
|
class |
BroadcastAMin
Broadcast Abs Min comparison op
|
class |
BroadcastCopyOp |
class |
BroadcastDivOp |
class |
BroadcastGradientArgs |
class |
BroadcastMax
Broadcast Max comparison op
|
class |
BroadcastMin
Broadcast Min comparison op
|
class |
BroadcastMulOp |
class |
BroadcastRDivOp
Broadcast reverse divide
|
class |
BroadcastRSubOp |
class |
BroadcastSubOp |
class |
BroadcastTo
BroadcastTo op: given 2 input arrays, content X and shape Y, broadcast X to the shape specified by the content of Y.
|
| Modifier and Type | Class and Description |
|---|---|
class |
BroadcastEqualTo |
class |
BroadcastGreaterThan |
class |
BroadcastGreaterThanOrEqual |
class |
BroadcastLessThan |
class |
BroadcastLessThanOrEqual |
class |
BroadcastNotEqual |
| Modifier and Type | Class and Description |
|---|---|
class |
Select |
class |
Where |
class |
WhereNumpy |
| Modifier and Type | Class and Description |
|---|---|
class |
BaseCompatOp |
class |
Enter |
class |
Exit |
class |
LoopCond |
class |
Merge |
class |
NextIteration |
class |
StopGradient |
class |
Switch
Switch op forwards input to one of two outputs based on the value of a predicate
|
| Modifier and Type | Class and Description |
|---|---|
class |
BaseGridOp |
class |
FreeGridOp
Simple GridOp that operates on arbitrary number of Ops, that have no relations between them.
|
| Modifier and Type | Class and Description |
|---|---|
class |
CropAndResize
CropAndResize Op
|
class |
ExtractImagePatches
Extract image patches op - a sliding window operation over 4d activations that puts the
output images patches into the depth dimension
|
class |
ImageResize |
class |
NonMaxSuppression
Non max suppression
|
class |
NonMaxSuppressionV3
Non max suppression
|
class |
ResizeArea |
class |
ResizeBicubic
ResizeBicubic op wrapper
|
class |
ResizeBilinear
ResizeBilinear op wrapper
|
class |
ResizeNearestNeighbor
ResizeNearestNeighbor op wrapper
|
| Modifier and Type | Class and Description |
|---|---|
class |
FirstIndex
Calculate the index
of max value over a vector
|
class |
IAMax
Calculate the index of the max absolute value over a vector
|
class |
IAMin
Calculate the index of the max absolute value over a vector
|
class |
IMax
Calculate the index
of max value over a vector
|
class |
IMin
Calculate the index of min value over a vector
|
class |
LastIndex
Calculate the index
of max value over a vector
|
| Modifier and Type | Class and Description |
|---|---|
class |
ArgMax |
class |
ArgMin
ArgMin function
|
| Modifier and Type | Class and Description |
|---|---|
class |
ExternalErrorsFunction |
| Modifier and Type | Class and Description |
|---|---|
class |
AvgPooling2D
Average Pooling2D operation
|
class |
AvgPooling3D
Average Pooling3D operation
|
class |
BatchNorm
BatchNorm operation
|
class |
BatchNormDerivative
BatchNormDerivative operation
|
class |
Col2Im
Col2Im operation.
|
class |
Conv1D
Conv2D operation
|
class |
Conv1DDerivative
Conv1D Backprop operation
|
class |
Conv2D
Conv2D operation
|
class |
Conv2DDerivative
Conv2DDerivative operation
|
class |
Conv3D
Conv3D operation
|
class |
Conv3DDerivative
Conv3DDerivative operation
|
class |
DeConv2D
DeConv2D operation
|
class |
DeConv2DDerivative
DeConv2DDerivative operation
|
class |
DeConv2DTF
DeConv2D operation, TF-wrapper
|
class |
DeConv3D
DeConv3D operation
|
class |
DeConv3DDerivative
DeConv3DDerivative operation
|
class |
DeConv3DTF
DeConv3D operation, TF-wrapper
|
class |
DepthToSpace
Inverse operation to SpaceToDepth.
|
class |
DepthwiseConv2D
Depthwise Conv2D operation
|
class |
DepthwiseConv2DBp
Backpropagation for Depthwise Conv2D operation
|
class |
Im2col
Im2col operation
|
class |
Im2colBp
Im2col operation
|
class |
LocalResponseNormalization
LocalResponseNormalization operation
|
class |
LocalResponseNormalizationDerivative
LocalResponseNormalizationDerivative operation
|
class |
MaxPooling2D
Max Pooling2D operation
|
class |
MaxPooling3D
Max Pooling3D operation
|
class |
MaxPoolWithArgmax |
class |
Pooling2D
Pooling2D operation
|
class |
Pooling2DDerivative
Pooling2DDerivative operation
|
class |
Pooling3D
Pooling3D operation
|
class |
Pooling3DDerivative
Pooling3DDerivative operation
|
class |
SConv2D
Separable convolution 2D operation
|
class |
SConv2DDerivative
SConv2DDerivative operation
|
class |
SpaceToDepth
This operation takes 4D array in, in either NCHW or NHWC format, and moves data from spatial dimensions (HW)
to channels (C) for given blockSize
Example:
blockSize = 4
dataFormat = "NCHW"
input shape = [128, 16, 16, 3]
output shape = [128, 16/4, 16/4, 3*4*4]
|
class |
Upsampling2d
Upsampling operation
|
class |
Upsampling2dDerivative
UpsamplingDerivative operation
|
class |
Upsampling3d
Upsampling3d operation
|
class |
Upsampling3dBp |
| Modifier and Type | Class and Description |
|---|---|
class |
GRU |
class |
GRUBp |
class |
GRUCell
GRU cell for RNNs
|
class |
LSTMBlock
LSTM layer implemented as a single operation.
|
class |
LSTMBlockCell
LSTM Block cell - represents forward pass for a single time step of an LSTM RNN.
|
class |
LSTMCell
LSTM cell
|
class |
LSTMLayer
LSTM layer implemented as a single operation.
|
class |
LSTMLayerBp
LSTM layer backpropagation
|
class |
SRU
Simple recurrent unit
|
class |
SRUCell
A simple recurrent unit cell.
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbsoluteDifferenceLoss
Absolute difference loss
|
class |
BaseLoss |
class |
CosineDistanceLoss
Cosine distance loss
|
class |
HingeLoss
Hinge loss
|
class |
HuberLoss
Huber loss
|
class |
L2Loss
L2 loss op wrapper
|
class |
LogLoss
Binary log loss, or cross entropy loss:
-1/numExamples * sum_i (labels[i] * log(predictions[i] + epsilon) + (1-labels[i]) * log(1-predictions[i] + epsilon)) |
class |
LogPoissonLoss
Log Poisson loss
Note: This expects that the input/predictions are log(x) not x!
|
class |
MeanPairwiseSquaredErrorLoss
Mean Pairwise Squared Error Loss
|
class |
MeanSquaredErrorLoss
Mean squared error loss
|
class |
SigmoidCrossEntropyLoss
Sigmoid cross entropy loss with logits
|
class |
SoftmaxCrossEntropyLoss
Softmax cross entropy loss
|
class |
SoftmaxCrossEntropyWithLogitsLoss
Softmax cross entropy loss with Logits
|
class |
SparseSoftmaxCrossEntropyLossWithLogits
Sparse softmax cross entropy loss with logits.
|
class |
WeightedCrossEntropyLoss
Weighted cross entropy loss with logits
|
| Modifier and Type | Class and Description |
|---|---|
class |
AbsoluteDifferenceLossBp
Absolute difference loss backprop
|
class |
BaseLossBp |
class |
CosineDistanceLossBp
Cosine distance loss
|
class |
HingeLossBp
Hinge loss
|
class |
HuberLossBp
Hinge loss
|
class |
LogLossBp
Binary log loss, or cross entropy loss:
-1/numExamples * sum_i (labels[i] * log(predictions[i] + epsilon) + (1-labels[i]) * log(1-predictions[i] + epsilon)) |
class |
LogPoissonLossBp
Log Poisson loss backprop
|
class |
MeanPairwiseSquaredErrorLossBp
Mean Pairwise Squared Error Loss Backprop
|
class |
MeanSquaredErrorLossBp
Mean squared error loss
|
class |
SigmoidCrossEntropyLossBp
Sigmoid cross entropy loss with logits
|
class |
SoftmaxCrossEntropyLossBp
Softmax cross entropy loss
|
class |
SoftmaxCrossEntropyWithLogitsLossBp
Softmax cross entropy loss with Logits
|
class |
SparseSoftmaxCrossEntropyLossWithLogitsBp
Sparse softmax cross entropy loss with logits.
|
| Modifier and Type | Class and Description |
|---|---|
class |
BaseMetaOp |
class |
InvertedPredicateMetaOp
This MetaOp covers case, when Op A and Op B are both using linear memory access
You're NOT supposed to directly call this op.
|
class |
PostulateMetaOp
You're NOT supposed to directly call this op.
|
class |
PredicateMetaOp
This MetaOp covers case, when Op A and Op B are both using linear memory access
You're NOT supposed to directly call this op.
|
class |
ReduceMetaOp
This is special case PredicateOp, with opB being only either ReduceOp, Variance or Reduce3 op
|
| Modifier and Type | Class and Description |
|---|---|
class |
CbowRound |
class |
SkipGramRound |
| Modifier and Type | Class and Description |
|---|---|
class |
HashCode
This is hashCode op wrapper.
|
class |
Mmul
Matrix multiplication/dot product
|
class |
MmulBp
Matrix multiplication/dot product Backprop
|
class |
Moments |
class |
NormalizeMoments |
class |
SufficientStatistics
Sufficient statistics: returns 3 or 4 output arrays:
If shift is not provided: count, sum of elements, sum of squares
If shift is provided: count, sum of elements, sum of squares, shift
|
class |
TensorMmul
TensorMmul
|
class |
ZeroFraction
Compute the fraction of zero elements
|
| Modifier and Type | Class and Description |
|---|---|
class |
All
Boolean AND accumulation
|
class |
Any
Boolean AND pairwise transform
|
class |
IsInf
IsInf function
|
class |
IsNaN
IsInf function
|
| Modifier and Type | Class and Description |
|---|---|
class |
BaseReductionBp |
class |
CumProdBp
Backprop op for cumulative product operation
|
class |
CumSumBp
Backprop op for cumulative sum operation
|
class |
DotBp
Backprop op for Dot pairwise reduction operation
|
class |
MaxBp
Backprop op for Max reduction operation
|
class |
MeanBp
Backprop op for Mean reduction operation
|
class |
MinBp
Backprop op for Min reduction operation
|
class |
Norm1Bp
Backprop op for Norm1 reduction operation
|
class |
Norm2Bp
Backprop op for Norm2 reduction operation
|
class |
NormMaxBp
Backprop op for Norm Max reduction operation
|
class |
PowBp |
class |
ProdBp
Backprop op for Product reduction operation
|
class |
SquaredNormBp
Backprop op for squared norm (sum_i x_i^2) reduction operation
|
class |
StandardDeviationBp
Backprop op for standard deviation reduction operation
|
class |
SumBp
Backprop op for Sum reduction operation
|
class |
VarianceBp
Backprop op for variance reduction operation
|
| Modifier and Type | Class and Description |
|---|---|
class |
BatchMmul
Batched matrix multiplication.
|
class |
LogSumExp
LogSumExp - this op returns https://en.wikipedia.org/wiki/LogSumExp
|
| Modifier and Type | Class and Description |
|---|---|
class |
AMean
Calculate the absolute mean of the given vector
|
class |
Entropy
Entropy Op - returns the entropy (information gain, or uncertainty of a random variable).
|
class |
LogEntropy
Log Entropy Op - returns the log entropy (information gain, or uncertainty of a random variable).
|
class |
Mean
Calculate the mean of the vector
|
class |
Norm1
Sum of absolute values
|
class |
Norm2
Sum of squared values (real)
Sum of squared complex modulus (complex)
|
class |
NormMax
The max absolute value
|
class |
ShannonEntropy
Non-normalized Shannon Entropy Op - returns the entropy (information gain, or uncertainty of a random variable).
|
class |
SquaredNorm
Squared norm (sum_i x_i^2) reduction operation
|
| Modifier and Type | Class and Description |
|---|---|
class |
CountNonZero
Count the number of non-zero elements
|
class |
CountZero
Count the number of zero elements
|
class |
MatchCondition
This operation returns number of elements matching specified condition
|
| Modifier and Type | Class and Description |
|---|---|
class |
AMax
Calculate the absolute max over a vector
|
class |
AMin
Calculate the absolute minimum over a vector
|
class |
ASum
Absolute sum the components
|
class |
Max
Calculate the max over an array
|
class |
Min
Calculate the min over an array
|
class |
Prod
Prod the components
|
class |
Sum
Sum the components
|
| Modifier and Type | Class and Description |
|---|---|
class |
BaseReduce3Op
Manhattan distance
|
class |
CosineDistance
Cosine distance
Note that you need to initialize
a scaling constant equal to the norm2 of the
vector
|
class |
CosineSimilarity
Cosine similarity
Note that you need to initialize
a scaling constant equal to the norm2 of the
vector
|
class |
Dot
Dot product.
|
class |
EqualsWithEps
Operation for fast INDArrays equality checks
|
class |
EuclideanDistance
Euclidean distance
|
class |
HammingDistance
Hamming distance (simple)
|
class |
JaccardDistance
Jaccard distance (dissimilarity)
|
class |
ManhattanDistance
Manhattan distance
|
| Modifier and Type | Class and Description |
|---|---|
class |
LeakyReLU
Leaky Rectified linear unit.
|
class |
LogX
Log on arbitrary base op
|
class |
Pow
Pow function
|
class |
PowDerivative
Pow derivative
z = n * x ^ (n-1)
|
class |
PRelu
Parameterized ReLU op
|
class |
RectifiedLinear
Rectified linear units
|
class |
RectifiedLinearDerivative |
class |
Relu6
Rectified linear unit 6, i.e. min(max(input, cutoff), 6), where cutoff can be chosen.
|
class |
ReplaceNans
Element-wise "Replace NaN" implementation as Op
|
class |
ScalarAdd
Scalar addition
|
class |
ScalarDivision
Scalar division
|
class |
ScalarFMod
Scalar floating-point remainder (fmod aka 'floormod')
|
class |
ScalarMax
Scalar max operation.
|
class |
ScalarMin
Scalar max operation.
|
class |
ScalarMultiplication
Scalar multiplication
|
class |
ScalarRemainder
Scalar floating-point remainder
|
class |
ScalarReverseDivision
Scalar reverse division
|
class |
ScalarReverseSubtraction
Scalar reverse subtraction
|
class |
ScalarSet
Scalar max operation.
|
class |
ScalarSubtraction
Scalar subtraction
|
class |
Step
Unit step function.
|
| Modifier and Type | Class and Description |
|---|---|
class |
ScalarAnd
Return a binary (0 or 1)
when greater than a number
|
class |
ScalarEps
Return a binary (0 or 1) when greater than a number
|
class |
ScalarEquals
Return a binary (0 or 1) when greater than a number
|
class |
ScalarGreaterThan
Return a binary (0 or 1) when greater than a number
|
class |
ScalarGreaterThanOrEqual
Return a binary (0 or 1) when greater than or equal to a number
|
class |
ScalarLessThan
Return a binary (0 or 1) when less than a number
|
class |
ScalarLessThanOrEqual
Return a binary (0 or 1) when less than
or equal to a number
|
class |
ScalarNot
Return a binary (0 or 1)
when greater than a number
|
class |
ScalarNotEquals
Return a binary (0 or 1)
when greater than a number
|
class |
ScalarOr
Return a binary (0 or 1)
when greater than a number
|
class |
ScalarSetValue
Scalar value set operation.
|
class |
ScalarXor
Return a binary (0 or 1)
when greater than a number
|
| Modifier and Type | Class and Description |
|---|---|
class |
ScatterAdd
Created by farizrahman4u on 3/23/18.
|
class |
ScatterDiv
Created by farizrahman4u on 3/23/18.
|
class |
ScatterMax |
class |
ScatterMin |
class |
ScatterMul
Created by farizrahman4u on 3/23/18.
|
class |
ScatterNd
Scatter ND operation
|
class |
ScatterNdAdd
Scatter ND add operation
|
class |
ScatterNdSub
Scatter ND subtract operation
|
class |
ScatterNdUpdate
Scatter ND add operation
|
class |
ScatterSub
Created by farizrahman4u on 3/23/18.
|
class |
ScatterUpdate
Scatter update op
|
| Modifier and Type | Class and Description |
|---|---|
class |
ApplyGradientDescent
Reshape function
|
class |
BroadcastDynamicShape
Broadcast dynamic shape function
|
class |
Concat |
class |
ConfusionMatrix |
class |
Create
This operation creates a new, optionally nullified, array with a given shape, order and data type
|
class |
Cross
Pairwise cross-product of two tensors of the same shape.
|
class |
Diag
Computes a diagonal matrix of shape (n, n) from a vector of length n.
|
class |
DiagPart
Return the diagonal part of a tensor.
|
class |
ExpandDims
ExpandDims function
|
class |
Eye
Computes a batch of identity matrices of shape (numRows, numCols), returns a single tensor.
|
class |
Gather
Gather op
|
class |
GatherNd
GatherND op
|
class |
MergeAvg |
class |
MergeMax |
class |
MergeMaxIndex |
class |
MergeSum |
class |
MeshGrid |
class |
OneHot
Created by susaneraly on 3/14/18.
|
class |
OnesLike
OnesLike function - gives an output array with all values/entries being 1, with the same shape as the input.
|
class |
ParallelStack
Stacks n input tensors of same shape to tensor of rank n + 1.
|
class |
Permute
Permute function
|
class |
Rank
Rank function
|
class |
ReductionShape |
class |
Repeat
Repeat function
|
class |
Reshape
Reshape function
|
class |
SequenceMask
Created by farizrahman4u on 3/28/18.
|
class |
Shape
Returns the shape of the input array.
|
class |
ShapeN
Returns the shape of N input array as N output arrays
|
class |
Size
Returns the size of the input as a rank 0 array
|
class |
SizeAt
Returns the size of the input along given dimension as a rank 0 array
|
class |
Slice
Slice function
|
class |
Split
Split op
|
class |
SplitV
SplitV op
|
class |
Squeeze |
class |
Stack
Stack operation.
|
class |
StridedSlice
Strided Slice function
|
class |
Tile
Tile function
|
class |
Transpose
Transpose function
|
class |
Unstack
Unstack op conversion
|
class |
ZerosLike
Reshape function
|
| Modifier and Type | Class and Description |
|---|---|
class |
ConcatBp
Backprop op for concat
|
class |
MergeAvgBp |
class |
MergeMaxBp |
class |
SliceBp
Slice backprop function
|
class |
StridedSliceBp
Strided Slice backprop function
|
class |
TileBp
Tile backprop function
|
| Modifier and Type | Class and Description |
|---|---|
class |
BaseTensorOp |
class |
EmbeddingLookup |
class |
TensorArray |
class |
TensorArrayConcat |
class |
TensorArrayGather |
class |
TensorArrayRead |
class |
TensorArrayScatter |
class |
TensorArraySize |
class |
TensorArraySplit |
class |
TensorArrayWrite |
| Modifier and Type | Class and Description |
|---|---|
class |
StandardDeviation
Standard deviation (sqrt of variance)
|
class |
Variance
Variance with bias correction.
|
| Modifier and Type | Class and Description |
|---|---|
class |
Angle
Angle op for tensorflow import
Given ND4J currently only supports real arrays; hence by definition this always outputs 0 |
class |
Assert
Assertion op wrapper
|
class |
BaseDynamicTransformOp |
class |
BinCount
BinCount: counts the number of times each value appears in an integer array.
|
class |
CheckNumerics
CheckNumerics op wrapper
|
class |
Cholesky
Cholesky op wrapper
|
class |
Histogram
Histogram op wrapper
|
class |
HistogramFixedWidth
Histogram fixed with op
|
class |
IdentityN
IdentityN op wrapper
|
class |
MaxOut
Max out activation:
https://arxiv.org/pdf/1302.4389.pdf
|
class |
NthElement
NthElement op wrapper
|
class |
Pad
Pad op
|
class |
ReluLayer
Composed op: relu((X, W) + b)
|
| Modifier and Type | Class and Description |
|---|---|
class |
Assign
Identity function
|
class |
IsMax
[1, 2, 3, 1] -> [0, 0, 1, 0]
|
| Modifier and Type | Class and Description |
|---|---|
class |
BooleanNot
Boolean NOT transform
|
class |
IsFinite
IsFinite function
|
class |
MatchConditionTransform
Match condition transform
|
| Modifier and Type | Class and Description |
|---|---|
class |
ClipByAvgNorm |
class |
ClipByNorm |
class |
ClipByNormBp |
class |
ClipByValue |
| Modifier and Type | Class and Description |
|---|---|
class |
CompareAndReplace
Element-wise Compare-and-Replace implementation as Op
Basically this op does the same as Compare-and-Set, but op.X is checked against Condition instead
|
class |
CompareAndSet
Element-wise Compare-and-set implementation as Op
Please check javadoc to specific constructors, for detail information.
|
class |
Eps
Bit mask over the ndarrays as to whether
the components are equal or not
|
| Modifier and Type | Class and Description |
|---|---|
class |
ATan2
Arc Tangent elementwise function
|
class |
BatchToSpace
N-dimensional batch to space operation.
|
class |
BatchToSpaceND
N-dimensional batch to space operation.
|
class |
BitsHammingDistance |
class |
BitwiseAnd
Bit-wise AND operation, broadcastable
|
class |
BitwiseOr
Bit-wise OR operation, broadcastable
|
class |
BitwiseXor
Bit-wise XOR operation, broadcastable
|
class |
Choose
This op allows us to (based on the passed in condition)
to return the element fulfilling the condition.
|
class |
CReLU |
class |
CReluBp |
class |
CumProd |
class |
CumSum
Cumulative sum operation, optionally along dimension.
|
class |
CyclicRShiftBits
Element-wise roll operation, rolls bits to the left, <<
|
class |
CyclicShiftBits
Element-wise roll operation, rolls bits to the left, <<
|
class |
Dilation2D
Dilation2D op wrapper
|
class |
DotProductAttention
(optionally scaled) dot product attention
See also "Attention is all you need" (https://arxiv.org/abs/1706.03762, p. 4, eq. 1)
|
class |
DotProductAttentionBp
(optionally scaled) dot product attention Backprop
See also "Attention is all you need" (https://arxiv.org/abs/1706.03762, p. 4, eq. 1)
|
class |
DynamicPartition
Transforms a given input tensor into numPartitions partitions, as indicated by the indices in "partitions".
|
class |
DynamicStitch
Transforms a given input tensor into numPartitions partitions, as indicated by the indices in "partitions".
|
class |
EqualTo
Bit mask over the ndarrays as to whether
the components are equal or not
|
class |
FakeQuantWithMinMaxArgs
Fake quantization operation.
|
class |
FakeQuantWithMinMaxVars
Fake quantization operation.
|
class |
Fill
Fill an array of given "shape" with the provided "value", e.g.
|
class |
GreaterThan
Bit mask over the ndarrays as to whether
the components are greater than or not
|
class |
GreaterThanOrEqual
Bit mask over the ndarrays as to whether
the components are greater than or equal or not
|
class |
InTopK
In Top K op
|
class |
InvertPermutation
Inverse of index permutation.
|
class |
IsNonDecreasing
This op takes 1 n-dimensional array as input,
and returns true if for every adjacent pair we have x[i] <= x[i+1].
|
class |
IsNumericTensor
This op takes 1 n-dimensional array as input, and returns true if input is a numeric array.
|
class |
IsStrictlyIncreasing
This op takes 1 n-dimensional array as input,
and returns true if for every adjacent pair we have x[i] < x[i+1].
|
class |
LayerNorm
Composed op: g*standarize(x) + b
Bias is optional, and can be set as null
|
class |
LayerNormBp
Composed op: g*standarize(x) + b
Bias is optional, and can be set as null
|
class |
LessThan
Bit mask over the ndarrays as to whether
the components are less than or not
|
class |
LessThanOrEqual
Bit mask over the ndarrays as to whether
the components are less than or equal or not
|
class |
ListDiff |
class |
LogicalAnd |
class |
LogicalNot |
class |
LogicalOr |
class |
LogicalXor |
class |
LogMatrixDeterminant
Log Matrix Determinant op
Given input with shape [..., N, N] output the log determinant for each sub-matrix.
|
class |
LogSoftMax
Log(softmax(X))
|
class |
MatrixDeterminant
Matrix Determinant op
Given input with shape [..., N, N] output the determinant for each sub-matrix.
|
class |
MatrixDiag |
class |
MatrixDiagPart |
class |
MatrixInverse
Matrix Inverse Function
|
class |
MatrixSetDiag |
class |
MaximumBp |
class |
MirrorPad |
class |
MultiHeadDotProductAttention
(optionally scaled) multi head dot product attention
See also "Attention is all you need" (https://arxiv.org/abs/1706.03762, pp. 4,5, "3.2.2 Multi-Head Attention")
|
class |
MultiHeadDotProductAttentionBp
(optionally scaled) multi head dot product attention Backprop
See also "Attention is all you need" (https://arxiv.org/abs/1706.03762, pp. 4,5, "3.2.2 Multi-Head Attention")
|
class |
NotEqualTo
Not equal to function:
Bit mask over whether 2 elements are not equal or not
|
class |
ParallelConcat |
class |
Qr |
class |
Reverse |
class |
ReverseBp |
class |
ReverseSequence
Created by farizrahman4u on 3/16/18.
|
class |
ReverseV2
This is compatibility op for ReverseV2
|
class |
RShiftBits
Element-wise shift operation, shift bits to the right, >>
|
class |
ShiftBits
Element-wise shift operation, shift bits to the left, <<
|
class |
SoftMax
Soft max function
row_maxes is a row vector (max for each row)
row_maxes = rowmaxes(input)
diff = exp(input - max) / diff.rowSums()
Outputs a probability distribution.
|
class |
SpaceToBatch
N-dimensional space to batch operation.
|
class |
SpaceToBatchND
N-dimensional space to batch operation.
|
class |
Standardize |
class |
StandardizeBp |
class |
Svd
SVD - singular value decomposition
|
class |
ThresholdRelu
Threshold ReLU op.
|
class |
TopK
Top K op
|
class |
Trace
Matrix trace operation
|
class |
Unique |
class |
UniqueWithCounts |
class |
XwPlusB
Composed op: mmul (X, W) + b
|
class |
Zeta
Element-wise Zeta function.
|
| Modifier and Type | Class and Description |
|---|---|
class |
SegmentMax
Segment max operation
|
class |
SegmentMean
Segment mean operation
|
class |
SegmentMin
Segment min operation
|
class |
SegmentProd
Segment product operation
|
class |
SegmentSum
Segment sum operation
|
| Modifier and Type | Class and Description |
|---|---|
class |
Cast
Cast op wrapper.
|
| Modifier and Type | Class and Description |
|---|---|
class |
RSqrt
RSqrt function
|
class |
Sqrt
Sqrt function
|
| Modifier and Type | Class and Description |
|---|---|
class |
CubeBp
Cube backpropagation op - dL/dIn from in and dL/dOut
|
class |
CubeDerivative
Deprecated.
Use
CubeBp |
class |
DynamicPartitionBp
Backprop operation for dynamic partition
|
class |
EluBp
ELU backpropagation op - dL/dIn from in and dL/dOut
|
class |
GradientBackwardsMarker |
class |
HardSigmoidBp
Hard Sigmoid backpropagation op - dL/dIn from in and dL/dOut
|
class |
HardSigmoidDerivative
Deprecated.
Use
HardSigmoidBp |
class |
HardTanhBp
Hard Tanh backpropagation op - dL/dIn from in and dL/dOut
|
class |
HardTanhDerivative
Deprecated.
Use
HardTanhBp |
class |
LeakyReLUBp
LReLU backpropagation op - dL/dIn from in and dL/dOut
|
class |
LeakyReLUDerivative
Leaky ReLU derivative.
|
class |
LogSoftMaxDerivative |
class |
PReluBp
PRelu backpropagation op - dL/dIn from in and dL/dOut
|
class |
RationalTanhBp
Rational Tanh backpropagation op - dL/dIn from in and dL/dOut
|
class |
RationalTanhDerivative
Deprecated.
Use
RationalTanhBp |
class |
RectifiedTanhBp
Rectified Tanh backpropagation op - dL/dIn from in and dL/dOut
|
class |
RectifiedTanhDerivative
Deprecated.
Use
RectifiedTanhBp |
class |
Relu6Derivative
Derivative of Rectified linear unit 6, i.e. min(max(input, cutoff), 6), where cutoff can be chosen.
|
class |
SeluBp
SELU backpropagation op - dL/dIn from in and dL/dOut
|
class |
SELUDerivative
Deprecated.
Use
SeluBp |
class |
SoftmaxBp
Softmax backpropagation op - dL/dIn from in and dL/dOut
|
class |
SoftPlusBp
SoftPlus backpropagation op - dL/dIn from in and dL/dOut
|
class |
SoftSignBp
SoftSign backpropagation op - dL/dIn from in and dL/dOut
|
class |
SoftSignDerivative
Deprecated.
Use
SoftSignBp |
class |
ThresholdReluBp
Threshold ReLU Backprop op - dL/dIn from in and dL/dOut
For
RectifiedLinear as well as ThresholdRelu . |
| Modifier and Type | Class and Description |
|---|---|
class |
BinaryMinimalRelativeError |
class |
BinaryRelativeError |
class |
RelativeError |
class |
Set
Set
|
| Modifier and Type | Class and Description |
|---|---|
class |
AddOp
Addition operation
|
class |
Axpy
Level 1 blas op Axpy as libnd4j native op
|
class |
CopyOp
Copy operation
|
class |
DivOp
Division operation
|
class |
FloorDivOp
Truncated division operation
|
class |
FloorModOp
Floor mod
|
class |
FModOp
Floating-point mod
|
class |
MergeAddOp
Addition operation for n operands, called "mergeadd" in libnd4j
|
class |
ModOp
Modulo operation
|
class |
MulOp
Multiplication operation
|
class |
PowPairwise
Pairwise version of PoW
|
class |
RDivOp
Reverse Division operation
|
class |
RealDivOp
RealDivision operation
|
class |
RemainderOp
Floating-point remainder operation
|
class |
RSubOp
Reverse subtraction operation
|
class |
SquaredDifferenceOp
Squared difference operation, i.e. returns (x - y) * (x - y)
|
class |
SubOp
Subtraction operation
|
class |
TruncateDivOp
Truncated division operation
|
| Modifier and Type | Class and Description |
|---|---|
class |
AddBpOp
Addition backprop operation.
|
class |
BaseArithmeticBackpropOp
Base arithmetic backprop operation
|
class |
DivBpOp
Division backprop operation.
|
class |
FloorDivBpOp
Floor div backprop operation.
|
class |
FloorModBpOp
Floor div backprop operation.
|
class |
MergeAddBp |
class |
ModBpOp
Modulo backprop operation.
|
class |
MulBpOp
Division backprop operation.
|
class |
RDivBpOp
Division backprop operation.
|
class |
RSubBpOp
Division backprop operation.
|
class |
SquaredDifferenceBpOp
Backprop op for squared difference operation, i.e. backprop for (x - y) * (x - y)
|
class |
SubBpOp
Division backprop operation.
|
| Modifier and Type | Class and Description |
|---|---|
class |
And
Boolean AND pairwise transform
|
class |
Not
Boolean AND pairwise transform
|
class |
Or
Boolean OR pairwise transform
|
class |
Xor
Boolean XOR pairwise transform
|
| Modifier and Type | Class and Description |
|---|---|
class |
Abs
Abs elementwise function
|
class |
Ceil
Ceiling elementwise function
|
class |
Cube
Cube (x^3) elementwise function
|
class |
Floor
Floor elementwise function
|
class |
Identity
Identity function
|
class |
Negative
Negative function
|
class |
OneMinus
1 - input
|
class |
Reciprocal
Created by susaneraly on 3/28/18.
|
class |
Round
Rounding function
|
class |
Sign
Signum function
|
class |
Square
Square function (x ^ 2)
|
class |
TimesOneMinus
If x is input: output is x*(1-x)
|
| Modifier and Type | Class and Description |
|---|---|
class |
UnsortedSegmentMax
Unsorted segment max operation
|
class |
UnsortedSegmentMean
Unsorted segment mean operation
|
class |
UnsortedSegmentMin
Unsorted segment min operation
|
class |
UnsortedSegmentProd
Unsorted segment product operation
|
class |
UnsortedSegmentSqrtN
Unsorted Sqrt(count) op
|
class |
UnsortedSegmentSum
Unsorted segment sum operation
|
| Modifier and Type | Class and Description |
|---|---|
class |
SegmentMaxBp
Segment max backprop operation
|
class |
SegmentMeanBp
Segment mean backprop operation
|
class |
SegmentMinBp
Segment min backprop operation
|
class |
SegmentProdBp
Segment product backprop operation
|
class |
SegmentSumBp
Segment sum backprop operation
|
class |
UnsortedSegmentMaxBp
Unsorted segment max backprop operation
|
class |
UnsortedSegmentMeanBp
Unsorted segment mean backprop operation
|
class |
UnsortedSegmentMinBp
Unsorted segment min backprop operation
|
class |
UnsortedSegmentProdBp
Unsorted segment product backprop operation
|
class |
UnsortedSegmentSqrtNBp
Unsorted segment sqrt(n) backprop operation
|
class |
UnsortedSegmentSumBp
Unsorted segment sum backprop operation
|
| Modifier and Type | Class and Description |
|---|---|
class |
ACos
Log elementwise function
|
class |
ACosh
ACosh elementwise function
|
class |
ASin
Arcsin elementwise function
|
class |
ASinh
Arcsin elementwise function
|
class |
ATan
Arc Tangent elementwise function
|
class |
ATanh
tan elementwise function
|
class |
Cos
Cosine elementwise function
|
class |
Cosh
Cosine Hyperbolic elementwise function
|
class |
ELU
ELU: Exponential Linear Unit (alpha=1.0)
Introduced in paper: Fast and Accurate Deep Network Learning by Exponential Linear Units (ELUs) Djork-Arné Clevert, Thomas Unterthiner, Sepp Hochreiter (2015) https://arxiv.org/abs/1511.07289 |
class |
Erf
Gaussian error function (erf) function, which is defined as
erf(x) = 1 / sqrt(pi) * integral_(-x, x) exp(-t^2) dt
|
class |
Erfc
Complementary Gaussian error function (erfc), defined as
erfc(x) = 1 - erf(x)
where erf denotes regular Gaussian error.
|
class |
Exp
Element-wise exponential function
|
class |
Expm1
Element-wise exponential function minus 1, i.e. for each element x in a tensor computes the
transformation exp(x) - 1.
|
class |
GELU
GELU activation function - Gaussian Error Linear Units
For more details, see Gaussian Error Linear Units (GELUs) - https://arxiv.org/abs/1606.08415 Note: This op implements both the sigmoid and tanh-based approximations; to use the sigmoid approximation (recommended) use precise=false; otherwise, use precise = true for the slower but marginally more accurate tanh version. |
class |
GELUDerivative
GELU derivative
|
class |
HardSigmoid
HardSigmoid function
|
class |
HardTanh
Hard tanh elementwise function
|
class |
Log
Log elementwise function
|
class |
Log1p
Log1p function
|
class |
LogSigmoid
LogSigmoid function
|
class |
Mish
Mish activation function
|
class |
MishDerivative
Mish derivative
|
class |
PreciseGELU
GELU activation function - Gaussian Error Linear Units
For more details, see Gaussian Error Linear Units (GELUs) - https://arxiv.org/abs/1606.08415 Note: This op implements both the sigmoid and tanh-based approximations; to use the sigmoid approximation (recommended) use precise=false; otherwise, use precise = true for the slower but marginally more accurate tanh version. |
class |
PreciseGELUDerivative
GELU derivative
|
class |
RationalTanh
Rational Tanh Approximation elementwise function, as described at https://github.com/deeplearning4j/libnd4j/issues/351
|
class |
RectifiedTanh
RectifiedTanh
Essentially max(0, tanh(x))
|
class |
Rint
Rint function
|
class |
SELU
SELU activation function
https://arxiv.org/pdf/1706.02515.pdf
|
class |
SetRange
Set range to a particular set of values
|
class |
Sigmoid
Sigmoid function
|
class |
SigmoidDerivative
Deprecated.
|
class |
Sin
Log elementwise function
|
class |
Sinh
Sinh function
|
class |
SoftPlus |
class |
SoftSign
Softsign element-wise activation function. f(x) = x/(1+abs(x))
Similar in shape to tanh but may outperform it due to 'gentler' nonlinearity (smoother asymptotes). |
class |
Stabilize
Stabilization function, forces values to be within a range
|
class |
Swish
Swish function
|
class |
SwishDerivative
Swish derivative
|
class |
Tan
Tanh elementwise function
|
class |
TanDerivative
Tan Derivative elementwise function
|
class |
Tanh
Tanh elementwise function
|
class |
TanhDerivative
Deprecated.
Use
TanhDerivative . |
| Modifier and Type | Class and Description |
|---|---|
class |
AdaDeltaUpdater |
class |
AdaGradUpdater |
class |
AdaMaxUpdater |
class |
AdamUpdater |
class |
AmsGradUpdater |
class |
NadamUpdater |
class |
NesterovsUpdater |
class |
RmsPropUpdater |
class |
SgdUpdater |
| Modifier and Type | Class and Description |
|---|---|
class |
RestoreV2 |
class |
SaveV2 |
| Modifier and Type | Class and Description |
|---|---|
class |
BaseRandomOp |
| Modifier and Type | Class and Description |
|---|---|
class |
RandomStandardNormal
This op is a wrapper for RandomNormal Op
|
| Modifier and Type | Class and Description |
|---|---|
class |
DistributionUniform
Uniform distribution wrapper
|
class |
RandomBernoulli
Random bernoulli distribution: p(x=1) = p, p(x=0) = 1-p
i.e., output is 0 or 1 with probability p.
|
class |
RandomExponential
Random exponential distribution: p(x) = lambda * exp(-lambda * x)
|
class |
RandomGamma |
class |
RandomNormal
Random normal distribution
|
class |
RandomPoisson |
class |
RandomShuffle |
| Modifier and Type | Class and Description |
|---|---|
class |
AlphaDropOut
AlphaDropOut implementation as Op
|
class |
BernoulliDistribution
BernoulliDistribution implementation
|
class |
BinomialDistribution
This Op generates binomial distribution
|
class |
BinomialDistributionEx
This Op generates binomial distribution
|
class |
Choice
This Op implements numpy.choice method
It fills Z from source, following probabilities for each source element
|
class |
DropOut
DropOut implementation as Op
|
class |
DropOutInverted
Inverted DropOut implementation as Op
|
class |
GaussianDistribution
This Op generates normal distribution over provided mean and stddev
|
class |
Linspace
Linspace/arange Op implementation, generates from..to distribution within Z
|
class |
LogNormalDistribution
This Op generates log-normal distribution over provided mean and stddev
|
class |
ProbablisticMerge |
class |
Range
Range Op implementation, generates from..to distribution within Z
|
class |
TruncatedNormalDistribution
This Op generates truncated normal distribution over provided mean and stddev
|
class |
UniformDistribution |
| Modifier and Type | Class and Description |
|---|---|
class |
PrintAffinity
This is a wrapper for PrintAffinity op that just prints out affinity & locality status of INDArray
|
class |
PrintVariable
This is a wrapper for PrintVariable op that just prints out Variable to the stdout
|
| Modifier and Type | Method and Description |
|---|---|
protected void |
NativeOpExecutioner.appendSameDiffInfo(StringBuilder sb,
DifferentialFunction df) |
Copyright © 2020. All rights reserved.


giddy.mobility.markov_mobility¶
- giddy.mobility.markov_mobility(p, measure='P', ini=None)[source]¶
Markov-based mobility index.
- Parameters:
- parray
(k, k), Markov transition probability matrix.
- measurestring
If measure= “P”, \(M_{P} = \frac{m-\sum_{i=1}^m P_{ii}}{m-1}\); if measure = “D”, \(M_{D} = 1 - |\det(P)|\), where \(\det(P)\) is the determinant of \(P\); if measure = “L2”, \(M_{L2} = 1 - |\lambda_2|\), where \(\lambda_2\) is the second largest eigenvalue of \(P\); if measure = “B1”, \(M_{B1} = \frac{m-m \sum_{i=1}^m \pi_i P_{ii}}{m-1}\), where \(\pi\) is the initial income distribution; if measure == “B2”, \(M_{B2} = \frac{1}{m-1} \sum_{i=1}^m \sum_{ j=1}^m \pi_i P_{ij} |i-j|\), where \(\pi\) is the initial income distribution.
- iniarray
(k,), initial distribution. Need to be specified if measure = “B1” or “B2”. If not, the initial distribution would be treated as a uniform distribution.
- Returns:
- mobifloat
Mobility value.
Notes
The mobility indices are based on [FSZ04].
Examples
>>> import numpy as np >>> import libpysal >>> import mapclassify as mc >>> from giddy.markov import Markov >>> from giddy.mobility import markov_mobility >>> f = libpysal.io.open(libpysal.examples.get_path("usjoin.csv")) >>> pci = np.array([f.by_col[str(y)] for y in range(1929,2010)]) >>> q5 = np.array([mc.Quantiles(y).yb for y in pci]).transpose() >>> m = Markov(q5) The Markov Chain is irreducible and is composed by: 1 Recurrent class (indices): [0 1 2 3 4] 0 Transient classes. The Markov Chain has 0 absorbing states. >>> m.p array([[0.91011236, 0.0886392 , 0.00124844, 0. , 0. ], [0.09972299, 0.78531856, 0.11080332, 0.00415512, 0. ], [0. , 0.10125 , 0.78875 , 0.1075 , 0.0025 ], [0. , 0.00417827, 0.11977716, 0.79805014, 0.07799443], [0. , 0. , 0.00125156, 0.07133917, 0.92740926]])
Estimate Shorrock1 mobility index:
>>> mobi_1 = markov_mobility(m.p, measure="P") >>> print("{:.5f}".format(mobi_1)) 0.19759
Estimate Shorrock2 mobility index:
>>> mobi_2 = markov_mobility(m.p, measure="D") >>> print("{:.5f}".format(mobi_2)) 0.60685
Estimate Sommers and Conlisk mobility index:
>>> mobi_3 = markov_mobility(m.p, measure="L2") >>> print("{:.5f}".format(mobi_3)) 0.03978
(4) Estimate Bartholomew1 mobility index (note that the initial distribution should be given):
>>> ini = np.array([0.1,0.2,0.2,0.4,0.1]) >>> mobi_4 = markov_mobility(m.p, measure = "B1", ini=ini) >>> print("{:.5f}".format(mobi_4)) 0.22777
(5) Estimate Bartholomew2 mobility index (note that the initial distribution should be given):
>>> ini = np.array([0.1,0.2,0.2,0.4,0.1]) >>> mobi_5 = markov_mobility(m.p, measure = "B2", ini=ini) >>> print("{:.5f}".format(mobi_5)) 0.04637


Recipes
Login
Signup
Welcome To Recipes. All About Reciping
Recipes
Pasta
Banana Split
Creme Salad
Jollof Rice
Roasted chicken
Madrelle Chips
Categories
Breakfast
Lunch
Dinner
Desserts
Noodles
Drinks
Popular
Jollof Rice
Cappuccino
Margherita Pizza


5 references to
System.Management.Automation (5)
engine\parser\ast.cs (5)
4231: base(extent, label, expression, body)
4355: base(extent, label, condition, body)
4435: base(extent, label, condition, body)
4491: base(extent, label, condition, body)
4547: base(extent, label, condition, body)


IPCD Device Simulator
Actions
Device Model
Console
Comm Log
This is the main actions div
This is the main device model div
This is the main console div
This is the main comm log div


Implementation using the Gini Accounting API of the network related tasks required by the Gini Vision Library.
Adding this library along with the Gini Vision Library to your application is the quickest way to integrate document scanning with Gini's Accounting API.
In order for the Gini Vision Library to use this networking library pass the instances to
the GiniVision.Builder
when creating a new GiniVision
.
Important:You must not enable multi-page in the Gini Vision Library when using it with this networking library. The multi-page feature is currently only supported by the default networking library.
Android 4.4+ (API Level 19+)
@version 2.x @author Gini GmbH


To force a specific order of operation, use the group operator ( ) around a part of the expression.
Modulo : Very useful operation to check divisibility of numbers, check for even & odd, whether a number is prime, and much more! (Discrete Math concept, circular problems can be solved with modulo)
Whenever you have a smaller number % a larger number, the answer will just be the initial small number.
console.log(7 % 10); // => 7;
The String Data Type
The string data type is a primitive data type that used to represent textual data.
can be wrapped by either single or double quotation marks, best to choose one and stick with it for consistency.
If your string contains quotation marks inside, can layer single or double quotation marks to allow it to work.
"That's a great string"; (valid)
'Shakespeare wrote, "To be or not to be"'; (valid)
'That's a bad string'; (invalid)
Alt. way to add other quotes within strings is to use template literals.
`This is a temp'l'ate literal ${function}` // use ${} to invoke functions within.
.length : property that can be appended to data to return the length.
empty strings have a length of zero.
indices : indexes of data that begin at 0, can call upon index by using the bracket notation [ ].
Logical Order of Operations : JS will evaluate !, then &&, then ||.
De Morgan’s Law : Common mistake in boolean logic is incorrectly distributing ! across parentheses.
!(A || B) === !A && !B; !(A && B) === !A || !B;
In summary, to correctly distribute ! across parentheses we must also flip the operation within.
Short-Circuit Evaluation : Because JS evalutes from left to right, expressions can “short-circuit”. For example if we have true on the left of an || logical comparison, it will stop evaluating and yield true instead of wasting resources on processing the rest of the statement.
console.log(true || !false); // => stops after it sees "true ||"
Comparison Operators
All comparison operators will result in a boolean output.
The relative comparators
> (greater than)
< (less than)
>= (greater than or equal to)
<= (less than or equal to)
=== (equal to)
!== (not equal to)
Fun Fact: “a” < “b” is considered valid JS Code because string comparisons are compared lexicographically (meaning dictionary order), so “a” is less than “b” because it appears earlier!
If there is ever a standstill comparison of two string lexicographically (i.e. app vs apple) the comparison will deem the shorter string lesser.
Difference between == and ===
=== : Strict Equality, will only return true if the two comparisons are entirely the same.
== : Loose Equality, will return true even if the values are of a different type, due to coercion. (Avoid using this)
Variables
Variables are used to store information to be referenced and manipulated in a program.
We initialize a variable by using the let keyword and a = single equals sign (assignment operator).
let bootcamp = "Lambda"; console.log(bootcamp); // "Lambda"
JS variable names can contain any alphanumeric characters, underscores, or dollar signs (cannot being with a number).
If you do not declare a value for a variable, undefined is automatically set.
let bootcamp; console.log(bootcamp); // undefined
We can change the value of a previously declared variable (let, not const) by re-assigning it another value.
let is the updated version of var; there are some differences in terms of hoisting and global/block scope — will be covered later in the course (common interview question!)
Assignment Shorthand
let num = 0;
num += 10; // same as num = num + 10
num -= 2; // same as num = num - 2
num /= 4; // same as num = num / 4
num *= 7; // same as num = num * 7
In general, any nonsensical arithmetic will result in NaN ; usually operations that include undefined.
declaration : process of simply introducing a variable name.
initialization : process of both declaring and assigning a variable on the same line.
Functions
A function is a procedure of code that will run when called. Functions are used so that we do not have to rewrite code to do the same thing over and over. (Think of them as ‘subprograms’)
Function Declaration : Process when we first initially write our function.
Includes three things:
Name of the function.
A list of parameters ()
The code to execute {}
Function Calls : We can call upon our function whenever and wherever* we want. (*wherever is only after the initial declaration)
JS evaluates code top down, left to right.
When we execute a declared function later on in our program we refer to this as invoking our function.
Every function in JS returns undefined unless otherwise specified.
When we hit a return statement in a function we immediately exit the function and return to where we called the function.
When naming functions in JS always use camelCase and name it something appropriate. > Greate code reads like English and almost explains itself. Think: Elegant, readable, and maintainable!
Parameters and Arguments
Parameters : Comma seperated variables specified as part of a function’s declaration.
Arguments : Values passed to the function when it is invoked.
If the number of arguments passed during a function invocation is different than the number of parameters listed, it will still work.
However, is there are not enough arguments provided for parameters our function will likely yield Nan.


I was born in a place called Hayward, CA. It is a suburb about 15 minutes outside of Oakland, CA in the San Francisco Bay Area. It is know as The Heart of The Bay.
Currently, I live in San Jose, CA. This is about 30 miles away from where I grew up. This means I'm close enough to see my family, but far enough to have my own life.
I went to San Jose State University. I studied Computer Engineering as an undergrad and primarily focused on real-time embedded systems. However, I gave that up to pursue Software Engineering
When I am not in working I spend most of my time hanging out with my housemates. We love playing poker, singing kareoke, or watching the newest thing on netflix. I am also an avid gamer.


| ID | Title |
|---|
| 7 | Software validation, research and implementation | |
| 18 | Project Kickoff | |
| 11 | Research | |
| 19 | Validation with Customers | |
| 20 | Market Research | |
| 39 | Functional and Technical Specification | |
| 12 | Design | |
| 22 | UI Design | |
| 23 | HTML Prototype | |
| 13 | Implementation | |
| 24 | Prototype | |
| 26 | Architecture | |
| 27 | Data Layer | |
| 29 | UI and Interaction | |
| 28 | Unit Tests | |
| 14 | Testing | |
| 32 | Integration Testing | |
| 33 | Load Testing | |
| 30 | Documentation | |
| 34 | Structure | |
| 35 | Articles | |
| 31 | Demos | |
| 17 | Release |
| Sun 6/01 - Sat 6/07 | Sun 6/08 - Sat 6/14 | Sun 6/15 - Sat 6/21 | Sun 6/22 - Sat 6/28 | Sun 6/29 - Sat 7/05 | Sun 7/06 - Sat 7/12 | ||||||||||||||||||||||||||||||||||||
| Sun 6/01 | Mon 6/02 | Tue 6/03 | Wed 6/04 | Thu 6/05 | Fri 6/06 | Sat 6/07 | Sun 6/08 | Mon 6/09 | Tue 6/10 | Wed 6/11 | Thu 6/12 | Fri 6/13 | Sat 6/14 | Sun 6/15 | Mon 6/16 | Tue 6/17 | Wed 6/18 | Thu 6/19 | Fri 6/20 | Sat 6/21 | Sun 6/22 | Mon 6/23 | Tue 6/24 | Wed 6/25 | Thu 6/26 | Fri 6/27 | Sat 6/28 | Sun 6/29 | Mon 6/30 | Tue 7/01 | Wed 7/02 | Thu 7/03 | Fri 7/04 | Sat 7/05 | Sun 7/06 | Mon 7/07 | Tue 7/08 | Wed 7/09 | Thu 7/10 | Fri 7/11 | Sat 7/12 |


Launch demo modal
Alert
×
Are you sure you want to clear the form?
Launch demo modal
Verification Code
×
Launch demo modal
Alert
×
Form is expired...please contact your PO.


Why is JavaScript so popular ?
I have been searching and reading on the internet the reasons why is Javascript so popular and I listed the main one below:
- Because it's an easy language compare to C or C++ with a simpler syntax.
- There are a lot of libraries that help you to create object that makes Javascript so convenient ot use.
- It looks like Javascript is very light weight and fast on the client side so the speed is greatly improved. And you can also create your server with Javascript without the need of any other languages.
- Javascript is supported by every browsers. It is the defacto language of all browsers.
- It is open source so free, fast evolving, there is a lot of free materials, projects and libraries on the web.
On another way Javascript I found some people saying that it is the hardest language to debug on cross browser testing.
Despite this debug issue, JavaScript is considered by his supporters and a large part of the programming community as the Ultimate Scripting Language and is growing even more day by day.
By Frenchie


Dell's latest PremierColor monitor has a built-in colorimeter and Thunderbolt 3
A 27-inch 4K monitor with very accurate color reproduction
by Shawn KnightWhat just happened? Dell makes some of the best high-end monitors on the market and its latest creation looks to be no exception. The Dell UltraSharp 27 4K PremierColor Monitor (UP2720Q), unveiled today during the Adobe Max convention, is the world’s first 4K monitor with a built-in colorimeter and Thunderbolt 3 connectivity.
The UltraSharp 27 4K PremierColor boasts a resolution of 3,840 x 2,160 with a pixel density of 163 PPI and a contrast ratio of 1,300:1. It covers 100 percent of the Adobe RGB gamut, 98 percent of the DCI-P3 spectrum and 80 percent of the BT.2020 spectrum although curiously enough, its brightness rating is relatively low at just 250 nits.
A colorimeter is a color calibration tool used to help dial in settings so your monitor displays colors as accurately as possible. For working professionals or those that simply care deeply about photography or digital art creation, having accurate colors is an absolute must.
Connectivity-wise, the UltraSharp 27 4K PremierColor offers one DisplayPort 1.4 connection, two HDMI 2.0 ports, a Thunderbolt 3 upstream port, a Thunderbolt 3 downstream port, two USB 3.2 Gen2 downstream ports (DP1.4), two USB 3.2 Gen2 downstream ports and two USB 3.2 Gen1 downstream ports.
The included stand offers height, tilt and swivel adjustments and there’s even VESA mounting holes and an anti-theft lock slot for increased flexibility and security, respectively, with regard to installation.
The Dell UltraSharp 27 4K PremierColor Monitor (UP2720Q) launches on January 15, 2020, priced at $1,999.99.


--- layout: post title: Layout Design Tips permalink: layout-design-tips/ date: 2013-11-11 13:34:33.000000000 +08:00 categories: - coding tags: [] status: draft type: post published: false meta: _edit_last: '2' cleaned: true ---
When choosing colors, use pre defined color themes made by other. Kuler is a great tool for this purpose.


Man Utd, Arsenal target told where his future lies as club makes decision
Juventus defender Merih Demiral has been told by the club that he is free to look for a move away from Turin when the transfer window opens in January.
The 21-year-old has only made one appearance in Serie A for Maurizio Sarri’s side so far this term having been unable to find game time ahead of the likes of Matthijs de Ligt and Leonardo Bonucci.
Turkish international Demiral has been linked with both Manchester United and Arsenal in recent weeks and, according to the Daily Express, the Premier League duo have been handed a boost in their efforts to sign him.
The newspaper says that should Demiral choose to leave the club, his employers will not stop him from trying to do so, with Sarri said to be happy with his current options at the back.
Arsenal, who signed David Luiz from Chelsea in the summer, have been linked with bringing in another defender in January with their defence – which has shipped 17 goals in 12 Premier League games so far – coming in for criticism.
As well as the Gunners and United, the Express adds that Manchester City are keeping a close eye on Demiral’s progress, with Aymeric Laporte set to be sidelined until early next year through injury.


You don't have to create any permissions here in order to use them.
If you use a new permission in an authentication check ( A::authenticate("some_new_permission") ) it will automatically be added to the database and available here for editing.
You can edit any of the permissions by double clicking on the field or clicking the edit button to the right. To submit a field just press enter.


Facebook
LinkedIn
Twitter
menu
Cross Digital
home
share
Contact
We are working on a
New Website!
Thank you for your patience!
Contact us at
<EMAIL_ADDRESS>in the meantime


Open the web developer tools Console tab to test... (You may need to refresh the page after opening it.)


6.1 Saved states / 6.2 Storage of global variables / 6.3 The stack / 6.4 Routine calls / 6.5 Stack frames / 6.6 User stacks (V6)
The "state of play" is defined as the following: the contents of dynamic memory; the contents of the stack; the value of the program counter (PC), and the "routine call state" (that is, the chain of routines which have called each other in sequence, and the values of their local variables). Note that the routine call state, the stack and the PC must be stored outside the Z-machine memory map, in the interpreter's private memory.
The entire state of play must be stored when the game is saved.
The format of a saved game file is not specified.
An internal saved game for "undo" purposes (if there is one) is not part of the state of play. This is important: if a saved game file also contained the internal saved game at the time of saving, it would be impossible to undo the act of restoration. It also prevents internal saved games from growing larger and larger as they include their predecessors.
It is illegal to save the game (either with save or save_undo) during an "interrupt routine" (one coming about through timed input, sound effect termination or newline interrupts). Therefore saved games need not store information capable of restoring such a position.
On a "restore" or "undo" (which restores a game saved into internal memory), the entire state of play is written back except that 'Flags 2' in the header is preserved. (This information includes whether the game is being transcribed to printer and whether a fixed-pitch font is being used.)
Before a "restore", an interpreter should check that the file to be used has been saved from the same game currently being played. (See remark below.)
After a "restore" or "undo", an interpreter should reset the header values marked Rst in the header table of S 11. (It should not be assumed that the game was saved by the same interpreter.)
A "restart" is similar: the entire state is restored from the original story file, and the stack is emptied; but 'Flags 2' is preserved; and the interpreter should reset the Rst parts of the header.
In Versions 5 and later, an interpreter unable to save the game state into internal memory (for "undo" purposes) must clear bit 4 of 'Flags 2' in the header.
Global variables (variable numbers $10 to $ff) are stored in a table in the Z-machine's dynamic memory, at a byte address given in word 6 of the header. The table consists of 240 2-byte words and the initial values of the global variables are the values initially contained in the table. (It is legal for a program to alter the table's contents directly in play, though not for it to change the table's address.)
Writing to the stack pointer (variable number $00) pushes a value onto the stack; reading from it pulls a value off. Stack entries are 2-byte words as usual.
The stack is considered as empty at the start of each routine: it is illegal to pull values from it unless values have first been pushed on.
The stack is left empty at the end of each routine: when a return occurs, any values pushed during the routine are thrown away.
The absolute minimum standard for stack size is defined as:
let the 'usage' of a routine call be 4 plus the number of local variables it has. During a game the total of the usages for each routine in the recursive chain of routines being called, plus the game's own stack usage, can be assumed to never reach 1024.
However, more recent games have required a much larger stack size than this allows for. It is advised that interpreters allow for these games by having a larger stack size if at all possible.
Two examples of modern interpreters with increased stack size are Windows Frotz, with 32768, and nfrotz with 61440.
In the seven opcodes that take indirect variable references (inc, dec, inc_chk, dec_chk, load, store, pull), an indirect reference to the stack pointer does not push or pull the top item of the stack - it is read or written in place.
Routine calls occur in the following circumstances: when one of the call... opcodes is executed; in Versions 4 and later, when timed keyboard input is being monitored; in Versions 5 and later, when a sound effect finishes; in Version 6, when the game begins (to call the "main" routine); in Version 6, when a "newline interrupt" occurs.
A routine call may have any number of arguments, from 0 to 3 (in Versions 1 to 3) or 0 to 7 (Versions 4 and later). All routines return a value (though sometimes this value is thrown away afterward: for example by opcodes in the form call_vn*).
Routine calls preserve local variables and the stack (except when the return value is stored in a local variable or onto the top of the stack).
A routine call to packed address 0 is legal: it does nothing and returns false (0). Otherwise it is illegal to call a packed address where no routine is present.
When a routine is called, its local variables are created with initial values taken from the routine header (Versions 1 to 4) or with initial value 0 (Versions 5 and later). Next, the arguments are written into the local variables (argument 1 into local 1 and so on).
It is legal for there to be more arguments than local variables (any spare arguments are thrown away) or for there to be fewer.
The return value of a routine can be any Z-machine number. Returning 'false' means returning 0; returning 'true' means returning 1.
A "stack frame" is an index to the routine call state (that is, the call-stack of return addresses from routines currently running, and values of local variables within them). This index is a Z-machine number. The interpreter must be able to produce the current value and to set a value further down the call-stack than the current one, effectively throwing away its recent history (see catch and throw).
In Version 6, the Z-machine understands a third kind of stack: a "user stack", which is a table of words in dynamic memory. The first word in this table always holds the number of spare slots on the stack (so the initial value is the capacity of the stack). The Z-machine makes no check on stack under-flow (i.e., pulling more values than were pushed) which would over-run the length of the table if the program allowed it to happen.
Some interpreters store the whole of dynamic memory to disc as part of their saved game files, which can make them as much as 45K or so long. A player making a serious attack on a game may end up wasting a whole megabyte, more than convenient without a hard disc. A technique invented by Bryan Scattergood, taken up by most modern interpreters, greatly reduces file size by only saving bytes of dynamic memory which differ from the initial state of the game.
It is unspecified how an interpreter should decide whether a saved game file belongs to the game currently being played. It is normal to insist that the release numbers, serial codes and checksums all match. The Pinfocom interpreter deliberately checks only the release number, so that saved games can be exchanged between different editions of 'Seastalker' (presumably compiled to handle the sonarscope differently).
These issues are taken up in great detail in Martin Frost's Quetzal standard for saved game files, created to allow different interpreters to exchange saved games. This Standard doesn't require compliance with Quetzal, but interpreter writers are urged to consider it: it can only help authors if players can send them saved games where bugs seem to have appeared.
The stack is stored in the interpreter's own memory, not anywhere in the Z-machine. The game program has no direct access to the stack memory or stack pointer; on some implementations the game's main stack is also used to store the routine call state (i.e. the game stack and the call-stack are the same) but this need not be true.
The stack size specification guarantees in particular that if the game itself never uses more than 32 stack entries at once then it can have a recursive depth of at least 90 routine calls. The author believes that old Infocom games will all run with a stack size of 512 words.
Note that the "state of play" does not include numerous input/output settings (the current window, cursor position, splitness or otherwise, which streams are selected, etc.): neither does it include the state of the random-number generator. (Games with elaborate status lines must redraw them after a restore has taken place.)
Zip provides "undo" but most versions of the ITF interpreter do not (and save_undo returns 0, unfortunately). This is probably its greatest failing. Some Infocom-written interpreters will only provide "undo" to a game which has bit 4 of 'Flags 2' set: but Inform 5.5 doesn't set this bit, so modern interpreters should be more generous.
Given the existence of Quetzal, a portable saved file format, it is quite possible that after loading, the game may be running on a different interpreter to that on which the game started. As a result, it is strongly advisable for games to recheck any interpreter capabilities (eg Standard version, unicode support, etc) after loading.
Section 1 / 2 / 3 / 4 / 5 / 6 / 7 / 8 / 9 / 10 / 11 / 12 / 13 / 14 / 15 / 16
Appendix A / B / C / D / E / F


Definition at line 311 of file paragraphs.cpp.
◆ UnicodeSpanSkipper()
| tesseract::UnicodeSpanSkipper::UnicodeSpanSkipper |
( |
const UNICHARSET * |
unicharset, |
|
|
const WERD_CHOICE * |
word |
|
) |
| |
|
inline |
◆ SkipAlpha()
| int tesseract::UnicodeSpanSkipper::SkipAlpha |
( |
int |
pos | ) |
|
◆ SkipDigits()
| int tesseract::UnicodeSpanSkipper::SkipDigits |
( |
int |
pos | ) |
|
◆ SkipPunc()
| int tesseract::UnicodeSpanSkipper::SkipPunc |
( |
int |
pos | ) |
|
◆ SkipRomans()
| int tesseract::UnicodeSpanSkipper::SkipRomans |
( |
int |
pos | ) |
|
The documentation for this class was generated from the following file:


Amazon sues Pentagon over $10B contract awarded to Microsoft
Amazon is suing the Pentagon over a $10 billion cloud-computing contract awarded to Microsoft.
Amazon said it filed a legal complaint Friday with the U.S. Court of Federal Claims seeking to challenge the decision.
The complaint is sealed, but the company said earlier this month there was "unmistakable bias" on the government's part.
Amazon's competitive bid for the "war cloud" project drew criticism from President Donald Trump, who said over the summer that he wanted the Pentagon to take a closer look.
The Pentagon awarded the contract to Microsoft in late October.
U.S. Defense Secretary Mark Esper has said the procurement was done fairly without outside influence.
The contract, formally called the Joint Enterprise Defense Infrastructure, or JEDI, was sought by Microsoft, Amazon, Oracle and IBM.


?
?
???!
?
0
1
2
3
4
5
6
7
8
9
10
i/r//n\v3M
The
New
York
?
???I
I
cm
copyright
reserved
Botanical
Garden
*
-
-
New
York
Botanical
Garden
lfc225€M
PLANTS
OF
HAITI
ChsL
^
/
Qnyj
/Qr-gt^/.
Pali
^sv2l*do
,
Vicinity
ol
No
/5
jL*%/
EMERY
C.
LEONARD
i
ã
'
'
GENEVIEVE
M.
LEONARD)
Collt;ctors
Vicinity
of
Port
de
s'IAusiasxjC
2.Z
J929
1622584
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


Lucky die: {{ luckyDie }}
Backstab: {{ backstab }}
Sneak Silently: {{ sneakSilently }}
Hide In Shadows: {{ hideInShadows }}
Pick Pocket: {{ pickPocket }}
Climb Sheer Surfaces: {{ climbSheerSurfaces }}
Pick Lock: {{ pickLock }}
Find Trap: {{ findTrap }}
Disable Trap: {{ disableTrap }}
Forge Document: {{ forgeDocument }}
Disguise Self: {{ disguiseSelf }}
Read Languages: {{ readLanguages }}
Handle Poison: {{ handlePoison }}
Cast Spell From Scroll: {{ castSpellFromScroll }}


HAICOR Project
About
Contact
Concept Search
Unspecified
Noun
Adjective
Adjective satellite
Verb
Adverb
Q
Insert into knowledge graph
Concept Display
Remove
Connect
Unselect
Submit
Set Source
Set Target


Exploring your values
When I think of the times in my life where I have been the happiest, the proudest, or the most satisfied, these are the following things that come to my mind:
- Accomplishment
- Personal development
- Competition
- Status
- Music
- Money
The value that is most important to me is Accomplishment. I feel very satisfied when I accomplish my goals - be it at work, school or playing a game. Accomplishment isn't about winning the ultimate prize. It is the satisfaction of completing a task successfully by putting in my best efforts. There have been times in my life when I know that I could have put in a little more effort and achieved my goals but I try to improve myself with every goal I set for myself.
In general I try to live up to these values:
- Accomplishment: 3
- Personal development: 4
- Competition: 3
- Status: 3
- Music: 3
- Money: 4
The last topic someone asked my advice was my brother on some of the struggles he was having at MBA school. When he fist joined the school it was a big change for him having to move from Boston to Georgetown. He had no friends in Georgetown and his first month in MBA school was tough. I advised him to not panic and take it easy and focus on studying. Every time you come to a new place you have to adjust and adapt and eventually you will make friends and enjoyt your new surroundings.


{% extends "StoryApp/base.html" %} {% block maininfo %} {% if form.errors %}
Your username and password didn't match. Please try again.
{% endif %} {% if next %} {% if user.is_authenticated %}Your account doesn't have access to this page. To proceed, please login with an account that has access.
{% else %}Please login to see this page.
{% endif %} {% endif %} {% endblock %} {% block navi %}


scale eye track from [0 1] to image size This function scales the eye track (from between [0+i0, 1+i1]) to the size corresponding to the display, taking care not to change the -1 values corresponding to missing data. syntax: eyeTrack = scaleEyeTrack( eyeTrack, imageSize ) inputs: eyeTrack: vector of complex (x+i*y) coordinates. -1-i1 to identify missing data. imageSize: [height; width], probably [1024; 1280]; output: eyeTrack: the appropriately scaled version
0001 % scale eye track from [0 1] to image size 0002 % 0003 % This function scales the eye track (from between [0+i0, 1+i1]) to the 0004 % size corresponding to the display, taking care not to change the -1 0005 % values corresponding to missing data. 0006 % 0007 % syntax: eyeTrack = scaleEyeTrack( eyeTrack, imageSize ) 0008 % 0009 % inputs: 0010 % eyeTrack: vector of complex (x+i*y) coordinates. -1-i1 to identify 0011 % missing data. 0012 % imageSize: [height; width], probably [1024; 1280]; 0013 % 0014 % output: 0015 % eyeTrack: the appropriately scaled version 0016 0017 function [ eyeTrack imageSize ] = scaleEyeTrack( eyeTrack, imageSize ) 0018 0019 %default scaling amount 0020 if nargin < 2 || isempty( imageSize) 0021 imageSize = [1024; 1280]; 0022 end 0023 0024 0025 xEye = real( eyeTrack ); 0026 yEye = imag(eyeTrack); 0027 existSamples = find(xEye ~= -1 ); 0028 xEye( existSamples) = xEye( existSamples).*imageSize(2); 0029 0030 0031 yEye( existSamples) = yEye( existSamples).*imageSize(1); 0032 0033 eyeTrack = xEye+1i*yEye; 0034


|
|
IFXVertexBoneWeights Class ReferenceThis class is used as temp storage of bones data for single vertex.
More...
List of all members.
Detailed Description
This class is used as temp storage of bones data for single vertex.
Constructor & Destructor Documentation
| IFXVertexBoneWeights::IFXVertexBoneWeights |
( |
|
) |
|
|
| IFXVertexBoneWeights::~IFXVertexBoneWeights |
( |
|
) |
|
|
Member Function Documentation
| U32* IFXVertexBoneWeights::GetBoneIDs |
( |
void |
|
) |
[inline] |
|
| U32 IFXVertexBoneWeights::GetVertexIdx |
( |
void |
|
) |
[inline] |
|
| U32 IFXVertexBoneWeights::GetWeightCnt |
( |
void |
|
) |
[inline] |
|
| F32* IFXVertexBoneWeights::GetWeights |
( |
void |
|
) |
[inline] |
|
| void IFXVertexBoneWeights::SetBoneID |
( |
U32 |
i, |
|
|
U32 |
id |
|
) |
|
|
| void IFXVertexBoneWeights::SetVertexIdx |
( |
U32 |
v |
) |
[inline] |
|
| void IFXVertexBoneWeights::SetWeight |
( |
U32 |
i, |
|
|
F32 |
wg |
|
) |
|
|
| void IFXVertexBoneWeights::SetWeightCnt |
( |
U32 |
w |
) |
|
|
Member Data Documentation
|
|
Marker, used to mark uninitialized vertices.
|
© 1999 - 2006 Intel Corporation. All rights reserved.
* Other names and brands may be claimed as the property of others.
|
|


Setting up a Nikola site is really easy. You will need a few minutes’ time and a Python 3 interpreter.
Nikola is free open-source software, under the MIT license.
The best way to install Nikola is to use pip
in a virtual environment. We recommend installing the "Nikola[extras]"
distribution to access some extra features, but you can drop the [extras]
specifier if you don’t want them. Follow instructions on the right/below.
If you’ve never worked with Python virtual environments, you might want to read Python Virtual Environments in Five Minutes.
We don’t recommend using Pipenv, Poetry, or PDM to manage Nikola. Those package managers are aimed at people developing software using Python, not running software written in Python, so using them will not offer a good user experience.
Nikola supports Windows! Here are a few things to keep in mind:
git config --global core.symlinks true
before cloning the Nikola repo (recent versions of the git installer offer to do this for you). Nikola will work either way, but if you don’t enable symlinks, Nikola will have to fix them, which changes the working tree.\
as path separator (instead of /
)\r\n
) as the line separator (instead of LF \n
)Installing Nikola on macOS is easy. You can use Homebrew, MacPorts, Fink, or the Apple-provided Python 3 interpreter.
We recommend using Homebrew. After you install it, you can run brew install python3
to install Python 3. You can then follow the instructions on the right/below. Your venvs may require fixing, reconfiguration or recreating if you update Python.
Other package/port managers, such as MacPorts or Fink may be used if you prefer them and have those installed. Make sure to use only one manager to avoid conflicts.
The Apple-provided Python 3 will work too. Starting with Catalina, Python 3 is available, and it seems to be updated reasonably often. You might need to install Xcode Command Line Tools (xcode-select --install
), or possibly the full Xcode environment (from the App Store), to use it.
Nikola is packaged for some Linux distributions, you may get that instead of installing via pip
(which is the recommended way). Keep in mind that those packages might be outdated and that we don’t support versions that are too old. Proceed with care!
You can also install Nikola from GitHub. This will get you the code that is still under development. It probably has bugs, but there are often new features or bugfixes. Start by creating and activating a virtual environment.
$ pip install "git+https://github.com/getnikola/nikola#egg=Nikola[extras]"
For development work, or if you otherwise want a local clone of the repository, use this:
$ git clone https://github.com/getnikola/nikola # wherever you store your projects; you may also use a ssh remote address
$ cd nikola
$ pip install -e ".[extras]"
You should not need to compile any C extension modules to run Nikola. Both lxml and Pillow have pre-compiled wheels available for Windows, macOS and Linux (compatible with all distributions).
However, if pip still attempts to compile those packages, you may need to do the following:
pip install -U pip setuptools wheel
(on Windows, use py -m pip
)Python.h
, you need to install development packages for Python (eg. python3-dev or python3-devel).There are unofficial Docker images by Olaf Meeuwissen (based on Alpine Linux) available:
$ docker pull registry.gitlab.com/paddy-hack/nikola $ docker run --rm -it -v $PWD:/site -w /site -u $(id -u):$(id -g) \ registry.gitlab.com/paddy-hack/nikola nikola init .
Check out the image’s README for details and usage hints.
There is also a Dockerfile by Rob Brewer, based on Arch Linux and official Arch packages.
There are also Snapcraft packages (snap install nikola --edge
), but those inherit many limitations of the platform and are not recommended for daily use.
First, make sure Python 3 is installed.
On macOS, we recommend getting Python from Homebrew.
On Debian/Ubuntu, you also need the python3-venv package.
When you are done installing, run:$ python3 -m venv nikola-env $ cd nikola-env $ bin/python -m pip install -U pip setuptools wheel $ bin/python -m pip install -U "Nikola[extras]" ...snip... Successfully installed Nikola
You can now use Nikola by launching the script directly: $ bin/nikola Or you can activate the environment before working with Nikola and use the nikola command: $ source bin/activate $ nikola
First, install Python 3. Then you can run:
> py -m venv nikola-env
> cd nikola-env
> Scripts\python -m pip install -U pip setuptools wheel
> Scripts\python -m pip install -U "Nikola[extras]"
...snip...
Successfully installed Nikola
You can now use Nikola by launching the script directly:
> Scripts\nikola
Or you can activate the environment before working
with Nikola and use the nikola command:
> Scripts\activate
> nikola
After installing Nikola, you should create a site. A site is a collection of all assets needed to create your site: configuration, posts, pages, images, and all other files and customizations. This is the important data, so put it where you put that kind of things.
To create a site, you need to run nikola init --demo <directory_name>
. A friendly wizard will be launched, letting you configure your site easily. The --demo
option is used to fill your site with some demo content. (If you do not want the wizard, use the --quiet
argument.)
If you’re using a virtual environment, you should use the path to the Nikola script in your virtual environment (bin/nikola init
on *nix, Scripts\nikola init
on Windows), or alternatively, you can activate the environment (source bin/activate
on *nix, Scripts\activate
on Windows) and use the nikola
command directly.
 Virtual environments are meant to be ephemeral (you should be able to delete and recreate one at any time).
$ nikola init --demo my_first_site
Creating Nikola Site
====================
This is Nikola. We will now ask you a few easy questions about your new site.
If you do not want to answer and want to go with the defaults instead, simply restart with the `-q` parameter.
--- Questions about the site ---
Site title [My Nikola Site]: My First Nikola Site
...a couple more questions...
That's it, Nikola is now configured. Make sure to edit conf.py to your liking.
If you are looking for themes and addons, check out https://themes.getnikola.com/ and https://plugins.getnikola.com/.
Have fun!
INFO: init: A new site with example data has been created at my_first_site.
INFO: init: See README.txt in that folder for more information.
You can now build the site you created. Just run nikola build
inside your site directory. The output directory will then be filled with the contents of your site, which is now ready to deploy.
$ cd my_first_site
$ nikola build
Scanning posts....done!
. render_galleries:output/galleries
. render_galleries:output/galleries/demo
. render_galleries:output/galleries/index.html
. render_galleries:output/galleries/rss.xml
. render_galleries:output/galleries/demo/tesla4_lg.thumbnail.jpg
...and many more files in between...
. render_tags:output/categories/cat_nikola.xml
. render_pages:output/stories/social_buttons/index.html
. render_pages:output/stories/quickref/index.html
. render_tags:output/categories/python.xml
. generate_rss:output/rss.xml
. render_pages:output/stories/a-study-in-scarlet/index.html
. sitemap:output/sitemap.xml
. sitemap:output/sitemapindex.xml
. robots_file:output/robots.txt
Your site currently contains demo content — that is, some Nikola documentation, a demo gallery and listing, and a blog post welcoming you.
You should make it more interesting and personal. Write your own post!
To do that, you can just use nikola new_post -e
. (The -e
option will open the post in your text editor of choice; many more options are available)
The command will create the file for you in the right place, with the metadata headers and a writing prompt.
By default, Nikola creates posts in reStructuredText. You can read the reStructuredText Primer to get accustomed to the syntax.
If you prefer Markdown, it is also available and configured by default: run nikola new_post -e -f markdown
to create a new Markdown post.
You can also use many other input formats; to do this, your site needs some special configuration.
If you want a static site that does not have any blog-related elements, see our Creating a Site (Not a Blog) with Nikola guide.
$ nikola new_post -e
Creating New Post
-----------------
Title: My First Blog Post!
Scanning posts....done!
INFO: new_post: Your post's text is at: posts/my-first-blog-post.rst
When you’re done writing your post, you must rebuild your site to make it visible on your site. Run nikola build
again.
Note that the list of files is much shorter now: Nikola does fast, incremental rebuilds (courtesy of doit). Nikola built only the pages for this post, the indexes, the feeds, and the previous post (to add a Next post navigation button). All the demo pages and assets were left untouched, saving you time and resources (it does not have to work on building some larger things, and rsync
will not have to upload everything)
$ nikola build
Scanning posts....done!
. render_posts:timeline_changes
. render_posts:cache/posts/my-first-blog-post.html
. render_sources:output/posts/my-first-blog-post/index.rst
. render_archive:output/2018/index.html
. render_archive:output/archive.html
. render_indexes:output/index.html
. render_pages:output/posts/welcome-to-nikola/index.html
. generate_rss:output/rss.xml
. render_pages:output/posts/my-first-blog-post/index.html
. sitemap:output/sitemap.xml
. sitemap:output/sitemapindex.xml
You’re done! You just created a Nikola site, wrote your first post and built your site. Congratulations!
Run nikola serve --browser
to start the development server and open your site in a web browser. Press Ctrl+C to stop the server.
You can also use a server with automatic rebuilds by running nikola auto --browser
. Note that both servers should be used for development only; use other deployment solutions instead.
$ nikola serve --browser
INFO: serve: Serving HTTP on <IP_ADDRESS> port 8000...
INFO: serve: Opening http://<IP_ADDRESS>:8000/ in the default web browser...
nikola help
.conf.py
file to your liking.Input formats other than reStructuredText, Markdown, and raw HTML need some configuration, which has been described in The Nikola Handbook.
When you’re done exploring, you should remove the demo content before deploying it to your server. Remove the demo stories, welcome post, demo gallery and listing manually. Run nikola build
to make them disappear from the archives. Note that this is not enough; you need to delete the now orphaned files. Nikola can do it for you — run nikola check --clean-files
. Note that this command will delete all files in the output directory it does not know about, which can be dangerous — please back up your files or find out what will be deleted by using nikola orphans
.
Hint: files in the files/
directory are copied to the output directory as-is.
The development server (nikola serve
) should not be used outside of your local network. Instead, you should use a more serious web server. Nikola sites work on any web server which can host html files. You can use shared hosting, your own server (VPS/dedicated), GitHub Pages, or any other service that lets you host a website. For more details on deployment and related configuration, see the Deployment section in the Handbook.


Label: {{address.label}}
Balance: {{address.balance | currency : 'CSC ' : 8}}
Transactions: {{address.txApperances}}


This package contains generic interfaces for the analysis
xArch XML schema and DOM-based implementations of those interfaces.
To use this package, users should first create an IXArch
object
using the methods in edu.uci.isr.xarch.XArchUtils
.
Then, they should create a analysisContext
object using that IXArch
. The context object can
be used to create objects in this namespace.


Parallel.Foreach with ordered output using arrays
One of the problems I’ve recently had was to process a collection of data and return the outcome of each processing in another collection. To utilise the multiple and/or hyper threaded cores of the machine that executes the processing, I’ve used the Task Parallel Library.
The problem is that the output collection had to be ordered, i.e. each element of the collection had to correspond to the same order as the element in the input collection that it came from. A scenario for this is where we need to run a batch operation and need to match the output elements to each input element, such as updating multiple prices in a catalogue of products. One other way of matching input and output would be to assign identifiers to each element but I’ve decided against adding two temporary fields for an operation that could just be resolved with ordering.
Prototype:
public class ParallelNumberIncrementor
{
internal int[] Increment(int[] input)
{
int[] output = new int[input.Length];
Parallel.ForEach(input, (i, state, index) =>
{
output[index] = i + 1;
});
return output;
}
}
That’s what it is in its simplest form. Arrays are not thread safe but in this instance a thread accesses an array position only once. We’re using the overload of Parallel.ForEach
that gives us access to the index of the element being processed in each iteration.
In order to provide live documentation and also to test that our logic does what it’s meant to do, we can unit test this. We should remove the Parallel static from the ParallelNumberIncrementor
because we’re not testing the Task Parallel Library but only our own logic. So let’s isolate the TPL functionality.
public interface IParallelLooper
{
ParallelLoopResult ForEach<TSource>(IEnumerable<TSource> source, Action<TSource, ParallelLoopState, long> body);
}
This interface copies the Parallel.ForEach method signature for this example. You can add its overloads into it as per your needs.
The implementing class:
public class ParallelLooper
{
ParallelLoopResult ForEach<TSource>(IEnumerable<TSource> source, Action<TSource, ParallelLoopState, long> body)
{
return Parallel.ForEach(source, body);
}
}
So now let’s implement a ParallelNumberIncrementor
which is decoupled from the TPL. The logic to test is that even though each iteration can finish at different times on each execution of the loop, the end array will have its elements in the same order as the corresponding elements of the input array.
Let’s start by writing our first test for this.
[Test]
public void Increment_WhenElementProcessingFinishesInOrder_OutputElementsAppearInOrder()
{
var parallelNumberIncrementor = new ParallelNumberIncrementor();
var input = new[]{ 1, 2, 3 };
var output = parallelNumberIncrementor.Increment(input);
Assert.AreEqual(new[] { 2, 3, 4 }, output);
}
Getting it to pass:
public IEnumerable<int> Increment(int[] input)
{
foreach (var i in input)
yield return i + 1;
}
Ok, nothing fancy here. Also, we want the incrementing operations to happen in parallel iterations and this isn’t happening yet. If we could get an IParallelLooper involved that will make a case for parallelism.
Let’s re-think the ParallelNumberIncrementor:
public class ParallelNumberIncrementor
{
private readonly IParallelLooper _parallelLooper;
public ParallelNumberIncrementor(IParallelLooper parallelLooper)
{
_parallelLooper = parallelLooper
}
internal int[] Increment(int[] input)
{
return new int[0];
}
}
The skeleton is in place. This will build but will fail all the tests as it’s doing the minimal thing that’s required just to build (I prefer to not use null objects in place of collections but this is another topic altogether). We can delegate parallelism to the ParallelLooper and deal with the logic that outputs an array in the desired order. As our unit tests have to be deterministic, i.e. take the system under test from a precondition to post-assertion consistently with each run, we can fake the order the output elements are finished being produced. Then it will be the ParallelLooper
’s responsibility to reorder these elements.
Let’s rewrite the first test but with a ParallelLooper
.
[Test]
public void Increment_WhenElementProcessingFinishesInOrder_OutputElementsAppearInOrder()
{
var parallelLooper = new Mock<IParallelLooper>();
parallelLooper.Setup(x => x.ForEach(It.IsAny<IEnumerable<int>>(), It.IsAny<Action<int, ParallelLoopState, long>>()))
.Callback<IEnumerable<int>, Action<int, ParallelLoopState, long>>
((numbers, loopBody) =>
{
loopBody.Invoke(numbers.ElementAt(0), null, 1);
loopBody.Invoke(numbers.ElementAt(1), null, 2);
loopBody.Invoke(numbers.ElementAt(2), null, 3);
});
var parallelNumberIncrementor = new ParallelNumberIncrementor(parallelLooper.Object);
var input = new[]{ 1, 2, 3 };
var output = parallelNumberIncrementor.Increment(input);
Assert.AreEqual(new[] { 2, 3, 4 }, output);
}
We can mock an IParallelLooper
to return the output elements in reverse order and the ParallelNumberIncrementor will be responsible outputting the correct order.
We can have a design in mind just not be married to it.
public class ParallelNumberIncrementor
{
private readonly IParallelLooper _parallelLooper;
public ParallelNumberIncrementor(IParallelLooper parallelLooper)
{
_parallelLooper = parallelLooper
}
internal int[] Increment(int[] input)
{
int[] output = new int[input.Length];
_parallelLooper.ForEach(input, (i, state, index) =>
{
output[index] = i + 1;
});
return output;
}
}
- Installing the NewRelic .NET agent on an Alpine Docker image
- An implementation of the Capital Controls kata in Python
- Trigger validation of a dropdown box when tabbing over it in KnockoutJS
- The Capital Controls Kata
- Github Pages offers HTTPS for one custom domain. However you can point more than one domain to your pages (with caveats).


The persistence layer uses a 'normal' workspace as storage. The storage can later
be exchanged by a more scaleable one. The application layer operates on the
persistent one and provides the internal view of the version storage. It is
manifested through the InternalVersion
and
InternalVersionHistory
objects.
The internal versions are also mapped to the content and exposed through the
API (i.e. the Version
extends Node
and can be inspected
with normal Node methods). Furthermore the version store is also exposed below
/jcr:system/jcr:versionStorage
. The exact structure of it is not
defined yet, so applications should not relay on it and rather use
Node.getVersionHistory()
to access a particular version history or
use the search mechanisms to find the respective versions.
The presentation layer is managed by the VersionManager
. it is
responsible for mapping the version storage to the content.
Open issues: