triangle_nco_rule.h File Reference

Go to the source code of this file.

Functions
int	i4_max (int i1, int i2)
int	i4_min (int i1, int i2)
int	i4_modp (int i, int j)
int	i4_wrap (int ival, int ilo, int ihi)
double	r8_huge ()
int	r8_nint (double x)
void	reference_to_physical_t3 (double t[], int n, double ref[], double phy[])
void	timestamp ()
double	triangle_area (double t[2 *3])
int	triangle_nco_degree (int rule)
int	triangle_nco_order_num (int rule)
void	triangle_nco_rule (int rule, int order_num, double xy[], double w[])
int	triangle_nco_rule_num ()
int *	triangle_nco_suborder (int rule, int suborder_num)
int	triangle_nco_suborder_num (int rule)
void	triangle_nco_subrule (int rule, int suborder_num, double suborder_xyz[], double suborder_w[])
void	triangle_nco_subrule_01 (int suborder_num, int suborder_xyz_n[], int *suborder_xyz_d, int suborder_w_n[], int *suborder_w_d)
void	triangle_nco_subrule_02 (int suborder_num, int suborder_xyz_n[], int *suborder_xyz_d, int suborder_w_n[], int *suborder_w_d)
void	triangle_nco_subrule_03 (int suborder_num, int suborder_xyz_n[], int *suborder_xyz_d, int suborder_w_n[], int *suborder_w_d)
void	triangle_nco_subrule_04 (int suborder_num, int suborder_xyz_n[], int *suborder_xyz_d, int suborder_w_n[], int *suborder_w_d)
void	triangle_nco_subrule_05 (int suborder_num, int suborder_xyz_n[], int *suborder_xyz_d, int suborder_w_n[], int *suborder_w_d)
void	triangle_nco_subrule_06 (int suborder_num, int suborder_xyz_n[], int *suborder_xyz_d, int suborder_w_n[], int *suborder_w_d)
void	triangle_nco_subrule_07 (int suborder_num, int suborder_xyz_n[], int *suborder_xyz_d, int suborder_w_n[], int *suborder_w_d)
void	triangle_nco_subrule_08 (int suborder_num, int suborder_xyz_n[], int *suborder_xyz_d, int suborder_w_n[], int *suborder_w_d)
void	triangle_nco_subrule_09 (int suborder_num, int suborder_xyz_n[], int *suborder_xyz_d, int suborder_w_n[], int *suborder_w_d)

Function Documentation

i4_max()

int i4_max	(	int	i1,
		int	i2
	)

Definition at line 459 of file gm_rule.c.

{
  int value;
 
  if ( i2 < i1 )
  {
    value = i1;
  }
  else
  {
    value = i2;
  }
  return value;
}

i4_min()

int i4_min	(	int	i1,
		int	i2
	)

Definition at line 500 of file gm_rule.c.

{
  int value;
 
  if ( i1 < i2 )
  {
    value = i1;
  }
  else
  {
    value = i2;
  }
  return value;
}

i4_modp()

int i4_modp	(	int	i,
		int	j
	)

Definition at line 89 of file triangle_ncc_rule.c.

{
  int value;
 
  if ( j == 0 )
  {
    fprintf ( stderr, "\n" );
    fprintf ( stderr, "I4_MODP - Fatal error!\n" );
    fprintf ( stderr, "  I4_MODP ( I, J ) called with J = %d\n", j );
    exit ( 1 );
  }
 
  value = i % j;
 
  if ( value < 0 )
  {
    value = value + abs ( j );
  }
 
  return value;
}

i4_wrap()

int i4_wrap	(	int	ival,
		int	ilo,
		int	ihi
	)

Definition at line 166 of file triangle_ncc_rule.c.

{
  int jhi;
  int jlo;
  int value;
  int wide;
 
  if ( ilo < ihi )
  {
   jlo = ilo;
   jhi = ihi;
  }
  else
  {
    jlo = ihi;
    jhi = ilo;
  }
 
  wide = jhi + 1 - jlo;
 
  if ( wide == 1 )
  {
    value = jlo;
  }
  else
  {
    value = jlo + i4_modp ( ival - jlo, wide );
  }
 
  return value;
}

