/***************************************************************************/
/* */
/* afhints.c */
/* */
/* Auto-fitter hinting routines (body). */
/* */
/* Copyright 2003-2015 by */
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
/* */
/* This file is part of the FreeType project, and may only be used, */
/* modified, and distributed under the terms of the FreeType project */
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
/* this file you indicate that you have read the license and */
/* understand and accept it fully. */
/* */
/***************************************************************************/
#include "afhints.h"
#include "aferrors.h"
#include FT_INTERNAL_CALC_H
#include FT_INTERNAL_DEBUG_H
/*************************************************************************/
/* */
/* The macro FT_COMPONENT is used in trace mode. It is an implicit */
/* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */
/* messages during execution. */
/* */
#undef FT_COMPONENT
#define FT_COMPONENT trace_afhints
/* Get new segment for given axis. */
FT_LOCAL_DEF( FT_Error )
af_axis_hints_new_segment( AF_AxisHints axis,
FT_Memory memory,
AF_Segment *asegment )
{
FT_Error error = FT_Err_Ok;
AF_Segment segment = NULL;
if ( axis->num_segments < AF_SEGMENTS_EMBEDDED )
{
if ( axis->segments == NULL )
{
axis->segments = axis->embedded.segments;
axis->max_segments = AF_SEGMENTS_EMBEDDED;
}
}
else if ( axis->num_segments >= axis->max_segments )
{
FT_Int old_max = axis->max_segments;
FT_Int new_max = old_max;
FT_Int big_max = (FT_Int)( FT_INT_MAX / sizeof ( *segment ) );
if ( old_max >= big_max )
{
error = FT_THROW( Out_Of_Memory );
goto Exit;
}
new_max += ( new_max >> 2 ) + 4;
if ( new_max < old_max || new_max > big_max )
new_max = big_max;
if ( axis->segments == axis->embedded.segments )
{
if ( FT_NEW_ARRAY( axis->segments, new_max ) )
goto Exit;
ft_memcpy( axis->segments, axis->embedded.segments,
sizeof ( axis->embedded.segments ) );
}
else
{
if ( FT_RENEW_ARRAY( axis->segments, old_max, new_max ) )
goto Exit;
}
axis->max_segments = new_max;
}
segment = axis->segments + axis->num_segments++;
Exit:
*asegment = segment;
return error;
}
/* Get new edge for given axis, direction, and position, */
/* without initializing the edge itself. */
FT_LOCAL( FT_Error )
af_axis_hints_new_edge( AF_AxisHints axis,
FT_Int fpos,
AF_Direction dir,
FT_Memory memory,
AF_Edge *anedge )
{
FT_Error error = FT_Err_Ok;
AF_Edge edge = NULL;
AF_Edge edges;
if ( axis->num_edges < AF_EDGES_EMBEDDED )
{
if ( axis->edges == NULL )
{
axis->edges = axis->embedded.edges;
axis->max_edges = AF_EDGES_EMBEDDED;
}
}
else if ( axis->num_edges >= axis->max_edges )
{
FT_Int old_max = axis->max_edges;
FT_Int new_max = old_max;
FT_Int big_max = (FT_Int)( FT_INT_MAX / sizeof ( *edge ) );
if ( old_max >= big_max )
{
error = FT_THROW( Out_Of_Memory );
goto Exit;
}
new_max += ( new_max >> 2 ) + 4;
if ( new_max < old_max || new_max > big_max )
new_max = big_max;
if ( axis->edges == axis->embedded.edges )
{
if ( FT_NEW_ARRAY( axis->edges, new_max ) )
goto Exit;
ft_memcpy( axis->edges, axis->embedded.edges,
sizeof ( axis->embedded.edges ) );
}
else
{
if ( FT_RENEW_ARRAY( axis->edges, old_max, new_max ) )
goto Exit;
}
axis->max_edges = new_max;
}
edges = axis->edges;
edge = edges + axis->num_edges;
while ( edge > edges )
{
if ( edge[-1].fpos < fpos )
break;
/* we want the edge with same position and minor direction */
/* to appear before those in the major one in the list */
if ( edge[-1].fpos == fpos && dir == axis->major_dir )
break;
edge[0] = edge[-1];
edge--;
}
axis->num_edges++;
Exit:
*anedge = edge;
return error;
}
#ifdef FT_DEBUG_AUTOFIT
#include FT_CONFIG_STANDARD_LIBRARY_H
/* The dump functions are used in the `ftgrid' demo program, too. */
#define AF_DUMP( varformat ) \
do \
{ \
if ( to_stdout ) \
printf varformat; \
else \
FT_TRACE7( varformat ); \
} while ( 0 )
static const char*
af_dir_str( AF_Direction dir )
{
const char* result;
switch ( dir )
{
case AF_DIR_UP:
result = "up";
break;
case AF_DIR_DOWN:
result = "down";
break;
case AF_DIR_LEFT:
result = "left";
break;
case AF_DIR_RIGHT:
result = "right";
break;
default:
result = "none";
}
return result;
}
#define AF_INDEX_NUM( ptr, base ) (int)( (ptr) ? ( (ptr) - (base) ) : -1 )
#ifdef __cplusplus
extern "C" {
#endif
void
af_glyph_hints_dump_points( AF_GlyphHints hints,
FT_Bool to_stdout )
{
AF_Point points = hints->points;
AF_Point limit = points + hints->num_points;
AF_Point point;
AF_DUMP(( "Table of points:\n" ));
if ( hints->num_points )
AF_DUMP(( " [ index | xorg | yorg | xscale | yscale"
" | xfit | yfit | flags ]\n" ));
else
AF_DUMP(( " (none)\n" ));
for ( point = points; point < limit; point++ )
AF_DUMP(( " [ %5d | %5d | %5d | %6.2f | %6.2f"
" | %5.2f | %5.2f | %c ]\n",
AF_INDEX_NUM( point, points ),
point->fx,
point->fy,
point->ox / 64.0,
point->oy / 64.0,
point->x / 64.0,
point->y / 64.0,
( point->flags & AF_FLAG_WEAK_INTERPOLATION ) ? 'w' : ' '));
AF_DUMP(( "\n" ));
}
#ifdef __cplusplus
}
#endif
static const char*
af_edge_flags_to_string( FT_UInt flags )
{
static char temp[32];
int pos = 0;
if ( flags & AF_EDGE_ROUND )
{
ft_memcpy( temp + pos, "round", 5 );
pos += 5;
}
if ( flags & AF_EDGE_SERIF )
{
if ( pos > 0 )
temp[pos++] = ' ';
ft_memcpy( temp + pos, "serif", 5 );
pos += 5;
}
if ( pos == 0 )
return "normal";
temp[pos] = '\0';
return temp;
}
/* Dump the array of linked segments. */
#ifdef __cplusplus
extern "C" {
#endif
void
af_glyph_hints_dump_segments( AF_GlyphHints hints,
FT_Bool to_stdout )
{
FT_Int dimension;
for ( dimension = 1; dimension >= 0; dimension-- )
{
AF_AxisHints axis = &hints->axis[dimension];
AF_Point points = hints->points;
AF_Edge edges = axis->edges;
AF_Segment segments = axis->segments;
AF_Segment limit = segments + axis->num_segments;
AF_Segment seg;
AF_DUMP(( "Table of %s segments:\n",
dimension == AF_DIMENSION_HORZ ? "vertical"
: "horizontal" ));
if ( axis->num_segments )
AF_DUMP(( " [ index | pos | dir | from"
" | to | link | serif | edge"
" | height | extra | flags ]\n" ));
else
AF_DUMP(( " (none)\n" ));
for ( seg = segments; seg < limit; seg++ )
AF_DUMP(( " [ %5d | %5.2g | %5s | %4d"
" | %4d | %4d | %5d | %4d"
" | %6d | %5d | %11s ]\n",
AF_INDEX_NUM( seg, segments ),
dimension == AF_DIMENSION_HORZ
? (int)seg->first->ox / 64.0
: (int)seg->first->oy / 64.0,
af_dir_str( (AF_Direction)seg->dir ),
AF_INDEX_NUM( seg->first, points ),
AF_INDEX_NUM( seg->last, points ),
AF_INDEX_NUM( seg->link, segments ),
AF_INDEX_NUM( seg->serif, segments ),
AF_INDEX_NUM( seg->edge, edges ),
seg->height,
seg->height - ( seg->max_coord - seg->min_coord ),
af_edge_flags_to_string( seg->flags ) ));
AF_DUMP(( "\n" ));
}
}
#ifdef __cplusplus
}
#endif
/* Fetch number of segments. */
#ifdef __cplusplus
extern "C" {
#endif
FT_Error
af_glyph_hints_get_num_segments( AF_GlyphHints hints,
FT_Int dimension,
FT_Int* num_segments )
{
AF_Dimension dim;
AF_AxisHints axis;
dim = ( dimension == 0 ) ? AF_DIMENSION_HORZ : AF_DIMENSION_VERT;
axis = &hints->axis[dim];
*num_segments = axis->num_segments;
return FT_Err_Ok;
}
#ifdef __cplusplus
}
#endif
/* Fetch offset of segments into user supplied offset array. */
#ifdef __cplusplus
extern "C" {
#endif
FT_Error
af_glyph_hints_get_segment_offset( AF_GlyphHints hints,
FT_Int dimension,
FT_Int idx,
FT_Pos *offset,
FT_Bool *is_blue,
FT_Pos *blue_offset )
{
AF_Dimension dim;
AF_AxisHints axis;
AF_Segment seg;
if ( !offset )
return FT_THROW( Invalid_Argument );
dim = ( dimension == 0 ) ? AF_DIMENSION_HORZ : AF_DIMENSION_VERT;
axis = &hints->axis[dim];
if ( idx < 0 || idx >= axis->num_segments )
return FT_THROW( Invalid_Argument );
seg = &axis->segments[idx];
*offset = ( dim == AF_DIMENSION_HORZ ) ? seg->first->ox
: seg->first->oy;
if ( seg->edge )
*is_blue = (FT_Bool)( seg->edge->blue_edge != 0 );
else
*is_blue = FALSE;
if ( *is_blue )
*blue_offset = seg->edge->blue_edge->cur;
else
*blue_offset = 0;
return FT_Err_Ok;
}
#ifdef __cplusplus
}
#endif
/* Dump the array of linked edges. */
#ifdef __cplusplus
extern "C" {
#endif
void
af_glyph_hints_dump_edges( AF_GlyphHints hints,
FT_Bool to_stdout )
{
FT_Int dimension;
for ( dimension = 1; dimension >= 0; dimension-- )
{
AF_AxisHints axis = &hints->axis[dimension];
AF_Edge edges = axis->edges;
AF_Edge limit = edges + axis->num_edges;
AF_Edge edge;
/*
* note: AF_DIMENSION_HORZ corresponds to _vertical_ edges
* since they have a constant X coordinate.
*/
AF_DUMP(( "Table of %s edges:\n",
dimension == AF_DIMENSION_HORZ ? "vertical"
: "horizontal" ));
if ( axis->num_edges )
AF_DUMP(( " [ index | pos | dir | link"
" | serif | blue | opos | pos | flags ]\n" ));
else
AF_DUMP(( " (none)\n" ));
for ( edge = edges; edge < limit; edge++ )
AF_DUMP(( " [ %5d | %5.2g | %5s | %4d"
" | %5d | %c | %5.2f | %5.2f | %11s ]\n",
AF_INDEX_NUM( edge, edges ),
(int)edge->opos / 64.0,
af_dir_str( (AF_Direction)edge->dir ),
AF_INDEX_NUM( edge->link, edges ),
AF_INDEX_NUM( edge->serif, edges ),
edge->blue_edge ? 'y' : 'n',
edge->opos / 64.0,
edge->pos / 64.0,
af_edge_flags_to_string( edge->flags ) ));
AF_DUMP(( "\n" ));
}
}
#ifdef __cplusplus
}
#endif
#undef AF_DUMP
#endif /* !FT_DEBUG_AUTOFIT */
/* Compute the direction value of a given vector. */
FT_LOCAL_DEF( AF_Direction )
af_direction_compute( FT_Pos dx,
FT_Pos dy )
{
FT_Pos ll, ss; /* long and short arm lengths */
AF_Direction dir; /* candidate direction */
if ( dy >= dx )
{
if ( dy >= -dx )
{
dir = AF_DIR_UP;
ll = dy;
ss = dx;
}
else
{
dir = AF_DIR_LEFT;
ll = -dx;
ss = dy;
}
}
else /* dy < dx */
{
if ( dy >= -dx )
{
dir = AF_DIR_RIGHT;
ll = dx;
ss = dy;
}
else
{
dir = AF_DIR_DOWN;
ll = -dy;
ss = dx;
}
}
/* return no direction if arm lengths do not differ enough */
/* (value 14 is heuristic, corresponding to approx. 4.1 degrees) */
/* the long arm is never negative */
if ( ll <= 14 * FT_ABS( ss ) )
dir = AF_DIR_NONE;
return dir;
}
FT_LOCAL_DEF( void )
af_glyph_hints_init( AF_GlyphHints hints,
FT_Memory memory )
{
/* no need to initialize the embedded items */
FT_MEM_ZERO( hints, sizeof ( *hints ) - sizeof ( hints->embedded ) );
hints->memory = memory;
}
FT_LOCAL_DEF( void )
af_glyph_hints_done( AF_GlyphHints hints )
{
FT_Memory memory;
int dim;
if ( !( hints && hints->memory ) )
return;
memory = hints->memory;
/*
* note that we don't need to free the segment and edge
* buffers since they are really within the hints->points array
*/
for ( dim = 0; dim < AF_DIMENSION_MAX; dim++ )
{
AF_AxisHints axis = &hints->axis[dim];
axis->num_segments = 0;
axis->max_segments = 0;
if ( axis->segments != axis->embedded.segments )
FT_FREE( axis->segments );
axis->num_edges = 0;
axis->max_edges = 0;
if ( axis->edges != axis->embedded.edges )
FT_FREE( axis->edges );
}
if ( hints->contours != hints->embedded.contours )
FT_FREE( hints->contours );
hints->max_contours = 0;
hints->num_contours = 0;
if ( hints->points != hints->embedded.points )
FT_FREE( hints->points );
hints->max_points = 0;
hints->num_points = 0;
hints->memory = NULL;
}
/* Reset metrics. */
FT_LOCAL_DEF( void )
af_glyph_hints_rescale( AF_GlyphHints hints,
AF_StyleMetrics metrics )
{
hints->metrics = metrics;
hints->scaler_flags = metrics->scaler.flags;
}
/* Recompute all AF_Point in AF_GlyphHints from the definitions */
/* in a source outline. */
FT_LOCAL_DEF( FT_Error )
af_glyph_hints_reload( AF_GlyphHints hints,
FT_Outline* outline )
{
FT_Error error = FT_Err_Ok;
AF_Point points;
FT_UInt old_max, new_max;
FT_Fixed x_scale = hints->x_scale;
FT_Fixed y_scale = hints->y_scale;
FT_Pos x_delta = hints->x_delta;
FT_Pos y_delta = hints->y_delta;
FT_Memory memory = hints->memory;
hints->num_points = 0;
hints->num_contours = 0;
hints->axis[0].num_segments = 0;
hints->axis[0].num_edges = 0;
hints->axis[1].num_segments = 0;
hints->axis[1].num_edges = 0;
/* first of all, reallocate the contours array if necessary */
new_max = (FT_UInt)outline->n_contours;
old_max = (FT_UInt)hints->max_contours;
if ( new_max <= AF_CONTOURS_EMBEDDED )
{
if ( hints->contours == NULL )
{
hints->contours = hints->embedded.contours;
hints->max_contours = AF_CONTOURS_EMBEDDED;
}
}
else if ( new_max > old_max )
{
if ( hints->contours == hints->embedded.contours )
hints->contours = NULL;
new_max = ( new_max + 3 ) & ~3U; /* round up to a multiple of 4 */
if ( FT_RENEW_ARRAY( hints->contours, old_max, new_max ) )
goto Exit;
hints->max_contours = (FT_Int)new_max;
}
/*
* then reallocate the points arrays if necessary --
* note that we reserve two additional point positions, used to
* hint metrics appropriately
*/
new_max = (FT_UInt)( outline->n_points + 2 );
old_max = (FT_UInt)hints->max_points;
if ( new_max <= AF_POINTS_EMBEDDED )
{
if ( hints->points == NULL )
{
hints->points = hints->embedded.points;
hints->max_points = AF_POINTS_EMBEDDED;
}
}
else if ( new_max > old_max )
{
if ( hints->points == hints->embedded.points )
hints->points = NULL;
new_max = ( new_max + 2 + 7 ) & ~7U; /* round up to a multiple of 8 */
if ( FT_RENEW_ARRAY( hints->points, old_max, new_max ) )
goto Exit;
hints->max_points = (FT_Int)new_max;
}
hints->num_points = outline->n_points;
hints->num_contours = outline->n_contours;
/* We can't rely on the value of `FT_Outline.flags' to know the fill */
/* direction used for a glyph, given that some fonts are broken (e.g., */
/* the Arphic ones). We thus recompute it each time we need to. */
/* */
hints->axis[AF_DIMENSION_HORZ].major_dir = AF_DIR_UP;
hints->axis[AF_DIMENSION_VERT].major_dir = AF_DIR_LEFT;
if ( FT_Outline_Get_Orientation( outline ) == FT_ORIENTATION_POSTSCRIPT )
{
hints->axis[AF_DIMENSION_HORZ].major_dir = AF_DIR_DOWN;
hints->axis[AF_DIMENSION_VERT].major_dir = AF_DIR_RIGHT;
}
hints->x_scale = x_scale;
hints->y_scale = y_scale;
hints->x_delta = x_delta;
hints->y_delta = y_delta;
hints->xmin_delta = 0;
hints->xmax_delta = 0;
points = hints->points;
if ( hints->num_points == 0 )
goto Exit;
{
AF_Point point;
AF_Point point_limit = points + hints->num_points;
/* compute coordinates & Bezier flags, next and prev */
{
FT_Vector* vec = outline->points;
char* tag = outline->tags;
AF_Point end = points + outline->contours[0];
AF_Point prev = end;
FT_Int contour_index = 0;
for ( point = points; point < point_limit; point++, vec++, tag++ )
{
point->in_dir = (FT_Char)AF_DIR_NONE;
point->out_dir = (FT_Char)AF_DIR_NONE;
point->fx = (FT_Short)vec->x;
point->fy = (FT_Short)vec->y;
point->ox = point->x = FT_MulFix( vec->x, x_scale ) + x_delta;
point->oy = point->y = FT_MulFix( vec->y, y_scale ) + y_delta;
switch ( FT_CURVE_TAG( *tag ) )
{
case FT_CURVE_TAG_CONIC:
point->flags = AF_FLAG_CONIC;
break;
case FT_CURVE_TAG_CUBIC:
point->flags = AF_FLAG_CUBIC;
break;
default:
point->flags = AF_FLAG_NONE;
}
point->prev = prev;
prev->next = point;
prev = point;
if ( point == end )
{
if ( ++contour_index < outline->n_contours )
{
end = points + outline->contours[contour_index];
prev = end;
}
}
}
}
/* set up the contours array */
{
AF_Point* contour = hints->contours;
AF_Point* contour_limit = contour + hints->num_contours;
short* end = outline->contours;
short idx = 0;
for ( ; contour < contour_limit; contour++, end++ )
{
contour[0] = points + idx;
idx = (short)( end[0] + 1 );
}
}
{
/*
* Compute directions of `in' and `out' vectors.
*
* Note that distances between points that are very near to each
* other are accumulated. In other words, the auto-hinter
* prepends the small vectors between near points to the first
* non-near vector. All intermediate points are tagged as
* weak; the directions are adjusted also to be equal to the
* accumulated one.
*/
/* value 20 in `near_limit' is heuristic */
FT_UInt units_per_em = hints->metrics->scaler.face->units_per_EM;
FT_Int near_limit = 20 * units_per_em / 2048;
FT_Int near_limit2 = 2 * near_limit - 1;
AF_Point* contour;
AF_Point* contour_limit = hints->contours + hints->num_contours;
for ( contour = hints->contours; contour < contour_limit; contour++ )
{
AF_Point first = *contour;
AF_Point next, prev, curr;
FT_Pos out_x, out_y;
/* since the first point of a contour could be part of a */
/* series of near points, go backwards to find the first */
/* non-near point and adjust `first' */
point = first;
prev = first->prev;
while ( prev != first )
{
out_x = point->fx - prev->fx;
out_y = point->fy - prev->fy;
/*
* We use Taxicab metrics to measure the vector length.
*
* Note that the accumulated distances so far could have the
* opposite direction of the distance measured here. For this
* reason we use `near_limit2' for the comparison to get a
* non-near point even in the worst case.
*/
if ( FT_ABS( out_x ) + FT_ABS( out_y ) >= near_limit2 )
break;
point = prev;
prev = prev->prev;
}
/* adjust first point */
first = point;
/* now loop over all points of the contour to get */
/* `in' and `out' vector directions */
curr = first;
/*
* We abuse the `u' and `v' fields to store index deltas to the
* next and previous non-near point, respectively.
*
* To avoid problems with not having non-near points, we point to
* `first' by default as the next non-near point.
*
*/
curr->u = (FT_Pos)( first - curr );
first->v = -curr->u;
out_x = 0;
out_y = 0;
next = first;
do
{
AF_Direction out_dir;
point = next;
next = point->next;
out_x += next->fx - point->fx;
out_y += next->fy - point->fy;
if ( FT_ABS( out_x ) + FT_ABS( out_y ) < near_limit )
{
next->flags |= AF_FLAG_WEAK_INTERPOLATION;
continue;
}
curr->u = (FT_Pos)( next - curr );
next->v = -curr->u;
out_dir = af_direction_compute( out_x, out_y );
/* adjust directions for all points inbetween; */
/* the loop also updates position of `curr' */
curr->out_dir = (FT_Char)out_dir;
for ( curr = curr->next; curr != next; curr = curr->next )
{
curr->in_dir = (FT_Char)out_dir;
curr->out_dir = (FT_Char)out_dir;
}
next->in_dir = (FT_Char)out_dir;
curr->u = (FT_Pos)( first - curr );
first->v = -curr->u;
out_x = 0;
out_y = 0;
} while ( next != first );
}
/*
* The next step is to `simplify' an outline's topology so that we
* can identify local extrema more reliably: A series of
* non-horizontal or non-vertical vectors pointing into the same
* quadrant are handled as a single, long vector. From a
* topological point of the view, the intermediate points are of no
* interest and thus tagged as weak.
*/
for ( point = points; point < point_limit; point++ )
{
if ( point->flags & AF_FLAG_WEAK_INTERPOLATION )
continue;
if ( point->in_dir == AF_DIR_NONE &&
point->out_dir == AF_DIR_NONE )
{
/* check whether both vectors point into the same quadrant */
FT_Pos in_x, in_y;
FT_Pos out_x, out_y;
AF_Point next_u = point + point->u;
AF_Point prev_v = point + point->v;
in_x = point->fx - prev_v->fx;
in_y = point->fy - prev_v->fy;
out_x = next_u->fx - point->fx;
out_y = next_u->fy - point->fy;
if ( ( in_x ^ out_x ) >= 0 && ( in_y ^ out_y ) >= 0 )
{
/* yes, so tag current point as weak */
/* and update index deltas */
point->flags |= AF_FLAG_WEAK_INTERPOLATION;
prev_v->u = (FT_Pos)( next_u - prev_v );
next_u->v = -prev_v->u;
}
}
}
/*
* Finally, check for remaining weak points. Everything else not
* collected in edges so far is then implicitly classified as strong
* points.
*/
for ( point = points; point < point_limit; point++ )
{
if ( point->flags & AF_FLAG_WEAK_INTERPOLATION )
continue;
if ( point->flags & AF_FLAG_CONTROL )
{
/* control points are always weak */
Is_Weak_Point:
point->flags |= AF_FLAG_WEAK_INTERPOLATION;
}
else if ( point->out_dir == point->in_dir )
{
if ( point->out_dir != AF_DIR_NONE )
{
/* current point lies on a horizontal or */
/* vertical segment (but doesn't start or end it) */
goto Is_Weak_Point;
}
{
AF_Point next_u = point + point->u;
AF_Point prev_v = point + point->v;
if ( ft_corner_is_flat( point->fx - prev_v->fx,
point->fy - prev_v->fy,
next_u->fx - point->fx,
next_u->fy - point->fy ) )
{
/* either the `in' or the `out' vector is much more */
/* dominant than the other one, so tag current point */
/* as weak and update index deltas */
prev_v->u = (FT_Pos)( next_u - prev_v );
next_u->v = -prev_v->u;
goto Is_Weak_Point;
}
}
}
else if ( point->in_dir == -point->out_dir )
{
/* current point forms a spike */
goto Is_Weak_Point;
}
}
}
}
Exit:
return error;
}
/* Store the hinted outline in an FT_Outline structure. */
FT_LOCAL_DEF( void )
af_glyph_hints_save( AF_GlyphHints hints,
FT_Outline* outline )
{
AF_Point point = hints->points;
AF_Point limit = point + hints->num_points;
FT_Vector* vec = outline->points;
char* tag = outline->tags;
for ( ; point < limit; point++, vec++, tag++ )
{
vec->x = point->x;
vec->y = point->y;
if ( point->flags & AF_FLAG_CONIC )
tag[0] = FT_CURVE_TAG_CONIC;
else if ( point->flags & AF_FLAG_CUBIC )
tag[0] = FT_CURVE_TAG_CUBIC;
else
tag[0] = FT_CURVE_TAG_ON;
}
}
/****************************************************************
*
* EDGE POINT GRID-FITTING
*
****************************************************************/
/* Align all points of an edge to the same coordinate value, */
/* either horizontally or vertically. */
FT_LOCAL_DEF( void )
af_glyph_hints_align_edge_points( AF_GlyphHints hints,
AF_Dimension dim )
{
AF_AxisHints axis = & hints->axis[dim];
AF_Segment segments = axis->segments;
AF_Segment segment_limit = segments + axis->num_segments;
AF_Segment seg;
if ( dim == AF_DIMENSION_HORZ )
{
for ( seg = segments; seg < segment_limit; seg++ )
{
AF_Edge edge = seg->edge;
AF_Point point, first, last;
if ( edge == NULL )
continue;
first = seg->first;
last = seg->last;
point = first;
for (;;)
{
point->x = edge->pos;
point->flags |= AF_FLAG_TOUCH_X;
if ( point == last )
break;
point = point->next;
}
}
}
else
{
for ( seg = segments; seg < segment_limit; seg++ )
{
AF_Edge edge = seg->edge;
AF_Point point, first, last;
if ( edge == NULL )
continue;
first = seg->first;
last = seg->last;
point = first;
for (;;)
{
point->y = edge->pos;
point->flags |= AF_FLAG_TOUCH_Y;
if ( point == last )
break;
point = point->next;
}
}
}
}
/****************************************************************
*
* STRONG POINT INTERPOLATION
*
****************************************************************/
/* Hint the strong points -- this is equivalent to the TrueType `IP' */
/* hinting instruction. */
FT_LOCAL_DEF( void )
af_glyph_hints_align_strong_points( AF_GlyphHints hints,
AF_Dimension dim )
{
AF_Point points = hints->points;
AF_Point point_limit = points + hints->num_points;
AF_AxisHints axis = &hints->axis[dim];
AF_Edge edges = axis->edges;
AF_Edge edge_limit = edges + axis->num_edges;
FT_UInt touch_flag;
if ( dim == AF_DIMENSION_HORZ )
touch_flag = AF_FLAG_TOUCH_X;
else
touch_flag = AF_FLAG_TOUCH_Y;
if ( edges < edge_limit )
{
AF_Point point;
AF_Edge edge;
for ( point = points; point < point_limit; point++ )
{
FT_Pos u, ou, fu; /* point position */
FT_Pos delta;
if ( point->flags & touch_flag )
continue;
/* if this point is candidate to weak interpolation, we */
/* interpolate it after all strong points have been processed */
if ( ( point->flags & AF_FLAG_WEAK_INTERPOLATION ) )
continue;
if ( dim == AF_DIMENSION_VERT )
{
u = point->fy;
ou = point->oy;
}
else
{
u = point->fx;
ou = point->ox;
}
fu = u;
/* is the point before the first edge? */
edge = edges;
delta = edge->fpos - u;
if ( delta >= 0 )
{
u = edge->pos - ( edge->opos - ou );
goto Store_Point;
}
/* is the point after the last edge? */
edge = edge_limit - 1;
delta = u - edge->fpos;
if ( delta >= 0 )
{
u = edge->pos + ( ou - edge->opos );
goto Store_Point;
}
{
FT_PtrDist min, max, mid;
FT_Pos fpos;
/* find enclosing edges */
min = 0;
max = edge_limit - edges;
#if 1
/* for a small number of edges, a linear search is better */
if ( max <= 8 )
{
FT_PtrDist nn;
for ( nn = 0; nn < max; nn++ )
if ( edges[nn].fpos >= u )
break;
if ( edges[nn].fpos == u )
{
u = edges[nn].pos;
goto Store_Point;
}
min = nn;
}
else
#endif
while ( min < max )
{
mid = ( max + min ) >> 1;
edge = edges + mid;
fpos = edge->fpos;
if ( u < fpos )
max = mid;
else if ( u > fpos )
min = mid + 1;
else
{
/* we are on the edge */
u = edge->pos;
goto Store_Point;
}
}
/* point is not on an edge */
{
AF_Edge before = edges + min - 1;
AF_Edge after = edges + min + 0;
/* assert( before && after && before != after ) */
if ( before->scale == 0 )
before->scale = FT_DivFix( after->pos - before->pos,
after->fpos - before->fpos );
u = before->pos + FT_MulFix( fu - before->fpos,
before->scale );
}
}
Store_Point:
/* save the point position */
if ( dim == AF_DIMENSION_HORZ )
point->x = u;
else
point->y = u;
point->flags |= touch_flag;
}
}
}
/****************************************************************
*
* WEAK POINT INTERPOLATION
*
****************************************************************/
/* Shift the original coordinates of all points between `p1' and */
/* `p2' to get hinted coordinates, using the same difference as */
/* given by `ref'. */
static void
af_iup_shift( AF_Point p1,
AF_Point p2,
AF_Point ref )
{
AF_Point p;
FT_Pos delta = ref->u - ref->v;
if ( delta == 0 )
return;
for ( p = p1; p < ref; p++ )
p->u = p->v + delta;
for ( p = ref + 1; p <= p2; p++ )
p->u = p->v + delta;
}
/* Interpolate the original coordinates of all points between `p1' and */
/* `p2' to get hinted coordinates, using `ref1' and `ref2' as the */
/* reference points. The `u' and `v' members are the current and */
/* original coordinate values, respectively. */
/* */
/* Details can be found in the TrueType bytecode specification. */
static void
af_iup_interp( AF_Point p1,
AF_Point p2,
AF_Point ref1,
AF_Point ref2 )
{
AF_Point p;
FT_Pos u, v1, v2, u1, u2, d1, d2;
if ( p1 > p2 )
return;
if ( ref1->v > ref2->v )
{
p = ref1;
ref1 = ref2;
ref2 = p;
}
v1 = ref1->v;
v2 = ref2->v;
u1 = ref1->u;
u2 = ref2->u;
d1 = u1 - v1;
d2 = u2 - v2;
if ( u1 == u2 || v1 == v2 )
{
for ( p = p1; p <= p2; p++ )
{
u = p->v;
if ( u <= v1 )
u += d1;
else if ( u >= v2 )
u += d2;
else
u = u1;
p->u = u;
}
}
else
{
FT_Fixed scale = FT_DivFix( u2 - u1, v2 - v1 );
for ( p = p1; p <= p2; p++ )
{
u = p->v;
if ( u <= v1 )
u += d1;
else if ( u >= v2 )
u += d2;
else
u = u1 + FT_MulFix( u - v1, scale );
p->u = u;
}
}
}
/* Hint the weak points -- this is equivalent to the TrueType `IUP' */
/* hinting instruction. */
FT_LOCAL_DEF( void )
af_glyph_hints_align_weak_points( AF_GlyphHints hints,
AF_Dimension dim )
{
AF_Point points = hints->points;
AF_Point point_limit = points + hints->num_points;
AF_Point* contour = hints->contours;
AF_Point* contour_limit = contour + hints->num_contours;
FT_UInt touch_flag;
AF_Point point;
AF_Point end_point;
AF_Point first_point;
/* PASS 1: Move segment points to edge positions */
if ( dim == AF_DIMENSION_HORZ )
{
touch_flag = AF_FLAG_TOUCH_X;
for ( point = points; point < point_limit; point++ )
{
point->u = point->x;
point->v = point->ox;
}
}
else
{
touch_flag = AF_FLAG_TOUCH_Y;
for ( point = points; point < point_limit; point++ )
{
point->u = point->y;
point->v = point->oy;
}
}
for ( ; contour < contour_limit; contour++ )
{
AF_Point first_touched, last_touched;
point = *contour;
end_point = point->prev;
first_point = point;
/* find first touched point */
for (;;)
{
if ( point > end_point ) /* no touched point in contour */
goto NextContour;
if ( point->flags & touch_flag )
break;
point++;
}
first_touched = point;
for (;;)
{
FT_ASSERT( point <= end_point &&
( point->flags & touch_flag ) != 0 );
/* skip any touched neighbours */
while ( point < end_point &&
( point[1].flags & touch_flag ) != 0 )
point++;
last_touched = point;
/* find the next touched point, if any */
point++;
for (;;)
{
if ( point > end_point )
goto EndContour;
if ( ( point->flags & touch_flag ) != 0 )
break;
point++;
}
/* interpolate between last_touched and point */
af_iup_interp( last_touched + 1, point - 1,
last_touched, point );
}
EndContour:
/* special case: only one point was touched */
if ( last_touched == first_touched )
af_iup_shift( first_point, end_point, first_touched );
else /* interpolate the last part */
{
if ( last_touched < end_point )
af_iup_interp( last_touched + 1, end_point,
last_touched, first_touched );
if ( first_touched > points )
af_iup_interp( first_point, first_touched - 1,
last_touched, first_touched );
}
NextContour:
;
}
/* now save the interpolated values back to x/y */
if ( dim == AF_DIMENSION_HORZ )
{
for ( point = points; point < point_limit; point++ )
point->x = point->u;
}
else
{
for ( point = points; point < point_limit; point++ )
point->y = point->u;
}
}
#ifdef AF_CONFIG_OPTION_USE_WARPER
/* Apply (small) warp scale and warp delta for given dimension. */
FT_LOCAL_DEF( void )
af_glyph_hints_scale_dim( AF_GlyphHints hints,
AF_Dimension dim,
FT_Fixed scale,
FT_Pos delta )
{
AF_Point points = hints->points;
AF_Point points_limit = points + hints->num_points;
AF_Point point;
if ( dim == AF_DIMENSION_HORZ )
{
for ( point = points; point < points_limit; point++ )
point->x = FT_MulFix( point->fx, scale ) + delta;
}
else
{
for ( point = points; point < points_limit; point++ )
point->y = FT_MulFix( point->fy, scale ) + delta;
}
}
#endif /* AF_CONFIG_OPTION_USE_WARPER */
/* END */
↑ V512 A call of the '__builtin___memset_chk' function will lead to underflow of the buffer 'hints'.
↑ V1048 The 'hints->x_scale' variable was assigned the same value.
↑ V1048 The 'hints->y_scale' variable was assigned the same value.
↑ V1048 The 'hints->x_delta' variable was assigned the same value.
↑ V1048 The 'hints->y_delta' variable was assigned the same value.


