Laws
[Kernel Functionality]

Collaboration diagram for Laws:


Classes
class	abs_law
	Provides methods for the ABS mathematical function. More...
class	and_law
	Provides methods for the AND boolean function. More...
class	arccos_law
	Provides methods for the ARCCOSINE mathematical function. More...
class	arccosh_law
	Provides methods for the ARCCOSH (Hyperbolic Arccosine) mathematical function. More...
class	arccot_law
	Provides methods for the ARCCOTANGENT mathematical function. More...
class	arccoth_law
	Provides methods for the ARCCOTH mathematical function. More...
class	arccsc_law
	Provides methods for the ARCCOSECANT mathematical function. More...
class	arccsch_law
	Provides methods for the ARCCOSECH mathematical function. More...
class	arcsec_law
	Provides methods for the ARCSECANT mathematical function. More...
class	arcsech_law
	Provides methods for the ARCSECH mathematical function. More...
class	arcsin_law
	Provides methods for the ARCSINE mathematical function. More...
class	arcsinh_law
	Provides methods for the ARCSINH (Hyperbolic Arcsine) mathematical function. More...
class	arctan_law
	Provides methods for the ARCTANGENT mathematical function. More...
class	arctanh_law
	Provides methods for the ARCTANH (Hyperbolic Arc Tangent) mathematical function. More...
class	base_curve_law_data
	Abstract base class for accessing a `curve_law_data` with or without the ACIS kernel. More...
class	base_pcurve_law_data
	Abstract base class for accessing a `pcurve_law_data` with or without the ACIS kernel. More...
class	base_pointer_map
	This class tracks reference counting of sub-objects used in making a deep copy. More...
class	base_surface_law_data
	Abstract base class for accessing a `surface_law_data` with or without the ACIS kernel. More...
class	base_transform_law_data
	Abstract base class for accessing `transform_law_data` with or without the ACIS kernel. More...
class	base_wire_law_data
	Abstract base class for accessing a `wire_law_data` with or without the ACIS kernel. More...
class	bend_law
	Creates a law to bend from a position around an axis in a given direction a specified amount. More...
class	binary_law
	Provides methods and data for laws that have two sublaws. More...
class	bs3_surface_law
	The bs3_surface_law's return the SPAposition of the spline approximating surface at the u,v parameters. More...
class	ceil_law
	Provides methods for the CEILING mathematical function. More...
class	composite_law
	Constructs the composition of two functions. More...
class	constant_law
	Creates a law that is constant. More...
class	cos_law
	Provides methods for the COSINE mathematical function. More...
class	cosh_law
	Provides methods for the COSH (Hyperbolic Cosine) mathematical function. More...
class	cot_law
	Provides methods for the COTANGENT mathematical function. More...
class	coth_law
	Provides methods for the COTH (Hyperbolic Cotangent) mathematical function. More...
class	cross_law
	Provides methods for the cross product mathematical function. More...
class	csc_law
	Provides methods for the COSECANT mathematical function. More...
class	csch_law
	Provides methods for the COSECH (Hyperbolic Cosecant) mathematical function. More...
class	curvature_law
	This law returns the curvature of the path sub law It is not defined for x's where the path sub law's derivative is undefined. More...
class	curve_law
	Returns the position on a curve when evaluated. More...
class	curve_law_data
	Serves as a wrapper for an ACIS `curve` object. More...
class	curveclosest_law
	Curve closest point. More...
class	curveperp_law
	Curve point perp. More...
class	dbend_law
	The derivative of the bend law for space warps. More...
class	dcurve_law
	Returns a position or one of the derivatives on a curve. More...
class	derivative_law
	Derivative law. More...
class	division_law
	Provides methods for the division mathematical function. More...
class	domain_law
	Domain law. More...
class	dot_law
	Provides methods for the dot product mathematical function. More...
class	dpcurve_law
	This law is the same as pcurve_law with an extra law_data field that holds how many derivatives to take. More...
class	dwire_law
	This law is the same as wire_law with an extra law_data field that holds how many derivatives to take. More...
class	e_law
	Constant law with e (Eulers Constant). More...
class	equal_law
	Provides methods for the equal boolean function. More...
class	even_law
	Provides methods for the even value than boolean function. More...
class	exp_law
	Provides methods for the EXP mathematical function. More...
class	exponent_law
	Provides methods for the exponent mathematical function. More...
class	false_law
	False law. More...
class	floor_law
	Provides methods for the FLOOR mathematical function. More...
class	frenet_law
	Describes a vector field for a given curve that points in the direction of curvature. More...
class	gaussian_curvature_law
	The gaussian_curvature_law's return the Gaussian curvature at the u,v coordinates of the surface. More...
class	greater_than_law
	Provides methods for the greater than boolean function. More...
class	greater_than_or_equal_law
	Provides methods for the greater or equal than boolean function. More...
class	identity_law
	Provides methods and data that return one term of the input value. More...
class	int_law
	Provides methods for the integer value than boolean function. More...
class	law
	Serves as the base class for all derived law classes. More...
class	LAW
	Stores a law mathematics function as an entity for saving to and restoring from a SAT file. More...
class	law_data
	Serves as a wrapper for ACIS objects, for passing as arguments to laws. More...
class	law_law_data
	Serves as a wrapper for a law object, for passing into unary and multiple law data classes. More...
class	length_law
	curve length More...
class	length_param_law
	curve range More...
class	less_than_law
	Provides methods for the less than boolean function. More...
class	less_than_or_equal_law
	Provides methods for the less or equal than boolean function. More...
class	log_law
	Provides methods for the log mathematical function. More...
class	map_law
	The map_law takes in a sub_law as its first law_data and a path as its second law_data and its maps the SPAinterval [0,1] to the domain of the given path. More...
class	max_curvature_law
	The max_curvature_law's return the greater curvature value at the u,v coordinates of the surface. More...
class	max_law
	Represents the maximum of its component laws. More...
class	mean_curvature_law
	The mean_curvature_law's return the mean curvature at the u,v coordinates of the surface. More...
class	min_law
	Represents the minimum of its component laws. More...
class	min_rotation_law
	The min_rotation_law cashes an array of vectors of size vec_size. More...
class	minus_law
	Provides methods for the minus, or subtraction, mathematical function. More...
class	mod_law
	Provides methods for the mod mathematical function. More...
class	multiple_data_law
	Provides methods and data for laws that have multiple law data members. More...
class	multiple_law
	Provides methods and data for laws that have multiple sublaws. More...
class	natural_log_law
	Provides methods for the NATURAL LOG mathematical function. More...
class	negate_law
	Provides methods for the unary minus, or negation, mathematical function. More...
class	norm_law
	Provides methods for the normalize mathematical function. More...
class	not_equal_law
	Provides methods for the not equal than boolean function. More...
class	not_law
	Provides methods for the not boolean function. More...
class	odd_law
	Provides methods for the odd value boolean function. More...
class	or_law
	Provides methods for the OR boolean function. More...
class	path_law_data
	Serves as a wrapper for either a curve or wire object, for input into a law. More...
class	pcurve_law
	Creates a law to support parameter curve calculations. More...
class	pcurve_law_data
	Serves as a wrapper for ACIS `pcurve` objects, for passing them as arguments to laws. More...
class	permanent_domain_law
	Permanent domain law. More...
class	pi_law
	Constant PI law. More...
class	piecewise_law
	The piecewise_law takes a sequence of sub laws of the form c1 s1 c2 s2 . More...
class	plus_law
	Provides methods for the plus, or addition, mathematical function. More...
class	prime_law
	Provides methods for the prime value than boolean function. More...
class	rand_law
	Provides methods for the RANDOM mathematical function. More...
class	rotate_law
	This law takes in three values and returns three values The first argument to the rotate_law is a law. More...
class	sec_law
	Provides methods for the SECANT mathematical function. More...
class	sech_law
	Provides methods for the SECH mathematical function. More...
class	set_law
	This law returns 1 if the sub law is greater than zero else it returns zero. More...
class	sin_law
	Provides methods for the SINE mathematical function. More...
class	sinh_law
	Provides methods for the SINH (Hyperbolic Sine) mathematical function. More...
class	size_law
	Size law. More...
class	sqrt_law
	Provides methods and data for the square root mathematical function. More...