r8_huge()

double r8_huge

(

)

Definition at line 250 of file triangle_ncc_rule.c.

{
  double value;
 
  value = 1.0E+30;
 
  return value;
}

r8_nint()

int r8_nint

(

double

x

)

Definition at line 290 of file triangle_ncc_rule.c.

{
  int s;
  int value;
 
  if ( x < 0.0 )
  {
    s = - 1;
  }
  else
  {
    s = + 1;
  }
  value = s * ( int ) ( fabs ( x ) + 0.5 );
 
  return value;
}

reference_to_physical_t3()

void reference_to_physical_t3	(	double	t[],
		int	n,
		double	ref[],
		double	phy[]
	)

Definition at line 347 of file triangle_ncc_rule.c.

{
  int i;
  int j;
 
  for ( i = 0; i < 2; i++ )
  {
    for ( j = 0; j < n; j++ )
    {
      phy[i+j*2] = t[i+0*2] * ( 1.0 - ref[0+j*2] - ref[1+j*2] )
                 + t[i+1*2] *       + ref[0+j*2]
                 + t[i+2*2] *                    + ref[1+j*2];
    }
  }
 
  return;
}

timestamp()

void timestamp

(

)

Definition at line 1268 of file gm_rule.c.

{
# define TIME_SIZE 40
 
  static char time_buffer[TIME_SIZE];
  const struct tm *tm;
  size_t len;
  time_t now;
 
  (void)(len);
 
  now = time ( NULL );
  tm = localtime ( &now );
 
  len = strftime ( time_buffer, TIME_SIZE, "%d %B %Y %I:%M:%S %p", tm );
 
  fprintf ( stdout, "%s\n", time_buffer );
 
  return;
# undef TIME_SIZE
}

triangle_area()

double triangle_area

(

double

t[2 *3]

)

Definition at line 472 of file triangle_ncc_rule.c.

{
  double area;
 
  area = 0.5 * (
    t[0+0*2] * ( t[1+1*2] - t[1+2*2] ) +
    t[0+1*2] * ( t[1+2*2] - t[1+0*2] ) +
    t[0+2*2] * ( t[1+0*2] - t[1+1*2] ) );
 
  return area;
}

triangle_nco_degree()

int triangle_nco_degree

(

int

rule

)

Definition at line 522 of file triangle_nco_rule.c.

{
  int degree;
 
  if ( 1 <= rule && rule <= 9 )
  {
    degree = rule - 1;
  }
  else
  {
    degree = -1;
    fprintf ( stderr, "\n" );
    fprintf ( stderr, "TRIANGLE_NCO_DEGREE - Fatal error!\n" );
    fprintf ( stderr, "  Illegal RULE = %d\n", rule );
    exit ( 1 );
  }
 
  return degree;
}

triangle_nco_order_num()

int triangle_nco_order_num

(

int

rule

)

Definition at line 576 of file triangle_nco_rule.c.

{
  int order;
  int order_num;
  int *suborder;
  int suborder_num;
 
  suborder_num = triangle_nco_suborder_num ( rule );
 
  suborder = triangle_nco_suborder ( rule, suborder_num );
 
  order_num = 0;
  for ( order = 0; order < suborder_num; order++ )
  {
    order_num = order_num + suborder[order];
  }
 
  free ( suborder );
 
  return order_num;
}

triangle_nco_rule()

void triangle_nco_rule	(	int	rule,
		int	order_num,
		double	xy[],
		double	w[]
	)

Definition at line 632 of file triangle_nco_rule.c.