Visualizing for Data-Driven #Advocacy
The Three Building Blocks of a Campaign:
Targeted Advocacy, Really Good Data, & the Right Packaging
Advocacy Is: "Supporting a cause and getting others to support it as well".
Advocacy can consist of: media campaigns, publishing research or lobbying legislatures.
The ultimate goal is to FACILITATE CHANGE.
Why is Advocacy Important for Your Work?
How to be an Effective Advocate:
Trying to reach everyone at once is a recipe for failure...
Advocacy campaigns should have a clear target audience and a clear goal
Some Examples of Target Audiences are: Government officials, professional groups, students
How Can Data Support your Campaign?
Data can describe, inform, educate, persuade, & communicate critical information.
Why Use Visuals to Communicate Data?
People rarely read long reports full of complex data..
Nothing Sticks in People's Minds as much as an IMAGE
The way you FRAME images determines their communicative power...
Juxtapose
Subvert
Invert
Materialize
Compare
Contrast
Illuminate
Parody


{{ define "main" }} {{ $pages := (partial "calendar/future-events" (dict "Site" .Site)) }} {{ $featured := ( where $pages "Params.featured" true ) }} {{ if gt (len $featured) 0 }} {{ range first 1 $featured.ByDate.Reverse }} {{ .Render "featured-event-card" }} {{ end }} {{ end }} {{ partial "calendar/events" (dict "Site" .Site ) }} {{ partial "whole-page-fragments/newsletter" (dict "divider" "rl" ) }} {{ end }}