class	step_law
	The step_law always takes an odd number of sub laws starting at zero the odd numbered (i.e. More...
class	surface_law
	Returns the position on a surface. More...
class	surface_law_data
	Serves as a wrapper for ACIS `surface` objects. More...
class	surfnorm_law
	Composes a law mathematical function that returns the normal to a surface at a given position. More...
class	surfperp_law
	Surface point perp. More...
class	surfvec_law
	Surface vector law. More...
class	tan_law
	Provides methods for the TANGENT mathematical function. More...
class	tanh_law
	Provides methods for the TANH (Hyperbolic Tangent) mathematical function. More...
class	term_law
	Provides methods for the term mathematical function that returns a single dimensional element of a multidimensional function. More...
class	times_law
	Provides methods for the times, or multiplication, mathematical function. More...
class	transform_law
	Applies an ACIS transform to a law that returns a three dimensional position. More...
class	transform_law_data
	Serves as a wrapper for an ACIS `SPAtransf` object. More...
class	true_law
	True law. More...
class	twist_path_law
	The twist_law constructor takes three laws A SPAvector field to twist (i.e the zero twist value or rail_law) A curve_law to twist it around and a twist_law that gives the angle of twist in radians. More...
class	unary_data_law
	Provides methods and data for laws that have one law data member. More...
class	unary_law
	Provides methods and data for laws that have one sublaw. More...
class	unbend_law
	The unbend law for space warps. More...
class	vector_law
	Combines one dimensional laws into a multi-dimensional law. More...
class	wire_law
	Wire_law's return the parametric postion of a wire where the parameterization has been scaled to the length of each of the sub coedges and starts at zero and ends at the length of the wire. More...
class	wire_law_data
	Serves as a wrapper for an ACIS `WIRE` object. More...
Defines
#define	ASSOCIATIVE 1
	Law type.
#define	COMMUTATIVE 1
	Law type.
#define	LAW_TYPE_BOUNDED 13
	Law type.
#define	LAW_TYPE_CONSTANT 3
	Law type.
#define	LAW_TYPE_CONTINUIOUS 12
	Law type.
#define	LAW_TYPE_G_1 11
	Law type.
#define	LAW_TYPE_G_2 10
	Law type.
#define	LAW_TYPE_G_3 9
	Law type.
#define	LAW_TYPE_G_4 8
	Law type.
#define	LAW_TYPE_G_5 7
	Law type.
#define	LAW_TYPE_G_INFINITY 6
	Law type.
#define	LAW_TYPE_INTEGER 2
	Law type.
#define	LAW_TYPE_LINEAR 4
	Law type.
#define	LAW_TYPE_POLYNOMIAL 5
	Law type.
#define	LAW_TYPE_RATIONAL 14
	Law type.
#define	LAW_TYPE_UNKNOWN 0
	Law type.
#define	LAW_TYPE_ZERO 1
	Law type.
#define	NOT_ASSOCIATIVE 0
	Law type.
#define	NOT_COMMUTATIVE 0
	Law type.
#define	PRECEDEDCE_AND 2
	Law precedence level.
#define	PRECEDEDCE_NOT 3
	Law precedence level.
#define	PRECEDEDCE_OR 1
	Law precedence level.
#define	PRECEDENCE_CONSTANT 9
	Law precedence level.
#define	PRECEDENCE_EQUAL 4
	Law precedence level.
#define	PRECEDENCE_FUNCTION 8
	Law precedence level.
#define	PRECEDENCE_PLUS 5
	Law precedence level.
#define	PRECEDENCE_POWER 7
	Law precedence level.
#define	PRECEDENCE_TIMES 6
	Law precedence level.
Functions
outcome	api_hedgehog (law field, law base, double starts, double ends, int dim, int hairs, ENTITY_LIST &return_item, AcisOptions ao=NULL)
	Creates a `DL_item` list of hairs to show a vector field.
outcome	api_integrate_law (law input_law, double start, double end, double &answer, double tolerance=1E-12, int min_level=2, int used_level=NULL)
	Integrates a law over a given domain to a given tolerance.
outcome	api_integrate_law_wrt (law input_law, double start, double end, int wrt, double along, double &answer, double tolerance=1E-12, int min_level=2, int *used_level=NULL)
	Integrates a law over a given domain to a given tolerance, with respect to a given variable.
outcome	api_integrate_law_wrt_and_splits (law input_law, double start, double end, int wrt, double along, double &answer, int number_of_splits=0, double splits=NULL, double tolerance=1E-12, int min_level=2, int used_level=NULL)
	Integrates a law over a given domain to a given tolerance, with respect to a given variable and an array of points used to split the domain.
outcome	api_law_to_entity (law input_law, ENTITY &out_ent, AcisOptions *ao=NULL)
	Converts a law mathematic function into an entity for the purposes of saving to and restoring from a SAT file.
outcome	api_make_cubic (double aval, double bval, double faval, double fbval, double ffaval, double ffbval, law *&answer)
	Creates a cubic law given {a,b,f(a),f(b),f'(a),f'(b)}.
outcome	api_make_linear (double aval, double bval, double faval, double fbval, law *&answer)
	Creates a linear law given {a,b,f(a),f(b)}.
outcome	api_make_polynomial_law (double coeff, int degree, law &answer)
	Creates a polynomial law.
outcome	api_make_quintic (double aval, double bval, double faval, double fbval, double ffaval, double ffbval, double fffaval, double fffbval, law *&answer)
	Creates a quintic law given {a,b,f(a),f(b),f'(a),f'(b) f''(a) f''(b)}.
outcome	api_make_rails (ENTITY path, law &rails, int &number_of_rails, law axis=NULL, FACE faces=NULL, law user_rails=NULL, law twist_law=NULL, AcisOptions ao=NULL, SPAunit_vector const &in_rigid_tangent=(const class SPAunit_vector *) NULL_REF)
	Creates the default rail laws for sweeping along a wire.
outcome	api_ndifferentiate_law (law input_law, double where, int which_dim, double *answer, int type=0, int times=1)
	Numerically differentiates a law at a given point with respect to a given variable a given number of times.
outcome	api_nmax_of_law (law input_law, double start, double end, double answer)
	Gets the maximum value of a given law over the given domain.
outcome	api_nmin_of_law (law input_law, double start, double end, double answer)
	Gets the minimum value of a given law over the given domain.
outcome	api_nroots_of_law (law input_law, double start, double end, int size, double **answer)
	Gets all the roots of the given law over the given domain.
outcome	api_nsolve_laws (law input_law1, law input_law2, double start, double end, int size, double *answer)
	Determines where two given laws are equal within a given domain.
outcome	api_str_to_law (const char str, law answer, law_data data=NULL, int size=0, AcisOptions ao=NULL)
	Creates a law from a string and an optional array of law data.
	base_curve_law_data::base_curve_law_data (double in_start=0, double in_end=0)
	Constructs a `base_curve_law_data`.
	base_pcurve_law_data::base_pcurve_law_data (double in_start=0, double in_end=0)
	Constructs a `base_pcurve_law_data`.
	base_surface_law_data::base_surface_law_data ()
	Constructs a `base_surface_law_data`.
	base_wire_law_data::base_wire_law_data (double in_start=0, double in_end=0)
	Constructs a `base_wire_law_data`.
logical	initialize_law ()
	Initializes the law library.
int	new_law_id ()
	Creates a unique id number for the given law, which is used for type identification.
logical	terminate_law ()
	Terminates the law library.

Define Documentation

#define ASSOCIATIVE 1

Law type.

#define COMMUTATIVE 1

Law type.

#define LAW_TYPE_BOUNDED 13

Law type.

#define LAW_TYPE_CONSTANT 3

Law type.

#define LAW_TYPE_CONTINUIOUS 12

Law type.

#define LAW_TYPE_G_1 11

Law type.

#define LAW_TYPE_G_2 10

Law type.

#define LAW_TYPE_G_3 9

Law type.

#define LAW_TYPE_G_4 8

Law type.

#define LAW_TYPE_G_5 7

Law type.

#define LAW_TYPE_G_INFINITY 6

Law type.

#define LAW_TYPE_INTEGER 2

Law type.

#define LAW_TYPE_LINEAR 4

Law type.

#define LAW_TYPE_POLYNOMIAL 5

Law type.

#define LAW_TYPE_RATIONAL 14

Law type.

#define LAW_TYPE_UNKNOWN 0

Law type.

#define LAW_TYPE_ZERO 1

Law type.

#define NOT_ASSOCIATIVE 0

Law type.

#define NOT_COMMUTATIVE 0

Law type.

#define PRECEDEDCE_AND 2

Law precedence level.

#define PRECEDEDCE_NOT 3

Law precedence level.

#define PRECEDEDCE_OR 1

Law precedence level.

#define PRECEDENCE_CONSTANT 9

Law precedence level.

#define PRECEDENCE_EQUAL 4

Law precedence level.

#define PRECEDENCE_FUNCTION 8

Law precedence level.

#define PRECEDENCE_PLUS 5

Law precedence level.

#define PRECEDENCE_POWER 7

Law precedence level.

#define PRECEDENCE_TIMES 6

Law precedence level.

Function Documentation

outcome api_hedgehog	(	law *	field,
		law *	base,
		double *	starts,
		double *	ends,
		int	dim,
		int *	hairs,
		ENTITY_LIST &	return_item,
		AcisOptions *	ao = `NULL`
	)

Creates a DL_item list of hairs to show a vector field.

Role: Field is a law specifying the vectors to show (the hairs). base is a law specifying where the roots of the hairs lie.
dim specifies whether a one-dimensional, two-dimensional, or three-dimensional array of hairs is produced.
starts and ends are arrays of one, two, or three start points and end points, depending on dim.
hairs is an array containing one, two, or three values, depending on dim, specifying how many hairs are to be created between the start and end points.
return_item contains the list of hairs for display.

Effect: Read-only

Journal: Not Available

Parameters:

	field	vector field.
	base	base of field.
	starts	min value in each dimension.
	ends	max value in each dimension.
	dim	size of starts and ends.
	hairs	number of hairs in each dimension.
	return_item	list of hairs returned.
	ao	acis options.

include <hog_api.hxx>

outcome api_integrate_law	(	law *	input_law,
		double	start,
		double	end,
		double &	answer,
		double	tolerance = `1E-12`,
		int	min_level = `2`,
		int *	used_level = `NULL`
	)

Integrates a law over a given domain to a given tolerance.

Effect: Read-only.

Journal: Not Available

Parameters:

	input_law	the law to be integrated.
	start	start of the domain of integration.
	end	end of the domain of integration.
	answer	result of the integration.
	tolerance	(optional) tolerance for the accuracy of the result.
	min_level	(optional) minimum Romberg Table rows.
	used_level	(optional) number of Romberg rows returned.

include <kernapi.hxx>

outcome api_integrate_law_wrt	(	law *	input_law,
		double	start,
		double	end,
		int	wrt,
		double *	along,
		double &	answer,
		double	tolerance = `1E-12`,
		int	min_level = `2`,
		int *	used_level = `NULL`
	)

Integrates a law over a given domain to a given tolerance, with respect to a given variable.

Effect: Read-only.

Journal: Not Available

Parameters:

	input_law	the law to be integrated.
	start	start of the domain of integration.
	end	end of the domain of integration.
	wrt	variable over which to integrate.
	along	an array (the size of the take dim of the law) that gives the values for all variables other than the integration variable.
	answer	result of the integration.
	tolerance	(optional) tolerance for the accuracy of the result.
	min_level	(optional) minimum Romberg Table rows.
	used_level	(optional) number of Romberg rows returned.

include <kernapi.hxx>

outcome api_integrate_law_wrt_and_splits	(	law *	input_law,
		double	start,
		double	end,
		int	wrt,
		double *	along,
		double &	answer,
		int	number_of_splits = `0`,
		double *	splits = `NULL`,
		double	tolerance = `1E-12`,
		int	min_level = `2`,
		int *	used_level = `NULL`
	)

Integrates a law over a given domain to a given tolerance, with respect to a given variable and an array of points used to split the domain.

Role: During the integration the function will take into account an array of points into which to split the domain. This function should be used if the domain contains known singularities.

Effect: Read-only.

Journal: Not Available

Parameters:

	input_law	the law to be integrated.
	start	start of the domain of integration.
	end	end of the domain of integration.
	wrt	variable over which to integrate.
	along	an array (the size of the take dim of the law) that gives the values for all variables other than the integration variable.
	answer	result of the integration.
	number_of_splits	(optional) number of singularities.
	splits	(optional) number of splits.
	tolerance	(optional) tolerance for the accuracy of the result.
	min_level	(optional) minimum Romberg Table rows.
	used_level	(optional) number of Romberg rows returned.

include <kernapi.hxx>

outcome api_law_to_entity	(	law *	input_law,
		ENTITY *&	out_ent,
		AcisOptions *	ao = `NULL`
	)

Converts a law mathematic function into an entity for the purposes of saving to and restoring from a SAT file.

Role: Law mathematic functions that are used for the analysis of a design are not normally saved to the SAT file. Typically, only laws that are attached to model entities through geometry definitions are saved to the SAT file. In order to make laws more persistent and to share them from session to session, they can be turned into LAW instances, which being derived from ENTITY can be saved and restored.

Effect: Changes model.

Journal: Available

Parameters:

	input_law	the law function to be converted.
	out_ent	the resulted entity into which the law is converted.
	ao	ACIS options.

include <kernapi.hxx>

outcome api_make_cubic	(	double	aval,
		double	bval,
		double	faval,
		double	fbval,
		double	ffaval,
		double	ffbval,
		law *&	answer
	)

Creates a cubic law given {a,b,f(a),f(b),f'(a),f'(b)}.

Role: Produces a cubic polynomial with given boundary conditions for both it and its first derivative. The user supplies the boundary values a and b, the desired output of the law at a and b (e.g., f_a and f_b), and the desired output of the first derivative at a and b (e.g., df_a and df_b). The result is a cubic polynomial meeting these boundary conditions.

 F(a)  = fa.
 F(b)  = fb.
 F'(a) = ffa.
 F'(b) = ffb.

Effect: Changes model

Journal: Not Available

Parameters:

	aval	a value.
	bval	b value.
	faval	f at a.
	fbval	f at b.
	ffaval	deriv of f at a.
	ffbval	deriv of f at b.
	answer	ptr to law.

See also:: api_make_linear, api_make_quintic

include <kernapi.hxx>

outcome api_make_linear	(	double	aval,
		double	bval,
		double	faval,
		double	fbval,
		law *&	answer
	)

Creates a linear law given {a,b,f(a),f(b)}.

Role: Produces a linear polynomial with given boundary conditions for both its output. The user supplies the boundary values a and b and the desired output of the law at a and b (e.g., f_a and f_b). The result is a linear polynomial meeting these boundary conditions.

Effect: Changes model

Journal: Not Available

Parameters:

	aval	a value.
	bval	b value.
	faval	f at a.
	fbval	f at b.
	answer	ptr to law.

See also:: api_make_cubic, api_make_quintic

include <kernapi.hxx>

outcome api_make_polynomial_law	(	double *	coeff,
		int	degree,
		law *&	answer
	)

Creates a polynomial law.

Role: Given an array of coefficients and the maximum degree for the polynomial, this creates a law that represents the associated polynomial.

Effect: Read-only

Journal: Not Available

Parameters:

	coeff	array of coefficients.
	degree	maximum degree of polynomial.
	answer	ptr to law.

include <kernapi.hxx>

outcome api_make_quintic	(	double	aval,
		double	bval,
		double	faval,
		double	fbval,
		double	ffaval,
		double	ffbval,
		double	fffaval,
		double	fffbval,
		law *&	answer
	)

Creates a quintic law given {a,b,f(a),f(b),f'(a),f'(b) f''(a) f''(b)}.

Role: Produces a quintic polynomial with given boundary conditions for it, its first derivative, and its second derivative. The user supplies the boundary values a and b, the desired output of the law at a and b (e.g., f_a and f_b), the desired output of the first derivative at a and b (e.g., df_a and df_b), and the desired output of the second derivative at a and b (e.g., ddf_a and ddf_b). The result is a quintic polynomial meeting these boundary conditions.

 F(a)   = fa.
 F(b)   = fb.
 F'(a)  = ffa.
 F'(b)  = ffb.
 F''(a) = fffa.
 F''(b) = fffb.

Effect: Read-only

Journal: Not Available

Parameters:

	aval	a value.
	bval	b value.
	faval	f at a.
	fbval	f at b.
	ffaval	1st deriv of f at a.
	ffbval	1st deriv of f at b.
	fffaval	2nd deriv of f at a.
	fffbval	2nd deriv of f at b.
	answer	ptr to law.

See also:: api_make_cubic, api_make_linear

include <kernapi.hxx>

outcome api_make_rails	(	ENTITY *	path,
		law **&	rails,
		int &	number_of_rails,
		law **	axis = `NULL`,
		FACE **	faces = `NULL`,
		law **	user_rails = `NULL`,
		law *	twist_law = `NULL`,
		AcisOptions *	ao = `NULL`,
		SPAunit_vector const &	in_rigid_tangent = `(const class SPAunit_vector ) NULL_REF`
	)

Creates the default rail laws for sweeping along a wire.

Role: This produces an array of rail laws that can be used by sweeping in the sweep options. A single rail law is produced if path is a single edge or a wire with a single underlying edge. Otherwise, it creates multiple rail laws, one for each underlying edge in path.

The only required argument is path. If no other arguments are supplied, then default rails are created. The default for the creation of rails is:

If the path is planar, the rail law is the planar normal. A constant vector law is returned.
If the path is a helix, the rail law points towards the axis. The Frenet law is returned.
If all edges in the wire are planar, then an array of rail laws is created, whereby each law in the array corresponds to an edge in the wire. The rail laws correspond to the planar normal of edges.
If faces are provided, then surface normal laws are returned. In this case, the path should be a wire, with edges on the supplied faces.
If the path isn't one of the above cases, the rail uses minimum rotation.

If the input path is composed of multiple pieces, such as a wire with more than one underlying edge, then array arguments must supply the same number of elements as the number of path elements. They may pad their array with NULL arguments.

The axis argument is used for path segments that have an implied center axis. An example of this might be a helix, an expanding helix, or the coil of a telephone handset cable. The axis argument is the derivative of the implied center axis, which tells the implied axis direction. When the axis is supplied, then its cross product with the path is returned. The axis array can be padded with NULL for sections of the path that do not have an implied axis.

The face argument is used when a portion of the path segments borders a non-analytic face. The coedge of the wire provided as path must actually belong to the face entity supplied. The face must be non-analytic. The resulting rail is oriented to the face normal. The face array can be padded with NULL for sections of the path that do not have such a face.

The user_rails argument permits any default rail for a given section of the path to be overridden by the user-supplied law in the array. The user_rails array can be padded with NULL for sections of the path that are to use the default.

The twist argument works on the whole rail array. After the other rail parameters have been input and calculated, the law provided by twist operates on the whole set of rails. This takes in an angle of twist per distance along the path.

Limitations: When faces are supplied, the path must be a wire, with each edge lying in the corresponding face. The edges must not have non-G1 discontinuities in this case.

Effect: Read-only.

Journal: Not Available

Parameters:

	path	a WIRE or EDGE.
	rails	array of rail laws returned.
	number_of_rails	number of rail laws returned.
	axis	optional axis in an array.
	faces	optional faces in an array.
	user_rails	optional user defined rails.
	twist_law	optional twist law.
	ao	ACIS options.

include <kernapi.hxx>

outcome api_ndifferentiate_law	(	law *	input_law,
		double *	where,
		int	which_dim,
		double *	answer,
		int	type = `0`,
		int	times = `1`
	)

Numerically differentiates a law at a given point with respect to a given variable a given number of times.

Role: The derivative may be taken from both sides or just from the left or right.

Effect: Read-only.

Journal: Not Available

Parameters:

	input_law	the law to differentiate.
	where	where to take the derivative.
	which_dim	which variable to take the derivative with respect to.
	answer	the result of the differentiation.
	type	0 = normal, 1 = from the left, 2 = from the right.
	times	how many times to take the derivative.

include <kernapi.hxx>

outcome api_nmax_of_law	(	law *	input_law,
		double	start,
		double	end,
		double *	answer
	)

Gets the maximum value of a given law over the given domain.

Effect: Read-only.

Journal: Not Available

Parameters:

	input_law	law whose maximum is desired.
	start	start of the domain.
	end	end of the domain.
	answer	returns the location of maximum value within the domain.

include <kernapi.hxx>

outcome api_nmin_of_law	(	law *	input_law,
		double	start,
		double	end,
		double *	answer
	)

Gets the minimum value of a given law over the given domain.

Effect: Read-only.

Journal: Not Available

Parameters:

	input_law	law whose minimum is desired.
	start	start of the domain.
	end	end of the domain.
	answer	returns the location of the minimum value within the domain.

include <kernapi.hxx>

outcome api_nroots_of_law	(	law *	input_law,
		double	start,
		double	end,
		int *	size,
		double **	answer
	)

Gets all the roots of the given law over the given domain.

Effect: Read-only.

Journal: Not Available

Parameters:

	input_law	law whose roots are desired.
	start	start of the domain.
	end	end of the domain.
	size	returns the number of roots that were found.
	answer	returns the roots.

include <kernapi.hxx>

outcome api_nsolve_laws	(	law *	input_law1,
		law *	input_law2,
		double	start,
		double	end,
		int *	size,
		double **	answer
	)

Determines where two given laws are equal within a given domain.

Limitations: The number of points at which the two laws are equal must be finite.

Effect: Read-only.

Journal: Not Available

Parameters:

	input_law1	first law.
	input_law2	second law.
	start	start of the domain.
	end	end of the domain.
	size	returns the number of points at which the two laws are equal.
	answer	returns the set of points at which the two laws are equal.

include <kernapi.hxx>

outcome api_str_to_law	(	const char *	str,
		law **	answer,
		law_data **	data = `NULL`,
		int	size = `0`,
		AcisOptions *	ao = `NULL`
	)

Creates a law from a string and an optional array of law data.

Role: This API parses a character string (str), generates the associated law classes, and returns a pointer to the top-level law that was created (answer). Deriving the law class and all associated classes individually is possible. However, it is more likely that api_str_to_law and law string parsing will be employed, because it is easier and more straightforward to implement.

The valid syntax for the character strings (str) in the law mathematical functions are given in the law symbol templates. The law mathematical functions support nesting of law symbols. Once the character string (str) has been created, it is passed to api_str_to_law along with a pointer to an output law (answer), an array of law data (data), and the size of the law data array (size).

The unary_law, binary_law, and multiple_law classes are used if the application is passing only laws into a law class, in which case it becomes a pointer to a law or an array of pointers to laws, respectively. Numbers, positions, parametric positions, vectors, and vector fields, in addition to the law symbols, are passed as input to the api_str_to_law and become laws for these purposes.

On the other hand, the unary_data_law and multiple_data_law classes are used if the application is passing more complicated structures into a law class. These could be curves, wires, surfaces, transforms, or even laws. Instead of having a pointer to a law or an array of pointers to laws, the unary_data_law and multiple_data_law classes have a pointer to a law_data class or an array of pointers to law_data classes, respectively.

Effect: Read-only.

Journal: Not Available

Parameters:

	str	string of the law to be created.
	answer	returns the created law.
	data	array of supporting data used in the law creation.
	size	size of the law data array.
	ao	ACIS options.

include <kernapi.hxx>

base_curve_law_data::base_curve_law_data	(	double	in_start = `0`,
		double	in_end = `0`
	)			`[inline, inherited]`

Constructs a base_curve_law_data.

Parameters:

	in_start	start parameter.
	in_end	end parameter.

base_pcurve_law_data::base_pcurve_law_data	(	double	in_start = `0`,
		double	in_end = `0`
	)			`[inline, inherited]`

Constructs a base_pcurve_law_data.

Parameters:

	in_start	start parameter.
	in_end	end parameter.

base_surface_law_data::base_surface_law_data ( ) [inline, inherited]

Constructs a base_surface_law_data.

base_wire_law_data::base_wire_law_data	(	double	in_start = `0`,
		double	in_end = `0`
	)			`[inline, inherited]`

Constructs a base_wire_law_data.

Parameters:

	in_start	start parameter.
	in_end	end parameter.

logical initialize_law ( )

Initializes the law library.

Effect: System routine

include <main_law.hxx>

int new_law_id ( )

Creates a unique id number for the given law, which is used for type identification.

Role: The id number this function creates is unique for the currently defined laws in the system. It is not persistent and is not saved to SAT. It is used mostly for law type identification. This function is never called directly by an application.It is used internally by the law system. This is called by law member functions. It returns a unique number which is used by the id method of the respective law class.

Effect: System routine

include <law_base.hxx>

logical terminate_law ( )

Terminates the law library.

Effect: System routine

include <main_law.hxx>

Laws [Kernel Functionality]

Classes

Defines

Functions

Define Documentation

Function Documentation

Laws
[Kernel Functionality]