{
  int k;
  int o;
  int s;
  int *suborder;
  int suborder_num;
  double *suborder_w;
  double *suborder_xyz;
/*
  Get the suborder information.
*/
  suborder_num = triangle_nco_suborder_num ( rule );
 
  suborder_xyz = ( double * ) malloc ( 3 * suborder_num * sizeof ( double ) );
  suborder_w = ( double * ) malloc ( suborder_num * sizeof ( double ) );
 
  suborder = triangle_nco_suborder ( rule, suborder_num );
 
  triangle_nco_subrule ( rule, suborder_num, suborder_xyz, suborder_w );
/*
  Expand the suborder information to a full order rule.
*/
  o = 0;
 
  for ( s = 0; s < suborder_num; s++ )
  {
    if ( suborder[s] == 1 )
    {
      xy[0+o*2] = suborder_xyz[0+s*3];
      xy[1+o*2] = suborder_xyz[1+s*3];
      w[o] = suborder_w[s];
      o = o + 1;
    }
    else if ( suborder[s] == 3 )
    {
      for ( k = 0; k < 3; k++ )
      {
        xy[0+o*2] = suborder_xyz [ i4_wrap(k,  0,2) + s*3 ];
        xy[1+o*2] = suborder_xyz [ i4_wrap(k+1,0,2) + s*3 ];
        w[o] = suborder_w[s];
        o = o + 1;
      }
    }
    else if ( suborder[s] == 6 )
    {
      for ( k = 0; k < 3; k++ )
      {
        xy[0+o*2] = suborder_xyz [ i4_wrap(k,  0,2) + s*3 ];
        xy[1+o*2] = suborder_xyz [ i4_wrap(k+1,0,2) + s*3 ];
        w[o] = suborder_w[s];
        o = o + 1;
      }
 
      for ( k = 0; k < 3; k++ )
      {
        xy[0+o*2] = suborder_xyz [ i4_wrap(k+1,0,2) + s*3 ];
        xy[1+o*2] = suborder_xyz [ i4_wrap(k,  0,2) + s*3 ];
        w[o] = suborder_w[s];
        o = o + 1;
      }
    }
    else
    {
      fprintf ( stderr, "\n" );
      fprintf ( stderr, "TRIANGLE_NCO_RULE - Fatal error!\n" );
      fprintf ( stderr, "  Illegal SUBORDER(%d) = %d\n", s, suborder[s] );
      exit ( 1 );
    }
  }
 
  free ( suborder );
  free ( suborder_xyz );
  free ( suborder_w );
 
  return;
}

triangle_nco_rule_num()

int triangle_nco_rule_num

(

)

Definition at line 747 of file triangle_nco_rule.c.

{
  int rule_num;
 
  rule_num = 9;
 
  return rule_num;
}

triangle_nco_suborder()

int * triangle_nco_suborder	(	int	rule,
		int	suborder_num
	)

Definition at line 787 of file triangle_nco_rule.c.

{
  int *suborder;
 
  suborder = ( int * ) malloc ( suborder_num * sizeof ( int ) );
 
  if ( rule == 1 )
  {
    suborder[0] = 1;
  }
  else if ( rule == 2 )
  {
    suborder[0] = 3;
  }
  else if ( rule == 3 )
  {
    suborder[0] = 3;
    suborder[1] = 3;
  }
  else if ( rule == 4 )
  {
    suborder[0] = 3;
    suborder[1] = 6;
    suborder[2] = 1;
  }
  else if ( rule == 5 )
  {
    suborder[0] = 3;
    suborder[1] = 6;
    suborder[2] = 3;
    suborder[3] = 3;
  }
  else if ( rule == 6 )
  {
    suborder[0] = 3;
    suborder[1] = 6;
    suborder[2] = 6;
    suborder[3] = 3;
    suborder[4] = 3;
  }
  else if ( rule == 7 )
  {
    suborder[0] = 3;
    suborder[1] = 6;
    suborder[2] = 6;
    suborder[3] = 3;
    suborder[4] = 3;
    suborder[5] = 6;
    suborder[6] = 1;
  }
  else if ( rule == 8 )
  {
    suborder[0] = 3;
    suborder[1] = 6;
    suborder[2] = 6;
    suborder[3] = 3;
    suborder[4] = 6;
    suborder[5] = 6;
    suborder[6] = 3;
    suborder[7] = 3;
  }
  else if ( rule == 9 )
  {
    suborder[0] = 3;
    suborder[1] = 6;
    suborder[2] = 6;
    suborder[3] = 3;
    suborder[4] = 6;
    suborder[5] = 6;
    suborder[6] = 3;
    suborder[7] = 6;
    suborder[8] = 3;
    suborder[9] = 3;
  }
  else
  {
    fprintf ( stderr, "\n" );
    fprintf ( stderr, "TRIANGLE_NCO_SUBORDER - Fatal error!\n" );
    fprintf ( stderr, "  Illegal RULE = %d\n", rule );
    exit ( 1 );
  }
 
  return suborder;
}

