viberation.cpp

来自「故障诊断工作涉及的领域相当广泛」· C++ 代码 · 共 314 行

// viberation.cpp: implementation of the viberation class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "richtest.h"
#include "viberation.h"
#include "mymatrix_idl.h"
#include "mymatrix_idl_i.c"
#include "mclcommain.h"
#include "mclcomclass.h"
#include "testcom.h"
#include "testcom_i.c"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
class disp_conetor;
//const IID IID_IMWFlags = {0x0A295776,0x23A1,0x410a,{0x94,0xBD,0x0C,0x6C,0x61,0xB8,0x91,0xB7}};
const CLSID CLSID_MWFlags = {0x02730550,0xC3E2,0x4a60,{0xBA,0x7B,0x9A,0xBC,0xD4,0x81,0x25,0x0D}};
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
HRESULT __stdcall get_MWFlags(IMWFlags** ppFlags)
    {
        HRESULT hr = S_OK;       // Return code
		IMWFlags* m_pFlags;
        if (ppFlags == NULL)
            return E_INVALIDARG;
        *ppFlags = NULL;
        // If there is not one already allocated, creat a new one. Use lock to prevent
        // two threads from creating at same time.
        
            hr = CoCreateInstance(CLSID_MWFlags, NULL, CLSCTX_INPROC_SERVER, 
                                  IID_IMWFlags, (void**)&m_pFlags);
            
       *ppFlags=m_pFlags;
	   return S_OK;
        
    }
void mwArray2VARIANT(VARIANT* var,const mwArray& in)
{_MCLCONVERSION_FLAGS flags;
IMWFlags* pFlags = NULL;
        // Get Conversion flags
        if (FAILED(get_MWFlags(&pFlags)))
        {
            AfxMessageBox("Error getting data conversion flags");
           // return FALSE;
        }
        if (FAILED(GetConversionFlags(pFlags, &flags)))
        {
            AfxMessageBox("Error getting data conversion flags");
            //return FALSE;
        }
        pFlags->Release();
VariantInit(var);
mxArray2Variant(in.GetData(),var,&flags);
//V_VT(var)=VT_R8|VT_BYREF;
//var->pdblVal=in;
};
void VARIANT2mwArray(const VARIANT& var,mwArray* out)
{_MCLCONVERSION_FLAGS flags;
IMWFlags* pFlags = NULL;
        // Get Conversion flags
        if (FAILED(get_MWFlags(&pFlags)))
        {
            AfxMessageBox("Error getting data conversion flags");
           // return FALSE;
        }
        if (FAILED(GetConversionFlags(pFlags, &flags)))
        {
            AfxMessageBox("Error getting data conversion flags");
            //return FALSE;
        }
        pFlags->Release();
		mxArray* temp;
Variant2mxArray(&var,&temp,&flags);
*out=mwArray(temp);
//V_VT(var)=VT_R8|VT_BYREF;
//var->pdblVal=in;
};
viberation::viberation(const mydata* in,mydata* out)
{	M=*(in->pdata.mw);
	C=*(in->pdata.mw+1);
	K=*(in->pdata.mw+2);
	F=*(in->pdata.mw+3);
	this->out=out;
}
viberation::viberation(mydata* in_M, mydata* in_C, mydata* in_K, mydata* in_F,int in_n)
{int M_rank,K_rank,C_rank,F_rank;
	M_rank=sqrt(in_M->get_length());
	C_rank=sqrt(in_C->get_length());
	K_rank=sqrt(in_K->get_length());
	F_rank=in_F->get_length();
	input_correct=(M_rank==C_rank&&C_rank==K_rank&&K_rank==F_rank);
	input_correct&=M_rank*M_rank==in_M->get_length();
	if(input_correct)
	{
		n=M_rank;
		mwArray M1(n,n,in_M->pdata.dou),C1(n,n,in_C->pdata.dou),K1(n,n,in_K->pdata.dou),F1(n,n,in_F->pdata.dou);
		M.CopyInputArg(M1);
		C.CopyInputArg(C1);
		K.CopyInputArg(K1);
		F.CopyInputArg(F1);
		mwArray2VARIANT(&vM,M);
		mwArray2VARIANT(&vC,C);
		mwArray2VARIANT(&vK,K);
		mwArray2VARIANT(&vF,F);

	};
VariantInit(&vn);
V_VT(&vn)=VT_R8;
vn.dblVal=n;
}
viberation::~viberation()
{
	

}
 	 
