精华内容
下载资源
问答
  • 易语言建筑台阶计算程序源码,建筑台阶计算程序,正式程序,调整坡度计算,调整斜坡方式优选方案,坡度计算,接路宽度计算,纯斜坡计算程序,子程序_导出,工作簿导入,列表框赋值给变量,变量赋值给编辑框,配置文件记录更改,...
  • 程序编辑框中文本公式计算的模块.rar 让程序编辑框中文本公式计算的模块.rar 让程序编辑框中文本公式计算的模块.rar 让程序编辑框中文本公式计算的模块.rar 让程序编辑框中文本公式计算的模块.rar ...
  • 易语言让程序编辑框中文本公式计算的模块源码,让程序编辑框中文本公式计算的模块
  • 易语言源码让程序编辑框中文本公式计算的模块.rar 易语言源码让程序编辑框中文本公式计算的模块.rar 易语言源码让程序编辑框中文本公式计算的模块.rar 易语言源码让程序编辑框中文本公式计算的模块.rar ...
  • 华中科技大学电气学院大四课设。...本程序界面类似Protel,可实现同时对电力系统网络图的编辑,自由地对各个元器件进行拖动、复制、粘贴、删除等。 目前只实现三相短路的计算。。。更多功能有待日后实现。
  • windows计算程序运行时间

    千次阅读 2010-08-26 09:11:00
    1. 这个是windows里面常用来计算程序运行时间的函数: 1: DWORD dwStart = GetTickCount(); 2: Test(); // Your program. 3: DWORD dwEnd = GetTickCount(); 4: DWORD dwTimes = dwEnd - dwStart;...

    1. 这个是windows里面常用来计算程序运行时间的函数:

       1: DWORD dwStart = GetTickCount();
       2: Test(); // Your program.
       3: DWORD dwEnd = GetTickCount();
       4: DWORD dwTimes = dwEnd - dwStart;

    则(dwEnd-dwStart)就是你的程序运行时间, 以毫秒为单位这个函数只精确到55ms,1个tick就是55ms。

    2. timeGetTime()基本等于GetTickCount(),但是精度更高:

       1: DWORD dwStart = timeGetTime();
       2: Test(); // Your program
       3: DWORD dwEnd = timeGetTime();
       4: DWORD dwTimes = dwEnd - dwStart;

    则(dwEnd-dwStart)就是你的程序运行时间, 以毫秒为单位虽然返回的值单位应该是ms,但传说精度只有10ms。

    3. 用clock()函数,得到系统启动以后的毫秒级时间,然后除以CLOCKS_PER_SEC,就可以换成“秒”,标准c函数。
    clock_t clock ( void );

       1: #include <time.h>
       2: clock_t t = clock();
       3: long sec = t / CLOCKS_PER_SEC;

    他是记录时钟周期的,实现看来不会很精确,需要试验验证。

       1: #include <iostream>
       2: #include <ctime>
       3: using namespace std;
       4: int main()
       5: {
       6:     time_t begin,end;
       7:     begin = clock();
       8:     //这里加上你的代码
       9:     end = clock();
      10:     cout << "runtime:   " << double(end - begin) / CLOCKS_PER_SEC << endl;
      11:     return 0;
      12: }

    4. unix时间相关,也是标准库的
    这些在<time.h>
    1). timegm函数只是将struct tm结构转成time_t结构,不使用时区信息;

       1: time_t timegm(struct tm *tm);

         2).mktime使用时区信息

       1: time_t mktime(struct tm *tm);

    timelocal 函数是GNU扩展的与posix函数mktime相当

       1: time_t timelocal (struct tm *tm);


    3). gmtime函数只是将time_t结构转成struct tm结构,不使用时区信息;

       1: struct tm * gmtime(const time_t *clock);

    4).  localtime使用时区信息
             
       1: struct tm * localtime(const time_t *clock);

    5). time获取时间,stime设置时间
       1: time_t t;
       2: t = time(&t);

    6). stime其参数应该是GMT时间,根据本地时区设置为本地时间;
       1: int stime(time_t *tp)

    UTC=true 表示采用夏时制;文件的修改时间等信息全部采用GMT时间存放,不同的系统在得到修改时间后通过localtime转换成本地时间;
    设置时区推荐使用setup来设置;设置时区也可以先更变/etc/sysconfig/clock中的设置 再将ln -fs /usr/share/zoneinfo/xxxx/xxx /etc/localtime 才能重效
    time_t只能表示68年的范围,即mktime只能返回1970-2038这一段范围的time_t看看你的系统是否有time_t64,它能表示更大的时间范围

    5. Window里面的一些不一样的

    CTime MFC类,好像就是把time.h封了个类,没扩展

       1: CTime t = GetCurrentTime();

    SYSTEMTIME 结构包含毫秒信息

     

       1: typedef struct _SYSTEMTIME {
       2:     WORD wYear;
       3:     WORD wMonth;
       4:     WORD wDayOfWeek;
       5:     WORD wDay;
       6:     WORD wHour;
       7:     WORD wMinute;
       8:     WORD wSecond;
       9:     WORD wMilliseconds;
      10: } SYSTEMTIME, *PSYSTEMTIME;
      11:  
      12: SYSTEMTIME t1;
      13: GetSystemTime(&t1)
      14: CTime curTime(t1);
      15: WORD ms = t1.wMilliseconds;
      16:  
      17: SYSTEMTIME sysTm;
      18: ::GetLocalTime(&sysTm);

    在time.h中的_strtime() //只能在windows中用

       1: char t[11];
       2: _strtime(t);
       3: puts(t);

    6. 下面是转的一个用汇编的精确计时方法
    ---------------------------------------------------------------------------------------
    如何获得程序或者一段代码运行的时间?你可能说有专门的程序测试工具,确实,不过你也可以在程序中嵌入汇编代码来实现。
    在Pentium的指令系统中有一条指令可以获得CPU内部64位计数器的值,我们可以通过代码两次获取该计数器的值而获得程序或代码运行的时钟周期数,进而通过你的cpu的频率算出一个时钟周期的时间,从而算出程序运行的确切时间。
    我们通过指令TDSIC来获得cpu内部计数器的值,指令TDSIC返回值放在EDX:EAX中,其中EDX中存放64位寄存器中高32位的值,EAX存放第32位的值。下面看看实现的代码:

       1: //用汇编实现获取一段代码运行的时间
       2: #include<iostream>
       3: using namespace std;
       4:  
       5: void GetClockNumber (long high, long low);
       6: void GetRunTime();
       7:  
       8: int main()
       9: {  
      10:     long HighStart,LowStart,HighEnd,LowEnd;
      11:     long numhigh,numlow;
      12:     //获取代码运行开始时cpu内部计数器的值
      13:     __asm      
      14:     {
      15:         RDTSC
      16:         mov HighStart, edx
      17:         mov LowStart, eax
      18:     }
      19:     for(int i= 0; i<100000; i++ )
      20:     {
      21:        for(int i= 0; i<100000; i++ )
      22:        {
      23:        }
      24:     }
      25:     //获取代码结束时cpu内部计数器的值,并减去初值
      26:     __asm
      27:     {
      28:         RDTSC
      29:         mov HighEnd, edx
      30:         Mov LowEnd, eax
      31:         //获取两次计数器值得差
      32:         sub eax, LowStart
      33:         cmp eax, 0    ; 如果低32的差为负则求返,因为第二次取得永远比第一次的大
      34:         jg   L1
      35:         neg   eax
      36:         jmp   L2
      37:       L1: mov numlow, eax
      38:       L2: sbb edx, HighStart
      39:         mov numhigh, edx
      40:     }
      41:     //把两个计数器值之差放在一个64位的整形变量中
      42:     //先把高32位左移32位放在64的整形变量中,然后再加上低32位
      43:     __int64 timer =(numhigh<<32) + numlow;
      44:      //输出代码段运行的时钟周期数
      45:      //以频率1.1Gcpu为例,如果换计算机把其中的1.1改乘其它即可,因为相信大家的cpu都应该在1G以上 ^_^
      46:     cout<< (double) (timer /1.1/1000000000) << endl;
      47:     return 0;
      48: }

           这样通过一条简单的汇编指令就可以获得程序或一段代码的大概时间,不过并不能得到运行的确切时间,因为即使去掉中间的循环,程序也会有个运行时间,
           因为在第一次取得计数器的值后,有两条汇编指令mov HighStart, edx    mov LowStart, eax这两条指令当然也有运行时间 ,当然你可以减去这两条指令的运行时间(在1.1G的机子上是3e-8s),这样会更精确一点。
    如果你要确切知道程序的运行时间,专业的测试软件肯定会更好一点,不过好像一般没有必要获取除非专门的要求的程序。
    不过能DIY一个也是不错的,不管有没有,最起码你可以学到在VC++中如何嵌入汇编代码以及如何使用32位的寄存器,其实和16位的寄存器一样使用,将来64的也应该一样,只不过位数不同罢了  。

       1: //C++高精度实现计算程序运行时间
       2: #include <iostream>    
       3: #include <windows.h>    
       4: using namespace std;    
       5:   
       6: void Test()//测试程序  
       7: {   
       8:     for(int i=0; i<1000; i++)   
       9:     {      
      10:         for(int j=0; j<100; j++)   
      11:         {   
      12:             printf("%d,%d/n",i,j);   
      13:         }      
      14:     }   
      15: }   
      16:   
      17: int main(void)    
      18: {    
      19:     LARGE_INTEGER BegainTime ;    
      20:     LARGE_INTEGER EndTime ;    
      21:     LARGE_INTEGER Frequency ;    
      22:     QueryPerformanceFrequency(&Frequency);    
      23:     QueryPerformanceCounter(&BegainTime) ;    
      24:   
      25:     //要测试的代码放在这里   
      26:     Test();   
      27:   
      28:     QueryPerformanceCounter(&EndTime);   
      29:   
      30:     //输出运行时间(单位:s)   
      31:     cout << "运行时间(单位:s):" <<(double)( EndTime.QuadPart - BegainTime.QuadPart )/ Frequency.QuadPart <<endl;    
      32:   
      33:     system("pause") ;    
      34:     return 0 ;    
      35: }

    附 vc计算高精度时间差

    面线框里的代码便可实现计算精度达到微秒级的时间差:

    ------------------------------------------------------------------------------------

       1: LARGE_INTEGER litmp;
       2: LONGLONG QPart1,Qpart2;
       3: double dfMinus,dfFreq,dfTime;
       4:  
       5: //获得计时器的时钟频率
       6: QueryPerformanceFrequency(&litmp);
       7: dfFreq = (double)litmp.QuadPart;
       8: QueryPerformanceCounter(&litmp);
       9: Qpart1 = litmp.QuadPart; //开始计时
      10:  
      11: Block1(); //工作模块 函数等,根据自己需要添加。
      12:  
      13: QueryPerformanceCounter(&litmp);
      14: Qpart2 = litmp.QuadPart; //终止计时
      15: dfMinus = (double)(QPart2 - QPart1);//计算计数器值
      16: dfTime = dfMinus / dfFreq;//获得对应时间,单位为秒 你可以乘1000000精确到毫秒级(us)

    --------------------------------------------------------------------------------------

    在一些计算机硬件系统中,包含有高精度运行计数器(high-resolution   performance  
    counter),利用它可以获得高精度定时间隔,其精度与CPU的时钟频率有关。  
    1、首先调用QueryPerformanceFrequency函数取得高精度运行计数器的频率f。单位是每秒多少次(n/s),此数  
    一般很大。  
    2、在需要定时的代码的两端分别调用QueryPerformanceCounter以取得高精度运行计数器的数值n1,n2。两次数  
    值的差值通过f换算成时间间隔,t=(n2-n1)/f。  
    下面举一个例子来演示这种方法的使用及它的精确度。  
    在VC   6.0   下用MFC建立一个对话框工程,取名为HightTimer.在对话框面板中控件的布局如下图:  
    其中包含两个静态文本框,两个编辑框和两个按纽。上面和下面位置的编辑框的ID分别为IDC_E_TEST和IDC_E_ACT  
    UAL,通过MFC   ClassWizard添加的成员变量也分别对应为DWORD   m_dwTest和DWORD   m_dwAct.  
    “退出”按钮的ID为IDOK,“开始测试”按按钮ID为IDC_B_TEST,用MFC  
    ClassWizard添加此按纽的单击消息处理函数如下:
     

     

       1: void   CHightTimerDlg::OnBTest()    
       2: {  
       3:     //   TODO:   Add   your   control   notification   handler   code   here  
       4:     UpdateData(TRUE);   //取输入的测试时间值到与编辑框相关联的成员变量m_dwTest中  
       5:     LARGE_INTEGER   frequence;//LARGE_INTEGER是一个联合,其中LOWPART为低32位,HIGHPART为高32位,  
       6:     //两者构成一个结构,而QuadPart是其中的64位符号整数,为LongLong类型  
       7:     if(!QueryPerformanceFrequency( &frequence))   //取高精度运行计数器的频率,若硬件不支持则返回FALSE  
       8:         MessageBox("Your computer hardware doesn't support the high-resolution performance counter",  
       9:             "Not Support",   MB_ICONEXCLAMATION | MB_OK);    
      10:     LARGE_INTEGER test, ret;  
      11:     test.QuadPart = frequence.QuadPart * m_dwTest / 1000000;  
      12:     //通过频率换算微秒数到对应的数量(与CPU时钟有关),1秒=1000000微秒  
      13:     //test   中存储着m_dwTest毫秒所需的次数  
      14:     ret = MySleep( test );   //调用此函数开始延时,返回实际花销的数量  
      15:     m_dwAct = (DWORD)(1000000 * ret.QuadPart / frequence.QuadPart );   //换算到微秒数  
      16:     UpdateData(FALSE);   //显示到对话框面板  
      17: }   
       1: LARGE_INTEGER   CHightTimerDlg::MySleep(LARGE_INTEGER   Interval)  
       2: ///  
       3: //  
       4: //   功能:执行实际的延时功能  
       5: //   参数:Interval   参数为需要执行的延时与时间有关的数量  
       6: //   返回值:返回此函数执行后实际所用的时间有关的数量  
       7: ///  
       8:   
       9: {  
      10:     LARGE_INTEGER   privious,   current,   Elapse;  
      11:     QueryPerformanceCounter(   &privious   );  
      12:     current = privious;  
      13:     while( current.QuadPart - privious.QuadPart < Interval.QuadPart )  
      14:     QueryPerformanceCounter( &t );  
      15:     Elapse.QuadPart = current.QuadPart - privious.QuadPart;  
      16:     return   Elapse;  
      17: }   

    注:别忘了在头文件中为此函数添加函数声明。  
    至此,可以编译和执行此工程了,当测试时间超过3微秒时,准确度已经非常高了,此时机器执行本身延时函数代码的时间对需要延时的时间影响很小了。  
    上面的函数由于演示测试的需要,没有在函数级封装,下面给出的函数基本上可以以全局函数的形式照搬到别的程序中。
      

       1: BOOL   MySleep(DWORD   dwInterval)  
       2: ///  
       3: //  
       4: //   功能:执行微秒级的延时功能  
       5: //   参数:Interval   参数为需要的延时数(单位:微秒)  
       6: //   返回值:若计算机硬件不支持此功能,返回FALSE,若函数执行成功,返回TRUE  
       7: ///  
       8:   
       9: {  
      10:     BOOL bNormal = TRUE;  
      11:     LARGE_INTEGER   frequence,   privious,   current,   interval;  
      12:     if(!QueryPerformanceFrequency(   &frequence))  
      13:     {  
      14:         ::MessageBox(NULL,   "Your   computer   hardware   doesn't   support   the   high-resolution   performance  
      15:             counter",  "Not   Support",   MB_ICONEXCLAMATION   |   MB_OK);   //或其它的提示信息  
      16:         return FALSE;  
      17:     }  
      18:     interval.QuadPart = frequence.QuadPart * dwInterval / 1000000;  
      19:     bNormal = bNormal && QueryPerformanceCounter( &privious );  
      20:     current = privious;  
      21:    while( current.QuadPart - privious.QuadPart < interval.QuadPart )  
      22:     bNormal = bNormal && QueryPerformanceCounter( &t );  
      23:     return bNormal;  
      24: }   

    需要指出的是,由于在此函数中的代码很多,机器在执行这些代码所花费的时间也很长,所以在需要几个微秒的  
    延时时,会影响精度。实际上,读者在熟悉这种方法后,只要使用QueryPerformanceFrequency和QueryPerforman  
    ceCounter这两个函数就能按实际需要写出自己的延时代码了。
     

    一个计算时间的类:

       1: //   Elapsed.h:   interface   for   the   CElapsed   class.  
       2: //  
       3: //  
       4:    
       5: #if   !defined(AFX_ELAPSED_H__4A992E21_8B47_11D6_B1B2_FFFCE130B010__INCLUDED_)  
       6: #define   AFX_ELAPSED_H__4A992E21_8B47_11D6_B1B2_FFFCE130B010__INCLUDED_  
       7:    
       8: #if   _MSC_VER   >   1000  
       9: #pragma   once  
      10: #endif   //   _MSC_VER   >   1000  
      11:    
      12: class   CElapsed      
      13: {  
      14: private:  
      15:    int Initialized;  
      16:    __int64 Frequency;  
      17:    __int64 BeginTime;  
      18:    
      19: public:  
      20:    BOOL   Avaliable();  
      21:    double   End();  
      22:    BOOL   Begin();  
      23:    CElapsed();  
      24:    virtual   ~CElapsed();    
      25: };  
      26:    
      27: #endif   //   !defined(AFX_ELAPSED_H__4A992E21_8B47_11D6_B1B2_FFFCE130B010__INCLUDED_)  
      28:    
      29:    
      30:    
      31: //   Elapsed.cpp:   implementation   of   the   CElapsed   class.  
      32: //  
      33: //  
      34:    
      35: #include   "stdafx.h"  
      36: //#include   "myimage.h"  
      37: #include   "Elapsed.h"  
      38:    
      39: #ifdef   _DEBUG  
      40: #undef   THIS_FILE  
      41: static   char   THIS_FILE[]=__FILE__;  
      42: #define   new   DEBUG_NEW  
      43: #endif  
      44:    
      45: //  
      46: //   Construction/Destruction  
      47: //  
      48:    
      49: CElapsed::CElapsed()  
      50: {  
      51:    Initialized=QueryPerformanceFrequency((LARGE_INTEGER   *)&Frequency);  
      52: }  
      53:    
      54: CElapsed::~CElapsed()  
      55: {  
      56:    
      57: }  
      58:    
      59: BOOL   CElapsed::Begin()  
      60: {  
      61:    if(!Initialized)  
      62:     return 0;
      63:    return   QueryPerformanceCounter((LARGE_INTEGER   *)&BeginTime);  
      64: }
      65:     
      66: double   CElapsed::End()
      67: {  
      68:    if(!Initialized)  
      69:     return 0;
      70:    __int64   endtime;  
      71:    QueryPerformanceCounter((LARGE_INTEGER   *)&endtime);  
      72:    
      73:    __int64   elapsed=endtime-BeginTime;  
      74:    
      75:    return   (double)elapsed/(double)Frequency;  
      76: }    
      77: BOOL   CElapsed::Avaliable()
      78: {  
      79:    return Initialized;  
      80: }   
    展开全文
  • 多核计算程序设计-周伟明 电子书(高清+可编辑)+源代码
  • 栈的理解以及如何计算程序所需栈的大小并在IAR中设置栈

    转自:http://www.cnblogs.com/harleygwak1206/p/5856562.html

    #栈的理解

    一个程序大体上讲都是由变量和函数组合而成,变量有全局变量和局部变量,还有函数间传值的参数以及返回值。

    Stack是为了程序运行过程中临时保存所需数据而在内存里分配的一小块空间。保存的数据类型一般情况下包括以下几种:

    1. 函数中声明的局部变量以及参数

    2. 函数返回值

    3. 中断时CPU 寄存器值

    4. 函数运行后返回的地址

    比方说下面的例子,函数里声明的局部变量保存在stack里面,在该函数中调用其他函数的时候其他函数中的局部变量也会添加到stack里保存。


    从IAR编译器里确定Stack。

    在IAR编译器里通过使用Stack Windows来确认stack的使用量和stack中保存的值。(View->Stack->Stack Window)

    用Bar Graph形式来查看stack的话stack中的数据和地址等信息都能查看的到。


    * 上面为了确定stack最大使用量,通过菜单Tools->Options->Stack中的 Enable graphical stack display and stack usage tracking 选项来检查。

    #如何设定stack大小

    Stack的大小是由开发者直接设置,编译时由编译器分配空间。

    Stack大小分配不足的话保存的变量要么overwrite,要么程序异常终止。相反,如果空间分配太大又浪费。

    所以程序里要需要多大的stack空间必须准确的计算把握。

    在IAR Compiler里提供了预测stack大小的stack使用量分析功能(stack usage analysis)。

    (Project Option -> Linker -> Advanced -> Enable stack usage analysis)


    stack使用量在map文件里可以查看得到,前提是你要打开生成map文件的功能,如下:


    编译程序后,map文件在project output文件夹下


    打开map文件可以看到stack usage情况,如下:


    程序里使用最大的stack大小为108bytes,中断使用的stack大小为40bytes和16bytes。 所以程序里要设置比108+400+16大的stack空间才型。

    CSTACK Size >= maxstack("Program entry") + totalstack("interrupt") + safety margin(100);

    类似上面情况 需要分配108 + 40 + 16 + 100 = 264Byte 的stack空间。

    #设置stack大小

    程序需要的stack大小前面已经计算出来了,那么怎么设置呢?

    如下图,在项目的Linker选项里设置。

    Linker的 Config选项卡里点击Edit变更设置。


    Stack/Heap Sizes选项卡里变更CSTACK的大小.


    或者是用文本编辑器打开icf文件直接修改stack大小,如下图


    展开全文
  • 直线__缓和曲线_圆曲线坐标计算EXCEL程序 超级实用 输入主要元素既可以计算
  • 编写计算阶乘的程序

    千次阅读 2020-10-13 21:20:57
    计算阶乘的程序片段如下: int fact=1; for(int i=1;i<n;i++) { fact=fact*i; } 其中的整数n由editText1控件中输入的字符串并通过使用Interger类中的parselnt()函数转换而来。 int n=Integer.parseInt...

    计算阶乘的程序片段如下:

    int fact=1;
            for(int i=1;i<n;i++)
            {
                fact=fact*i;
            }
    

    其中的整数n由editText1控件中输入的字符串并通过使用Interger类中的parselnt()函数转换而来。
    int n=Integer.parseInt(editText1.getText().toString());
    fact变量保存好后的阶乘计算结果,最后显示到textView控件中。
    textView1.setText(""+fact);

    程序代码:

    布局文件的内容如下:

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:app="http://schemas.android.com/apk/res-auto"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:id="@+id/LinearLayout1"
        android:orientation="vertical"
        tools:context=".MainActivity"
        >
    
        <EditText
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:id="@+id/editText1"
            android:ems="10"
            android:hint="请输入一个整数"
            android:text="">
            <requestFocus/>
        </EditText>
        <Button
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:id="@+id/button1"
            android:onClick="calc"
            android:text="计算阶乘" />
        <TextView
            android:layout_width="match_parent"
            android:layout_height="match_parent"
            android:id="@+id/textView1"
            android:text=""
            android:textAlignment="center" />
    </LinearLayout>
    

    活动源程序文件的内容如下:

    package com.example.test01;
    
    import androidx.appcompat.app.AppCompatActivity;
    
    import android.os.Bundle;
    import android.app.Activity;
    import android.view.View;
    import android.widget.EditText;
    import android.widget.TextView;
    
    public class MainActivity extends AppCompatActivity {
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
        }
        public void calc(View view){
            EditText editText1=(EditText)this.findViewById(R.id.editText1);
            TextView textView1=(TextView)this.findViewById(R.id.textView1);
            int n=Integer.parseInt(editText1.getText().toString());
            int fact=1;
            for(int i=1;i<n;i++){
                fact=fact*i;
            }
            textView1.setText(""+fact);
        }
    }
    

    实验结果:

    在这里插入图片描述

    程序的初始运行结果和输出12进行阶乘计算的结果:

    在这里插入图片描述
    程序的初始运行结果和输出10进行阶乘计算的结果:
    在这里插入图片描述

    展开全文
  • 用于创建此对象的程序是 ...在Word中打开公式编辑器mathtype时出现:“用于创建此对象的程序是 Equation。您的计算机尚未安装此程序或此程序无响应。若要编辑此对象,请安装 Equation或确保 Equation中的任何对话框...

    用于创建此对象的程序是 Equation。您的计算机尚未安装此程序或此程序无响应。 若要编辑此对象,请安装 Equation或确保 Equation中的任何对话框都已关闭


    一、问题描述

    在Word中打开公式编辑器mathtype时出现:“用于创建此对象的程序是 Equation。您的计算机尚未安装此程序或此程序无响应。若要编辑此对象,请安装 Equation或确保 Equation中的任何对话框都已关闭”
    点击确定以后依然无法正常使用。
    在这里插入图片描述在这里插入图片描述

    二、解决方法

    删除最近新安装的字体,原因是字体有冲突
    在这里插入图片描述

    三、效果

    mathtype成功打开

    四、其他问题

    • mathtype提示
      MathType requires a newer version of the MT Extra(True Type)
      font than is currently installed Please reinstall MathType(using your CD or downloaded installer)to obtain the correct fonts
    • 解决方法
      打开mathtype安装路径下的 font 文件夹,复制里面的字体到以下路径
      C:\Windows\Fonts
      在这里插入图片描述

    参考资料

    展开全文
  • Python如何计算编辑距离?

    千次阅读 2019-01-19 16:27:00
    计算文本的相似性时,经常会用到编辑距离。编辑距离,又称Levenshtein距离,是指两个字串之间,由一个转成另一个所需的最少编辑操作次数。通常来说,编辑距离越小,两个文本的相似性越大。这里的编辑操作主要包括...
  • 零基础入门微信小程序开发

    万次阅读 多人点赞 2018-07-03 02:45:07
    本课程是一个系列入门教程,目标是从 0 开始带领读者上手实战,课程以微信小程序的核心概念作为主线,介绍配置文件、页面样式文件、JavaScript 的基本知识并以指南针为例对基本知识进行扩展,另外加上开发工具的安装...
  • 用于创建此对象的程序是package 您的计算机尚未安装此程序,需要在C:\WINDOWS\system32放入 package.exe
  • 假设给定两个字符串str1和str2,如果我们想把str1变为str2,这一过程中所需的最少的插入、删除和替换等基本操作的个数称为str1与str2之间的编辑距离。比如如果想把字符串abandon变为aband最好的方案是删除on这两个...
  • 1.获得用户输入的一个整数N,计算并输出N的32次方。 2.获得用户输入的一段文字,将这段文字进行垂直输出。 3.获得用户输入的一个合法算式,例如1.2+3.4,输出运算结果。 4.获得用户输入的一个小数,提取并输出其...
  • 文章目录程序填空题题目...程序中,函数fun的功能是:计算形参x所指数组中N个数的平均值(规定所有数均为正数),将所指数组中大于平均值的 数据移至数组的前部,小于等于平均值的数据移至x所指数组的后部,平均值作为...
  • 一、简介:此程序主要是实现一个计算学生平均成绩的
  • 想做一个微信计算运势和命理的程序,请问在使用visual studi环境中,如何构一个这种程序,又怎么通过微信二维码收费?
  • 教材《模式识别与智能计算MATLAB版》(杨淑莹)中的源程序,文件格式为*.m,一行一行敲入的,可以编辑和复用,不是教材光盘中的*.p文件。
  • 计算圆面积和周长小程序 希望对大家有用。 #include <stdio.h> #define pi 3.14159 main() { int i; double r; printf(“请输入半径:”); scanf("%lf",&r);//这里是Lf不是1f printf(“选择计算结果,1周长...
  • 进入vi编辑器后 按i进入插入模式,可以开始编辑 ...使用vi编辑器编写c语言程序并用gcc工具箱编译 1、touch test.c创建空文件test.c 2、vi test.c编辑文件,在里面写c语言代码 3、写完后保存并退出 4、gcc test.c ...
  • 什么是计算机能直接执行的程序

    千次阅读 2014-03-17 11:37:15
    程序运行时,指令由内存读入cpu,然后译码,执行.只有内存中的机器码,即机器语言程序,计算机才能执行.然而,.机器码很难记忆,使用时极易出错,因此,直接利用机器码编制程序是极其困难又枯燥乏味的工作.编程的程序,...
  • 代码注释很容易理解 <!-- 最外层视图pages --> <view class="pages"> <view wx:if="{{hasList}}"&...-- 编辑 --> <view class='edit'> <label class='edit_btn' bindtap...
  • C语言程序及设计初步——周长及面积计算一、目的计算长方形的周长和面积程序代码如下:/* *copyright(c)2018,CSDN学院 *All rights reserved. *文件名称:周长及面积 *作 者:刘杰 *完成日期:2018年5月16日 *版 本 ...
  • 写一个计算圆面积的小程序

    千次阅读 2016-10-29 19:04:27
    安装autoIt,输入代码,并编译成新的可执行文件 代码: Dim $pi=3.1415926 Dim $r,$s $r=InputBox("圆的面积计算","请输入圆的半径:") If @error=1 Then Exit ...MsgBox(0,"圆的面积计算",Round($s,2))
  • ABB机器人的ProgramEditor(程序编辑器)我想大家应该都不陌生吧。它可以称得上是我们在ABB示教器中使用的最多的一个功能了。它集成rapid程序的创建、修改、调试于一身。在程序编辑器的调试菜单中: “pp移至main”...
  • 计算最少钱币数C++程序代码。

    千次阅读 2014-02-28 10:37:30
    你的任务就是,给定若干个互不相同的钱币面值,编程计算,最少需要多少个钱币才能凑 成某个给出的钱数。 【要求】  每个测试用例的第一行是待凑的钱数值 M(1 【数据输入】 输入可以有多个测试用例。 ,整数...
  • 无法启动此程序,因为计算机丢失Qt5Core.dll。"等dll丢失问题 一、简述  将QtCreate编译生成的exe文件拷贝到其它目录或主机,出现以下问题: 类似"无法启动此程序,因为计算机丢失Qt5Core.dll。尝试...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 411,322
精华内容 164,528
关键字:

如何编辑计算程序