triangle_nco_suborder_num()

int triangle_nco_suborder_num

(

int

rule

)

Definition at line 908 of file triangle_nco_rule.c.

{
  int suborder_num;
 
  if ( rule == 1 )
  {
    suborder_num = 1;
  }
  else if ( rule == 2 )
  {
    suborder_num = 1;
  }
  else if ( rule == 3 )
  {
    suborder_num = 2;
  }
  else if ( rule == 4 )
  {
    suborder_num = 3;
  }
  else if ( rule == 5 )
  {
    suborder_num = 4;
  }
  else if ( rule == 6 )
  {
    suborder_num = 5;
  }
  else if ( rule == 7 )
  {
    suborder_num = 7;
  }
  else if ( rule == 8 )
  {
    suborder_num = 8;
  }
  else if ( rule == 9 )
  {
    suborder_num = 10;
  }
  else
  {
    suborder_num = -1;
    fprintf ( stderr, "\n" );
    fprintf ( stderr, "TRIANGLE_NCO_SUBORDER_NUM - Fatal error!\n" );
    fprintf ( stderr,"  Illegal RULE = %d\n", rule );
    exit ( 1 );
  }
 
  return suborder_num;
}

triangle_nco_subrule()

void triangle_nco_subrule	(	int	rule,
		int	suborder_num,
		double	suborder_xyz[],
		double	suborder_w[]
	)

Definition at line 994 of file triangle_nco_rule.c.

{
  int i;
  int s;
  int suborder_w_d;
  int *suborder_w_n;
  int suborder_xyz_d;
  int *suborder_xyz_n;
 
  suborder_xyz_n = ( int * ) malloc ( 3 * suborder_num * sizeof ( int ) );
  suborder_w_n = ( int * ) malloc ( suborder_num * sizeof ( int ) );
 
  if ( rule == 1 )
  {
    triangle_nco_subrule_01 ( suborder_num, suborder_xyz_n, &suborder_xyz_d,
    suborder_w_n, &suborder_w_d );
  }
  else if ( rule == 2 )
  {
    triangle_nco_subrule_02 ( suborder_num, suborder_xyz_n, &suborder_xyz_d,
    suborder_w_n, &suborder_w_d );
  }
  else if ( rule == 3 )
  {
    triangle_nco_subrule_03 ( suborder_num, suborder_xyz_n, &suborder_xyz_d,
    suborder_w_n, &suborder_w_d );
  }
  else if ( rule == 4 )
  {
    triangle_nco_subrule_04 ( suborder_num, suborder_xyz_n, &suborder_xyz_d,
    suborder_w_n, &suborder_w_d );
  }
  else if ( rule == 5 )
  {
    triangle_nco_subrule_05 ( suborder_num, suborder_xyz_n, &suborder_xyz_d,
    suborder_w_n, &suborder_w_d );
  }
  else if ( rule == 6 )
  {
    triangle_nco_subrule_06 ( suborder_num, suborder_xyz_n, &suborder_xyz_d,
    suborder_w_n, &suborder_w_d );
  }
  else if ( rule == 7 )
  {
    triangle_nco_subrule_07 ( suborder_num, suborder_xyz_n, &suborder_xyz_d,
    suborder_w_n, &suborder_w_d );
  }
  else if ( rule == 8 )
  {
    triangle_nco_subrule_08 ( suborder_num, suborder_xyz_n, &suborder_xyz_d,
    suborder_w_n, &suborder_w_d );
  }
  else if ( rule == 9 )
  {
    triangle_nco_subrule_09 ( suborder_num, suborder_xyz_n, &suborder_xyz_d,
    suborder_w_n, &suborder_w_d );
  }
  else
  {
    fprintf ( stderr, "\n" );
    fprintf ( stderr, "TRIANGLE_NCO_SUBRULE - Fatal error!\n" );
    fprintf ( stderr, "  Illegal RULE = %d\n", rule );
    exit ( 1 );
  }
 
  for ( s = 0; s < suborder_num; s++ )
  {
    for ( i = 0; i < 3; i++ )
    {
      suborder_xyz[i+s*3] =
          ( double ) ( 1 + suborder_xyz_n[i+s*3] )
        / ( double ) ( 3 + suborder_xyz_d );
    }
  }
  for ( s = 0; s < suborder_num; s++ )
  {
    suborder_w[s] = ( double ) suborder_w_n[s] / ( double ) suborder_w_d;
  }
 
  free ( suborder_w_n );
  free ( suborder_xyz_n );
 
  return;
}

