C Specification
The VkPhysicalDeviceFeatures
structure is defined as:
// Provided by VK_VERSION_1_0
typedef struct VkPhysicalDeviceFeatures {
VkBool32 robustBufferAccess;
VkBool32 fullDrawIndexUint32;
VkBool32 imageCubeArray;
VkBool32 independentBlend;
VkBool32 geometryShader;
VkBool32 tessellationShader;
VkBool32 sampleRateShading;
VkBool32 dualSrcBlend;
VkBool32 logicOp;
VkBool32 multiDrawIndirect;
VkBool32 drawIndirectFirstInstance;
VkBool32 depthClamp;
VkBool32 depthBiasClamp;
VkBool32 fillModeNonSolid;
VkBool32 depthBounds;
VkBool32 wideLines;
VkBool32 largePoints;
VkBool32 alphaToOne;
VkBool32 multiViewport;
VkBool32 samplerAnisotropy;
VkBool32 textureCompressionETC2;
VkBool32 textureCompressionASTC_LDR;
VkBool32 textureCompressionBC;
VkBool32 occlusionQueryPrecise;
VkBool32 pipelineStatisticsQuery;
VkBool32 vertexPipelineStoresAndAtomics;
VkBool32 fragmentStoresAndAtomics;
VkBool32 shaderTessellationAndGeometryPointSize;
VkBool32 shaderImageGatherExtended;
VkBool32 shaderStorageImageExtendedFormats;
VkBool32 shaderStorageImageMultisample;
VkBool32 shaderStorageImageReadWithoutFormat;
VkBool32 shaderStorageImageWriteWithoutFormat;
VkBool32 shaderUniformBufferArrayDynamicIndexing;
VkBool32 shaderSampledImageArrayDynamicIndexing;
VkBool32 shaderStorageBufferArrayDynamicIndexing;
VkBool32 shaderStorageImageArrayDynamicIndexing;
VkBool32 shaderClipDistance;
VkBool32 shaderCullDistance;
VkBool32 shaderFloat64;
VkBool32 shaderInt64;
VkBool32 shaderInt16;
VkBool32 shaderResourceResidency;
VkBool32 shaderResourceMinLod;
VkBool32 sparseBinding;
VkBool32 sparseResidencyBuffer;
VkBool32 sparseResidencyImage2D;
VkBool32 sparseResidencyImage3D;
VkBool32 sparseResidency2Samples;
VkBool32 sparseResidency4Samples;
VkBool32 sparseResidency8Samples;
VkBool32 sparseResidency16Samples;
VkBool32 sparseResidencyAliased;
VkBool32 variableMultisampleRate;
VkBool32 inheritedQueries;
} VkPhysicalDeviceFeatures;
Description
-
robustBufferAccess
specifies that accesses to buffers are bounds-checked against the range of the buffer descriptor (as determined byVkDescriptorBufferInfo
::range
, VkBufferViewCreateInfo::range
, or the size of the buffer). Out of bounds accesses must not cause application termination, and the effects of shader loads, stores, and atomics must conform to an implementation-dependent behavior as described below.-
A buffer access is considered to be out of bounds if any of the following are true:
-
The pointer was formed by
OpImageTexelPointer
and the coordinate is less than zero or greater than or equal to the number of whole elements in the bound range. -
The pointer was not formed by
OpImageTexelPointer
and the object pointed to is not wholly contained within the bound range. This includes accesses performed via variable pointers where the buffer descriptor being accessed cannot be statically determined. Uninitialized pointers and pointers equal toOpConstantNull
are treated as pointing to a zero-sized object, so all accesses through such pointers are considered to be out of bounds. Buffer accesses through buffer device addresses are not bounds-checked. If thecooperativeMatrixRobustBufferAccess
feature is not enabled, then accesses usingOpCooperativeMatrixLoadNV
andOpCooperativeMatrixStoreNV
may not be bounds-checked.NoteIf a SPIR-V
OpLoad
instruction loads a structure and the tail end of the structure is out of bounds, then all members of the structure are considered out of bounds even if the members at the end are not statically used. -
If
robustBufferAccess2
is not enabled and any buffer access is determined to be out of bounds, then any other access of the same type (load, store, or atomic) to the same buffer that accesses an address less than 16 bytes away from the out of bounds address may also be considered out of bounds. -
If the access is a load that reads from the same memory locations as a prior store in the same shader invocation, with no other intervening accesses to the same memory locations in that shader invocation, then the result of the load may be the value stored by the store instruction, even if the access is out of bounds. If the load is
Volatile
, then an out of bounds load must return the appropriate out of bounds value.
-
-
Accesses to descriptors written with a VK_NULL_HANDLE resource or view are not considered to be out of bounds. Instead, each type of descriptor access defines a specific behavior for accesses to a null descriptor.
-
Out-of-bounds buffer loads will return any of the following values:
-
If the access is to a uniform buffer and
robustBufferAccess2
is enabled, loads of offsets between the end of the descriptor range and the end of the descriptor range rounded up to a multiple of robustUniformBufferAccessSizeAlignment bytes must return either zero values or the contents of the memory at the offset being loaded. Loads of offsets past the descriptor range rounded up to a multiple of robustUniformBufferAccessSizeAlignment bytes must return zero values. -
If the access is to a storage buffer and
robustBufferAccess2
is enabled, loads of offsets between the end of the descriptor range and the end of the descriptor range rounded up to a multiple of robustStorageBufferAccessSizeAlignment bytes must return either zero values or the contents of the memory at the offset being loaded. Loads of offsets past the descriptor range rounded up to a multiple of robustStorageBufferAccessSizeAlignment bytes must return zero values. Similarly, stores to addresses between the end of the descriptor range and the end of the descriptor range rounded up to a multiple of robustStorageBufferAccessSizeAlignment bytes may be discarded. -
Non-atomic accesses to storage buffers that are a multiple of 32 bits may be decomposed into 32-bit accesses that are individually bounds-checked.
-
If the access is to an index buffer and
robustBufferAccess2
is enabled, zero values must be returned. -
If the access is to a uniform texel buffer or storage texel buffer and
robustBufferAccess2
is enabled, zero values must be returned, and then Conversion to RGBA is applied based on the buffer view’s format. -
Values from anywhere within the memory range(s) bound to the buffer (possibly including bytes of memory past the end of the buffer, up to the end of the bound range).
-
Zero values, or (0,0,0,x) vectors for vector reads where x is a valid value represented in the type of the vector components and may be any of:
-
0, 1, or the maximum representable positive integer value, for signed or unsigned integer components
-
0.0 or 1.0, for floating-point components
-
-
-
Out-of-bounds writes may modify values within the memory range(s) bound to the buffer, but must not modify any other memory.
-
If
robustBufferAccess2
is enabled, out of bounds writes must not modify any memory.
-
-
Out-of-bounds atomics may modify values within the memory range(s) bound to the buffer, but must not modify any other memory, and return an undefined value.
-
If
robustBufferAccess2
is enabled, out of bounds atomics must not modify any memory, and return an undefined value.
-
-
If
robustBufferAccess2
is disabled, vertex input attributes are considered out of bounds if the offset of the attribute in the bound vertex buffer range plus the size of the attribute is greater than either:-
vertexBufferRangeSize
, ifbindingStride
== 0; or -
(
vertexBufferRangeSize
- (vertexBufferRangeSize
%bindingStride
))
where
vertexBufferRangeSize
is the byte size of the memory range bound to the vertex buffer binding andbindingStride
is the byte stride of the corresponding vertex input binding. Further, if any vertex input attribute using a specific vertex input binding is out of bounds, then all vertex input attributes using that vertex input binding for that vertex shader invocation are considered out of bounds.-
If a vertex input attribute is out of bounds, it will be assigned one of the following values:
-
Values from anywhere within the memory range(s) bound to the buffer, converted according to the format of the attribute.
-
Zero values, format converted according to the format of the attribute.
-
Zero values, or (0,0,0,x) vectors, as described above.
-
-
-
If
robustBufferAccess2
is enabled, vertex input attributes are considered out of bounds if the offset of the attribute in the bound vertex buffer range plus the size of the attribute is greater than the byte size of the memory range bound to the vertex buffer binding.-
If a vertex input attribute is out of bounds, the raw data extracted are zero values, and missing G, B, or A components are filled with (0,0,1).
-
-
If
robustBufferAccess
is not enabled, applications must not perform out of bounds accesses.
-
-
fullDrawIndexUint32
specifies the full 32-bit range of indices is supported for indexed draw calls when using a VkIndexType ofVK_INDEX_TYPE_UINT32
.maxDrawIndexedIndexValue
is the maximum index value that may be used (aside from the primitive restart index, which is always 232-1 when the VkIndexType isVK_INDEX_TYPE_UINT32
). If this feature is supported,maxDrawIndexedIndexValue
must be 232-1; otherwise it must be no smaller than 224-1. See maxDrawIndexedIndexValue. -
imageCubeArray
specifies whether image views with a VkImageViewType ofVK_IMAGE_VIEW_TYPE_CUBE_ARRAY
can be created, and that the correspondingSampledCubeArray
andImageCubeArray
SPIR-V capabilities can be used in shader code. -
independentBlend
specifies whether theVkPipelineColorBlendAttachmentState
settings are controlled independently per-attachment. If this feature is not enabled, theVkPipelineColorBlendAttachmentState
settings for all color attachments must be identical. Otherwise, a differentVkPipelineColorBlendAttachmentState
can be provided for each bound color attachment. -
geometryShader
specifies whether geometry shaders are supported. If this feature is not enabled, theVK_SHADER_STAGE_GEOMETRY_BIT
andVK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT
enum values must not be used. This also specifies whether shader modules can declare theGeometry
capability. -
tessellationShader
specifies whether tessellation control and evaluation shaders are supported. If this feature is not enabled, theVK_SHADER_STAGE_TESSELLATION_CONTROL_BIT
,VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT
,VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
,VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT
, andVK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO
enum values must not be used. This also specifies whether shader modules can declare theTessellation
capability. -
sampleRateShading
specifies whether Sample Shading and multisample interpolation are supported. If this feature is not enabled, thesampleShadingEnable
member of the VkPipelineMultisampleStateCreateInfo structure must be set toVK_FALSE
and theminSampleShading
member is ignored. This also specifies whether shader modules can declare theSampleRateShading
capability. -
dualSrcBlend
specifies whether blend operations which take two sources are supported. If this feature is not enabled, theVK_BLEND_FACTOR_SRC1_COLOR
,VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR
,VK_BLEND_FACTOR_SRC1_ALPHA
, andVK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA
enum values must not be used as source or destination blending factors. See https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#framebuffer-dsb. -
logicOp
specifies whether logic operations are supported. If this feature is not enabled, thelogicOpEnable
member of the VkPipelineColorBlendStateCreateInfo structure must be set toVK_FALSE
, and thelogicOp
member is ignored. -
multiDrawIndirect
specifies whether multiple draw indirect is supported. If this feature is not enabled, thedrawCount
parameter to thevkCmdDrawIndirect
andvkCmdDrawIndexedIndirect
commands must be 0 or 1. ThemaxDrawIndirectCount
member of theVkPhysicalDeviceLimits
structure must also be 1 if this feature is not supported. See maxDrawIndirectCount. -
drawIndirectFirstInstance
specifies whether indirect draw calls support thefirstInstance
parameter. If this feature is not enabled, thefirstInstance
member of allVkDrawIndirectCommand
andVkDrawIndexedIndirectCommand
structures that are provided to thevkCmdDrawIndirect
andvkCmdDrawIndexedIndirect
commands must be 0. -
depthClamp
specifies whether depth clamping is supported. If this feature is not enabled, thedepthClampEnable
member of the VkPipelineRasterizationStateCreateInfo structure must be set toVK_FALSE
. Otherwise, settingdepthClampEnable
toVK_TRUE
will enable depth clamping. -
depthBiasClamp
specifies whether depth bias clamping is supported. If this feature is not enabled, thedepthBiasClamp
member of the VkPipelineRasterizationStateCreateInfo structure must be set to 0.0 unless theVK_DYNAMIC_STATE_DEPTH_BIAS
dynamic state is enabled, and thedepthBiasClamp
parameter tovkCmdSetDepthBias
must be set to 0.0. -
fillModeNonSolid
specifies whether point and wireframe fill modes are supported. If this feature is not enabled, theVK_POLYGON_MODE_POINT
andVK_POLYGON_MODE_LINE
enum values must not be used. -
depthBounds
specifies whether depth bounds tests are supported. If this feature is not enabled, thedepthBoundsTestEnable
member of the VkPipelineDepthStencilStateCreateInfo structure must be set toVK_FALSE
. WhendepthBoundsTestEnable
is set toVK_FALSE
, theminDepthBounds
andmaxDepthBounds
members of the VkPipelineDepthStencilStateCreateInfo structure are ignored. -
wideLines
specifies whether lines with width other than 1.0 are supported. If this feature is not enabled, thelineWidth
member of the VkPipelineRasterizationStateCreateInfo structure must be set to 1.0 unless theVK_DYNAMIC_STATE_LINE_WIDTH
dynamic state is enabled, and thelineWidth
parameter tovkCmdSetLineWidth
must be set to 1.0. When this feature is supported, the range and granularity of supported line widths are indicated by thelineWidthRange
andlineWidthGranularity
members of theVkPhysicalDeviceLimits
structure, respectively. -
largePoints
specifies whether points with size greater than 1.0 are supported. If this feature is not enabled, only a point size of 1.0 written by a shader is supported. The range and granularity of supported point sizes are indicated by thepointSizeRange
andpointSizeGranularity
members of theVkPhysicalDeviceLimits
structure, respectively. -
alphaToOne
specifies whether the implementation is able to replace the alpha value of the fragment shader color output in the Multisample Coverage fragment operation. If this feature is not enabled, then thealphaToOneEnable
member of the VkPipelineMultisampleStateCreateInfo structure must be set toVK_FALSE
. Otherwise settingalphaToOneEnable
toVK_TRUE
will enable alpha-to-one behavior. -
multiViewport
specifies whether more than one viewport is supported. If this feature is not enabled:-
The
viewportCount
andscissorCount
members of the VkPipelineViewportStateCreateInfo structure must be set to 1. -
The
firstViewport
andviewportCount
parameters to thevkCmdSetViewport
command must be set to 0 and 1, respectively. -
The
firstScissor
andscissorCount
parameters to thevkCmdSetScissor
command must be set to 0 and 1, respectively. -
The
exclusiveScissorCount
member of the VkPipelineViewportExclusiveScissorStateCreateInfoNV structure must be set to 0 or 1. -
The
firstExclusiveScissor
andexclusiveScissorCount
parameters to thevkCmdSetExclusiveScissorNV
command must be set to 0 and 1, respectively.
-
-
samplerAnisotropy
specifies whether anisotropic filtering is supported. If this feature is not enabled, theanisotropyEnable
member of the VkSamplerCreateInfo structure must beVK_FALSE
. -
textureCompressionETC2
specifies whether all of the ETC2 and EAC compressed texture formats are supported. If this feature is enabled, then theVK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
,VK_FORMAT_FEATURE_BLIT_SRC_BIT
andVK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
features must be supported inoptimalTilingFeatures
for the following formats:-
VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK
-
VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK
-
VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK
-
VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK
-
VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK
-
VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK
-
VK_FORMAT_EAC_R11_UNORM_BLOCK
-
VK_FORMAT_EAC_R11_SNORM_BLOCK
-
VK_FORMAT_EAC_R11G11_UNORM_BLOCK
-
VK_FORMAT_EAC_R11G11_SNORM_BLOCK
To query for additional properties, or if the feature is not enabled, vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats as normal.
-
-
textureCompressionASTC_LDR
specifies whether all of the ASTC LDR compressed texture formats are supported. If this feature is enabled, then theVK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
,VK_FORMAT_FEATURE_BLIT_SRC_BIT
andVK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
features must be supported inoptimalTilingFeatures
for the following formats:-
VK_FORMAT_ASTC_4x4_UNORM_BLOCK
-
VK_FORMAT_ASTC_4x4_SRGB_BLOCK
-
VK_FORMAT_ASTC_5x4_UNORM_BLOCK
-
VK_FORMAT_ASTC_5x4_SRGB_BLOCK
-
VK_FORMAT_ASTC_5x5_UNORM_BLOCK
-
VK_FORMAT_ASTC_5x5_SRGB_BLOCK
-
VK_FORMAT_ASTC_6x5_UNORM_BLOCK
-
VK_FORMAT_ASTC_6x5_SRGB_BLOCK
-
VK_FORMAT_ASTC_6x6_UNORM_BLOCK
-
VK_FORMAT_ASTC_6x6_SRGB_BLOCK
-
VK_FORMAT_ASTC_8x5_UNORM_BLOCK
-
VK_FORMAT_ASTC_8x5_SRGB_BLOCK
-
VK_FORMAT_ASTC_8x6_UNORM_BLOCK
-
VK_FORMAT_ASTC_8x6_SRGB_BLOCK
-
VK_FORMAT_ASTC_8x8_UNORM_BLOCK
-
VK_FORMAT_ASTC_8x8_SRGB_BLOCK
-
VK_FORMAT_ASTC_10x5_UNORM_BLOCK
-
VK_FORMAT_ASTC_10x5_SRGB_BLOCK
-
VK_FORMAT_ASTC_10x6_UNORM_BLOCK
-
VK_FORMAT_ASTC_10x6_SRGB_BLOCK
-
VK_FORMAT_ASTC_10x8_UNORM_BLOCK
-
VK_FORMAT_ASTC_10x8_SRGB_BLOCK
-
VK_FORMAT_ASTC_10x10_UNORM_BLOCK
-
VK_FORMAT_ASTC_10x10_SRGB_BLOCK
-
VK_FORMAT_ASTC_12x10_UNORM_BLOCK
-
VK_FORMAT_ASTC_12x10_SRGB_BLOCK
-
VK_FORMAT_ASTC_12x12_UNORM_BLOCK
-
VK_FORMAT_ASTC_12x12_SRGB_BLOCK
To query for additional properties, or if the feature is not enabled, vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats as normal.
-
-
textureCompressionBC
specifies whether all of the BC compressed texture formats are supported. If this feature is enabled, then theVK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
,VK_FORMAT_FEATURE_BLIT_SRC_BIT
andVK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
features must be supported inoptimalTilingFeatures
for the following formats:-
VK_FORMAT_BC1_RGB_UNORM_BLOCK
-
VK_FORMAT_BC1_RGB_SRGB_BLOCK
-
VK_FORMAT_BC1_RGBA_UNORM_BLOCK
-
VK_FORMAT_BC1_RGBA_SRGB_BLOCK
-
VK_FORMAT_BC2_UNORM_BLOCK
-
VK_FORMAT_BC2_SRGB_BLOCK
-
VK_FORMAT_BC3_UNORM_BLOCK
-
VK_FORMAT_BC3_SRGB_BLOCK
-
VK_FORMAT_BC4_UNORM_BLOCK
-
VK_FORMAT_BC4_SNORM_BLOCK
-
VK_FORMAT_BC5_UNORM_BLOCK
-
VK_FORMAT_BC5_SNORM_BLOCK
-
VK_FORMAT_BC6H_UFLOAT_BLOCK
-
VK_FORMAT_BC6H_SFLOAT_BLOCK
-
VK_FORMAT_BC7_UNORM_BLOCK
-
VK_FORMAT_BC7_SRGB_BLOCK
To query for additional properties, or if the feature is not enabled, vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats as normal.
-
-
occlusionQueryPrecise
specifies whether occlusion queries returning actual sample counts are supported. Occlusion queries are created in aVkQueryPool
by specifying thequeryType
ofVK_QUERY_TYPE_OCCLUSION
in the VkQueryPoolCreateInfo structure which is passed tovkCreateQueryPool
. If this feature is enabled, queries of this type can enableVK_QUERY_CONTROL_PRECISE_BIT
in theflags
parameter tovkCmdBeginQuery
. If this feature is not supported, the implementation supports only boolean occlusion queries. When any samples are passed, boolean queries will return a non-zero result value, otherwise a result value of zero is returned. When this feature is enabled andVK_QUERY_CONTROL_PRECISE_BIT
is set, occlusion queries will report the actual number of samples passed. -
pipelineStatisticsQuery
specifies whether the pipeline statistics queries are supported. If this feature is not enabled, queries of typeVK_QUERY_TYPE_PIPELINE_STATISTICS
cannot be created, and none of the VkQueryPipelineStatisticFlagBits bits can be set in thepipelineStatistics
member of the VkQueryPoolCreateInfo structure. -
vertexPipelineStoresAndAtomics
specifies whether storage buffers and images support stores and atomic operations in the vertex, tessellation, and geometry shader stages. If this feature is not enabled, all storage image, storage texel buffers, and storage buffer variables used by these stages in shader modules must be decorated with theNonWritable
decoration (or thereadonly
memory qualifier in GLSL). -
fragmentStoresAndAtomics
specifies whether storage buffers and images support stores and atomic operations in the fragment shader stage. If this feature is not enabled, all storage image, storage texel buffers, and storage buffer variables used by the fragment stage in shader modules must be decorated with theNonWritable
decoration (or thereadonly
memory qualifier in GLSL). -
shaderTessellationAndGeometryPointSize
specifies whether thePointSize
built-in decoration is available in the tessellation control, tessellation evaluation, and geometry shader stages. If this feature is not enabled, members decorated with thePointSize
built-in decoration must not be read from or written to and all points written from a tessellation or geometry shader will have a size of 1.0. This also specifies whether shader modules can declare theTessellationPointSize
capability for tessellation control and evaluation shaders, or if the shader modules can declare theGeometryPointSize
capability for geometry shaders. An implementation supporting this feature must also support one or both of thetessellationShader
orgeometryShader
features. -
shaderImageGatherExtended
specifies whether the extended set of image gather instructions are available in shader code. If this feature is not enabled, theOpImage
*Gather
instructions do not support theOffset
andConstOffsets
operands. This also specifies whether shader modules can declare theImageGatherExtended
capability. -
shaderStorageImageExtendedFormats
specifies whether all the “storage image extended formats” below are supported; if this feature is supported, then theVK_FORMAT_FEATURE_STORAGE_IMAGE_BIT
must be supported inoptimalTilingFeatures
for the following formats:-
VK_FORMAT_R16G16_SFLOAT
-
VK_FORMAT_B10G11R11_UFLOAT_PACK32
-
VK_FORMAT_R16_SFLOAT
-
VK_FORMAT_R16G16B16A16_UNORM
-
VK_FORMAT_A2B10G10R10_UNORM_PACK32
-
VK_FORMAT_R16G16_UNORM
-
VK_FORMAT_R8G8_UNORM
-
VK_FORMAT_R16_UNORM
-
VK_FORMAT_R8_UNORM
-
VK_FORMAT_R16G16B16A16_SNORM
-
VK_FORMAT_R16G16_SNORM
-
VK_FORMAT_R8G8_SNORM
-
VK_FORMAT_R16_SNORM
-
VK_FORMAT_R8_SNORM
-
VK_FORMAT_R16G16_SINT
-
VK_FORMAT_R8G8_SINT
-
VK_FORMAT_R16_SINT
-
VK_FORMAT_R8_SINT
-
VK_FORMAT_A2B10G10R10_UINT_PACK32
-
VK_FORMAT_R16G16_UINT
-
VK_FORMAT_R8G8_UINT
-
VK_FORMAT_R16_UINT
-
VK_FORMAT_R8_UINT
NoteshaderStorageImageExtendedFormats
feature only adds a guarantee of format support, which is specified for the whole physical device. Therefore enabling or disabling the feature via vkCreateDevice has no practical effect.To query for additional properties, or if the feature is not supported, vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceImageFormatProperties can be used to check for supported properties of individual formats, as usual rules allow.
VK_FORMAT_R32G32_UINT
,VK_FORMAT_R32G32_SINT
, andVK_FORMAT_R32G32_SFLOAT
fromStorageImageExtendedFormats
SPIR-V capability, are already covered by core Vulkan mandatory format support. -
-
shaderStorageImageMultisample
specifies whether multisampled storage images are supported. If this feature is not enabled, images that are created with ausage
that includesVK_IMAGE_USAGE_STORAGE_BIT
must be created withsamples
equal toVK_SAMPLE_COUNT_1_BIT
. This also specifies whether shader modules can declare theStorageImageMultisample
andImageMSArray
capabilities. -
shaderStorageImageReadWithoutFormat
specifies whether storage images require a format qualifier to be specified when reading from storage images. If this feature is not enabled, theOpImageRead
instruction must not have anOpTypeImage
ofUnknown
. This also specifies whether shader modules can declare theStorageImageReadWithoutFormat
capability. -
shaderStorageImageWriteWithoutFormat
specifies whether storage images require a format qualifier to be specified when writing to storage images. If this feature is not enabled, theOpImageWrite
instruction must not have anOpTypeImage
ofUnknown
. This also specifies whether shader modules can declare theStorageImageWriteWithoutFormat
capability. -
shaderUniformBufferArrayDynamicIndexing
specifies whether arrays of uniform buffers can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type ofVK_DESCRIPTOR_TYPE_UNIFORM_BUFFER
orVK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC
must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare theUniformBufferArrayDynamicIndexing
capability. -
shaderSampledImageArrayDynamicIndexing
specifies whether arrays of samplers or sampled images can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type ofVK_DESCRIPTOR_TYPE_SAMPLER
,VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
, orVK_DESCRIPTOR_TYPE_SAMPLED_IMAGE
must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare theSampledImageArrayDynamicIndexing
capability. -
shaderStorageBufferArrayDynamicIndexing
specifies whether arrays of storage buffers can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type ofVK_DESCRIPTOR_TYPE_STORAGE_BUFFER
orVK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC
must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare theStorageBufferArrayDynamicIndexing
capability. -
shaderStorageImageArrayDynamicIndexing
specifies whether arrays of storage images can be indexed by dynamically uniform integer expressions in shader code. If this feature is not enabled, resources with a descriptor type ofVK_DESCRIPTOR_TYPE_STORAGE_IMAGE
must be indexed only by constant integral expressions when aggregated into arrays in shader code. This also specifies whether shader modules can declare theStorageImageArrayDynamicIndexing
capability. -
shaderClipDistance
specifies whether clip distances are supported in shader code. If this feature is not enabled, any members decorated with theClipDistance
built-in decoration must not be read from or written to in shader modules. This also specifies whether shader modules can declare theClipDistance
capability. -
shaderCullDistance
specifies whether cull distances are supported in shader code. If this feature is not enabled, any members decorated with theCullDistance
built-in decoration must not be read from or written to in shader modules. This also specifies whether shader modules can declare theCullDistance
capability. -
shaderFloat64
specifies whether 64-bit floats (doubles) are supported in shader code. If this feature is not enabled, 64-bit floating-point types must not be used in shader code. This also specifies whether shader modules can declare theFloat64
capability. Declaring and using 64-bit floats is enabled for all storage classes that SPIR-V allows with theFloat64
capability. -
shaderInt64
specifies whether 64-bit integers (signed and unsigned) are supported in shader code. If this feature is not enabled, 64-bit integer types must not be used in shader code. This also specifies whether shader modules can declare theInt64
capability. Declaring and using 64-bit integers is enabled for all storage classes that SPIR-V allows with theInt64
capability. -
shaderInt16
specifies whether 16-bit integers (signed and unsigned) are supported in shader code. If this feature is not enabled, 16-bit integer types must not be used in shader code. This also specifies whether shader modules can declare theInt16
capability. However, this only enables a subset of the storage classes that SPIR-V allows for theInt16
SPIR-V capability: Declaring and using 16-bit integers in thePrivate
,Workgroup
(for non-Block variables), andFunction
storage classes is enabled, while declaring them in the interface storage classes (e.g.,UniformConstant
,Uniform
,StorageBuffer
,Input
,Output
, andPushConstant
) is not enabled. -
shaderResourceResidency
specifies whether image operations that return resource residency information are supported in shader code. If this feature is not enabled, theOpImageSparse
* instructions must not be used in shader code. This also specifies whether shader modules can declare theSparseResidency
capability. The feature requires at least one of thesparseResidency*
features to be supported. -
shaderResourceMinLod
specifies whether image operations specifying the minimum resource LOD are supported in shader code. If this feature is not enabled, theMinLod
image operand must not be used in shader code. This also specifies whether shader modules can declare theMinLod
capability. -
sparseBinding
specifies whether resource memory can be managed at opaque sparse block level instead of at the object level. If this feature is not enabled, resource memory must be bound only on a per-object basis using thevkBindBufferMemory
andvkBindImageMemory
commands. In this case, buffers and images must not be created withVK_BUFFER_CREATE_SPARSE_BINDING_BIT
andVK_IMAGE_CREATE_SPARSE_BINDING_BIT
set in theflags
member of the VkBufferCreateInfo and VkImageCreateInfo structures, respectively. Otherwise resource memory can be managed as described in Sparse Resource Features. -
sparseResidencyBuffer
specifies whether the device can access partially resident buffers. If this feature is not enabled, buffers must not be created withVK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT
set in theflags
member of the VkBufferCreateInfo structure. -
sparseResidencyImage2D
specifies whether the device can access partially resident 2D images with 1 sample per pixel. If this feature is not enabled, images with animageType
ofVK_IMAGE_TYPE_2D
andsamples
set toVK_SAMPLE_COUNT_1_BIT
must not be created withVK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
set in theflags
member of the VkImageCreateInfo structure. -
sparseResidencyImage3D
specifies whether the device can access partially resident 3D images. If this feature is not enabled, images with animageType
ofVK_IMAGE_TYPE_3D
must not be created withVK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
set in theflags
member of the VkImageCreateInfo structure. -
sparseResidency2Samples
specifies whether the physical device can access partially resident 2D images with 2 samples per pixel. If this feature is not enabled, images with animageType
ofVK_IMAGE_TYPE_2D
andsamples
set toVK_SAMPLE_COUNT_2_BIT
must not be created withVK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
set in theflags
member of the VkImageCreateInfo structure. -
sparseResidency4Samples
specifies whether the physical device can access partially resident 2D images with 4 samples per pixel. If this feature is not enabled, images with animageType
ofVK_IMAGE_TYPE_2D
andsamples
set toVK_SAMPLE_COUNT_4_BIT
must not be created withVK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
set in theflags
member of the VkImageCreateInfo structure. -
sparseResidency8Samples
specifies whether the physical device can access partially resident 2D images with 8 samples per pixel. If this feature is not enabled, images with animageType
ofVK_IMAGE_TYPE_2D
andsamples
set toVK_SAMPLE_COUNT_8_BIT
must not be created withVK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
set in theflags
member of the VkImageCreateInfo structure. -
sparseResidency16Samples
specifies whether the physical device can access partially resident 2D images with 16 samples per pixel. If this feature is not enabled, images with animageType
ofVK_IMAGE_TYPE_2D
andsamples
set toVK_SAMPLE_COUNT_16_BIT
must not be created withVK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT
set in theflags
member of the VkImageCreateInfo structure. -
sparseResidencyAliased
specifies whether the physical device can correctly access data aliased into multiple locations. If this feature is not enabled, theVK_BUFFER_CREATE_SPARSE_ALIASED_BIT
andVK_IMAGE_CREATE_SPARSE_ALIASED_BIT
enum values must not be used inflags
members of the VkBufferCreateInfo and VkImageCreateInfo structures, respectively. -
variableMultisampleRate
specifies whether all pipelines that will be bound to a command buffer during a subpass which uses no attachments must have the same value for VkPipelineMultisampleStateCreateInfo::rasterizationSamples
. If set toVK_TRUE
, the implementation supports variable multisample rates in a subpass which uses no attachments. If set toVK_FALSE
, then all pipelines bound in such a subpass must have the same multisample rate. This has no effect in situations where a subpass uses any attachments. -
inheritedQueries
specifies whether a secondary command buffer may be executed while a query is active.
Document Notes
For more information, see the Vulkan Specification
This page is extracted from the Vulkan Specification. Fixes and changes should be made to the Specification, not directly.