BOOL viberation::go(mydata* bag)
{mwArray mi,mj,mk,ml;
	double i,j,k,l;
if(FAILED(CoInitialize(NULL)))
  AfxMessageBox("组件库初试化错误"); 
IUnknown* up;
Imymatrix* p;
IDispatch* dp;
HRESULT hr=CoCreateInstance(CLSID_mymatrix,NULL,CLSCTX_INPROC,IID_IUnknown,(void**)&up);
 hr=up->QueryInterface(IID_Imymatrix,(void**)&p);
 hr=up->QueryInterface(IID_IDispatch,(void**)&dp);
if(FAILED(hr))
	AfxMessageBox("没有找到矩阵组件"); 
	if(!input_correct)
		{AfxMessageBox("输入数据数量错误");
			return FALSE;
		};
	VARIANT var;
	double ddd[10],ttt[10];
//	mwArray mw(&vM);
	
	C.ExtractData(ddd);
	_MCLCONVERSION_FLAGS flags;
        IMWFlags* pFlags = NULL;
        // Get Conversion flags
        if (FAILED(get_MWFlags(&pFlags)))
        {
            AfxMessageBox("Error getting data conversion flags");
            return FALSE;
        }
        if (FAILED(GetConversionFlags(pFlags, &flags)))
        {
            AfxMessageBox("Error getting data conversion flags");
            return FALSE;
        }
        pFlags->Release();
		mxArray* here=NULL;
	VariantInit(&var);
	p->invmatrix(1,&var,vM,vC,vK);
	IMWComplex* pTemp = (IMWComplex*)var.pdispVal;//复数类型的接口 
	pTemp->get_MWFlags(&pFlags);
	Variant2mxArray(&var,&here,&flags);
	static mwArray hh1(here);
	double r[4],ii[4];
	hh1.ExtractData(r,ii);
	hh1.ExtractData(r,ii);
	VariantInit(&var);
	disp_conector it;
	disp_conector* pit=⁢
DWORD* dwp=(DWORD*)dp;
DWORD* vtable=(DWORD*)(*dwp);
DWORD* dw=(DWORD*)&(pit->p3i1o);
			*dw=*(vtable+9);
	//		pit->p3i1o=(p3i1ov)(*(vtable+9));
			it.p3i1o(dp,1,&var,vM,vC,vK);

Variant2mxArray(&var,&here,&flags);
	static mwArray hhh1(here);
	hhh1.ExtractData(r,ii);
	hhh1.ExtractData(r,ii);
	VariantInit(&var);
//hr=
//	Variant2mxArray(&var,&here,&flags);
//	static mwArray mm0(here);
	//	mm0.ExtractData(ddd,ttt);
	char chname[]="Imymatrix";
	CRuntimeClass eee;
	eee.m_lpszClassName=chname;
//	eee.CreateObject();


	VARIANT re[5];

	DISPID dspid;
	LPOLESTR name=L"invmatrix";
	char* ssss=(char*)name;
	hr=dp->GetIDsOfNames(IID_NULL,&name,1,LOCALE_SYSTEM_DEFAULT,&dspid);
	
	if(!FAILED(hr))	
	{DISPPARAMS disparams;
	memset(&disparams,0,sizeof(DISPPARAMS));
	disparams.cArgs=4;
	VARIANTARG* pArg=new VARIANTARG[disparams.cArgs];
	disparams.rgvarg=pArg;
	memset(pArg,0,sizeof(VARIANT)*disparams.cArgs);
	//disparams.rgvarg[0].vt=VT_I4;
	//disparams.rgvarg[0].lVal=1;
	disparams.rgvarg[0].vt=VT_VARIANT|VT_BYREF;
	disparams.rgvarg[0].pvarVal=&var;
	mwArray2VARIANT(disparams.rgvarg+0,M);
	mwArray2VARIANT(disparams.rgvarg+1,M);
	mwArray2VARIANT(disparams.rgvarg+2,C);
	mwArray2VARIANT(disparams.rgvarg+3,K);
//	disparams.rgvarg[4].pvarVal=&vK;
	hr=dp->Invoke(dspid,IID_NULL,LOCALE_SYSTEM_DEFAULT,DISPATCH_METHOD,&disparams,&var,0,NULL);
if(!FAILED(hr))
{IMWComplex* pTemp = (IMWComplex*)disparams.rgvarg->pdispVal;//复数类型的接口 
	pTemp->get_MWFlags(&pFlags);
	Variant2mxArray(disparams.rgvarg,&here,&flags);
	static mwArray hh1(here);
	double r[4],ii[4];
	hh1.ExtractData(r,ii);
	hh1.ExtractData(r,ii);
}

	
	}

//HMODULE hdll=::LoadLibrary("e:\\lzk\\mymatrixc_1_0.dll");		
//	it=(pdvovi)::GetProcAddress(hdll,"invmatrix");
		
	
static	mwArray mm1(here);
	
  mm1.ExtractData(ddd,ttt);
//myeig(1,M,C,K,bag);
	CoUninitialize();
	bag->mset_data(NULL,0,type_mw,NULL,0,1,&mm1);
return TRUE;

}
 int _stdcall viberation::myeig(mwArray *out,unsigned int* o_cnt, const mwArray* in,unsigned int i_cnt) 
{
    mwArray k = mwArray::UNDEFINED;
    mwArray m = mwArray::UNDEFINED;
    mwArray m1 = mwArray::UNDEFINED;
    m1 = *in*0;
  //  m
  //    = vertcat(
  //        mwVarargin(
  //          horzcat(mwVarargin(mwVv(m1, "m1"), mwVa(in, "in"))),
   //         horzcat(mwVarargin(mwVa(in, "in"), mwVa(in1, "in1")))));
	m = vertcat(horzcat(m1, *in),horzcat(*in,*(in+1)));
  //  k
   //   = vertcat(
    //      mwVarargin(
     //       horzcat(mwVarargin(mwVa(in, "in"), mwVv(m1, "m1"))),
      //      horzcat(mwVarargin(mwVv(m1, "m1"), - mwVa(in2, "in2"))))); 
	k = vertcat(horzcat(*in,m1),horzcat(m1,-*(in+2)));
    k = k*inv(m);
	double r[4],i[4];
	*out=eig(k);
	*o_cnt=1;
    //mwValidateOutput(*out, 1, nargout_, "out", "invmatrix");  
return S_OK; 
}
void viberation::attach()
{
};
BOOL viberation::check()
{return TRUE;
}
BOOL viberation::go()
{	
	mwArray2VARIANT(&vM,M);
	mwArray2VARIANT(&vC,C);
	mwArray2VARIANT(&vK,K);
	mwArray2VARIANT(&vF,F);
	//mwArray bag;
	if(check())
		go(out);
	else return FALSE;

	return TRUE;
}
void viberation::out_create()
{
}
extern "C" _declspec(dllexport) int _stdcall myeig(mwArray *out,unsigned int* o_cnt, const mwArray* in,unsigned int i_cnt) 
{
    mwArray k = mwArray::UNDEFINED;
    mwArray m = mwArray::UNDEFINED;
    mwArray m1 = mwArray::UNDEFINED;
    m1 = *in*0;
  //  m
  //    = vertcat(
  //        mwVarargin(
  //          horzcat(mwVarargin(mwVv(m1, "m1"), mwVa(in, "in"))),
   //         horzcat(mwVarargin(mwVa(in, "in"), mwVa(in1, "in1")))));
	m = vertcat(horzcat(m1, *in),horzcat(*in,*(in+1)));
  //  k
   //   = vertcat(
    //      mwVarargin(
     //       horzcat(mwVarargin(mwVa(in, "in"), mwVv(m1, "m1"))),
      //      horzcat(mwVarargin(mwVv(m1, "m1"), - mwVa(in2, "in2"))))); 
	k = vertcat(horzcat(*in,m1),horzcat(m1,-*(in+2)));
    k = k*inv(m);
	double r[4],i[4];
	*out=eig(k);
	*o_cnt=1;
    //mwValidateOutput(*out, 1, nargout_, "out", "invmatrix");  
return S_OK; 
}