triangle_nco_subrule_01()

void triangle_nco_subrule_01	(	int	suborder_num,
		int	suborder_xyz_n[],
		int *	suborder_xyz_d,
		int	suborder_w_n[],
		int *	suborder_w_d
	)

Definition at line 1118 of file triangle_nco_rule.c.

{
  int i;
  int s;
  int suborder_xyz_n_01[3*1] = {
      0, 0, 0
  };
  int suborder_xyz_d_01 = 0;
  int suborder_w_n_01[1] = { 1 };
  int suborder_w_d_01 = 1;
 
  for ( s = 0; s < suborder_num; s++ )
  {
    for ( i = 0; i < 3; i++ )
    {
      suborder_xyz_n[i+s*3] = suborder_xyz_n_01[i+s*3];
    }
  }
  *suborder_xyz_d = suborder_xyz_d_01;
 
  for ( s = 0; s < suborder_num; s++ )
  {
    suborder_w_n[s] = suborder_w_n_01[s];
  }
  *suborder_w_d = suborder_w_d_01;
 
  return;
}

triangle_nco_subrule_02()

void triangle_nco_subrule_02	(	int	suborder_num,
		int	suborder_xyz_n[],
		int *	suborder_xyz_d,
		int	suborder_w_n[],
		int *	suborder_w_d
	)

Definition at line 1191 of file triangle_nco_rule.c.

{
  int i;
  int s;
  int suborder_xyz_n_02[3*1] = {
      1, 0, 0
  };
  int suborder_xyz_d_02 = 1;
  int suborder_w_n_02[1] = { 1 };
  int suborder_w_d_02 = 3;
 
  for ( s = 0; s < suborder_num; s++ )
  {
    for ( i = 0; i < 3; i++ )
    {
      suborder_xyz_n[i+s*3] = suborder_xyz_n_02[i+s*3];
    }
  }
  *suborder_xyz_d = suborder_xyz_d_02;
 
  for ( s = 0; s < suborder_num; s++ )
  {
    suborder_w_n[s] = suborder_w_n_02[s];
  }
  *suborder_w_d = suborder_w_d_02;
 
  return;
}

triangle_nco_subrule_03()

void triangle_nco_subrule_03	(	int	suborder_num,
		int	suborder_xyz_n[],
		int *	suborder_xyz_d,
		int	suborder_w_n[],
		int *	suborder_w_d
	)

Definition at line 1264 of file triangle_nco_rule.c.