Heapster on Kubernetes 1.11.3
Introduction
This is the english post on this post.
Although Heapster is deprecated on Kubernetes 1.11, but metrics-server looks like developing and a little inconvenience for me (for example, no dashboard support). So I tried to install Heapster to Kubernetes 1.11.3.
But at 2018-10-29, It doesn’t work easily. In this post, I write the small patch to work correctly in the following environment.
$ uname -a
Linux XXX 4.4.0-137-generic #163-Ubuntu SMP x86/64
$ kubectl version
Client Version: version.Info{Major:"1", Minor:"11", GitVersion:"v1.11.3", GitCommit:"a4529464e4629c21224b3d52edfe0ea91b072862", GitTreeState:"clean", BuildDate:"2018-09-09T18:02:47Z", GoVersion:"go1.10.3", Compiler:"gc", Platform:"linux/amd64"}
Server Version: version.Info{Major:"1", Minor:"11", GitVersion:"v1.11.4", GitCommit:"bf9a868e8ea3d3a8fa53cbb22f566771b3f8068b", GitTreeState:"clean", BuildDate:"2018-10-25T19:06:30Z", GoVersion:"go1.10.3", Compiler:"gc", Platform:"linux/amd64"}
$ docker version
Client:
Version: 17.03.2-ce
API version: 1.27
Go version: go1.6.2
Git commit: f5ec1e2
Built: Thu Jul 5 23:07:48 2018
OS/Arch: linux/amd64
Server:
Version: 17.03.2-ce
API version: 1.27 (minimum version 1.12)
Go version: go1.6.2
Git commit: f5ec1e2
Built: Thu Jul 5 23:07:48 2018
OS/Arch: linux/amd64
Experimental: false
Heapster
Clone
First, clone the Heapster repository.
$ git clone https://github.com/kubernetes/heapster/
$ cd heapster
Then, set Grafana Service Type to NodePort and downgrade container version from 5.0.4 to 4.4.3 as follows. The reason why I downgrade the version is the dashboard on Grafana is not shown in 5.0.4.
diff --git a/deploy/kube-config/influxdb/grafana.yaml b/deploy/kube-config/influxdb/grafana.yaml
index 216bd9a..266f47a 100644
--- a/deploy/kube-config/influxdb/grafana.yaml
+++ b/deploy/kube-config/influxdb/grafana.yaml
@@ -13,7 +13,7 @@ spec:
spec:
containers:
- name: grafana
- image: k8s.gcr.io/heapster-grafana-amd64:v5.0.4
+ image: k8s.gcr.io/heapster-grafana-amd64:v4.4.3
ports:
- containerPort: 3000
protocol: TCP
@@ -64,7 +64,7 @@ spec:
# or through a public IP.
# type: LoadBalancer
# You could also use NodePort to expose the service at a randomly-generated port
- # type: NodePort
+ type: NodePort
ports:
- port: 80
targetPort: 3000
In this point, The pods are launched if I kubectl apply
under
deploy/kube-config/rbac
and deploy/kube-config/influxdb
, but the following error logs are generated and not worked correctly.
E1028 07:39:05.011439 1 manager.go:101] Error in scraping containers from Kubelet:XX.XX.XX.XX:10255: failed to get all container stats from Kubelet URL "http://XX.XX.XX.XX:10255/stats/container/": Post http://XX.XX.XX.XX:10255/stats/container/: dial tcp XX.XX.XX.XX:10255:
getsockopt: connection refused
Apply patch
After googling the error message, I found this issue.
It looks the port to access are changed and I need to deal with HTTPS.
So I edit deploy/kube-config/influxdb/heapster.yaml
and deploy/kube-config/rbac/heapster-rbac.yaml
as below.
diff --git a/deploy/kube-config/influxdb/heapster.yaml b/deploy/kube-config/influxdb/heapster.yaml
index e820ca5..195061a 100644
--- a/deploy/kube-config/influxdb/heapster.yaml
+++ b/deploy/kube-config/influxdb/heapster.yaml
@@ -24,7 +24,7 @@ spec:
imagePullPolicy: IfNotPresent
command:
- /heapster
- - --source=kubernetes:https://kubernetes.default
+ - --source=kubernetes.summary_api:''?useServiceAccount=true&kubeletHttps=true&kubeletPort=10250&insecure=true
- --sink=influxdb:http://monitoring-influxdb.kube-system.svc:8086
---
apiVersion: v1
diff --git a/deploy/kube-config/rbac/heapster-rbac.yaml b/deploy/kube-config/rbac/heapster-rbac.yaml
index 6e63803..1f982fb 100644
--- a/deploy/kube-config/rbac/heapster-rbac.yaml
+++ b/deploy/kube-config/rbac/heapster-rbac.yaml
@@ -5,7 +5,7 @@ metadata:
roleRef:
apiGroup: rbac.authorization.k8s.io
kind: ClusterRole
- name: system:heapster
+ name: heapster
subjects:
- kind: ServiceAccount
name: heapster
Moreover, I create deploy/kube-config/rbac/heapster-role.yaml
.
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
name: heapster
rules:
- apiGroups:
- ""
resources:
- pods
- nodes
- namespaces
verbs:
- get
- list
- watch
- apiGroups:
- extensions
resources:
- deployments
verbs:
- get
- list
- update
- watch
- apiGroups:
- ""
resources:
- nodes/stats
verbs:
- get
Create pods
Finally, I apply these configurations.
$ kubectl create -f ./deploy/kube-config/rbac/
clusterrolebinding.rbac.authorization.k8s.io/heapster created
clusterrole.rbac.authorization.k8s.io/heapster created
$ kubectl create -f ./deploy/kube-config/influxdb/
deployment.extensions/monitoring-grafana created
service/monitoring-grafana created
serviceaccount/heapster created
deployment.extensions/heapster created
service/heapster created
deployment.extensions/monitoring-influxdb created
service/monitoring-influxdb created
After updating, I can configure launching Heapster, Grafana, and Influx DB by kubectl get all -n kube-system
.
And after waiting for minutes, I can see the metrics by kubectl top
node
.
Thought
When I faced to some miss behavior on Kubernetes, I often find a clue of solution by seeing the log
by kubectl logs
.


