Attachment #230393 for bug #318045




++ libs/libFreeMat/Array.cpp


void Array::set(const QString& field, ArrayVector& data) {
  if (isEmpty() && m_type.Class != Struct)
    *this = Array(Struct);
  if (m_type.Class != Struct) throw Exception("Unsupported type for A.field=B");
  StructArray &rp(structPtr());
  if (isEmpty()) 
++ libs/libFreeMat/Math.cpp


Array Not(const Array& A) {
  if (A.isScalar())
    return Array(!A.toClass(Bool).constRealScalar<bool>());
  const Array &Abool(A.toClass(Bool));
  return Array(Apply(Abool.constReal<bool>(),notfunc));
}

Array Plus(const Array& A) {
++ libs/libFreeMat/Operators.hpp

  if (!Bcast.isScalar()) Bcast = Bcast.asDenseArray();
  if (Acast.isScalar() && Bcast.isScalar()) {
    if (Acast.allReal() && Bcast.allReal()) {
      F = Array(Op::func(Acast.constRealScalar<T>(),
				Bcast.constRealScalar<T>()));
    } else {
      Acast.forceComplex(); Bcast.forceComplex();
      F = Array(T(0),T(0));
      Op::func(Acast.constRealScalar<T>(),
	       Acast.constImagScalar<T>(),
	       Bcast.constRealScalar<T>(),

    }
  } else if (Acast.isScalar()) {
    if (Acast.allReal() && Bcast.allReal()) {
      F = Array(Tclass,Bcast.dimensions());
      T* ret = F.real<T>().data();
      const T& Ap = Acast.constRealScalar<T>();
      const T* Bp = Bcast.constReal<T>().constData();

      for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap,Bp[i]);
    } else {
      Acast.forceComplex(); Bcast.forceComplex();
      F = Array(Tclass,Bcast.dimensions());
      T* Cr = F.real<T>().data();
      T* Ci = F.imag<T>().data();
      const T& Ar = Acast.constRealScalar<T>();

    }
  } else if (Bcast.isScalar()) {
    if (Bcast.allReal() && Acast.allReal()) {
      F = Array(Tclass,Acast.dimensions());
      T* ret = F.real<T>().data();
      const T* Ap = Acast.constReal<T>().constData();
      const T& Bp = Bcast.constRealScalar<T>();

      for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap[i],Bp);
    } else { 
      Acast.forceComplex(); Bcast.forceComplex();
      F = Array(Tclass,Acast.dimensions());
      T* Cr = F.real<T>().data();
      T* Ci = F.imag<T>().data();
      const T* Ar = Acast.constReal<T>().constData();

    if (Acast.dimensions() != Bcast.dimensions())
      throw Exception("size mismatch in arguments to binary operator");
    if (Bcast.allReal() && Acast.allReal()) {
      F = Array(Tclass,Acast.dimensions());
      T* ret = F.real<T>().data();
      const T* Ap = Acast.constReal<T>().constData();
      const T* Bp = Bcast.constReal<T>().constData();

      for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap[i],Bp[i]);
    } else {
      Acast.forceComplex(); Bcast.forceComplex();
      F = Array(Tclass,Acast.dimensions());
      T* Cr = F.real<T>().data();
      T* Ci = F.imag<T>().data();
      const T* Ar = Acast.constReal<T>().constData();

  if (!Acast.isScalar()) Acast = Acast.asDenseArray();
  if (!Bcast.isScalar()) Bcast = Bcast.asDenseArray();
  if (Acast.isScalar() && Bcast.isScalar()) {
    F = Array(Op::func(Acast.constRealScalar<T>(),
			      Bcast.constRealScalar<T>()));
  } else if (Acast.isScalar()) {
    F = Array(Bool,Bcast.dimensions());
    bool* ret = F.real<bool>().data();
    const T& Ap = Acast.constRealScalar<T>();
    const T* Bp = Bcast.constReal<T>().constData();
    uint64 q = uint64(Bcast.length());
    for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap,Bp[i]);
  } else if (Bcast.isScalar()) {
    F = Array(Bool,Acast.dimensions());
    bool* ret = F.real<bool>().data();
    const T* Ap = Acast.constReal<T>().constData();
    const T& Bp = Bcast.constRealScalar<T>();

  } else {
    if (Acast.dimensions() != Bcast.dimensions())
      throw Exception("size mismatch in arguments to binary operator");
    F = Array(Bool,Acast.dimensions());
    bool* ret = F.real<bool>().data();
    const T* Ap = Acast.constReal<T>().constData();
    const T* Bp = Bcast.constReal<T>().constData();

  if (!Bcast.isScalar()) Bcast = Bcast.asDenseArray();
  if (Acast.isScalar() && Bcast.isScalar()) {
    if (Acast.allReal() && Bcast.allReal()) {
      F = Array(Op::func(Acast.constRealScalar<T>(),
				Bcast.constRealScalar<T>()));
    } else {
      Acast.forceComplex(); Bcast.forceComplex();
      F = Array(Op::func(Acast.constRealScalar<T>(),
				Acast.constImagScalar<T>(),
				Bcast.constRealScalar<T>(),
				Bcast.constImagScalar<T>()));
    }
  } else if (Acast.isScalar()) {
    if (Acast.allReal() && Bcast.allReal()) {
      F = Array(Bool,Bcast.dimensions());
      bool* ret = F.real<bool>().data();
      const T& Ap = Acast.constRealScalar<T>();
      const T* Bp = Bcast.constReal<T>().constData();

      for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap,Bp[i]);
    } else {
      Acast.forceComplex(); Bcast.forceComplex();
      F = Array(Bool,Bcast.dimensions());
      bool* ret = F.real<bool>().data();
      const T& Ar = Acast.constRealScalar<T>();
      const T& Ai = Acast.constImagScalar<T>();

    }
  } else if (Bcast.isScalar()) {
    if (Bcast.allReal() && Acast.allReal()) {
      F = Array(Bool,Acast.dimensions());
      bool* ret = F.real<bool>().data();
      const T* Ap = Acast.constReal<T>().constData();
      const T& Bp = Bcast.constRealScalar<T>();

      for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap[i],Bp);
    } else {
      Acast.forceComplex(); Bcast.forceComplex();
      F = Array(Bool,Acast.dimensions());
      bool* ret = F.real<bool>().data();
      const T* Ar = Acast.constReal<T>().constData();
      const T* Ai = Acast.constImag<T>().constData();

    if (Acast.dimensions() != Bcast.dimensions())
      throw Exception("size mismatch in arguments to binary operator");
    if (Bcast.allReal() && Acast.allReal()) {
      F = Array(Bool,Acast.dimensions());
      bool* ret = F.real<bool>().data();
      const T* Ap = Acast.constReal<T>().constData();
      const T* Bp = Bcast.constReal<T>().constData();

      for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap[i],Bp[i]);
    } else {
      Acast.forceComplex(); Bcast.forceComplex();
      F = Array(Bool,Acast.dimensions());
      bool* ret = F.real<bool>().data();
      const T* Ar = Acast.constReal<T>().constData();
      const T* Ai = Acast.constImag<T>().constData();

  if (!Acast.isScalar()) Acast = Acast.asDenseArray();
  if (Acast.isScalar()) {
    if (Acast.allReal()) {
      F = Array(Op::func(Acast.constRealScalar<T>()));
    } else {
      F = Array(T(0),T(0));
      Op::func(Acast.constRealScalar<T>(),
	       Acast.constImagScalar<T>(),
	       F.realScalar<T>(),F.imagScalar<T>());

Return to bug 318045

Line Link Here

(-)file_not_specified_in_diff (-28 / +28 lines)
0	-- libs/libFreeMat/Array.cpp	0	++ libs/libFreeMat/Array.cpp
Lines 465-471 Link Here
465		465
466	void Array::set(const QString& field, ArrayVector& data) {	466	void Array::set(const QString& field, ArrayVector& data) {
467	if (isEmpty() && m_type.Class != Struct)	467	if (isEmpty() && m_type.Class != Struct)
468	*this = Array::Array(Struct);	468	*this = Array(Struct);
469	if (m_type.Class != Struct) throw Exception("Unsupported type for A.field=B");	469	if (m_type.Class != Struct) throw Exception("Unsupported type for A.field=B");
470	StructArray &rp(structPtr());	470	StructArray &rp(structPtr());
471	if (isEmpty())	471	if (isEmpty())
472	-- libs/libFreeMat/Math.cpp	472	++ libs/libFreeMat/Math.cpp
Lines 1590-1598 Link Here
1590		1590
1591	Array Not(const Array& A) {	1591	Array Not(const Array& A) {
1592	if (A.isScalar())	1592	if (A.isScalar())
1593	return Array::Array(!A.toClass(Bool).constRealScalar<bool>());	1593	return Array(!A.toClass(Bool).constRealScalar<bool>());
1594	const Array &Abool(A.toClass(Bool));	1594	const Array &Abool(A.toClass(Bool));
1595	return Array::Array(Apply(Abool.constReal<bool>(),notfunc));	1595	return Array(Apply(Abool.constReal<bool>(),notfunc));
1596	}	1596	}
1597		1597
1598	Array Plus(const Array& A) {	1598	Array Plus(const Array& A) {
1599	-- libs/libFreeMat/Operators.hpp	1599	++ libs/libFreeMat/Operators.hpp
Lines 142-152 Link Here
142	if (!Bcast.isScalar()) Bcast = Bcast.asDenseArray();	142	if (!Bcast.isScalar()) Bcast = Bcast.asDenseArray();
143	if (Acast.isScalar() && Bcast.isScalar()) {	143	if (Acast.isScalar() && Bcast.isScalar()) {
144	if (Acast.allReal() && Bcast.allReal()) {	144	if (Acast.allReal() && Bcast.allReal()) {
145	F = Array::Array(Op::func(Acast.constRealScalar<T>(),	145	F = Array(Op::func(Acast.constRealScalar<T>(),
146	Bcast.constRealScalar<T>()));	146	Bcast.constRealScalar<T>()));
147	} else {	147	} else {
148	Acast.forceComplex(); Bcast.forceComplex();	148	Acast.forceComplex(); Bcast.forceComplex();
149	F = Array::Array(T(0),T(0));	149	F = Array(T(0),T(0));
150	Op::func(Acast.constRealScalar<T>(),	150	Op::func(Acast.constRealScalar<T>(),
151	Acast.constImagScalar<T>(),	151	Acast.constImagScalar<T>(),
152	Bcast.constRealScalar<T>(),	152	Bcast.constRealScalar<T>(),
Lines 155-161 Link Here
155	}	155	}
156	} else if (Acast.isScalar()) {	156	} else if (Acast.isScalar()) {
157	if (Acast.allReal() && Bcast.allReal()) {	157	if (Acast.allReal() && Bcast.allReal()) {
158	F = Array::Array(Tclass,Bcast.dimensions());	158	F = Array(Tclass,Bcast.dimensions());
159	T* ret = F.real<T>().data();	159	T* ret = F.real<T>().data();
160	const T& Ap = Acast.constRealScalar<T>();	160	const T& Ap = Acast.constRealScalar<T>();
161	const T* Bp = Bcast.constReal<T>().constData();	161	const T* Bp = Bcast.constReal<T>().constData();
Lines 163-169 Link Here
163	for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap,Bp[i]);	163	for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap,Bp[i]);
164	} else {	164	} else {
165	Acast.forceComplex(); Bcast.forceComplex();	165	Acast.forceComplex(); Bcast.forceComplex();
166	F = Array::Array(Tclass,Bcast.dimensions());	166	F = Array(Tclass,Bcast.dimensions());
167	T* Cr = F.real<T>().data();	167	T* Cr = F.real<T>().data();
168	T* Ci = F.imag<T>().data();	168	T* Ci = F.imag<T>().data();
169	const T& Ar = Acast.constRealScalar<T>();	169	const T& Ar = Acast.constRealScalar<T>();
Lines 175-181 Link Here
175	}	175	}
176	} else if (Bcast.isScalar()) {	176	} else if (Bcast.isScalar()) {
177	if (Bcast.allReal() && Acast.allReal()) {	177	if (Bcast.allReal() && Acast.allReal()) {
178	F = Array::Array(Tclass,Acast.dimensions());	178	F = Array(Tclass,Acast.dimensions());
179	T* ret = F.real<T>().data();	179	T* ret = F.real<T>().data();
180	const T* Ap = Acast.constReal<T>().constData();	180	const T* Ap = Acast.constReal<T>().constData();
181	const T& Bp = Bcast.constRealScalar<T>();	181	const T& Bp = Bcast.constRealScalar<T>();
Lines 183-189 Link Here
183	for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap[i],Bp);	183	for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap[i],Bp);
184	} else {	184	} else {
185	Acast.forceComplex(); Bcast.forceComplex();	185	Acast.forceComplex(); Bcast.forceComplex();
186	F = Array::Array(Tclass,Acast.dimensions());	186	F = Array(Tclass,Acast.dimensions());
187	T* Cr = F.real<T>().data();	187	T* Cr = F.real<T>().data();
188	T* Ci = F.imag<T>().data();	188	T* Ci = F.imag<T>().data();
189	const T* Ar = Acast.constReal<T>().constData();	189	const T* Ar = Acast.constReal<T>().constData();
Lines 197-203 Link Here
197	if (Acast.dimensions() != Bcast.dimensions())	197	if (Acast.dimensions() != Bcast.dimensions())
198	throw Exception("size mismatch in arguments to binary operator");	198	throw Exception("size mismatch in arguments to binary operator");
199	if (Bcast.allReal() && Acast.allReal()) {	199	if (Bcast.allReal() && Acast.allReal()) {
200	F = Array::Array(Tclass,Acast.dimensions());	200	F = Array(Tclass,Acast.dimensions());
201	T* ret = F.real<T>().data();	201	T* ret = F.real<T>().data();
202	const T* Ap = Acast.constReal<T>().constData();	202	const T* Ap = Acast.constReal<T>().constData();
203	const T* Bp = Bcast.constReal<T>().constData();	203	const T* Bp = Bcast.constReal<T>().constData();
Lines 205-211 Link Here
205	for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap[i],Bp[i]);	205	for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap[i],Bp[i]);
206	} else {	206	} else {
207	Acast.forceComplex(); Bcast.forceComplex();	207	Acast.forceComplex(); Bcast.forceComplex();
208	F = Array::Array(Tclass,Acast.dimensions());	208	F = Array(Tclass,Acast.dimensions());
209	T* Cr = F.real<T>().data();	209	T* Cr = F.real<T>().data();
210	T* Ci = F.imag<T>().data();	210	T* Ci = F.imag<T>().data();
211	const T* Ar = Acast.constReal<T>().constData();	211	const T* Ar = Acast.constReal<T>().constData();
Lines 328-344 Link Here
328	if (!Acast.isScalar()) Acast = Acast.asDenseArray();	328	if (!Acast.isScalar()) Acast = Acast.asDenseArray();
329	if (!Bcast.isScalar()) Bcast = Bcast.asDenseArray();	329	if (!Bcast.isScalar()) Bcast = Bcast.asDenseArray();
330	if (Acast.isScalar() && Bcast.isScalar()) {	330	if (Acast.isScalar() && Bcast.isScalar()) {
331	F = Array::Array(Op::func(Acast.constRealScalar<T>(),	331	F = Array(Op::func(Acast.constRealScalar<T>(),
332	Bcast.constRealScalar<T>()));	332	Bcast.constRealScalar<T>()));
333	} else if (Acast.isScalar()) {	333	} else if (Acast.isScalar()) {
334	F = Array::Array(Bool,Bcast.dimensions());	334	F = Array(Bool,Bcast.dimensions());
335	bool* ret = F.real<bool>().data();	335	bool* ret = F.real<bool>().data();
336	const T& Ap = Acast.constRealScalar<T>();	336	const T& Ap = Acast.constRealScalar<T>();
337	const T* Bp = Bcast.constReal<T>().constData();	337	const T* Bp = Bcast.constReal<T>().constData();
338	uint64 q = uint64(Bcast.length());	338	uint64 q = uint64(Bcast.length());
339	for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap,Bp[i]);	339	for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap,Bp[i]);
340	} else if (Bcast.isScalar()) {	340	} else if (Bcast.isScalar()) {
341	F = Array::Array(Bool,Acast.dimensions());	341	F = Array(Bool,Acast.dimensions());
342	bool* ret = F.real<bool>().data();	342	bool* ret = F.real<bool>().data();
343	const T* Ap = Acast.constReal<T>().constData();	343	const T* Ap = Acast.constReal<T>().constData();
344	const T& Bp = Bcast.constRealScalar<T>();	344	const T& Bp = Bcast.constRealScalar<T>();
Lines 347-353 Link Here
347	} else {	347	} else {
348	if (Acast.dimensions() != Bcast.dimensions())	348	if (Acast.dimensions() != Bcast.dimensions())
349	throw Exception("size mismatch in arguments to binary operator");	349	throw Exception("size mismatch in arguments to binary operator");
350	F = Array::Array(Bool,Acast.dimensions());	350	F = Array(Bool,Acast.dimensions());
351	bool* ret = F.real<bool>().data();	351	bool* ret = F.real<bool>().data();
352	const T* Ap = Acast.constReal<T>().constData();	352	const T* Ap = Acast.constReal<T>().constData();
353	const T* Bp = Bcast.constReal<T>().constData();	353	const T* Bp = Bcast.constReal<T>().constData();
Lines 395-412 Link Here
395	if (!Bcast.isScalar()) Bcast = Bcast.asDenseArray();	395	if (!Bcast.isScalar()) Bcast = Bcast.asDenseArray();
396	if (Acast.isScalar() && Bcast.isScalar()) {	396	if (Acast.isScalar() && Bcast.isScalar()) {
397	if (Acast.allReal() && Bcast.allReal()) {	397	if (Acast.allReal() && Bcast.allReal()) {
398	F = Array::Array(Op::func(Acast.constRealScalar<T>(),	398	F = Array(Op::func(Acast.constRealScalar<T>(),
399	Bcast.constRealScalar<T>()));	399	Bcast.constRealScalar<T>()));
400	} else {	400	} else {
401	Acast.forceComplex(); Bcast.forceComplex();	401	Acast.forceComplex(); Bcast.forceComplex();
402	F = Array::Array(Op::func(Acast.constRealScalar<T>(),	402	F = Array(Op::func(Acast.constRealScalar<T>(),
403	Acast.constImagScalar<T>(),	403	Acast.constImagScalar<T>(),
404	Bcast.constRealScalar<T>(),	404	Bcast.constRealScalar<T>(),
405	Bcast.constImagScalar<T>()));	405	Bcast.constImagScalar<T>()));
406	}	406	}
407	} else if (Acast.isScalar()) {	407	} else if (Acast.isScalar()) {
408	if (Acast.allReal() && Bcast.allReal()) {	408	if (Acast.allReal() && Bcast.allReal()) {
409	F = Array::Array(Bool,Bcast.dimensions());	409	F = Array(Bool,Bcast.dimensions());
410	bool* ret = F.real<bool>().data();	410	bool* ret = F.real<bool>().data();
411	const T& Ap = Acast.constRealScalar<T>();	411	const T& Ap = Acast.constRealScalar<T>();
412	const T* Bp = Bcast.constReal<T>().constData();	412	const T* Bp = Bcast.constReal<T>().constData();
Lines 414-420 Link Here
414	for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap,Bp[i]);	414	for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap,Bp[i]);
415	} else {	415	} else {
416	Acast.forceComplex(); Bcast.forceComplex();	416	Acast.forceComplex(); Bcast.forceComplex();
417	F = Array::Array(Bool,Bcast.dimensions());	417	F = Array(Bool,Bcast.dimensions());
418	bool* ret = F.real<bool>().data();	418	bool* ret = F.real<bool>().data();
419	const T& Ar = Acast.constRealScalar<T>();	419	const T& Ar = Acast.constRealScalar<T>();
420	const T& Ai = Acast.constImagScalar<T>();	420	const T& Ai = Acast.constImagScalar<T>();
Lines 425-431 Link Here
425	}	425	}
426	} else if (Bcast.isScalar()) {	426	} else if (Bcast.isScalar()) {
427	if (Bcast.allReal() && Acast.allReal()) {	427	if (Bcast.allReal() && Acast.allReal()) {
428	F = Array::Array(Bool,Acast.dimensions());	428	F = Array(Bool,Acast.dimensions());
429	bool* ret = F.real<bool>().data();	429	bool* ret = F.real<bool>().data();
430	const T* Ap = Acast.constReal<T>().constData();	430	const T* Ap = Acast.constReal<T>().constData();
431	const T& Bp = Bcast.constRealScalar<T>();	431	const T& Bp = Bcast.constRealScalar<T>();
Lines 433-439 Link Here
433	for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap[i],Bp);	433	for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap[i],Bp);
434	} else {	434	} else {
435	Acast.forceComplex(); Bcast.forceComplex();	435	Acast.forceComplex(); Bcast.forceComplex();
436	F = Array::Array(Bool,Acast.dimensions());	436	F = Array(Bool,Acast.dimensions());
437	bool* ret = F.real<bool>().data();	437	bool* ret = F.real<bool>().data();
438	const T* Ar = Acast.constReal<T>().constData();	438	const T* Ar = Acast.constReal<T>().constData();
439	const T* Ai = Acast.constImag<T>().constData();	439	const T* Ai = Acast.constImag<T>().constData();
Lines 446-452 Link Here
446	if (Acast.dimensions() != Bcast.dimensions())	446	if (Acast.dimensions() != Bcast.dimensions())
447	throw Exception("size mismatch in arguments to binary operator");	447	throw Exception("size mismatch in arguments to binary operator");
448	if (Bcast.allReal() && Acast.allReal()) {	448	if (Bcast.allReal() && Acast.allReal()) {
449	F = Array::Array(Bool,Acast.dimensions());	449	F = Array(Bool,Acast.dimensions());
450	bool* ret = F.real<bool>().data();	450	bool* ret = F.real<bool>().data();
451	const T* Ap = Acast.constReal<T>().constData();	451	const T* Ap = Acast.constReal<T>().constData();
452	const T* Bp = Bcast.constReal<T>().constData();	452	const T* Bp = Bcast.constReal<T>().constData();
Lines 454-460 Link Here
454	for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap[i],Bp[i]);	454	for (uint64 i=0;i<q;i++) ret[i] = Op::func(Ap[i],Bp[i]);
455	} else {	455	} else {
456	Acast.forceComplex(); Bcast.forceComplex();	456	Acast.forceComplex(); Bcast.forceComplex();
457	F = Array::Array(Bool,Acast.dimensions());	457	F = Array(Bool,Acast.dimensions());
458	bool* ret = F.real<bool>().data();	458	bool* ret = F.real<bool>().data();
459	const T* Ar = Acast.constReal<T>().constData();	459	const T* Ar = Acast.constReal<T>().constData();
460	const T* Ai = Acast.constImag<T>().constData();	460	const T* Ai = Acast.constImag<T>().constData();
Lines 533-541 Link Here
533	if (!Acast.isScalar()) Acast = Acast.asDenseArray();	533	if (!Acast.isScalar()) Acast = Acast.asDenseArray();
534	if (Acast.isScalar()) {	534	if (Acast.isScalar()) {
535	if (Acast.allReal()) {	535	if (Acast.allReal()) {
536	F = Array::Array(Op::func(Acast.constRealScalar<T>()));	536	F = Array(Op::func(Acast.constRealScalar<T>()));
537	} else {	537	} else {
538	F = Array::Array(T(0),T(0));	538	F = Array(T(0),T(0));
539	Op::func(Acast.constRealScalar<T>(),	539	Op::func(Acast.constRealScalar<T>(),
540	Acast.constImagScalar<T>(),	540	Acast.constImagScalar<T>(),
541	F.realScalar<T>(),F.imagScalar<T>());	541	F.realScalar<T>(),F.imagScalar<T>());