{
  int i;
  int s;
  int suborder_xyz_n_03[3*2] = {
      2, 0, 0,
      1, 1, 0
  };
  int suborder_xyz_d_03 = 2;
  int suborder_w_n_03[2] = { 7, -3 };
  int suborder_w_d_03 = 12;
 
  for ( s = 0; s < suborder_num; s++ )
  {
    for ( i = 0; i < 3; i++ )
    {
      suborder_xyz_n[i+s*3] = suborder_xyz_n_03[i+s*3];
    }
  }
  *suborder_xyz_d = suborder_xyz_d_03;
 
  for ( s = 0; s < suborder_num; s++ )
  {
    suborder_w_n[s] = suborder_w_n_03[s];
  }
  *suborder_w_d = suborder_w_d_03;
 
  return;
}

triangle_nco_subrule_04()

void triangle_nco_subrule_04	(	int	suborder_num,
		int	suborder_xyz_n[],
		int *	suborder_xyz_d,
		int	suborder_w_n[],
		int *	suborder_w_d
	)

Definition at line 1338 of file triangle_nco_rule.c.

{
  int i;
  int s;
  int suborder_xyz_n_04[3*3] = {
      3, 0, 0,
      2, 1, 0,
      1, 1, 1
  };
  int suborder_xyz_d_04 = 3;
  int suborder_w_n_04[3] = { 8, 3, -12 };
  int suborder_w_d_04 = 30;
 
  for ( s = 0; s < suborder_num; s++ )
  {
    for ( i = 0; i < 3; i++ )
    {
      suborder_xyz_n[i+s*3] = suborder_xyz_n_04[i+s*3];
    }
  }
  *suborder_xyz_d = suborder_xyz_d_04;
 
  for ( s = 0; s < suborder_num; s++ )
  {
    suborder_w_n[s] = suborder_w_n_04[s];
  }
  *suborder_w_d = suborder_w_d_04;
 
  return;
}

triangle_nco_subrule_05()

void triangle_nco_subrule_05	(	int	suborder_num,
		int	suborder_xyz_n[],
		int *	suborder_xyz_d,
		int	suborder_w_n[],
		int *	suborder_w_d
	)

Definition at line 1413 of file triangle_nco_rule.c.

{
  int i;
  int s;
  int suborder_xyz_n_05[3*4] = {
      4, 0, 0,
      3, 1, 0,
      2, 2, 0,
      2, 1, 1
  };
  int suborder_xyz_d_05 = 4;
  int suborder_w_n_05[4] = { 307, -316, 629, -64 };
  int suborder_w_d_05 = 720;
 
  for ( s = 0; s < suborder_num; s++ )
  {
    for ( i = 0; i < 3; i++ )
    {
      suborder_xyz_n[i+s*3] = suborder_xyz_n_05[i+s*3];
    }
  }
  *suborder_xyz_d = suborder_xyz_d_05;
 
  for ( s = 0; s < suborder_num; s++ )
  {
    suborder_w_n[s] = suborder_w_n_05[s];
  }
  *suborder_w_d = suborder_w_d_05;
 
  return;
}

triangle_nco_subrule_06()

void triangle_nco_subrule_06	(	int	suborder_num,
		int	suborder_xyz_n[],
		int *	suborder_xyz_d,
		int	suborder_w_n[],
		int *	suborder_w_d
	)

Definition at line 1489 of file triangle_nco_rule.c.

{
  int i;
  int s;
  int suborder_xyz_n_06[3*5] = {
      5, 0, 0,
      4, 1, 0,
      3, 2, 0,
      3, 1, 1,
      2, 2, 1
  };
  int suborder_xyz_d_06 = 5;
  int suborder_w_n_06[5] = { 71, -13, 57, -167, 113 };
  int suborder_w_d_06 = 315;
 
  for ( s = 0; s < suborder_num; s++ )
  {
    for ( i = 0; i < 3; i++ )
    {
      suborder_xyz_n[i+s*3] = suborder_xyz_n_06[i+s*3];
    }
  }
  *suborder_xyz_d = suborder_xyz_d_06;
 
  for ( s = 0; s < suborder_num; s++ )
  {
    suborder_w_n[s] = suborder_w_n_06[s];
  }
  *suborder_w_d = suborder_w_d_06;
 
  return;
}