--- layout: post title: 'Rails ProTip: Stop generating empty files you are not gonna use!' date: '2014-01-20T09:38:00+00:00' tags: - rails protip author: alex tumblr_url: http://blog.seriousfox.co.uk/post/73947455877/rails-protip-stop-generating-empty-files-you-are ---
I regularly work on projects where there are default pending specs and helpers/assets that are empty. This is bad for two reasons: firstly RSpec and the Asset pipeline still check/load these files which slows things down, and secondly they make the project harder to navigate.
I recommend adding this too your application.rb today!
{% highlight ruby %}config.generators do |g| g.test_framework :rspec, views: false, routes: false g.helper_specs false g.stylesheets = false g.javascripts = false g.helper = false end {% endhighlight %}Alex


There is an excellent procedure for setting up Hadoop 2.6 on Mac OS X Yosemite. It was created by Yaonan Zhong and it is located at http://zhongyaonan.com/hadoop-tutorial/setting-up-hadoop-2-6-on-mac-osx-yosemite.html. The steps are re-iterated below with some modifications where I encountered a problem or for additional clarification.


Structs
The following structs are available globally.
-
A collection of images to search.
See moreDeclaration
Swift
public struct Collection: JSONDecodable
-
A classifier for the Visual Recognition service.
See moreDeclaration
Swift
public struct Classifier: JSONDecodable
-
Information about an error that occurred during classification.
See moreDeclaration
Swift
public struct ErrorInfo: JSONDecodable
-
A class associated with a Visual Recognition classifier.
See moreDeclaration
Swift
public struct PositiveExample
-
The results of detecting faces in one or more images.
See moreDeclaration
Swift
public struct ImagesWithFaces: JSONDecodable
-
An image with detected faces.
See moreDeclaration
Swift
public struct ImageWithFaces: JSONDecodable
-
A face identified in an image.
See moreDeclaration
Swift
public struct Face: JSONDecodable
-
The age of an identified face.
See moreDeclaration
Swift
public struct Age: JSONDecodable
-
The gender of an identified face.
See moreDeclaration
Swift
public struct Gender: JSONDecodable
-
The location of an identified face.
See moreDeclaration
Swift
public struct FaceLocation: JSONDecodable
-
The identity of an identified face.
See moreDeclaration
Swift
public struct Identity: JSONDecodable
-
Information about a warning that occurred.
See moreDeclaration
Swift
public struct WarningInfo: JSONDecodable
-
The results from classifying one or more images.
See moreDeclaration
Swift
public struct ClassifiedImages: JSONDecodable
-
A classified image.
See moreDeclaration
Swift
public struct ClassifiedImage: JSONDecodable
-
A classifier’s classifications for a given image.
See moreDeclaration
Swift
public struct ClassifierResults: JSONDecodable
-
The classification of an image.
See moreDeclaration
Swift
public struct Classification: JSONDecodable