Better Metrics for Education
Updated on | By DJ Strouse | Permalink
Why today's tests are unnatural and some thoughts on how to improve them.
Have you ever taken a standardized test in your life that you thought properly measured the skill it was trying to test? Ever in your daily work found yourself thinking, “Wow! This job is just like that test I took in high school!”? Unless you make your living as a Mechanical Turk, probably not. Standardized tests seem to be almost universally regarded as artificial, but what exactly is it about them that is so far from the reality they are supposed to simulate?
Why Standardized Tests are Unnatural
Wrong temporal scale of pressure
Time management is an important skill in any field, but the majority of exams probe this skill on far too small a scale. In life, time management on the order of days, weeks, and months is far more crucial to success than time management on the order of minutes and hours. Standardized tests demand that not a minute is wasted, that essays be churned out in 20 minutes a piece, and that quantitative results be produced so fast that reflection is impossible. Who works like that?
Too close to purgatory
Unless you’re a deceased pagan in 14th century poetry, you probably spend very little time working in purgatory. Why then do tests take place in empty, silent, foreign rooms, devoid of pleasant stimulations such as music, window views, or our favorite cushy office chair? There’s a reason that people are so particular about their work environments - because it matters. Learning research shows that information learned in a particular context is often best recalled in that same context. By placing students in such unnatural conditions, ones they are unlikely to ever encounter again, we’re placing them at an unnecessary (and uneven) disadvantage.
Isolated from other people
It’s time to give up the myth of the lone genius. Successful people, regardless of their field, know how to work with others. Yes, those people also know how to work independently and produce unique and creative contributions, but they balance their time. Tests too should strike a balance between collaborative and independent work.
Isolated from information tools
It’s also time to stop ignoring the fact that just about every worker in the world has Google at their fingertips. No one needs to memorize the periodic tables of elements, the quadratic formula, or how to spell “paramecium.” Far more important is how to find and use information. Let students bring books, iPhones, and laptops to exams and start testing skills that matter.
A Marketplace for Metrics
So what kind of metrics do we need? To argue for one or a few in particular would only serve to bias the educational system in favor of certain social classes or types of learners. What we really need is a vibrant marketplace of metrics. Allowing a single metric (i.e. the SATs) to so fully dominate a measuring process as complicated as predicting the lifelong success of an eighteen year old is naive and irresponsible. I doubt a small group of middle-aged white male “experts” gathered at a roundtable in Washington, D.C. are going to solve the problem either. Instead, we need a wide field of people with different strategies competing to provide better measures of student aptitude.
Exactly what types of metrics this competition would converge on, I don’t know. I imagine students taking one or more general exams as well as a few less common ones focusing on the particular strengths they would like to emphasize. This test selection process would not only be a great exercise for young students in reflecting on their own strengths and weaknesses, it would help schools and employers better understand which characteristics a student most wants to emphasize.
That said, there are two particular skills alluded to above that I would hope to see quickly worked in to some of the competing metrics - collaboration and long-term time management. I’ve never seen a standardized test that probed either skill and yet, I can’t think of any two more important to my daily success.
This rant was inspired by a lunchtime discussion with Phil Zager and David Livingston. Thank you to both for providing such great conversation.


