Context Navigation

← Previous Change
Next Change →

fflas_bounds.inl

Timestamp:

04/28/07 20:58:32 (2 years ago)

Author:

pernet

Message:

Introduction of the field Modular<float> and the corresponding specializations using the float BLAS.

Files:

: 1 modified

include/fflas-ffpack/fflas_bounds.inl (modified) (4 diffs)

Legend:

: Unmodified
: Added
: Removed

include/fflas-ffpack/fflas_bounds.inl

r8	r18
22	22	//---------------------------------------------------------------------
23	23	template <class Field>
24		inline size_t DotProdBoundCompute (const Field& F, const size_t w,
25		const typename Field::Element& beta)
26		{
27		typename Field::Element mone;
28		static FFLAS_INT_TYPE p;
29		F.characteristic(p);
30		F.init (mone, -1.0);
31		size_t kmax;
32		if (p == 0)
33		kmax = 2;
34		else
35		if (w > 0) {
36		size_t ex=1;
37		for (size_t i=0; i < w; ++i) ex *= 3;
38		//FFLAS_INT_TYPE c = (p-1)*(ex)/2; //bound for a centered representation
39		long long c = (p-1)*(1+ex)/2;
40		kmax = lround(( double(1ULL << DOUBLE_MANTISSA) /double(cc) + 1)(1 << w));
41		if (kmax == ( 1ULL << w))
42		kmax = 2;
43		}
44		else{
45		long long c = p-1;
46		long long cplt=0;
47		if (!F.isZero (beta))
48		if (F.isOne (beta) \|\| F.areEqual (beta, mone))
49		cplt = c;
50		else cplt = c*c;
51		kmax = lround(( double((1ULL << DOUBLE_MANTISSA) - cplt)) /double(c*c));
52		if (kmax < 2)
53		kmax = 2;
54		}
55		return MIN(kmax,1ULL<<31);
56		}
	24	inline size_t FFLAS::DotProdBoundCompute (const Field& F, const size_t w,
	25	const typename Field::Element& beta){
	26	return callDotProdBoundCompute<typename Field::Element>() (F, w, beta);
	27	}
	28
	29	template<class Element>
	30	class FFLAS::callDotProdBoundCompute {
	31	public:
	32	template <class Field>
	33	size_t operator () (const Field& F, const size_t w,
	34	const typename Field::Element& beta)
	35	{
	36	typename Field::Element mone;
	37	static FFLAS_INT_TYPE p;
	38	F.characteristic(p);
	39	F.init (mone, -1.0);
	40	size_t kmax;
	41	if (p == 0)
	42	kmax = 2;
	43	else
	44	if (w > 0) {
	45	size_t ex=1;
	46	for (size_t i=0; i < w; ++i) ex *= 3;
	47	//FFLAS_INT_TYPE c = (p-1)*(ex)/2; //bound for a centered representation
	48	long long c = (p-1)*(1+ex)/2;
	49	kmax = lround(( double(1ULL << DOUBLE_MANTISSA) /double(cc) + 1)(1 << w));
	50	if (kmax == ( 1ULL << w))
	51	kmax = 2;
	52	}
	53	else{
	54	long long c = p-1;
	55	long long cplt=0;
	56	if (!F.isZero (beta))
	57	if (F.isOne (beta) \|\| F.areEqual (beta, mone))
	58	cplt = c;
	59	else cplt = c*c;
	60	kmax = lround(( double((1ULL << DOUBLE_MANTISSA) - cplt)) /double(c*c));
	61	if (kmax < 2)
	62	kmax = 2;
	63	}
	64	return MIN(kmax,1ULL<<31);
	65	}
	66	};
	67