DMD Compiler for Windows
- Requirements and Downloads
- Installation
- Example
- Compiler Arguments and Switches
- Files
- Linking
- Environment Variables
- sc.ini Initialization File
- Common Installation Problems
- Differences between Windows and Linux versions
- D Interface Files
- Building Libraries
- Compiling dmd
- Compiling Phobos
Requirements and Downloads
- DMD Compiler
- Windows operating system, Windows 7 or later, 32 or 64 bit
- Download dmc.zip (C and C++ compiler) for Win32 (not required, but it complements dmd for Windows)
Installation
Open a console window (for Windows this is done by clicking on [Start][Command Prompt]). All the tools are command line tools, which means they are run from a console window. Switch to the root directory. Unzip the files in the root directory. dmd.zip will create a \dmd2 directory with all the files in it. dmc.zip will create a \dm directory with all the files in it.
A typical session might look like:
C:\Documents and Settings\Your Name>cd \ C:\>unzip dmd.zip C:\>unzip dmc.zip
Example
Run:
\dmd2\windows\bin\shell all.sh
in the \dmd2\samples\d directory for several small examples.
Compiler Arguments and Switches
- dmd files... -switches...
- files...
-
File Extensions Extension File Type none D source files .c C source files .d D source files .dd Ddoc source files .di D interface files .i preprocessed C source files .obj Object files to link in .lib Object code libraries to search .exe Output executable file .def module definition file .res resource file - @cmdfile
- If cmdfile is an environment variable, read the compiler arguments and switches from the value of that variable. Otherwise, read compiler arguments and switches from the text file cmdfile. The file may contain single-line comments starting with the hash symbol (#).
- -allinst
- Generate code for all template instantiations
- -betterC
-
Adjusts the compiler to implement D as a better C:
- Predefines D_BetterC version.
- Assert Expressions, when they fail, call the C runtime library assert failure function rather than a function in the D runtime.
- Array overflows call the C runtime library assert failure function rather than a function in the D runtime.
- Final switch errors call the C runtime library assert failure function rather than a function in the D runtime.
- Does not automatically link with phobos runtime library.
- Module constructors and destructors are not generated meaning that static and shared static constructors and destructors will not get called.
- ModuleInfo is not generated.
- TypeInfo instances will not be generated for structs.
- -boundscheck=[on|safeonly|off ]
-
Controls if bounds checking is enabled.
- on: Bounds checks are enabled for all code. This is the default.
- safeonly: Bounds checks are enabled only in @safe code. This is the default for -release builds.
- off: Bounds checks are disabled completely (even in @safe code). This option should be used with caution and as a last resort to improve performance. Confirm turning off @safe bounds checks is worthwhile by benchmarking.
- -c
- Compile only, do not link
- -check=[assert|bounds|in|invariant|out|switch ][=[on|off]]
-
Overrides default, -boundscheck, -release and -unittest options to enable or disable specific checks.
- assert: assertion checking
- bounds: array bounds
- in: in contracts
- invariant: class/struct invariants
- out: out contracts
- switch: finalswitch failure checking
- on or not specified: specified check is enabled.
- off: specified check is disabled.
- -check=[h|help|? ]
- List information on all available checks
- -checkaction=[D|C|halt|context ]
-
Sets behavior when an assert fails, and array boundscheck fails,
or a final switch errors.
- D: Default behavior, which throws an unrecoverable AssertError.
- C: Calls the C runtime library assert failure function.
- halt: Executes a halt instruction, terminating the program.
- context: Prints the error context as part of the unrecoverable AssertError.
- -checkaction=[h|help|? ]
- List information on all available check actions
- -color
- Turn colored console output on
- -color=[on|off|auto ]
-
Show colored console output. The default depends on terminal capabilities.
- auto: use colored output if a tty is detected (default)
- on: always use colored output.
- off: never use colored output.
- -conf=filename
- Use config file at filename
- -cov
- Do code coverage analysis
- -cov=ctfe
- Include code executed during CTFE in coverage report
- -cov=nnn
- Perform code coverage analysis and generate .lst file with report.
- -D
-
Generate documentation from source.
Note: mind the security considerations.
- -Dddirectory
- Write documentation file to directory . -op can be used if the original package hierarchy should be retained
- -Dffilename
- Write documentation file to filename
- -d
- Silently allow deprecated features and use of symbols with deprecated attributes.
- -de
- Issue an error when deprecated features or symbols are used (halt compilation)
- -dw
- Issue a message when deprecated features or symbols are used (default)
- -debug
- Compile in debug code
- -debug=level
- Compile in debug level <= level
- -debug=ident
- Compile in debug identifier ident
- -debuglib=name
- Link in libname as the default library when compiling for symbolic debugging instead of phobos.lib. If libname is not supplied, then no default library is linked in.
- -defaultlib=name
- Link in libname as the default library when not compiling for symbolic debugging instead of phobos.lib. If libname is not supplied, then no default library is linked in.
- -deps
- Print module dependencies (imports/file/version/debug/lib)
- -deps=filename
- Without filename, print module dependencies (imports/file/version/debug/lib). With filename, write module dependencies as text to filename (only imports).
- -extern-std=standard
-
Standards supported are:
- c++98: Use C++98 name mangling, Sets __traits(getTargetInfo, "cppStd") to 199711
- c++11 (default): Use C++11 name mangling, Sets __traits(getTargetInfo, "cppStd") to 201103
- c++14: Use C++14 name mangling, Sets __traits(getTargetInfo, "cppStd") to 201402
- c++17: Use C++17 name mangling, Sets __traits(getTargetInfo, "cppStd") to 201703
- c++20: Use C++20 name mangling, Sets __traits(getTargetInfo, "cppStd") to 202002
- -extern-std=[h|help|? ]
- List all supported standards
- -fPIC
- Generate position independent code
- -fPIE
- Generate position independent executables
- -g
- Add CodeView symbolic debug info. See Debugging on Windows.
- -gdwarf=version
- The value of version may be 3, 4 or 5, defaulting to 3.
- -gf
- Symbolic debug info is emitted for all types referenced by the compiled code, even if the definition is in an imported file not currently being compiled.
- -gs
- Always emit stack frame
- -gx
- Adds stack stomp code, which overwrites the stack frame memory upon function exit.
- -H
- Generate D interface file
- -Hd=directory
- Write D interface file to dir directory. -op can be used if the original package hierarchy should be retained.
- -Hf=filename
- Write 'header' file to filename
- -HC[=[silent|verbose ]]
-
Generate C++ 'header' files using the given configuration:",
- silent
- only list extern(C[++]) declarations (default)
- verbose
- also add comments for ignored declarations (e.g. extern(D))
- -HC=[?|h|help ]
- List available modes for C++ 'header' file generation
- -HCd=directory
- Write C++ 'header' file to directory
- -HCf=filename
- Write C++ 'header' file to filename
- --help
- Print help and exit
- -I=directory
- Look for imports also in directory
- -i[=pattern ]
-
Enables "include imports" mode, where the compiler will include imported modules in the compilation, as if they were given on the command line. By default, when this option is enabled, all imported modules are included except those in druntime/phobos. This behavior can be overriden by providing patterns via -i=<pattern>. A pattern of the form -i=<package> is an "inclusive pattern", whereas a pattern of the form -i=-<package> is an "exclusive pattern". Inclusive patterns will include all module's whose names match the pattern, whereas exclusive patterns will exclude them. For example. all modules in the package foo.bar can be included using -i=foo.bar or excluded using -i=-foo.bar. Note that each component of the fully qualified name must match the pattern completely, so the pattern foo.bar would not match a module named foo.barx.
The default behavior of excluding druntime/phobos is accomplished by internally adding a set of standard exclusions, namely, -i=-std -i=-core -i=-etc -i=-object. Note that these can be overriden with -i=std -i=core -i=etc -i=object.
When a module matches multiple patterns, matches are prioritized by their component length, where a match with more components takes priority (i.e. pattern foo.bar.baz has priority over foo.bar).
By default modules that don't match any pattern will be included. However, if at least one inclusive pattern is given, then modules not matching any pattern will be excluded. This behavior can be overriden by usig -i=. to include by default or -i=-. to exclude by default.
Note that multiple -i=... options are allowed, each one adds a pattern.
- -ignore
- Ignore unsupported pragmas
- -inline
- Inline functions at the discretion of the compiler. This can improve performance, at the expense of making it more difficult to use a debugger on it.
- -J=directory
- Where to look for files for ImportExpressions. This switch is required in order to use ImportExpressions. path is a ; separated list of paths. Multiple -J's can be used, and the paths are searched in the same order.
- -L=linkerflag
- Pass linkerflag to the linker optlink.exe , for example, ld
- -lib
- Generate library file as output instead of object file(s). All compiled source files, as well as object files and library files specified on the command line, are inserted into the output library. Compiled source modules may be partitioned into several object modules to improve granularity. The name of the library is taken from the name of the first source module to be compiled. This name can be overridden with the -of switch.
- -lowmem
- Enable the garbage collector for the compiler, reducing the compiler memory requirements but increasing compile times.
- -m32
- -m32mscoff
- Generate 32 bit code and write MS-COFF object files (deprecated use -m32)
- -m32omf
- Compile a 32 bit executable. The generated object code is in OMF and is meant to be used with the Digital Mars C/C++ compiler.
- -m64
- The generated object code is in MS-COFF and is meant to be used with the Microsoft Visual Studio 10 or later compiler.
- -main
- Add a default main() function when compiling. This is useful when unittesting a library, as it enables running the unittests in a library without having to manually define an entry-point function.
- -makedeps[=filename ]
- Print dependencies in Makefile compatible format. If filename is omitted, it prints to stdout. The emitted targets are the compiled artifacts (executable, object files, libraries). The emitted dependencies are imported modules and imported string files (via -J switch). Special characters in a dependency or target filename are escaped in the GNU Make manner.
- -man
- Open default browser on this page
- -map
- Generate a .map file
- -mcpu=id
- Set the target architecture for code generation, where:
- -mcpu=[h|help|? ]
- List all architecture options
- -mixin=filename
- Expand and save mixins to file specified by filename
- -mscrtlib=libname
- If building MS-COFF object files when targeting Windows, embed a reference to the given C runtime library libname into the object file containing main, DllMain or WinMain for automatic linking. The default is libcmt (release version with static linkage), the other usual alternatives are libcmtd, msvcrt and msvcrtd. If no Visual C installation is detected, a wrapper for the redistributable VC2010 dynamic runtime library and mingw based platform import libraries will be linked instead using the LLD linker provided by the LLVM project. The detection can be skipped explicitly if msvcrt120 is specified as libname. If libname is empty, no C runtime library is automatically linked in.
- -mv=package.module =
- Use path/filename as the source file for package.module. This is used when the source file path and names are not the same as the package and module hierarchy. The rightmost components of the path/filename and package.module can be omitted if they are the same.
- -noboundscheck
- Turns off all array bounds checking, even for safe functions. Deprecated (use -boundscheck=off instead).
- -O
- Optimize generated code. For fastest executables, compile with the -O -release -inline -boundscheck=off switches together.
- -o-
- Suppress generation of object file. Useful in conjuction with -D or -H flags.
- -od=directory
- Write object files relative to directory objdir instead of to the current directory. -op can be used if the original package hierarchy should be retained
- -of=filename
- Set output file name to filename in the output directory. The output file can be an object file, executable file, or library file depending on the other switches.
- -op
- Normally the path for .d source files is stripped off when generating an object, interface, or Ddoc file name. -op will leave it on.
- -os=os
-
Set the target operating system as other than the host.
- host: Target the host operating system (default).
- dragonflybsd: DragonFlyBSD
- freebsd: FreeBSD
- linux: Linux
- openbsd: OpenBSD
- osx: OSX
- solaris: Solaris
- windows: Windows
- -P=preprocessorflag
- Pass preprocessorflag to sppn.exe or cl.exe
- -preview=name
- Preview an upcoming language change identified by id
- -preview=[h|help|? ]
- List all upcoming language changes
- -profile
-
Instrument the generated code so that runtime performance data is collected
when the generated program is run.
Upon completion of the generated program, the files trace.log and trace.def
are generated. trace.log has two sections,
- Fan in and fan out for each profiled function. The name of the function is left-justified, the functions immediately preceding it are the other functions that call it (fan in) and how many times it is called. The functions immediately following are the functions that are called (fan out) and how many times it calls that function. The function itself has 3 numbers appended: the aggregate of the fan in counts, the tree time used by the function which is the function time plus the tree times of all the functions it calls, and the time used excluding the time used by fan out.
- Timing data for each function, sorted from most used to least.
- -profile=gc
-
- gc: Instrument calls to GC memory allocation and
write a report to the file profilegc.log upon program
termination. Note: Only instrumented calls will be
logged. These include:
- Language constructs that allocate memory
- Phobos functions that allocate GC memory
- GC allocations via core.memory.GC
- gc: Instrument calls to GC memory allocation and
write a report to the file profilegc.log upon program
termination. Note: Only instrumented calls will be
logged. These include:
- -release
- Compile release version, which means not emitting run-time checks for contracts and asserts. Array bounds checking is not done for system and trusted functions, and assertion failures are undefined behaviour.
- -revert=name
- Revert language change identified by id
- -revert=[h|help|? ]
- List all revertable language changes
- -run srcfile
- Compile, link, and run the program srcfile with the rest of the command line, args..., as the arguments to the program. No .obj or executable file is left behind.
- -shared
- Generate DLL library
- -target=triple
- arch is the architecture: either x86, x64, x86_64 or x32, vendor is always ignored, but supported for easier interoperability, os is the operating system, this may have a trailing version number: freestanding for no operating system, darwin or osx for MacOS, dragonfly or dragonflybsd for DragonflyBSD, freebsd, openbsd, linux, solaris or windows for their respective operating systems. cenv is the C runtime environment and is optional: musl for musl-libc, msvc for the MSVC runtime (the default for windows with this option), bionic for the Andriod libc, digital_mars for the Digital Mars runtime for Windows gnu or glibc for the GCC C runtime, newlib or uclibc for their respective C runtimes. ($ I cppenv) is the C++ runtime environment: clang for the LLVM C++ runtime gcc for GCC's C++ runtime, msvc for microsoft's MSVC C++ runtime (the default for windows with this switch), sun for Sun's C++ runtime and digital_mars for the Digital Mars C++ runtime for windows.
- -transition=name
- Show additional info about language change identified by id
- -transition=[h|help|? ]
- List all language changes
- -unittest
- Compile in unittest code, turns on asserts, and sets the unittest version identifier
- -v
- Enable verbose output for each compiler pass
- -vasm
- List generated assembler for each function
- -vcolumns
- Print character (column) numbers in diagnostics
- -verror-style=[digitalmars|gnu ]
-
Set the style for file/line number annotations on compiler messages,
where:
- digitalmars
- 'file(line[,column]): message'. This is the default.
- gnu
- 'file:line[:column]: message', conforming to the GNU standard used by gcc and clang.
- -verrors=num
- Limit the number of error messages (0 means unlimited)
- -verrors=context
- Show error messages with the context of the erroring source line
- -verrors=spec
- Show errors from speculative compiles such as __traits(compiles,...)
- --version
- Print compiler version and exit
- -version=level
- Compile in version level >= level
- -version=ident
- Compile in version identifier ident
- -vgc
- List all gc allocations including hidden ones
- -vtls
- List all variables going into thread local storage
- -vtemplates=[list-instances ]
-
An optional argument determines extra diagnostics,
where:
- list-instances
- Also shows all instantiation contexts for each template.
- -w
- Enable warnings
- -wi
- Enable informational warnings (i.e. compilation still proceeds normally)
- -X
- Generate JSON file
- -Xf=filename
- Write JSON file to filename
- -Xcc=driverflag
- Pass driverflag to the linker driver ($CC or cc)
dmd -cov -unittest myprog.d
Empty switches, i.e. "", are ignored.
Files
- \dmd2\src\phobos\
- D runtime library source
- \dmd2\src\dmd\
- D compiler front end source under dual (GPL and Artistic) license
- \dmd2\html\d\
- Documentation
- \dmd2\samples\d\
- Sample D programs
- \dmd2\windows\bin\ddemangle.exe
- D symbol demangler
- \dmd2\windows\bin\dman.exe
- D manual lookup tool
- \dmd2\windows\bin\dmd.exe
- D compiler executable
- \dmd2\windows\bin$(DUB)
- D's package manager
- \dmd2\windows\bin$(DUSTMITE)
- D source code minimizer
- \dmd2\windows\bin$(OPTLINK)
- OPTLINK
- \dmd2\windows\bin$(LINK2 http://www.digitalmars.com/ctg/make.html, make.exe)
- Digitalmars Make
- \dmd2\windows\bin\replace.exe
- Find/replace text in files
- \dmd2\windows\bin$(RDMD)
- D build tool for script-like D code execution
- \dmd2\windows\bin\sc.ini
- Global compiler settings
- \dmd2\windows\bin$(LINK2 http://www.digitalmars.com/ctg/shell.html, shell.exe)
- Simple command line shell
- \dmd2\windows\lib$(LIB)
- D runtime library
Linking
Linking is done directly by the dmd compiler after a successful compile. To prevent dmd from running the linker, use the -c switch.
32 bit programs must be linked with the D runtime library phobos.lib, followed by the Digital Mars C runtime library snn.lib. This is done automatically as long as the directories for the libraries are on the LIB environment variable path. A typical way to set LIB would be:
set LIB=\dmd2\lib;\dm\lib
If the dmd command is used to both compile and link to an executable, it will make certain optimizations that are valid only for Windows executable files. Do not use the resulting .obj files in a DLL. To compile modules into .obj files that can be used in an exe or DLL, compile with -c and -shared.
Linking 32 bit programs is done using Digital Mars optlink.exe.
Linking 64 bit programs is done using the Microsoft linker by default. If the Microsoft linker is not found, the included LLVM linker LLD will be used.
Environment Variables
The D compiler dmd uses the following environment variables:
- DFLAGS
- The value of DFLAGS is treated as if it were appended to the command line to dmd.exe.
- LIB
- The linker uses LIB to search for library files. For D, it will normally be set to:
- LINKCMD
- dmd normally runs the linker by looking for optlink.exe along the PATH. To use a specific linker for 32 bit programs instead, set the LINKCMD environment variable to it. For example:
- LINKCMD64
- dmd normally runs the linker by looking for optlink.exe along the PATH. To use a specific linker for 64 bit programs instead, set the LINKCMD64 environment variable to it. For example:
- PATH
- If the linker is not found in the same directory as dmd.exe is in, the PATH is searched for it. Note: other linkers named link.exe will likely not work. Make sure the Digital Mars optlink.exe is found first in the PATH before other link.exes, or use LINKCMD to specifically identify which linker to use.
set LIB=\dmd2\lib;\dm\lib
set LINKCMD=\dmd\windows\bin\link
set LINKCMD64=C:\Program Files (x86)\Microsoft Visual Studio 15.0\VC\bin\amd64\link.exe
sc.ini Initialization File
dmd will look for the initialization file sc.ini in the following sequence of directories:
- current working directory
- directory specified by the HOME environment variable
- directory dmd.exe resides in
If found, environment variable settings in the file will override any existing settings. This is handy to make dmd independent of programs with conflicting use of environment variables.
Initialization File Format
Comments are lines that begin with ; and are ignored.
Environment variables follow the [Environment] section heading, in NAME=value pairs. The NAMEs are treated as upper case. Comments are lines that start with ;. For example:
; sc.ini file for dmd ; Names enclosed by %% are searched for in the existing environment ; and inserted. The special name %@P% is replaced with the path ; to this file. [Environment] LIB="%@P%..\lib";\dm\lib<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>DDOCFILE=mysettings.ddoc
Location Independence of sc.ini
The %@P% is replaced with the path to sc.ini. Thus, if the fully qualified file name sc.ini is c:\dmd2\bin\sc.ini, then %@P% will be replaced with c:\dmd2\bin, and the above sc.ini will be interpreted as:
[Environment] LIB="c:\dmd2\bin..\lib";\dm\lib DFLAGS="-Ic:\dmd2\bin..\src\phobos" "-Ic:\dmd2\bin..\src\druntime\import" LINKCMD="c:\dmd2\bin....\dm\bin" DDOCFILE=mysettings.ddoc
This enables your dmd setup to be moved around without having to re-edit sc.ini.
Common Installation Problems
- Using Cygwin's unzip utility has been known to cause strange problems.
- Running the compiler under Cygwin's command shell has been also known to cause problems. Try getting it to work under the regular Windows shell cmd.exe before trying Cygwin's.
- Installing dmd and dmc into directory paths with spaces in them causes problems.
Differences between Windows and Linux versions
- String literals are read-only under Linux. Attempting to write to them will cause a segment violation.
D Interface Files
When an import declaration is processed in a D source file, the compiler searches for the D source file corresponding to the import, and processes that source file to extract the information needed from it. Alternatively, the compiler can instead look for a corresponding D interface file. A D interface file contains only what an import of the module needs, rather than the whole implementation of that module.
The advantages of using a D interface file for imports rather than a D source file are:
- D interface files are often significantly smaller and much faster to process than the corresponding D source file.
- They can be used to hide the source code, for example, one can ship an object code library along with D interface files rather than the complete source code.
D interface files can be created by the compiler from a D source file by using the -H switch to the compiler. D interface files have the .di file extension. When the compiler resolves an import declaration, it first looks for a .di D interface file, then it looks for a D source file.
D interface files bear some analogous similarities to C++ header files. But they are not required in the way that C++ header files are, and they are not part of the D language. They are a feature of the compiler, and serve only as an optimization of the build process.
Building Executables
dmd can build an executable much faster if as many of the source files as possible are put on the command line.
Another advantage to putting multiple source files on the same invocation of dmd is that dmd will be able to do some level of cross-module optimizations, such as function inlining across modules.
The -i flag can be used to automatically compile imported modules
Building Libraries
There are three ways to build a library. For example, given foo.d and bar.d which are to be compiled, and existing object file abc.obj and existing library def.lib which are all to be combined into a library foo.lib:
- Compile modules separately and then run the librarian on them:
dmd -c foo.d dmd -c bar.d phobos.lib -c -p32 foo.lib foo.obj bar.obj abc.obj def.lib del foo.obj bar.obj
This option is typical when using a makefile to avoid compiling modules that have already been compiled. - Compile modules together and then run the librarian on them:
dmd -c foo.d bar.d phobos.lib -c -p32 foo.lib foo.obj bar.obj abc.obj def.lib del foo.obj bar.obj
- Use dmd to compile and build library in one operation:
dmd -lib foo.d bar.d abc.obj def.lib
No object files are written to disk, it's all done in memory. Using -lib also has the advantage that modules may be compiled into multiple object files rather than exactly one per module. This improves granularity of the library without having to break up the modules.
Compiling dmd
Complete source code is provided to build the compiler. Follow these steps:
cd \dmd2\src\dmd make -f win32.mak
Compiling Phobos
Complete source code is provided to build Phobos, the D runtime library. Follow these steps:
cd \dmd2\src\druntime make -f win32.mak cd ..\phobos make -f win32.mak


Array_Constructors(7f) - [FORTRAN] An array constructor can be used to create and assign values to rank-one arrays (and array constants) (LICENSE:PD)
Syntax
Description
Options
Examples
See Also
An array constructor takes the following form:
(/ac-value-list/) [ac-value-list]
ac-value-list Is a list of one or more expressions or implied-DO loops. Each ac-value must have the same type and kind parameters, and be separated by commas. implied-do An implied-DO loop in an array constructor takes the following form: (ac-value-list, do-variable = expr1, expr2 [,expr3])
do-variable Is the name of a scalar integer variable. Its scope is that of the implied-DO loop.
expr Is a scalar integer expression. The expr1 and expr2 specify a range of values for the loop; expr3 specifies the stride. The expr3 must be a nonzero value; if it is omitted, it is assumed to be 1.
DescriptionThe array constructed has the same type as the ac-value-list expressions.
If the sequence of values specified by the array constructor is empty (an empty array expression or the implied-DO loop produces no values), the rank-one array has a size of zero.
An ac-value is interpreted as follows:
Form of ac-value Result A scalar expression Its value is an element of the new array. An array expression The values of the elements in the expression (in array element order) are the corresponding sequence of elements in the new array. An implied-DO loop It is expanded to form a list of array elements under control of the DO variable (like a DO construct). The following shows the three forms of an ac-value: C1 = (/4,8,7,6/) ! A scalar expression C2 = (/B(I, 1:5), B(I:J, 7:9)/) ! An array expression C3 = (/(I, I=1, 4)/) ! An implied-DO loopYou can also mix these forms, for example:
C4 = (/4, A(1:5), (I, I=1, 4), 7/)If every expression in an array constructor is a constant expression, the array constructor is a constant expression.
If the expressions are of type character, Fortran 95/90 requires each expression to have the same character length. However, Intel Fortran allows the character expressions to be of different character lengths. The length of the resultant character array is the maximum of the lengths of the individual character expressions. For example: print *,len ( (/a,ab,abc,d/) ) print *,++//(/a,ab,abc,d/)//--This causes the following to be displayed:
3
++a --++ab --++abc--++d --
If an implied-DO loop is contained within another implied-DO loop (nested), they cannot have the same DO variable (do-variable).To define arrays of more than one dimension, use the RESHAPE intrinsic function.
The following are alternative forms for array constructors:
Square brackets (instead of parentheses and slashes) to enclose array constructors; for example, the following two array constructors are equivalent:
INTEGER C(4) C = (/4,8,7,6/) C = [4,8,7,6]
The following example shows an array constructor using an implied-DO loop:
INTEGER ARRAY_C(10) ARRAY_C = (/(I, I=30, 48, 2)/)The values of ARRAY_C are the even numbers 30 through 48.
Implied-DO expressions and values can be mixed in the value list of an array constructor. For example:
INTEGER A(10) A = (/1, 0, (I, I = -1, -6, -1), -7, -8 /) !Mixed values and implied-DO in value list.This example sets the elements of A to the values, in order,
1, 0, -1, -2, -3, -4, -5, -6, -7, -8.The following example shows an array constructor of derived type that uses a structure constructor:
CHARACTER(LEN=30) NAME
TYPE(EMPLOYEE) CC_4T(4)
CC_4T = (/EMPLOYEE(2732, JONES ), EMPLOYEE(0217, LEE ), EMPLOYEE(1889,"RYAN"), EMPLOYEE(4339,"EMERSON")/)
The following example shows how the RESHAPE intrinsic function can be used to create a multidimensional array:
E = (/2.3, 4.7, 6.6/) D = RESHAPE(SOURCE = (/3.5, (/2.0, 1.0/), E/), SHAPE = (/2,3/))
D is a rank-two array with shape (2,3) containing the following elements:
3.5 1.0 4.7 2.0 2.3 6.6The following shows another example:
INTEGER B(2,3), C(8) ! Assign values to a (2,3) array. B = RESHAPE((/1, 2, 3, 4, 5, 6/),(/2,3/)) ! Convert B to a vector before assigning values to ! vector C. C = (/ 0, RESHAPE(B,(/6/)), 7 /)Example using general purpose fortran routines
program demo_array_constructors ! initializing small arrays use M_display, only : disp, disp_set implicit none integer :: i integer, parameter :: yy(*) = [ 10,20,30 , 40,50,60 ] ! make some data in a vector, could type this where yy appears below ! xx is same thing as yy, just using syntax for filling it that makes it clearer what I want to do with the data integer, parameter :: xx(*) = [ [10,20,30] , [40,50,60] ] ! make some data in a vector, could type this where xx appears belowinteger, dimension(2,3)::aa = reshape(xx,shape(aa),order=[2,1]) ! 2d by rows using reshaped scalar expression integer, dimension(2,3)::bb = reshape(xx,shape(bb) ) ! 2d by columns integer, dimension(2,3)::cc = reshape(xx,shape(cc),order=[1,2]) ! 2d by columns integer, dimension(2,3)::dd = reshape([(i*10,i=1,size(dd))],shape(dd)) ! an implied do by columns
integer, dimension(2,3):: ff, gg, hh ! CANNOT DO !integer, dimension(2,3)::ff = [10,20,30,40,50,60 ] ! 2d by columns ! BUT CAN DO data ff/10,20,30,40,50,60/ ! fill 2D with simple data statement ! AND CAN DO ! multi-dimensional by equivalence integer :: ee(2,3) integer :: e(size(ee))=xx equivalence (e(1),ee(1,1)) ! CANNOT DO !integer, dimension(2,3)::gg = [10,20,30] , [40,50,60] !integer, dimension(2,3)::gg = [[10,20,30] , [40,50,60]] ! BUT CAN DO data gg(1,:)/ 10, 20, 30 / ! fill rows with data statements data gg(2,:)/ 40, 50, 60 /
data hh(:,1)/ 10, 40 / ! fill columns with data statements data hh(:,2)/ 20, 50 / data hh(:,3)/ 30, 60 / call disp_set(style=left & number)
write(*,*)SIZE(aa)=,size(aa) write(*,*)SHAPE(aa)=,shape(aa) write(*,*)xx=,xx write(*,*)yy=,yy
call disp(aa=,aa) call disp(bb=,bb) call disp(cc=,cc) call disp(dd=,dd)
call disp(ee=,ee)
call disp(ff=,ff) call disp(gg=,gg) call disp(hh=,hh)
write(*,*)repeat(=,80) write(*,*)hh write(*,*)repeat(=,80) call print_buildfmt(hh) write(*,*)repeat(=,80) call print_fixedfmt(hh)
contains
subroutine print_buildfmt(arr) use M_strings, only : v2s implicit none integer,intent(in) :: arr(:,:) integer :: i character(len=:),allocatable :: fmt fmt=("> [",//v2s(size(arr,dim=2))//(i0:,","),"]") write(*,*)FMT=,fmt write(*,fmt)(arr(i,:),i=1,size(arr,dim=1)) end subroutine print_buildfmt
subroutine print_fixedfmt(arr) implicit none integer,intent(in) :: arr(:,:) integer :: i do i=1,size(arr,dim=1) write(*, ("> [",*(i0:,",")) ,advance=no)arr(i,:) write(*,("]")) enddo end subroutine print_fixedfmt
end program demo_array_constructors ! initializing small arrays
o DO construct o Derived types o Structure constructors o Array Elements for details on array element order o Array Assignment Statements for details on another way to assign values to arrays o Declaration Statements for Arrays for details on array specifications
| array_constructors (7) | January 01, 2020 |


--- layout: post title: FSharp.Formatting example published: false ---
This file demonstrates how to write literate F# script
files (*.fsx
) that can be transformed into nice HTML
using the literate.fsx
script from the F# Formatting
package.
As you can see, a comment starting with double asterisk is treated as part of the document and is transformed using Markdown, which means that you can use:
And numerous other Markdown features.
Code that is not inside comment will be formatted as a sample snippet (which also means that you can run it in Visual Studio or MonoDevelop).
1: 2: 3: 4: 5: 6: |
|
If you want to include some code in the source code,
but omit it from the output, you can use the hide
command.
The value will be defined in the F# code and so you can use it from other (visible) code and get correct tool tips:
1:
|
|
Sometimes, it is useful to first explain some code that
has to be located at the end of the snippet (perhaps
because it uses some definitions discussed in the middle).
This can be done using include
and define
commands.
The following snippet gets correct tool tips, even though
it uses laterFunction
:
1: 2: 3: |
|
Then we can explain how laterFunction
is defined:
1: 2: |
|
This example covers pretty much all features that are
currently implemented in literate.fsx
, but feel free
to fork the project on GitHub and add more
features or report bugs!


Workweek
1 Monday
2 Thuesday
3 Wednesday
4 Thursday
5 Friday
Weekend
6 Saturday
7 Sunday
REMINDERS
SPECIAL DATES


Input improved Exemple "ui-input"
Your Name :
Random text :
Search zone - "ui-input"
this !
Selection Process - "ui-selection-process"
Type something
Trouser


Auto results:
10. Winner is player 1!
Player
to make a move
Game nr.
NEW MANUAL GAME
NEW AUTO GAME
(WarGames style)
Number of runs:
Show Moves:
Ja
Nej
Show Result:
Ja
Nej
MS for move:


General discussion about Komodo. For useful links and more info click the pinned messages to the right. DON'T DM @jl777
100 messages
Before 05-Dec-19 12:00 AM
polycryptoblog27-Mar-19 12:32 PM
@crunchycat from a business perspective, why would I pay 3x more to do the same job
polycryptoblog27-Mar-19 12:46 PM
@crunchycat Also with the percentage mining model, it’s not cost effective even for the customer chains. You say even large chains will want VBK, imagine there is a coin similar in price and marketcap and mining parameters as Komodo. About 2.6 million coins are mined per year. 26000 coins at 1% mining fee roughly 26k usd , this is 4-5x the cost of Komodo DPoW. And only gets worse with more capitalized chains. Lower end chains face the problems a) no way to recuperate shitcoin for btc spent b) low value coins being split up = tragedy of the commons(edited)
jl777c27-Mar-19 12:49 PM
1576800 coins mined per year, still the cost is quite a bit higher
polycryptoblog27-Mar-19 12:51 PM
Ah yes My mistake, yes it still is like 3x higher.
jl777c27-Mar-19 12:52 PM
but KMD has pretty low mining emission due to the 5% APR, most other mining coins are issuing all new coins via mining, so it could be 3x more than 3x
LocoMB27-Mar-19 07:35 PM
oh come on!
what a cheap dog and pony show!
https://international.bittrex.com/Market/Index?MarketName=BTC-VBK
283,000,000 initial supply, and 70,000,000 for sale?!?
well guess what- it's nice club, but you're not in it, but now they offer some minor stake for small timers - for way more than they themselves paid(edited)
Cryptoon27-Mar-19 08:47 PM
ready to dump the cheap presale on the pleb
PHBA206127-Mar-19 09:32 PM
from what happened with IEO on binance, I don't think bittrex would dump their allocation of vbk right away if they want to keep this IEO trend going so they can earn more from future IEO.
taco27-Mar-19 10:11 PM
What is the cost/requirements to get listed on barterdex?
Cryptoon27-Mar-19 10:12 PM
Ask @cipi
taco27-Mar-19 10:13 PM
@cipi What is the cost/requirements to get listed on barterdex?
3
ComputerGenie 👴👴👴27-Mar-19 10:14 PM
lol
2
FishyGuts27-Mar-19 10:25 PM
Your sanity @taco
Cipi does integrations, and is an easy person to work with.(edited)
Why are Bitcoin transactions surging again? You are probably familiar with the reason by now
https://t.co/SoJgg1h8k1
Markus28-Mar-19 04:14 PM
holy shit
haha
Cryptoon28-Mar-19 04:25 PM
Yeah I can see it being exploitable and a lot of the funds that will be raised on monday will burn very fast
1
jl777c28-Mar-19 04:26 PM
what can go wrong doing 100x the BTC tx than dPoW. but maybe this is something the btcfee market peoples are wanting
Markus28-Mar-19 04:27 PM
sounds like a cheap way to use miners to do it so that the team dont have to fund the tx fees to btc
Alright28-Mar-19 04:28 PM
Can BTC pool owners just get free veriblock?
they totally can....
jl777c28-Mar-19 04:29 PM
spending 100x the funds doesnt sound cheap to me, ultimately somebody has to pay for this
Alright28-Mar-19 04:29 PM
I guess it's not free if you're replacing a tx that would have paid more
jl777c28-Mar-19 04:29 PM
and if it starts a fee market, maybe everyone will have to pay $30 per BTC tx
Alright28-Mar-19 04:29 PM
are they connected to blockstream?
that's a joke
tonystark209928-Mar-19 06:13 PM
which file on this page https://github.com/KomodoPlatform/komodo/releases is the correct one to download komodod? komodo_linux-master (which seems to be a test, because it is not recommend to use) or Komodo 0.3.3b beta?
1.Remove the bitcoin as a currency narrative. 2. Remove the bitcoin as gold narrative. 3. ??? 4. Profit? Peter Todd, a Bitcoin Core developer instrumental in maintaining the blocksize at...
@nic__carter @Porsenna @giacomozucco @Excellion @francispouliot @KomodoPlatform - The security of $VBK with none of the bloat, at a lesser cost to most projects.
1 $BTC tx for the same effect.
♂ I guess working tech that’s plain and boring but extremely...
A group of blockchain firms called Universal Protocol Alliance is launching a euro-pegged stablecoin that can be staked to earn annual returns.
Regnar29-Mar-19 04:55 PM
Dilithium Priv-key is 7,712 characters long lol
1
FishyGuts29-Mar-19 04:59 PM
1028 word mnemonic
Regnar29-Mar-19 05:01 PM
I was reading through the docs and saw how tiny the slide bar was haha
it's like 7 pages in Word. fun stuff
Cryptoon29-Mar-19 05:43 PM
Write it all down, no mistakes!
LocoMB29-Mar-19 05:43 PM
MEMORIZE! nothing less is acceptable!
long key is mandatory anyway, so that if you get tortured they you won't be able to make you recite it before you faint
jl777c29-Mar-19 05:56 PM
with dilithium a 256bit seed generates the giant keypair
PTYX29-Mar-19 06:26 PM
Some more assets coming to Chameleon :)
3
Alright29-Mar-19 06:27 PM
@Regnar I wrote a TUI for it because it was crashing text editors and terminal windows when I would try to copy paste it
1
wil29-Mar-19 06:27 PM
Nice!
Regnar29-Mar-19 06:29 PM
loving the docs page btw, it's coming along!
1
Regnar29-Mar-19 06:41 PM
The new quantum resistance is all about making keypairs so big it just crashes your computer when you try to use it.
Spaid29-Mar-19 06:53 PM
quantum secure is saying technology will never advance to break it... doesn't matter how big the key is, someday it will be broken
Regnar29-Mar-19 06:58 PM
It's more just saying we changed the problem being asked to one that is more difficult for a quantum computer to solve, assuming we understand HOW the computers will try and solve them.
There very well may be a new algorithm that QC will use that may break lattice based encryption, by that I mean just give it an advantage to some degree in solving it, but then we have to change the problem being asked again. repeat forever
jl777c29-Mar-19 07:00 PM
just because you cant be sure the new algo will remain quantum resistant, it is sure better than continuing to use obsolete algo that we know are totally cracked.
when QC arrive, we need to transition
will it be dilithium? who knows?
but we can practice ahead of time what the anti-QC migration would be like and solve whatever issues we encounter in the early ones
Regnar29-Mar-19 07:05 PM
It's definitely good to have a grasp of both sides of the situation. Seeing how computers and tech are evolving, what they are doing better, where their limitations are etc. and then finding hard problems that can only be solved (that we know of) in ways that those computers are not good at.
will the new Dilithium addresses work with SPV?
jl777c29-Mar-19 07:08 PM
SPV has no idea about dilithium, but it would be possible to calculate the special address where the registration opret is
Regnar29-Mar-19 07:12 PM
so lite/mobile wallets would be possible but take some additional work?
jl777c29-Mar-19 07:17 PM
yes, a fair amount of work, but less than for zSPV
Regnar29-Mar-19 07:27 PM
cool, wonder who will have the first qKMD mobile. << @PTYX
#Komodo on the edge of technology. This time full-quantum protection with an additional lattice-based digital signature Crystals-Dilithium. This technology also allows you to use handle as addresses in an easy - to-remember form. Like "komodo-cli sendtoaddress Bob 100" ...
PTYX29-Mar-19 08:26 PM
We need 3 iOS testers for Chameleon v2.0.3. If there are any volunteers please send me your email in PM and I'll send you the testing guide along with the testflight invitation. We will be testing the Komodo reward claiming feature so you must have at least 10 KMD to stake.
By CCN.com: The average transactions per Bitcoin block have gone to its all-time high in the past few days, and many people are attributing the rise in operations to a company called Veriblock. Veriblock is
KMD mentioned
Deleted User29-Mar-19 10:47 PM
marketing a tx flood
PTYX29-Mar-19 11:10 PM
blackjok3r29-Mar-19 11:27 PM
@Deleted User let's do it!
Deleted User29-Mar-19 11:27 PM
? :p
blackjok3r29-Mar-19 11:27 PM
A tx flood... Lol
Deleted User29-Mar-19 11:28 PM
wanna market a real flood ?, let s go to 1M
blackjok3r29-Mar-19 11:28 PM
Sure
Deleted User29-Mar-19 11:28 PM
without btc fee
blackjok3r29-Mar-19 11:28 PM
I think we can fill a few blocks on kmd then wait for it to be notarized


Switch
Custom width (120px)
Custom width
size (absolute):
px
size (relative):
%
Initial state = off
Initial state = on


BLOOD, GUTS, BULLETS AND OCTANE
Reviewed by Harvey Karten, Ph.D. Lions Gate Films Director: Joe Carnahan Writer: Joe Carnahan Cast: Joe Carnahan, Dan Leis, Ken Rululph, Dan Harlan, Hugh McChord, Kurt Johnson, Mark S. Allen, Kellee Benedict
The after-movie talk is likely to be not so much about the quality of "Blood, Guts, Bullets and Octane" but about how it got to be made at all. While some studios are vying for who can make the most expensive film, others compete for bargain-basement figures. Since this film, written and directed by Joe Carnahan, got into the can for $7300, it joins "El Mariachi" in a fight to make the Guinness Book for flourishing penury. Consider that Mel Gibson was paid $25 million for his role in "Lethal Weapon 4." Let's say he takes off after taxes with $15 million. Remember: that's for a couple of months' work! (It would take me, wow, three YEARS to earn that sort of bread.) If Mr. Gibson is not rushed into "Lethal Weapon 5" but decides instead to become a producer or director, how many "Blood, Guts, Bullets and Octane"'s could he make? Two thousand fifty-four. In every likelihood two thousand of them would be better than a "Lethal Weapon 5."
Put it another way. Joe Carnahan's movie at under eight large is actually superior to three of Gibson's police dramas. Its cast and crew were paid in Doritos and its star performer reliably comes through on a gallon or so of gas. A 1963 Pontiac LeMans is the center of attention, a vehicle which turns out to be worth more than Richard Quine's solid gold Cadillac. It's worth so much, in fact, that a guy is willing to pay two used-car dealers $250,000 just to give the LeMans a space for forty-eight hours. What gives this oversized convertible its value? You'll have to wait till the end for that, and you'll be glad you did. Carnahan's ultimate payoff is keenly realized, a remuneration explained in thorough, philosophic and sentimental terms by its most morally immoral character.
The indie film, considered by Village Voice critic Amy Taubin one of the two most captivating works to come out of the 19th Independent Feature Film Market, was shot in thirteen days, though its conception stretched out for half a year while Mr. Carnahan scraped up needed funds and equipment. Filmed in 16mm, transferred to video, and then relocated again to whatever could give it a grainy, indie feel, "Blood, Guts" highlights Sid (Carnahan) and Bob (Dan Leis) as its car's supporting individuals. They own a used car dealership about to go under, crushed by the next-door competition of Danny Woo (Dan Harlan), who has sewed up the market so tighly that Sid and Bob cannot even get deliveries of the autos they need. They get the chance of a lifetime to reinvent themselves when a thug offers them $250,000 if they would simply hold on to the LeMans and leave it in their fallow plot of land for two days. Though the more practical Bob is suspicious, he is talked into the deal by his partner, who would not have cared if forty people were killed over the lemon--as indeed they were.
Did somebody say "talked"? The folks in this accomplished film could always go into rap if their careers as actors were curtailed. Fast talkers all, they keep up such an outpouring of chatter that their seemingly improvised prattle will distract you from worrying about a plot hole. The flawed plotline would have you consider that in order to get the auto from South America to its final destination it became necessary over and over to sell and then to shoot and kill every bargain-hunter who fronted cash to get behind the driver's seat. Like business partners everywhere, Sid and Joe would spend their time bickering about the small things, seeming to disagree about every aspect of the business. Much of the film's fun is in the robust interchange of ideas between the plump, overbearing, excitable Sid and his handsome, practical partner Bob.
The actors, who obviously contributed their time, turn in professional ensemble work. Ken Rudulph as FBI Agent Jared embodies the no-nonsense federal cop of the Janeane Garafolo ("Clay Pigeons") variety, getting comic mileage as the straight man supervising the uncovering of bloody body parts in a hotel dumpster. As Danny Woo, Dan Harlan is the sentimental hub, a happily married man who will do anything for his sick, wheelchair-bound wife Dottie (Karla Cave). Carnahan provides an assortment of hillbilly oddballs and nerdish car buyers as well, in this nonlinear narrative about taking risks and about doing good by doing evil. The hand- held camera takes frequent breaks for quick, frequent flashbacks in color and in black and white as though Carnahan were gently spoofing film-school antics. On the whole, "Blood, Guts, Bullets & Octane" shows that with the right volunteer help and a financial incapacity to shoot the same scenes over and over, you can evoke enough spontaneity to capture the full attention of an intelligent audience.
Not Rated. Running time: 87 minutes. (C) Harvey Karten 1998
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


Ghana's Nettey targets Beattie knockdown in first international bout
by Simon Asare, GNA
Accra, Nov. 25, GNA - Ghanaian boxer Razak Nettey (22-2, 16 KO's) is confident of a knockout when takes on Scottish boxer Nathan Beattie (13-4, 9Ko’s) in his first international bout.
Nettey, would be looking to make an impressive debut on the international stage when he makes a ring appearance at a Championship Boxing Night dubbed ''Knockout Christmas Cracker'' slated for December 14, at the Northern Hotel in Aberdeen, United Kingdom.
Ahead of the Super Lightweight contest, Nettey has vowed to knockdown the 29-year-old Scottish counterpart and hoped it would pave way for him to compete for world titles in the near future.
I'm ready for the bout, I would not let this opportunity slip and I assure Ghanaian boxing fans of victory. My opponent is a good boxer but the bout would not travel the entire distance and I would surely knock him down,'' he said in an interview,
Nettey was optimistic about winning world and commonwealth titles for Ghana in the future and believes the bout offers him the opportunity to prove his worth not to only Ghanaians but the entire boxing world fraternity.
GNA


Alpine ski areas come in all sizes. And while you can't quantify the
character of a mountain, the tool below helps to visualize a ski area's size. Check out how
your home mountain compares, or how the big mountains stack up to each other.
The graph is a representation of a ski area's vertical drop and skiable area.
It does not model the actual shape of any particular mountain. I've collected this
data from each ski area's website and wikipedia; please let me know if you find
any missing or inaccurate data.


Fourier-Analysis, Data Input from a Picture
The coordinates of the quarter fold can be found from a picture by clicking on them.
Click on 'Import image' to open a *.BMP or *.JPG-file. The graphic may be loaded either from the clipboard (paste) or from a file.
The menu 'adjust image' enables you to rotate the image or to eliminate vergency.
To find the coordinates of the quarter fold click on the inflection point. Click on the hinge. Now click on the 1/3- and 2/3-coordinates (X1 and X2).


Buy Ads
Ad type:
Header banner 728x90 (10$/week)
Center banner 728x90 (9$/week)
Right banner 300x100 (7$/week)
Left banner 180x150 (6$/week)
Period:
1
2
3
4
Week
Price: 10$
Destination URL
Banner URL:
Title:
Text:
Payment:
Perfect money
Buy
728x90
180x150
728x90
300x100


1 Introduction
Statistics is not synonymous with data analysis; rigor vs practicality
“Evaluating the Success of a Data Analysis” (Hicks and Peng 2019)
“Data Alone is not Ground Truth” (Bassa 2017)
1.4 A case study
Now unplug your Internet cable, and start doing some serious work.
We have a nice figure in Figure 1.1, and also a table in Table 1.1.
| Sepal.Length | Sepal.Width | Petal.Length | Petal.Width | Species |
|---|---|---|---|---|
| 5.1 | 3.5 | 1.4 | 0.2 | setosa |
| 4.9 | 3.0 | 1.4 | 0.2 | setosa |
| 4.7 | 3.2 | 1.3 | 0.2 | setosa |
| 4.6 | 3.1 | 1.5 | 0.2 | setosa |
| 5.0 | 3.6 | 1.4 | 0.2 | setosa |
| 5.4 | 3.9 | 1.7 | 0.4 | setosa |


Carbon Datasource feature in Data Services Server can be used to create datasources which can be used inside data services directly through the name of the Carbon Datasource. The datasources created using Carbon Datasource feature will be persisted, and can be used when ever required.
To create the carbon datasource click on the Datasources menu item under the configuration.
Figure 1: Create Carbon Datasource menu
Click on 'Add Datasource' link in Datasources page which will direct you to a page where you can enter the details for the datasource.
You can select a datasource provider from the highlighted combo box. For the 'default' Data Source Provider, given connection properties Driver, URL, User Name and Password need to be entered.
Figure 2: Creating the Carbon Datasource
If you need to add a datasource supported by an External Datasource Provider class such as com.mysql.jdbc.jdbc2.optional.MysqlXADataSource, select 'external' as the Data Source Provider. Then enter the name and value of connection properties by clicking 'Add Property'. Given below is an example datasource of External Datasource Provider with eneterd values.
Figure 3: Creating the Carbon Datasource of External Datasource Provider
After entering the details you can test the connection by click on 'Test Connection' button on bottom of the page. Then click 'Add' to save the datasource.
Once you have created the carbon datasource, you can use it inside the data service. Select the 'Carbon Datasource' as the type of the datasource in Add datasource page in the data services wizard. Select the carbon datasource name which you have created from the drop down list.
Figure 4: Creating the datasource for Carbon Datasource
The adding datasource can be exposed as a JNDI Datasource as well. Expand 'Expose as a JNDI datasource' and enter the required values. If the datasource will be using Datasource Factory, click on the checkbox 'Use Datasource Factory' and define the JNDI properties. Given below is an example JNDI configuration.
Figure 5: Expose as a JNDI Datasource
When creating the data service select the datasource type as 'JNDI' and enter the values to be used to connect to the previously created JNDI enabled datasource.
Figure 6: Creating the datasource for JNDI
By expanding the 'Datasource Configuration Parameters' you can set the jdbc-pool properties for the datasource.
Figure 7: Expanding Datasource Configuration Parameters
Datasource Configuration Parameters with default values is showing below.
Figure 8: Datasource Configuration Parameters


HYDE is Jekyll's evil twin.
We have lots of data and data can be evil. But every cloud has a silver lining. So HYDE
help you make sense of the data to find a great place to live in sunny Singapore,
where housing, transport and health are great.
Made with Polymer, AngularJS & Leaflet
Data Sources: data.gov.sg, OneMap, URA, LTA, SLA...
Done by: Kah Khang, Lynnette Ng, Raymond, Ji An


|
UsingDoxygenwithMatlab
|
Functions | |
| function | Estimate4pLSGaussNewton (in x) |
| function | CreateCovMatrix (in Abh3, in bins, in Nx) |
| function | g2bh3 (in P, in Nx, in bins, in limit, in sf, in p, in Abh3) |
| function | g1 (in A, in B, in C, in f, in N, in bins, in limit, in sf, in p) |
| function | freq (in x) |
| function | polinom (in N) |
| function CreateCovMatrix | ( | in | Abh3, |
| in | bins, | ||
| in | Nx | ||
| ) |
| function Estimate4pLSGaussNewton | ( | in | x | ) |
| function freq | ( | in | x | ) |
| function g1 | ( | in | A, |
| in | B, | ||
| in | C, | ||
| in | f, | ||
| in | N, | ||
| in | bins, | ||
| in | limit, | ||
| in | sf, | ||
| in | p | ||
| ) |
| function g2bh3 | ( | in | P, |
| in | Nx, | ||
| in | bins, | ||
| in | limit, | ||
| in | sf, | ||
| in | p, | ||
| in | Abh3 | ||
| ) |
| function polinom | ( | in | N | ) |


Grab an install ISO file from the Manjaro website and flash to a micro SD card. Insert into computer, boot up and follow install instructions. This will install the OS on the SD card.
After the install is done, you'll may be presented with a welcome screen (depending on the distro you picked) from which you can begin the actual install on the laptop. If not, go to the application installer and search for manjaro-arm-flasher. Run that application to flash the actual laptop drive, shut down and remove the micro SD card. Reboot and follow the install prompts.
Most important control is the mod
key. In the Pinebook Pro, it's the key with a pinecone on it.
Make config changes in /etc/sway/
and ~/.config/sway
Terminal mod + Enter
App launcher mod + d
Quit current app mod + Shift + q
Exit options mod + Shift + e
Switch workspace mod + [1-10]
Move current app to workspace mod + Shift + [1-10]
Screenshot mod + Shift + s
, you'll be prompted for size options but add Shift
to save a file instead of adding to buffer.
Screen recording mod + Shift + r
, you'll be prompted for size options but add Shift
to include audio recording.
Scratchpad lets you toggle an app in an overlay mod + Minus
Add current app to scratchpad mod + Shift + Minus


Web Developer & Designer
Hello,My name is Carol Wambui.I am a developer and also a designer but still LEARNING.I am currently doing my programming studies at moringa school.
I went to St Michael Girls High School and thats where l did my form 4 exams way back in 2019.
I am still learing and focused to gradute for the course.
I have always dreamed of being a programmer and that is actually what pushed me to do programming.
I love Dancing.
Listening to music is also my thing.
I love hiking.
I like Coding.


Regular text columns!
Full width, two columns, three columns, simple text, columns with headings, columns with images, columns and more columns!
1/1
Lorem Ipsum is simply dummy text Lorem Ipsum is simply dummy text of the printing. of the printing.
1/2
Lorem Ipsum is simply dummy text of the printing.
2/2
Lorem Ipsum is simply dummy text of the printing.
1/3
Lorem Ipsum is simply dummy text of the print and industry.
2/3
Lorem Ipsum is simply dummy text of the print and industry.
3/3
Lorem Ipsum is simply dummy text of the print and industry.
Columns with small icons!
Full width, two columns, three columns, simple text, columns with headings, columns with images, columns and more columns!
Full width text!
Lorem Ipsum is simply dummy text Lorem Ipsum is simply dummy text of of the printing.
1/2
Lorem Ipsum is simply dummy text of the printing.
2/2
Lorem Ipsum is simply dummy text of the printing.
1/3
Lorem Ipsum is simply dum text of the pri nt and indu.
2/3
Lorem Ipsum is simply dum text of the pri nt and indu.
3/3
Lorem Ipsum is simply dum text of the pri nt and indu.
Columns with large icons!
Full width, two columns, three columns, simple text, columns with headings, columns with images, columns and more columns!
A large centered icon!
Lorem ipsum dolor sit amet, consec tetur elit.
Big Icons?
Lorem Ipsum is simply dummy text of the printing.
Centerd up!
Lorem Ipsum is simply dummy text of the printing.
Big Icons?
Lorem Ipsum is simply dummy text of the printing.
Big Icons?
Lorem Ipsum is simply dummy text of the printing.
Big Icons?
Lorem Ipsum is simply dummy text of the printing.
Image Columns
Any possible variation you can think of can happen with these columns!
Center Image
Image One
Image Two
Image One
Image Two
Image Three
Lists and Icon Lists?
lists are probably the most important element in any page! So we piled 40 of the best icons just for you!
- Addressbook.
- Block icon list.
- Bookmark list.
- Bubble icon list.
- Briefcase list.
- Buy icon list.
- Calendar list.
- Clipboard list.
- Delete icon list.
- Clock icon list.
- Diagram list.
- Document list.
- Down icon list.
- Flag icon list.
- Folder icon list.
- Gear icon list.
- Globe icon list.
- Heart icon list.
- Help icon list.
- Home icon list.
- Label icon list.
- Left icon list.
- Letter icon list.
- Monitor list.
- Pencil icon list.
- Plus icon list.
- Present list.
- Print icon list.
- Right icon list.
- Save icon list.
- Sheild icon list.
- Statistics list.
- Stop icon list.
- Tick icon list.
- Trash icon list.
- Up icon list.
- User icon list.
- Wallet icon list.
- Warning list.
- Key icon list.
Regular Lists
Icon lists are nice but some times old fashion is needed!
- List Element 1
- List Element 2
- List Element 3
- List Element 4
- List Element 5
- List Element 1
- List Element 2
- List Element 3
- List Element 4
- List Element 5
Numbered Lists
Icon lists are nice but some times old fashion is needed!
- List Element
- List Element
- List Element
- List Element
- List Element
- List Element
- List Element
- List Element
- List Element
- List Element
Left Heading
Lorem Ipsum is simply dummy text.
Center Heading
Lorem Ipsum is simply dummy text.
Right Heading
Lorem Ipsum is simply dummy text.
Show me the headings!
All types of headings, made beautiful, perfectly selected! Headings are amazing and are probably one of the most used elements in a template!
This is a heading example
This is a heading example
This is a heading example
This is a heading example
This is a heading example
Dropcaps!
Maybe you have a taste for oldschool typography! In that case you really need dropcaps! It's just amazing!
D ropcaps is amazing, especially when you love typopgraphy like I do! Typography is very important, and needs to be clean and perfectly sized!
Highlights!
There are some parts of text where bold just won't cut it! Having text highlights makes it so much easier to emphesize a point of view!
Highlighted textis simply awesome!
Highlighted textis simply awesome!
Highlighted textis simply awesome!
Highlighted textis simply awesome!
Speach bubbles?
A nice way of showing off a conversation maybe?
John Doe says:This is just an awesome bubble!
Jane Doe replied:Yeap! It's awesome isn't it and it's not that hard to use! And they act like bubbles, only expanding to 75% of width!
John Doe says:Awesome stuff!
Quotes
Maybe you have some testimonials you would like to share! So we've styled some quote styles for you!
"Lorem ipsum dolor sit amet, consec tetur adisc ipiscing elit." - John Doe, CEO
"Lorem ipsum dolor sit amet, consec tetur adisc ipiscing elit." - John Doe, CEO
Want code?
We have this too! Of course! It's suppose to be the most complete template out there!


@** * Copyright (C) 2014 Johannes Unterstein<EMAIL_ADDRESS>unterstein.info * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * http://www.apache.org/licenses/LICENSE-2.0 * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @(headline: Html = Html(""), headline2: Html = Html(""), scripts: Html = Html(""), css: Html = Html(""))(content: Html)(implicit request: play.api.mvc.Request[Any], lang: Lang)


You advise the school that cascading style sheets should be used. Your reasoning could include?
• Cascading style sheets reflects the school's structure. In other words, the school and its various
departments can each tailor the style sheet (using a hierarchy of style sheets) to suite their own image,
thereby providing some control and consistency over the overall layout without being too restrictive on
each department's Web page design.
• If the school were to change its image in the future, style sheets provide a quick and easy way to do so.
• If a design change is required during the development of the website, then style sheets provide a quick
and easy method to do so.
• You mention that if every teacher were to write their own style, the school's image would be lost. Further,
updating these separate designs to meet some future design standard is an arduous task.
• HTML tags:
• p, for text presentations.
• table.exam, for exam timetables.
• table.time, for student timetables.
• table.year, for yearly timetables.
• body, the style for the main page, which will be inherited by other pages.
• body.english, the style for the english department.
• body.maths, the style for the mathematics department.
• h1, headers.
• h2, other headers.


Home
Registration
login
User Profile
Shoping cart
Payment
Logout
Welcome to our checkout.
Name on Card
Card Number
Billing Address
Expiration
Year
Make Payment !
Please choose your method of payment and hit continue. You will then be sent down to pay using your selected payment option.


| W/L | Fighter | Str | Td | Sub | Pass | Weight class | Method | Round | Time |
|---|---|---|---|---|---|---|---|---|---|
|
|
59 51 |
0 0 |
0 0 |
0 0 |
Heavyweight |
KO/TKO Punches |
4 |
3:51 |
|
|
|
8 1 |
0 0 |
0 0 |
0 0 |
Middleweight |
KO/TKO Punch |
1 |
1:16 |
|
|
|
69 38 |
0 0 |
0 0 |
0 0 |
Lightweight |
KO/TKO Knee |
2 |
3:02 |
|
|
|
15 1 |
0 0 |
0 0 |
0 0 |
Light Heavyweight |
KO/TKO Punch |
1 |
0:22 |
|
|
|
3 1 |
1 0 |
1 0 |
1 0 |
Flyweight |
SUB Rear Naked Choke |
1 |
0:49 |
|
|
|
87 46 |
4 0 |
0 0 |
1 0 |
Featherweight |
U-DEC
|
3 |
5:00 |
|
|
|
19 21 |
0 0 |
0 0 |
0 0 |
Lightweight |
KO/TKO Punch |
1 |
3:37 |
|
|
|
40 44 |
0 1 |
0 0 |
0 1 |
Welterweight |
U-DEC
|
3 |
5:00 |
|
|
|
56 12 |
2 1 |
4 0 |
10 0 |
Flyweight |
U-DEC
|
3 |
5:00 |
|
|
|
37 25 |
2 2 |
0 0 |
1 2 |
Welterweight |
S-DEC
|
3 |
5:00 |
|
|
|
98 92 |
0 0 |
0 0 |
0 0 |
Women's Strawweight |
U-DEC
|
3 |
5:00 |