Created by Sean Kenny / @polycoder
OpenPipe utilizes a set of applications and tools for operation and testing
The core server components of OpenPipe were all written with PHP 5.3. PHP is a general-purpose server-side scripting language originally designed for web development to produce dynamic web pages.
The OpenPipe library that has currently been developed provides an adapter that interfaces with the CodeIgniter framework.
OpenPipe has been built and tested using the Apache HTTP server. OpenPipe is not limited to running on this architecture, and can theoretically be run on any web server that supplies integration with PHP.
All client side testing and analysis (manual and automated) of OpenPipe was performed using the FireFox web browser.
Selenium automates browsers by providing a common API that is provided in the form of a 'WebDriver'
A pipeline HTTP approach represented a traditional client-server communication process.
Every OpenPipe HTTP request cycle is composed of pipelets. A pipelet represents an atomic composition of HTML, CSS, and JavaScript. A web page request can be composed of one to many pipelets.

<link
rel="stylesheet"
type="text/css"
href="css/pipelet-1.css"
/>

Hello world!

Every pipelined HTTP request contains at least one initial pipelet. This pipelet determines the initial layout.

<title>Root Pipelet!</title>
<link rel="stylesheet" type="text/css" href="css/global.css" />

Hello World!

Pipelets can be nested within other pipelets. Pipletes are loaded breadth first. This allows for:
Pipelets that are part of the same depth can prioritized explicitly using the pipelet-priority OpenPipe HTML attribute

<title>Root Pipelet!</title>
<link rel="stylesheet" type="text/css" href="css/global.css" />

Hello World!

OpenPipe defines core interfaces for pluggable components of the system. Through utilizing provided interfaces, developers can contour and extend the library to meet new and existing needs.
The OpenPipe library utilizes design patterns where appropriate to make the available components easier to comprehend from a conceptual level, and also easier to extend for future use. The patterns explained below were chosen to provide maximum flexibility to the underlying system when integrating with existing PHP web application systems and frameworks.
Pipelet data is transmitted as JSON to the client. Each individual pipelet transmitted as JSON is referred to as a segment in the OpenPipe.js client library. Everything transmitted from the server to client is sent as a segment.
Implement an adapter for a PHP MVC framework, using the adapter strategy. An adapter was made for CodeIgniter.
$openPipeAdapter = new OpenPipe_Adapter_Pvc_CodeIgniter(dirname(__FILE__));
if(isset($_GET['nopipe'])){
$openPipeOutput = new OpenPipe_Output_Standard();
}else{
$openPipeOutput = new OpenPipe_Output_Piped('../../../../client/js');
}
$openPipeRunner = new OpenPipe_Runner($openPipeAdapter, $openPipeOutput);
$openPipeRunner->run();
Selenium was a perfect candidate for automated retrieval of data from window.performance.timing
interface PerformanceTiming {
long long navigationStart;
long long unloadEventStart;
long long unloadEventEnd;
long long redirectStart;
long long redirectEnd;
long long fetchStart;
long long domainLookupStart;
long long domainLookupEnd;
long long connectStart;
long long connectEnd;
long long secureConnectionStart;
long long requestStart;
long long responseStart;
long long responseEnd;
long long domLoading;
long long domInteractive;
long long domContentLoadedEventStart; long long domContentLoadedEventEnd; long long domComplete;
long long loadEventStart;
long long loadEventEnd;
};
To achieve an accurate simulation of load the freely available and opensource tool named, 'Siege', was utilized.
OpenPipe was tested while Siege was run at concurrency levels 10, 25, 50, and 100.
To achieve an accurate simulation of using resources during a web request, a resource simulator was created in CodeIgniter. It allows for simulated access of:
$this->externalevent->execute('webservice', 25);
$this->externalevent->execute('database', 10);
Demo time
<?php
$layoutData = file_get_contents(’layout.php’);
$pipe = new OpenPipe_Output_Handle(); $pipe->sendLayout($layoutData);
$dbRecords = mysql_query(’select * from facts ’); $content = ’’;
foreach($dbRecords as $dbRecord){
$content .= "
User {$dbRecord[’user_name ’]}
";
}
$pipe->sendContent(’user-names’, $content); $pipe->endPhase(1);
$pipe->close();


{% set no_robots = True %} {% extends "layout.html" %} {% block title %}Sample Data Import{% endblock %} {% block head %} {{ super() }} {% endblock %} {% block content %}
Use this form to upload sample genotypes.
Use the file input to select multiple files at a time if you have more than one. Each of these files should be using the names they were given by the genotyping service provider which should be in the format of "[sample ID]-raw-genotypes.txt".


---
layout: default
title: About Octanis
teaser: 'We are fascinated by big interdisciplinary challenges and we see it as our duty to inspire others. We believe that success originates primarily from discipline, attitude and ability. In that order. At Octanis, we incubate small hobbies into big, successful and open-to-all projects.'
cta: 'Work on a project
or come to our Makers Nights
every Tuesday, 18:15 - 22:00
at Octanis Microverse '
---
A project begins with a suggestion from a member. Usually this happens during an Octanis Makers Night on a Tuesday evening. This formal proposal can be a simple presentation or a prototype "show-n-tell". If other members are convinced, ressources can be allocated to the project and the project is given 18 months time to grow up. It is expected that the person who first presented the project will be the projects lead. This process is our form of incubation. N.b.: student members can directly apply for funding via our Minigrants!
All our projects are fueled by our belief in our founding values:
We are fascinated by big interdisciplinary challenges and we see it as our duty to inspire others. We believe that success originates primarily from motivation, attitude and ability. We are enlightened by the UNs Global Goals.
We use off-the-shelf affordable components wherever we can. It's not worth trying to build something for everyone if nobody can afford the parts to make it. Even in mass production, things that don't have to be custom, shouldn't be.
Everything we produce is published in a way so that anyone can reuse or build upon our work. On the other hand, we understand the confidentiality of some items we deal with and make sure to stay within the bounds.
Not only are we learning a great deal ourselves in every project we do, but we also commit to educating willing persons on practical and theoretical subjects, so they too are enabled to build something with little help.
 A lot of us attend or have attended one of the Swiss Federal Institutes of Technology. We all contribute in different ways to different projects within Octanis. Most members have one work area that they do very well and another that is a bit crazy and experimental!  After all, there's an unlimited supply of coffee!
The Comittee serves the members by providing direction, guiding projects, organising workshops and events, and taking care of administrative duties.
A robust and reliable phone that can be used without treating it with any caution and that requires charging once a month. Link to Wiki page
An anti-procrastination box which locks away your phone while you're studying.
No food waste on campus anymore!
Experimenting with a particle detector used for detecting ionizing radiation.


Vineet Tiwari
I am experienced in leveraging agile frameworks to provide a robust synopsis for high level overviews. Iterative approaches to corporate strategy foster collaborative thinking to further the overall value proposition.
Click here to View project:- Project
Download my Resume:- Resume


cloudflared
Command-line tool to create a persistent connection to the Cloudflare network.
More information: home page
- Authenticate and associate the connection to a domain in the Cloudflare account:
cloudflared tunnel login
- Establish a tunnel to a host in Cloudflare from the local server:
cloudflared tunnel --hostname hostname localhost:port_number
- Establish a tunnel to a host in Cloudflare from the local server, without verifying the local server's certificate:
cloudflared tunnel --hostname hostname localhost:port_number --no-tls-verify
- Save logs to a file:
cloudflared tunnel --hostname hostname http://localhost:port_number --loglevel panic|fatal|error|warn|info|debug --logfile path/to/file
- Install cloudflared as a system service:
cloudflared service install


supplychainpy.simulations package¶
Submodules¶
supplychainpy.simulations.monte_carlo module¶
-
class
supplychainpy.simulations.monte_carlo.
SetupMonteCarlo
(analysed_orders: list, period: str='months', period_length: int=12)¶ Bases:
object
Create a monte carlo simulation for inventory analysis.
-
build_window
(random_normal_demand: list, period_length: int=0, holding_cost_percentage: decimal.Decimal=0.48, shortage_cost_percentage: decimal.Decimal=0.3) → dict¶ Builds the simulation window for opening stock, demand, closing stock, backlog, holding cost and shortages.
The window represents a fixed time frame, supplied by the user. The window is then run several times to generate probabilities for example the probability of stocking out during the period specified or the probability that the final closing stock will be negative. The results will indicate the accuracy of the analytical model used to calculate the safety stock etc, based on a few assumptions.
Parameters: - random_normal_demand (list) – A list of random demand normally distributed.
- period_length (int) – length of window e.g. 12 weeks for a quarter etc.
- holding_cost_percentage (Decimal) – The percentage of unit cost to associate with holding cost,
- shortage_cost_percentage (Decimal) – The percentage of unit cost to associate with shortage cost,
Returns: - The build_window returns a dictionary of lists for opening_stock, demand, delivery,closing stock,
backlog, holding cost, shortage cost.
Return type: dict
Raises: ValueError
– The period_length is currently {} and the actual length of the demand is {}. Please make sure that the two values are equal”.format(period_length, len(random_normal_demand[0][sku.sku_id]))
-
generate_normal_random_distribution
(period_length: int) → list¶ Generates the random demand for a given sku.
For each sku a set of random demands are calculated based on the normal distribution of demand for this product.
Parameters: period_length (int) – length of window e.g. 12 weeks for a quarter etc. Returns: A list of randomly generated demand. Return type: list Raises: ValueError
-
normal_random_distribution
¶
-
supplychainpy.simulations.monte_carlo_frame module¶
-
class
supplychainpy.simulations.monte_carlo_frame.
BuildFrame
(**kwargs)¶ Bases:
supplychainpy.simulations.monte_carlo_frame.MainFrame
Shares the shared frame attribute with all instances to be used when using multi-threading for
-
class
supplychainpy.simulations.monte_carlo_frame.
MainFrame
¶ Bases:
object
Borg class making shared frame global
supplychainpy.simulations.sim_summary module¶
-
supplychainpy.simulations.sim_summary.
average_items
()¶
-
supplychainpy.simulations.sim_summary.
closing_stockout_percentage
()¶
-
supplychainpy.simulations.sim_summary.
frame
()¶
-
supplychainpy.simulations.sim_summary.
optimise_service_level
()¶ Optimises the safety stock for declared service level.
Identifies which skus under performed (experiencing a service level lower than expected) after simulating transactions over a specific period. The safety stock for these items are increased and the analysis is monte carlo is run again.
Parameters: - frame_summary (list) – window summary for each period multiplied by the number of runs.
- orders_analysis (list) – prior analysis of orders data.
- service_level (double) – required service level as a percentage.
- runs (int) – number of runs from previous
- percentage_increase (double) – the percentage increase required
Returns: - Updated orders analysis with new saftey stock values based optimised from the simulation. The initial values
from the analytical model.
Return type: list
-
supplychainpy.simulations.sim_summary.
optimise_sim
()¶
-
supplychainpy.simulations.sim_summary.
optimum_std
()¶
-
supplychainpy.simulations.sim_summary.
summarize_monte_carlo
()¶ summarises the monte carlo transaction summary
Generates random distribution for demand over period specified and creates a simulation window for opening_stock, demand, closing_stock, delivery and backlog for each sku in the data set. Creates a transaction summary window for inventory movements.
Parameters: - simulation_frame (list) – The path to the file containing two columns of data, 1 period and 1 data-point per sku.
- period_length (int) – The number of periods define the simulation window e.g. 12 weeks, months etc.
Returns: A list containing the transaction summary for each period.
Return type: list
supplychainpy.simulations.simulation_frame_summary module¶
-
class
supplychainpy.simulations.simulation_frame_summary.
MonteCarloFrameSummary
¶ Bases:
object
-
static
closing_stockout_percentage
(closing_stock: list, period_length: int)¶ Calculates the percentage of stock out that occurred during the period specified.
Parameters: - period_length (int) – length of window e.g. 12 weeks for a quarter etc.
- closing_stock (list) – list of closing stock values for a given sku over the same time frame as the period_length
Returns: Percentage of final closing stock values that result in stock out and backlog.
Return type: float
Raises: ValueError
– The number of stock positions and the period length must match exactly.
-
static
supplychainpy.simulations.simulation_gui module¶
-
class
supplychainpy.simulations.simulation_gui.
OrdersParcel
(**kwargs)¶ Bases:
kivy.uix.widget.Widget
-
move
()¶
-
velocity
¶ Property that allows the creation of a tuple of other properties.
For example, if x and y are
NumericProperty
s, we can create aReferenceListProperty
for the pos. If you change the value of pos, it will automatically change the values of x and y accordingly. If you read the value of pos, it will return a tuple with the values of x and y.For example:
class MyWidget(EventDispatcher): x = NumericProperty(0) y = NumericProperty(0) pos = ReferenceListProperty(x, y)
-
velocity_x
¶ Property that represents a numeric value.
Parameters: - defaultvalue: int or float, defaults to 0
Specifies the default value of the property.
>>> wid = Widget() >>> wid.x = 42 >>> print(wid.x) 42 >>> wid.x = "plop" Traceback (most recent call last): File "<stdin>", line 1, in <module> File "properties.pyx", line 93, in kivy.properties.Property.__set__ File "properties.pyx", line 111, in kivy.properties.Property.set File "properties.pyx", line 159, in kivy.properties.NumericProperty.check ValueError: NumericProperty accept only int/float
Changed in version 1.4.1: NumericProperty can now accept custom text and tuple value to indicate a type, like “in”, “pt”, “px”, “cm”, “mm”, in the format: ‘10pt’ or (10, ‘pt’).
-
velocity_y
¶ Property that represents a numeric value.
Parameters: - defaultvalue: int or float, defaults to 0
Specifies the default value of the property.
>>> wid = Widget() >>> wid.x = 42 >>> print(wid.x) 42 >>> wid.x = "plop" Traceback (most recent call last): File "<stdin>", line 1, in <module> File "properties.pyx", line 93, in kivy.properties.Property.__set__ File "properties.pyx", line 111, in kivy.properties.Property.set File "properties.pyx", line 159, in kivy.properties.NumericProperty.check ValueError: NumericProperty accept only int/float
Changed in version 1.4.1: NumericProperty can now accept custom text and tuple value to indicate a type, like “in”, “pt”, “px”, “cm”, “mm”, in the format: ‘10pt’ or (10, ‘pt’).
-
-
class
supplychainpy.simulations.simulation_gui.
SimulationFramework
(**kwargs)¶ Bases:
kivy.uix.widget.Widget
-
despatch_inventory
(vel=(0, -4))¶
-
parcel
¶ Property that represents a Python object.
Parameters: - defaultvalue: object type
Specifies the default value of the property.
- rebind: bool, defaults to False
Whether kv rules using this object as an intermediate attribute in a kv rule, will update the bound property when this object changes.
That is the standard behavior is that if there’s a kv rule
text: self.a.b.c.d
, wherea
,b
, andc
are properties withrebind
False
andd
is aStringProperty
. Then when the rule is applied,text
becomes bound only tod
. Ifa
,b
, orc
change,text
still remains bound tod
. Furthermore, if any of them wereNone
when the rule was initially evaluated, e.g.b
wasNone
; thentext
is bound tob
and will not become bound tod
even whenb
is changed to not beNone
.By setting
rebind
toTrue
, however, the rule will be re-evaluated and all the properties rebound when that intermediate property changes. E.g. in the example above, wheneverb
changes or becomes notNone
if it wasNone
before,text
is evaluated again and becomes rebound tod
. The overall result is thattext
is now bound to all the properties amonga
,b
, orc
that haverebind
set toTrue
.- **kwargs: a list of keyword arguments
- baseclass
If kwargs includes a baseclass argument, this value will be used for validation: isinstance(value, kwargs[‘baseclass’]).
Warning
To mark the property as changed, you must reassign a new python object.
Changed in version 1.9.0: rebind has been introduced.
Changed in version 1.7.0: baseclass parameter added.
-
set_globe
(vel=(0, -4))¶
-
stock
¶ Property that represents a Python object.
Parameters: - defaultvalue: object type
Specifies the default value of the property.
- rebind: bool, defaults to False
Whether kv rules using this object as an intermediate attribute in a kv rule, will update the bound property when this object changes.
That is the standard behavior is that if there’s a kv rule
text: self.a.b.c.d
, wherea
,b
, andc
are properties withrebind
False
andd
is aStringProperty
. Then when the rule is applied,text
becomes bound only tod
. Ifa
,b
, orc
change,text
still remains bound tod
. Furthermore, if any of them wereNone
when the rule was initially evaluated, e.g.b
wasNone
; thentext
is bound tob
and will not become bound tod
even whenb
is changed to not beNone
.By setting
rebind
toTrue
, however, the rule will be re-evaluated and all the properties rebound when that intermediate property changes. E.g. in the example above, wheneverb
changes or becomes notNone
if it wasNone
before,text
is evaluated again and becomes rebound tod
. The overall result is thattext
is now bound to all the properties amonga
,b
, orc
that haverebind
set toTrue
.- **kwargs: a list of keyword arguments
- baseclass
If kwargs includes a baseclass argument, this value will be used for validation: isinstance(value, kwargs[‘baseclass’]).
Warning
To mark the property as changed, you must reassign a new python object.
Changed in version 1.9.0: rebind has been introduced.
Changed in version 1.7.0: baseclass parameter added.
-
update
(dt)¶
-
-
class
supplychainpy.simulations.simulation_gui.
SimulationGuiApp
(**kwargs)¶ Bases:
kivy.app.App
-
build
()¶
-
globe
¶ Property that represents a Python object.
Parameters: - defaultvalue: object type
Specifies the default value of the property.
- rebind: bool, defaults to False
Whether kv rules using this object as an intermediate attribute in a kv rule, will update the bound property when this object changes.
That is the standard behavior is that if there’s a kv rule
text: self.a.b.c.d
, wherea
,b
, andc
are properties withrebind
False
andd
is aStringProperty
. Then when the rule is applied,text
becomes bound only tod
. Ifa
,b
, orc
change,text
still remains bound tod
. Furthermore, if any of them wereNone
when the rule was initially evaluated, e.g.b
wasNone
; thentext
is bound tob
and will not become bound tod
even whenb
is changed to not beNone
.By setting
rebind
toTrue
, however, the rule will be re-evaluated and all the properties rebound when that intermediate property changes. E.g. in the example above, wheneverb
changes or becomes notNone
if it wasNone
before,text
is evaluated again and becomes rebound tod
. The overall result is thattext
is now bound to all the properties amonga
,b
, orc
that haverebind
set toTrue
.- **kwargs: a list of keyword arguments
- baseclass
If kwargs includes a baseclass argument, this value will be used for validation: isinstance(value, kwargs[‘baseclass’]).
Warning
To mark the property as changed, you must reassign a new python object.
Changed in version 1.9.0: rebind has been introduced.
Changed in version 1.7.0: baseclass parameter added.
-
-
class
supplychainpy.simulations.simulation_gui.
StockParcel
(**kwargs)¶ Bases:
kivy.uix.widget.Widget
-
receive_inventory
(parcel)¶
-
-
supplychainpy.simulations.simulation_gui.
random
() → x in the interval [0, 1).¶
supplychainpy.simulations.simulation_summary module¶
supplychainpy.simulations.simulation_window module¶
-
class
supplychainpy.simulations.simulation_window.
MonteCarloWindow
¶ Bases:
object
Attributes for monte carlo calculations, for building the simulation window
-
backlog
¶
-
backlog_at_po_placement
¶
-
closing_stock
¶
-
demand
¶
-
holding_cost
¶
-
index
¶
-
lead_time
¶
-
opening_stock
¶
-
po_number_raised
¶
-
po_number_received
¶
-
po_raised_flag
¶
-
position
¶
-
purchase_order_raised_qty
¶
-
purchase_order_receipt_qty
¶
-
quantity_sold
¶
-
revenue
¶
-
shortage_cost
¶
-
shortage_units
¶
-
sku_id
¶
-
sold
¶
-


Select your native languages:
English
Afrikaans
Albanian
Amharic
Arabic
Armenian
Azeerbaijani
Basque
Bengali
Bosnian
Bulgarian
Catalan
Cebuano
Chinese (Simplified)
Chinese (Traditional)
Corsican
Croatian
Czech
Danish
Dutch
Esperanto
Estonian
Finnish
French
Frisian
Galician
Georgian
German
Greek
Gujarati
Haitian Creole
Hausa
Hawaiian
Hebrew
Hindi
Hmong
Hungarian
Icelandic
Igbo
Indonesian
Irish
Italian
Japanese
Javanese
Kannada
Kazakh
Khmer
Korean
Kurdish
Lao
Latvian
Lithuanian
Luxembourgish
Macedonian
Malagasy
Malay
Malayalam
Maltese
Maori
Marathi
Mongolian
Nepali
Norwegian
Nyanja (Chichewa)
Pashto
Persian
Polish
Portuguese
Punjabi
Romanian
Russian
Samoan
Scots Gaelic
Serbian
Sesotho
Shona
Sindhi
Sinhala (Sinhalese)
Slovak
Slovenian
Somali
Spanish
Swahili
Swedish
Tagalog (Filipino)
Tajik
Tamil
Telugu
Thai
Turkish
Ukranian
Urdu
Uzbek
Vietnamese
Welsh
Xhosa
Yiddish
Yoruba
Zulu


--- layout: plainarticle permalink: '/alumni-projects/alumni-consulting-initiative/jacobs-feed-episode-2/' title: JacobsFeed Episode 2 - Save Money, Help Jacobs ---
In our last article we went into the details of the outstanding loans and ended with a promise to present you with a concrete approach to minimize your loan burden AND help Jacobs improve their recovery rate at the same time.
Basically, this is how many of us felt after Graduation when we realized we had that massive outstanding loan:
Sometimes this is also what mid-term season felt like.
Graduating, looking for a job, and getting into the real world are all daunting challenges. However, they are also a reality everyone of us has to face! Unfortunately, in the process many of us forget about or stop prioritizing the loan we received from Jacobs. While this is bad for the University, its worse for your own wallet. The loan grows and grows until it turns into a mountain you feel you can never overcome. But does it really have to be like this? In fact – not at all! Thanks to very low interest rates, some generous offers from the University and some help from the government you might be done with your loan faster than you expect!
My reaction, when I discovered the pass option.
Did you know that you can always end the Jacobs tuition postponement earlier than scheduled in the payback plan? And on your last payment – you typically got a 5% discount.
Now, imagine that you inherit some money, save up a few years after starting to work, win a jackpot, or more realistically – have friends or family who are willing to lend you the cash or can get access to a cheap bank loan (see Opportunity No. 3). In the past – you could use this to pay off your loan at Jacobs in one go and save 5% of the amount in the process.
Now, here’s the best part, until the 31st of January 2015, the University is offering a one-time special 10 year reunion offer!
You get 10%, you get 10%, you all get 10% (sorry, we’re gifaholics – this wont stop)
What this means is – if you pay up your full Jacobs loan at once before the 31st of January, 2015 – you will get a solid 10% rebate on it. However, check with your tax consultant on how to potentially split this across 2014 and 2015 in order to get maximum savings (see Opportunity 4 for more tax related ideas).
Opportunity No. 2: Larger Installments
As you know, Jacobs charges every year 7.75% interest on the amount that you owe the university. By paying back smaller amounts every month than what you could actually sustain and thereby stretching the payment period unnecessarily further, you are in fact hurting yourself. If you manage to pay back your tuition loan in one year, starting right after graduation, Jacobs will charge only once the 7.75%. In comparison, if you pay back everything only after 8 years, Jacobs will charge 7.75% eight times! Admittedly, each time the interest is charged on a smaller face value since you gradually reduce your outstanding debt, but the difference stays large.
By voluntarily increasing your monthly rate, you can therefore save a lot of cash!
See an example calculation below:
Yes – that’s a significant amount of cash you can save just by putting a bit more of your savings into your loan every month.
Now, convert your savings to Zimbabwean Dollars – and roll in them Huell-Style
Opportunity No. 3: Cover the Jacobs loan with a lower interest loan from a local bank (Refinancing)
The Jacobs interest rate reflects the credit risk the University is bearing. Jacobs has had a constant interest rate of 7.75% for everyone. At the time you came to Jacobs, there was no choice but to take that Jacobs tuition postponement. Now, however, you are likely to be in a different position.  Under the current market conditions interest rate levels are very low, so chances are high that you will find a loan that charges less than the Jacobs 7.75%. (Many German banks for example offer personal loans for as little as 4,5% these days).
See an example calculation below (includes the 10% discount from Opportunity No. 1):
So combining the interest savings from refinancing together with the 10% discount you can effectively save a much larger percentage of your loan – in one go!
Make sure your loan is business baby approved.
Costs that are incurred during a university education are, in many countries, tax deductable. What that means is that the tuition loan payments you are making each year can be substracted from the gross income that will be subject to income tax. That can be a lot of money you can save, especially in countries with high income tax. For Germany that means up to 6000 € that can be claimed for the Bachelor’s, and unlimited amounts for a Master and PhD every year. Just ask a fellow Alumni living in your country or any tax advisor to be sure.
So what does this all mean?
That Gen CS 1 feeling
Don’t worry – we got your covered. To better illustrate what all these benefits mean when making use of all opportunities combined, let’s walk you through one comprehensive example and see what’s really in for you.
Assume the following case:
– You owe the university a total amount of 15000€.
– You went on to a Master’s for two years, right after graduation.
– You had a well-paying student job in the second year of your Master’s.
– You get a good job in Germany after you graduated and earn an annual salary of 40000€.
Now you know how you can help the University AND yourself at the same time. If you still have questions, read through our FAQ document and/ or come to the presentation at Homecoming to find out more. If you want to know how you can optimize your loan best – check out the cool loan calculator we will put online soon as a part of the new Almalink website.
Have fun saving money!


--- title: Israel shot 045 date: 2004-02-15T00:00:00.000Z filepathOriginal: photos/IMG0140.jpg filepathThumbnail: photos/IMG0140.thumbnail.jpg filepathPreview: photos/IMG0140.preview.jpg ---
Further up on the Nahal Arogot hike: stunning view of the Dead Sea and a coastal kibbutz below


Gparted is the Gnome Partition Editor, a Gtk 2 GUI for other command line tools that can create, reorganise or delete disk partitions.
This package is known to build and work properly using an LFS-7.6 systemd platform.
Download (HTTP): http://downloads.sourceforge.net/gparted/gparted-0.19.1.tar.bz2
Download MD5 sum: 9aff8cef2c46e5ca4adaab43588c9e64
Download size: 2.0 MB
Estimated disk space required: 77 MB (additional 3 MB, building the optional documentation)
Estimated build time: 0.9 SBU (additional 0.1 SBU, building the optional documentation)
GNOME Doc Utils and Rarian-0.8.1
User Notes: http://wiki.linuxfromscratch.org/blfs/wiki/gparted
Install Gparted by running the following commands:
./configure --prefix=/usr \ --disable-doc \ --disable-static && make
This package does not come with a testsuite.
Now, as the root
user:
make install
--disable-static
: This
switch prevents installation of static versions of the libraries.
--disable-doc
: This switch disables
building of the optional documentation. Remove it if you have
installed GNOME Doc Utils.
To manipulate file systems Gparted has a run time dependency on various file system tools (you only need to install the tools for file systems you actually use): e2fsprogs (installed as part of LFS), jfsutils-1.1.15, ntfs-3g-2014.2.15, reiserfsprogs-3.6.24, xfsprogs-3.2.1, btrfs-progs, dosfstools, mtools (required to read and write FAT16/32 volume labels and UUIDs), hfsutils, hfsprogs, nilfs-utils and reiser4progs.
Root privileges are required to run Gparted. If you wish to run the application from the menu, further packages and configuration are necessary. One solution is to use pkexec from Polkit-0.112. Another solution is to use ssh-askpass-6.6p1.
To optionally use ssh-askpass-6.6p1, run the following
commands as the root
user:
cp -v /usr/share/applications/gparted.desktop \ /usr/share/applications/gparted.desktop.back && sed -i 's/Exec=/Exec=sudo -A /' /usr/share/applications/gparted.desktop &&
To optionally use pkexec, you need polkit-gnome-0.105 or LXPolkit-0.1.0 or any Polkit authentication
agent provided by your desktop environment and Systemd (for
Logind). Run the following commands as the root
user:
cp -v /usr/share/applications/gparted.desktop \ /usr/share/applications/gparted.desktop.back && sed -i 's:/usr/sbin/gparted:/usr/sbin/gparted_polkit:' \ /usr/share/applications/gparted.desktop && cat > /usr/sbin/gparted_polkit << "EOF" &&#!/bin/sh pkexec /usr/sbin/gparted $@
EOF chmod -v 755 /usr/sbin/gparted_polkit cat > /usr/share/polkit-1/actions/org.gnome.gparted.policy << "EOF"<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE policyconfig PUBLIC "-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN" "http://www.freedesktop.org/standards/PolicyKit/1/policyconfig.dtd"> <policyconfig> <action id="org.freedesktop.policykit.pkexec.run-gparted"> <description>Run GParted</description> <message>Authentication is required to run GParted</message> <defaults> <allow_any>no</allow_any> <allow_inactive>no</allow_inactive> <allow_active>auth_admin_keep</allow_active> </defaults> <annotate key="org.freedesktop.policykit.exec.path">/usr/sbin/gparted</annotate> <annotate key="org.freedesktop.policykit.exec.allow_gui">true</annotate> </action> </policyconfig>
EOF chmod -v 644 /usr/share/polkit-1/actions/org.gnome.gparted.policy
Last updated on 2014-08-25 09:58:52 -0700


The prolog mode uses the default Emacs colors for font-locking as far as possible. The only custom settings are in the prolog process buffer. The default settings of the colors may not agree with your preferences, so here is how to change them.
If your Emacs supports it, use `Customize'. M-x customize-group <RET> font-lock <RET> will show the `Customize' settings for font locking and also contains pointers to the `Customize' group for the font lock (type)faces. The rest of this section outlines the more involved methods needed in older versions of Emacs.
First of all, list all available faces (a face is a combined setting of foreground and background colors, font, boldness, etc.) by typing M-x list-faces-display.
There are several functions that change the appearance of a face, the ones you will most likely need are:
set-face-foreground
set-face-background
set-face-underline-p
make-face-bold
make-face-bold-italic
make-face-italic
make-face-unbold
make-face-unitalic
These can be tested interactively by typing M-x
function-name. You will then be asked for the name of the face to
change and a value. If the buffers are not updated according to the new
settings, refontify the buffer using the Fontify
Buffer
menu entry in the Prolog
menu.
Colors are specified by a name or by RGB values. Available color names can be listed with M-x list-colors-display.
To store the settings of the faces, a few lines must be added to ~/.emacs. For example:
;; Customize font-lock faces (add-hook 'font-lock-mode-hook '(lambda () (set-face-foreground font-lock-variable-name-face "#00a000") (make-face-bold font-lock-keyword-face) (set-face-foreground font-lock-reference-face "Blue") ))