57	68	template <>
58		inline size_t DotProdBoundCompute (const Modular<double>& F, const size_t w,
59		const double& beta)
60		{
61		double mone;
62		static FFLAS_INT_TYPE p;
63		F.characteristic(p);
64		F.init (mone, -1.0);
65		size_t kmax;
66		if (p == 0)
67		kmax = 2;
68		else
69		if (w > 0) {
70		size_t ex=1;
71		for (size_t i=0; i < w; ++i) ex *= 3;
72		long long c;
	69	class FFLAS::callDotProdBoundCompute<double> {
	70	public:
	71	template <class Field>
	72	size_t operator() (const Field& F, const size_t w,
	73	const double& beta)
	74	{
	75	double mone;
	76	static FFLAS_INT_TYPE p;
	77	F.characteristic(p);
	78	F.init (mone, -1.0);
	79	size_t kmax;
	80	if (p == 0)
	81	kmax = 2;
	82	else
	83	if (w > 0) {
	84	size_t ex=1;
	85	for (size_t i=0; i < w; ++i) ex *= 3;
	86	long long c;
73	87	#ifndef _LINBOX_CONFIG_H
74		if (F.balanced)
75		c = (p-1)*(ex)/2; // balanced representation
76		else
77		#endif
78		c = (p-1)*(1+ex)/2; // positive representation
79		kmax = lround(double(1ULL << DOUBLE_MANTISSA) /(double(cc) + 1)(1ULL << w));
80		if (kmax == ( 1ULL << w))
81		kmax = 2;
82		}
83		else{
84		long long c = p-1;
85		long long cplt=0;
86		if (!F.isZero (beta))
87		if (F.isOne (beta) \|\| F.areEqual (beta, mone))
88		cplt = c;
89		else cplt = c*c;
90		kmax = lround( double((1ULL << DOUBLE_MANTISSA) - cplt) /(double(c*c)));
91		if (kmax < 2)
92		kmax = 2;
93		}
94		return (size_t) MIN(kmax,1ULL<<31);
95		}
	88	if (F.balanced)
	89	c = (p-1)*(ex)/2; // balanced representation
	90	else
	91	#endif
	92	c = (p-1)*(1+ex)/2; // positive representation
	93	kmax = lround(double(1ULL << DOUBLE_MANTISSA) /(double(cc) + 1)(1ULL << w));
	94	if (kmax == ( 1ULL << w))
	95	kmax = 2;
	96	}
	97	else{
	98	long long c = p-1;
	99	long long cplt=0;
	100	if (!F.isZero (beta))
	101	if (F.isOne (beta) \|\| F.areEqual (beta, mone))
	102	cplt = c;
	103	else cplt = c*c;
	104	kmax = lround( double((1ULL << DOUBLE_MANTISSA) - cplt) /(double(c*c)));
	105	if (kmax < 2)
	106	kmax = 2;
	107	}
	108	return (size_t) MIN(kmax,1ULL<<31);
	109	}
	110	};
	111
	112	template <>
	113	class FFLAS::callDotProdBoundCompute<float> {
	114	public:
	115	template <class Field>
	116	size_t operator () (const Field& F, const size_t w,
	117	const float& beta)
	118	{
	119	float mone,one;
	120	static FFLAS_INT_TYPE p;
	121	F.characteristic(p);
	122	F.init (one, 1.0F);
	123	F.neg(mone,one);
	124	size_t kmax;
	125	if (p == 0)
	126	kmax = 2;
	127	else
	128	if (w > 0) {
	129	size_t ex=1;
	130	for (size_t i=0; i < w; ++i) ex *= 3;
	131	long long c;
	132	#ifndef _LINBOX_CONFIG_H
	133	if (F.balanced)
	134	c = (p-1)*(ex)/2; // balanced representation
	135	else
	136	#endif
	137	c = (p-1)*(1+ex)/2; // positive representation
	138	kmax = lround(float(1ULL << FLOAT_MANTISSA) /(float(cc) + 1)(1ULL << w));
	139	if (kmax == ( 1ULL << w))
	140	kmax = 2;
	141	}
	142	else{
	143	long long c = p-1;
	144	long long cplt=0;
	145	if (!F.isZero (beta))
	146	if (F.isOne (beta) \|\| F.areEqual (beta, mone))
	147	cplt = c;
	148	else cplt = c*c;
	149	kmax = lround( float((1ULL << FLOAT_MANTISSA) - cplt) /(float(c*c)));
	150	if (kmax < 2)
	151	kmax = 2;
	152	}
	153	return (size_t) MIN(kmax,1ULL<<31);
	154	}
	155	};