triangle_nco_subrule_07()

void triangle_nco_subrule_07	(	int	suborder_num,
		int	suborder_xyz_n[],
		int *	suborder_xyz_d,
		int	suborder_w_n[],
		int *	suborder_w_d
	)

Definition at line 1566 of file triangle_nco_rule.c.

{
  int i;
  int s;
  int suborder_xyz_n_07[3*7] = {
      6, 0, 0,
      5, 1, 0,
      4, 2, 0,
      4, 1, 1,
      3, 3, 0,
      3, 2, 1,
      2, 2, 2
  };
  int suborder_xyz_d_07 = 6;
  int suborder_w_n_07[7] = { 767, -1257, 2901, 387, -3035, -915, 3509 };
  int suborder_w_d_07 = 2240;
 
  for ( s = 0; s < suborder_num; s++ )
  {
    for ( i = 0; i < 3; i++ )
    {
      suborder_xyz_n[i+s*3] = suborder_xyz_n_07[i+s*3];
    }
  }
  *suborder_xyz_d = suborder_xyz_d_07;
 
  for ( s = 0; s < suborder_num; s++ )
  {
    suborder_w_n[s] = suborder_w_n_07[s];
  }
  *suborder_w_d = suborder_w_d_07;
 
  return;
}

triangle_nco_subrule_08()

void triangle_nco_subrule_08	(	int	suborder_num,
		int	suborder_xyz_n[],
		int *	suborder_xyz_d,
		int	suborder_w_n[],
		int *	suborder_w_d
	)

Definition at line 1645 of file triangle_nco_rule.c.

{
  int i;
  int s;
  int suborder_xyz_n_08[3*8] = {
      7, 0, 0,
      6, 1, 0,
      5, 2, 0,
      5, 1, 1,
      4, 3, 0,
      4, 2, 1,
      3, 3, 1,
      3, 2, 2
  };
  int suborder_xyz_d_08 = 7;
  int suborder_w_n_08[8] = { 898, -662, 1573, -2522, -191, 2989, -5726, 1444 };
  int suborder_w_d_08 = 4536;
 
  for ( s = 0; s < suborder_num; s++ )
  {
    for ( i = 0; i < 3; i++ )
    {
      suborder_xyz_n[i+s*3] = suborder_xyz_n_08[i+s*3];
    }
  }
  *suborder_xyz_d = suborder_xyz_d_08;
 
  for ( s = 0; s < suborder_num; s++ )
  {
    suborder_w_n[s] = suborder_w_n_08[s];
  }
  *suborder_w_d = suborder_w_d_08;
 
  return;
}

triangle_nco_subrule_09()

void triangle_nco_subrule_09	(	int	suborder_num,
		int	suborder_xyz_n[],
		int *	suborder_xyz_d,
		int	suborder_w_n[],
		int *	suborder_w_d
	)

Definition at line 1725 of file triangle_nco_rule.c.

{
  int i;
  int s;
  int suborder_xyz_n_09[3*10] = {
      8, 0, 0,
      7, 1, 0,
      6, 2, 0,
      6, 1, 1,
      5, 3, 0,
      5, 2, 1,
      4, 4, 0,
      4, 3, 1,
      4, 2, 2,
      3, 3, 2
  };
  int suborder_xyz_d_09 = 8;
  int suborder_w_n_09[10] = {
    1051445, -2366706, 6493915, 1818134, -9986439,-3757007, 12368047,
    478257, 10685542, -6437608 };
  int suborder_w_d_09 = 3628800;
 
  for ( s = 0; s < suborder_num; s++ )
  {
    for ( i = 0; i < 3; i++ )
    {
      suborder_xyz_n[i+s*3] = suborder_xyz_n_09[i+s*3];
    }
  }
  *suborder_xyz_d = suborder_xyz_d_09;
 
  for ( s = 0; s < suborder_num; s++ )
  {
    suborder_w_n[s] = suborder_w_n_09[s];
  }
  *suborder_w_d = suborder_w_d_09;
 
  return;
}