LABEL
LABEL
Patients
0
0
Patients
0
0
totInstances
0
Patients
0
0
Patients
0
0
Destination AET:
DCM4CHEE
DCMRCV
Export Results
[ExportResult]
Close after export is finished
downloadERROR


Select the pages where you want to insert this plugin into the @{plugin->socket}@ socket of the @{plugin->skin}@ skin.


Dear Users,
We as a company strive to create a positive and affordable environment for VR and AR users. If you harm this community by not following the following terms, we withhold the right to revoke your access to buy our products or use any of the collaborative features in our games.
Illegal Behavior
It is a violation of the Terms of Service to use any UNAVRS products for illegal activity. This includes, but is not limited to:
- Homicide
- Predatory Behavior
- Theft of Information
- Blackmail
- Conspiracy
Piracy
Do not create or distribute copies of our games. Remember, piracy is not a victimless crime.
Tech Support
All UNAVRS products come with a 2 year return policy on all damage. The return policy is void if any of the following are present:
- Signs of obvious physical tampering
- Signs of abuse of equipment
- Signs of purposeful damage
Support
If you have any questions, problems, or concerns, please contact our support email<EMAIL_ADDRESS>Advertising
If you want to have your company advertised by UNAVRS email<EMAIL_ADDRESS>about any inquiries you may have.


To get the start time of the presentation from a raw video, add the url parameter "?url={cloudinary video url}"
Play
Backward
Forward


Introduction to statistics and data analysis, from simple average and variance to fit algorithms and hypothesis tests.
This lesson was made for a workshop on Python and Data Analysis that took place in 2019 at the Department of Chemistry of the King’s College London (London, UK).
Content
- Introduction
- Data Fitting
- Hypothesis Tests
Source(s)
- Press W H, Teukolsky S A, Vetterling W T and Flannery B P; Numerical Recipes in C - The Art of Scientific Computing, 1992, 2nd Edition, Cambridge Press


THE BIRDCAGE A film review by Steve Rhodes Copyright 1996 Steve Rhodes
RATING (0 TO ****): * 1/2
THE BIRDCAGE is a well constructed one joke movie that audiences seem to love and that some critics like and others don't. This critic admired Robin Williams's performance as well as some of the minor actors, but found the film's depiction of gay people more insulting to them than funny. Then again, perhaps I am too sensitive or maybe I just want more from a movie than caricature.
THE BIRDCAGE is based on the French film LA CAGE AUX FOLLES.  Albert is Armand's star in his transvestite nightclub. Although the other male singers in the club are quite convincing as females, Albert isn't and looks more like a male actor trying to play a transvestite. This is consistent with Lane's performance. Although I found Williams believable as gay, Lane overacted so much that I never found his character believable.
Val announces that he is going to marry Barbara (Calista Flockhart), who is the daughter of the founder of The Coalition for Moral Order, conservative Ohio Republican Senator Kevin Keeley (Gene Hackman). It seems that, whereas Armand and Albert are a real family, the Republicans are all hypocrites. Senator Keeley is backing fellow Moral Order Senator Jackson for President until Jackson is killed in the bed of an underaged black prostitute. The screen adaptation by Elaine May ridicules Senator Dole by name many times in order to make the movie topical and to make sure that audience knows they are serious about the Republican hypocrisy point.
 Albert decides to become a man again and play the part of Val's uncle while Val's biological mother, whom Val has never met, is asked to return to be to his Mom for an evening.
Let's cut to chase. The reason I do not like the show is the repeated single joke. Take, for example, Armand's teaching Albert to act masculine. Albert keeps sticking his pinkie towards the sky while drinking only to have Armand slap it down. Every time he hits the pinkie, the audience roars. Every time Albert use the female pronoun to refer to himself, the audience goes crazy.  Albert keeps claiming he is going to faint, he drives 20 mph for miles with his parking brake on, etc., ad nauseam. I found the antics demeaning to gays and highly repetitious.
  This character is the most insulting of them all. Director Mike Nichols should have been ashamed to have used such cheap shots.
There are some lines I liked. When Armand is trying to teach Albert how to act straight, he says, "What do you think about those Dolphins?" Albert, trying his best to act macho, answers in an attempted deeper voice with, "How do you think I feel? Betrayed? Bewildered?" In another scene, Armand describes his predicament as, "It's like riding a psychotic horse toward a burning stable." Senator Keeley does not trust the American public saying, "People in this country aren't interested in details. They only trust headlines."
There are two aspects of the show that deserve special mention. The cinematography (Emmanuel Lubezki) and the sets (Cheryl Carasik) are garish and great. Full of bright colors of limes, yellows, and roses. The costumes, especially those of Armand's done by Stephen Shubin, are both outlandish and visually compelling.
Today we have the Internet Movie Data Base to answer every question we ever want to ask about stars, as well, of course, as a way to find old reviews. There is one actress in the movie that plays the secretary to Val's biological mother. I believe I wrote down her name correctly as Francesca Cruz. She is not listed anywhere on the Web, which really bothers me. I know I have seen her somewhere before but I can not figure out where. If anyone knows, I wish they would drop me a line. She has a trivial part in the film, it is just that I can not figure out where I saw her before.
THE BIRDCAGE runs a little too long 1:58 thanks to editor Arthur Schmidt. The film is rated R for some mild language. There is no sex, nudity or violence. The film should be fine for teenagers. Although I do not recommend this show, I should point out in fairness that my wife liked it and was laughing right along with most of the rest of the audience. I suspect the film will make a bundle. I give the movie * 1/2 for William's performance plus the well done minor performances of Flockhart and Wiest, but I found little worth rewarding in the rest of the cast and found the script demeaning to gays and insulting to Republicans.
**** = One of the top few films of this or any year. A must see film. *** = Excellent show. Look for it. ** = Average movie. Kind of enjoyable. * = Poor show.  Totally unbearable.
REVIEW WRITTEN ON: March 8, 1996
Opinions expressed are mine and not meant to reflect my employer's.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


[§527‑14] Disclaimer. A beneficiary may disclaim all or part of the beneficiary's interest as provided by chapter 526, the Uniform Disclaimer of Property Interests Act. [L 2011, c 173, pt of §1]


{% extends "base.html" %} {% block title %} Delete Passenger - {{ passenger.passenger }} {% endblock %} {% block content %}
Are you sure you want to delete the passenger: {{ passenger.passenger }} ?
The action is permanent


Sample Food Ordering Application
Barkada Meal 1
Family Meal A
Chicken Value Meal 1
Family Drink Pack B
Barkada Meal 2
Food Order Choices:
Food Bundle A
Food Bundle B
Food Bundles A:
10 pcs. Deli cious Friend Chicken
Food Bundles B:
4 Cups Special Hal o-Halo Regular
Order Details:
Price:
Quantity:
Amount To Pay:
Cash From Customer:
Change:
CALCULATE BILLS
CHANGE
NEW


---
layout: post
title: Ed Byrne on wedding planning
date: '2014-02-14T11:27:00.000+01:00'
excerpt: "You wouldn't understand unless you've been there"
comments: true
tags:
- Humour
- Self-indulgence
modified_time: '2014-02-14T11:27:32.970+01:00'
blogger_id: tag:blogger.com,1999:blog-5442825777886761537.post-6129051084761088042
blogger_orig_url: http://stickmanscorral.blogspot.com/2014/02/ed-byrne-on-wedding-planning.html
---
As the man says, you wouldn't understand unless you've been there.
(Start from 2:45)


Machine Learning Engineer in Natural Language Processing team at Goldman Sachs. Graduated in July 2021 from the University of Birmingham with a First Class (Hons) in BSc Artificial Intelligence and Computer Science. Achieved a First Class in my dissertation. Passionate for code. I possess necessary programming skills and well-developed social skills. Flexible attitude to work and strong organisational skills for a variety of situations to achieve deadlines. Strong initiative and can work independently or as part of a team.
Natural Language Processing team within Data Science and Machine Learning group
Engineering Summer Analyst in the Risk Division
Placement year as L3 Support Engineer in cloud and cognitive software primarily working in C++ and Java.
Full-stack Python developer developing and maintaining the English Academic Paraphrase Practice, a Django Python LTI (Canvas external tool) of which the core feature is the automated analysis of students’ writing tasks. My role included:
One of 14 students selected from across the United Kingdom to gain insight as a software engineer in the Aladdin Product Group (APG). Completed coding challenges throughout the week and presented ideas on improving existing system architecture.
Summer internship as a ServiceNow developer for Europe’s largest independent IT group.
Apprentice full-stack developer building back-end systems for data analysis and front-end web applications to display outputs for a range of customers. Primarily worked in Python and JavaScript.
I explore how Bayesian networks can be utilised to create an intelligent system that effectively performs biosurveillance of infectious disease outbreaks. By combining the power of machine learning with modern issues involved in safeguarding public health, I share how achieving early, reliable detection can assist medical professionals and government bodies to provide time-critical response and treatment.
View PosterThis project aims to classify the emotion on a person's face when viewing advertisement media into one of seven categories, using deep convolutional neural networks. The model is trained on the FER-2013 dataset which consists of 35887 grayscale, 48x48 sized face images with seven emotions - angry, disgusted, fearful, happy, neutral, sad and surprised.
View ProjectUsing computer vision the EV3 robot will navigate obstacle courses clearly without collisions. Given a location as a goal to reach the robot will detect obstructions in its path and safely clear them by determining a better route.
Using sentiment analysis and social media data this hack predicts stock directionality. In the modern world it's no surprise that the sheer volume of activity and sentiment online can massively affect consumer facing businesses. Using forward monthly predictions to overcome random short-term noise we trained Random Forests models to generate alpha with predictions on a month-long trading horizon.
View ProjectHackTheMidlands 2018 MusicLab is an AI melody generator. Based on a short input (e.g. typing in notes, singing into a microphone or playing an instrument) MusicLab will create a melody from songs it's been trained on using Markov chains. Who said you need to learn how to compose music to actually compose music!?
View ProjectA.I.Camp Hackathon 2018 Inspired by the rising popularity of the phrase "Fake news" we created a news article bias checker. Both an independent website and a browser add-on, News.ai analyses the article you're reading and judges its bias based on a number of factors such as language, semantics, sources, author and more.
View Project