96	156
97	157	template < class Field >
…	…
120	180	// Computes nmax s.t. (p-1)/2*(p^{nmax-1} + (p-2)^{nmax-1}) < 2^53
121	181	//---------------------------------------------------------------------
122		size_t bound_compute(const long long pi) {
	182	size_t bound_compute_double(const long long pi) {
123	183
124	184	long long p=pi,p1=1,p2=1;
…	…
133	193	return nmax;
134	194	}
135		size_t bound_compute_balanced(const long long pi) {
	195	size_t bound_compute_double_balanced(const long long pi) {
136	196
137	197	long long p=(pi+1)/2,p1=1;
…	…
144	204	return nmax;
145	205	}
146
147		template<class Field>
148		size_t FFLAS::TRSMBound (const Field& F) {
149		FFLAS_INT_TYPE pi;
150		F.characteristic(pi);
151		static long unsigned int p=pi;
152		static size_t nmax=bound_compute(p);
153		if (p == pi)
154		return nmax;
155		else
156		return nmax=bound_compute(p=pi);
157		}
	206	size_t bound_compute_float(const long long pi) {
	207
	208	long long p=pi,p1=1,p2=1;
	209	size_t nmax=1;
	210	double max = ( ( 1ULL<<(FLOAT_MANTISSA+1) )/(p-1));
	211	while ( (p1 + p2) < max ){
	212	p1*=p;
	213	p2*=p-2;
	214	nmax++;
	215	}
	216	nmax--;
	217	return nmax;
	218	}
	219	size_t bound_compute_float_balanced(const long long pi) {
	220
	221	long long p=(pi+1)/2,p1=1;
	222	size_t nmax=0;
	223	double max = ( ( 1ULL<<(FLOAT_MANTISSA))/(p-1));
	224	while ( (p1) < max ){
	225	p1*=p;
	226	nmax++;
	227	}
	228	return nmax;
	229	}
	230
	231	template <class Field>
	232	inline size_t
	233	FFLAS::TRSMBound (const Field& F) {
	234	return callTRSMBound<typename Field::Element> () (F);
	235	}
	236
	237	template<class Element>
	238	class FFLAS::callTRSMBound {
	239	public:
	240	template <class Field>
	241	size_t operator () (const Field& F) {
	242	FFLAS_INT_TYPE pi;
	243	F.characteristic(pi);
	244	static long unsigned int p=pi;
	245	static size_t nmax=bound_compute_double(p);
	246	if (p == pi)
	247	return nmax;
	248	else
	249	return nmax=bound_compute_double(p=pi);
	250	}
	251	};
158	252
159	253	template<>
160		size_t FFLAS::TRSMBound (const Modular<double>& F) {
161		FFLAS_INT_TYPE pi;
162		F.characteristic(pi);
163		static FFLAS_INT_TYPE p=pi;
164		#ifdef _LINBOX_CONFIG_H
165		static size_t nmax = bound_compute(pi);
166		#else
167		static size_t nmax = (F.balanced) ? bound_compute_balanced(pi) : bound_compute(pi);
	254	class FFLAS::callTRSMBound<double> {
	255	public:
	256	template <class Field>
	257	size_t operator () (const Field& F) {
	258	FFLAS_INT_TYPE pi;
	259	F.characteristic(pi);
	260	static FFLAS_INT_TYPE p=pi;
	261	#ifdef _LINBOX_CONFIG_H
	262	static size_t nmax = bound_compute_double(pi);
	263	#else
	264	static size_t nmax = (F.balanced) ? bound_compute_double_balanced(pi) : bound_compute_double(pi);
168	265	#endif
169		if (p == pi)
170		return nmax;
171		else
172		#ifdef _LINBOX_CONFIG_H
173		return nmax= bound_compute (p=pi); //(F.balanced) ? bound_compute_balanced(p=pi) : bound_compute(p=pi);
174		#else
175		return (F.balanced) ? bound_compute_balanced(p=pi) : bound_compute(p=pi);
176		#endif
177		}
178
	266	if (p == pi)
	267	return nmax;
	268	else
	269	#ifdef _LINBOX_CONFIG_H
	270	return nmax= bound_compute (p=pi); //(F.balanced) ? bound_compute_balanced(p=pi) : bound_compute(p=pi);
	271	#else
	272	return (F.balanced) ? bound_compute_double_balanced(p=pi) : bound_compute_double(p=pi);
	273	#endif
	274	}
	275	};
	276
	277	template<>
	278	class FFLAS::callTRSMBound<float> {
	279	public:
	280	template <class Field>
	281	size_t operator () (const Field& F) {
	282	FFLAS_INT_TYPE pi;
	283	F.characteristic(pi);
	284	static FFLAS_INT_TYPE p=pi;
	285	#ifdef _LINBOX_CONFIG_H
	286	static size_t nmax = bound_compute_float(pi);
	287	#else
	288	static size_t nmax = (F.balanced) ? bound_compute_float_balanced(pi) : bound_compute_float(pi);
	289	#endif
	290	if (p == pi)
	291	return nmax;
	292	else
	293	#ifdef _LINBOX_CONFIG_H
	294	return nmax= bound_compute (p=pi); //(F.balanced) ? bound_compute_balanced(p=pi) : bound_compute(p=pi);
	295	#else
	296	return (F.balanced) ? bound_compute_float_balanced(p=pi) : bound_compute_float(p=pi);
	297	#endif
	298	}
	299	};
	300

Context Navigation

Changeset 18 for include/fflas-ffpack/fflas_bounds.inl

Legend:

include/fflas-ffpack/fflas_bounds.inl

Download in other formats: