g语言代码
㈠ G语言 图形
G 语言 太专业了 是不是c语言
㈡ C语言代码翻译
好像很厉害的一段代码，这是在做视图压缩啊还是矩阵加密啊？只是能不能用code的样式贴出来啊？实在没法看啊。。
我尝试着调整一下格式，仍发现好像源码错漏了{符号，真头大。
#include "stdlib.h"
#include "rinv.c"
int lman (n, m, k, f, q, r, h, y, x, p, g)
int n, m, k;
double f[], q[], r[], h[], y[], x[], p[], g[];
{
int i, j, kk, ii, l, jj, js;
double *e, *a, *b;
l = max(m, n);
e = malloc(m * m * sizeof(double));
a = malloc(l * l * sizeof(double));
b = malloc(l * l * sizeof(double));
/// 行列式 二维double 数组l*l足够大，填充n*n对象
for (i = 0; i <= n - 1; i++)
{
for (j = 0; j <= n - 1; j++)
{
ii = i * l + j;
a[ii] = 0.0;
for (kk = 0; kk <= n - 1; kk++)
{
/// p 数据横向遍历一行， f 数据纵向遍历一列
/// p 与 f 对应的横列元素分别相乘后相加
a[ii] += p[i * n + kk] * f[j * n + kk];
}
}
}
for (i = 0; i <= n - 1; i++)
{
for (j = 0; j <= n - 1; j++)
{
ii = i * n + j;
p[ii] = q[ii]; ///将q数组中n*n对象拷入p数组中初始化
for (kk = 0; kk <= n - 1; kk++)
{
p[ii] += f[i * n + kk] * a[kk * l + j];
}
}
}
for (ii = 2; ii <= k; ii++)
{
for (i = 0; i <= n - 1; i++)
{
for (j = 0; j <= m - 1; j++)
{
jj = i * l + j;
a[jj] = 0.0;
for (kk = 0; kk <= n - 1; kk++)
{
a[jj] = a[jj] + p[i * n + kk] * h[j * n + kk];
}
}
}
for (i = 0; i <= m - 1; i++)
{
for (j = 0; j <= m - 1; j++)
{
jj = i * m + j;
e[jj] = r[jj];
for (kk = 0; kk <= n - 1; kk++)
{
e[jj] = e[jj] + h[i * n + kk] * a[kk * l + j];
}
}
}
js = rinv(e, m);
if (js == 0)
{
free(e);
free(a);
free(b);
return (js);
}
for (i = 0; i <= n - 1; i++)
{
for (j = 0; j <= m - 1; j++)
{
jj = i * m + j;
g[jj] = 0.0;
for (kk = 0; kk <= m - 1; kk++)
{
g[jj] = g[jj] + a[i * l + kk] * e[j * m + kk];
}
}
}
for (i = 0; i <= n - 1; i++)
{
jj = (ii - 1) * n + i;
x[jj] = 0.0;
for (j = 0; j <= n - 1; j++)
{
x[jj] = x[jj] + f[i * n + j] * x[(ii - 2) * n + j];
}
}
for (i = 0; i <= m - 1; i++)
{
jj = i * l;
b[jj] = y[(ii - 1) * m + i];
for (j = 0; j <= n - 1; j++)
{
b[jj] = b[jj] - h[i * n + j] * x[(ii - 1) * n + j];
}
}
for (i = 0; i <= n - 1; i++)
{
jj = (ii - 1) * n + i;
for (j = 0; j <= m - 1; j++)
{
x[jj] = x[jj] + g[i * m + j] * b[j * l];
}
}
if (ii < k)
{
for (i = 0; i <= n - 1; i++)
{
for (j = 0; j <= n - 1; j++)
{
for (kk = 0; kk <= m - 1; kk++)
{
a[jj] = a[jj] - g[i * m + kk] * h[kk * n + j];
}
}
}
if (i == j)
{
a[jj] = 1.0 + a[jj];
}
}
for (i = 0; i <= n - 1; i++)
{
for (j = 0; j <= n - 1; j++)
{
jj = i * l + j;
b[jj] = 0.0;
for (kk = 0; kk <= n - 1; kk++)
{
b[jj] = b[jj] + a[i * l + kk] * p[kk * n + j];
}
}
}
for (i = 0; i <= n - 1; i++)
{
for (j = 0; j <= n - 1; j++)
{
jj = i * l + j;
a[jj] = 0.0;
for (kk = 0; kk <= n - 1; kk++)
{
a[jj] = a[jj] + b[i * l + kk] * f[j * n + kk];
}
}
}
for (i = 0; i <= n - 1; i++)
{
for (j = 0; j <= n - 1; j++)
{
jj = i * n + j;
p[jj] = q[jj];
for (kk = 0; kk <= n - 1; kk++)
{
p[jj] = p[jj] + f[i * n + kk] * a[j * l + kk];
}
}
}
}
}
free(e);
free(a);
free(b);
return (js);
}
㈢ 全部G代码并分类
1. 灵活设置参考点
BIEJING-FANUC Power Mate O数控车床共有二根轴，即主轴Z和刀具轴X。棒料中心为坐标系原点，各刀接近棒料时，坐标值减小，称之为进刀；反之，坐标值增大，称为退刀。当退到刀具开始时位置时，刀具停止，此位置称为参考点。参考点是编程中一个非常重要的概念，每执行完一次自动循环，刀具都必须返回到这个位置，准备下一次循环。因此，在执行程序前，必须调整刀具及主轴的实际位置与坐标数值保持一致。然而，参考点的实际位置并不是固定不变的，编程人员可以根据零件的直径、所用的刀具的种类、数量调整参考点的位置，缩短刀具的空行程。从而提高效率。
2. 化零为整法
在低压电器中，存在大量的短销轴类零件，其长径比大约为2~3，直径多在3mm以下。由于零件几何尺寸较小，普通仪表车床难以装夹，无法保证质量。如果按照常规方法编程，在每一次循环中只加工一个零件，由于轴向尺寸较短，造成机床主轴滑块在床身导轨局部频繁往复，弹簧夹头夹紧机构动作频繁。长时间工作之后，便会造成机床导轨局部过度磨损，影响机床的加工精度，严重的甚至会造成机床报废。而弹簧夹头夹紧机构的频繁动作，则会导致控制电器的损坏。要解决以上问题，必须加大主轴送进长度和弹簧夹头夹紧机构的动作间隔，同时不能降低生产率。由此设想是否可以在一次加工循环中加工数个零件，则主轴送进长度为单件零件长度的数倍 ，甚至可达主轴最大运行距离，而弹簧夹头夹紧机构的动作时间间隔相应延长为原来的数倍。更重要的是，原来单件零件的辅助时间分摊在数个零件上，每个零件的辅助时间大为缩短，从而提高了生产效率。为了实现这一设想，我联想到电脑程序设计中主程序和子程序的概念，如果将涉及零件几何尺寸的命令字段放在一个子程序中，而将有关机床控制的命令字段及切断零件的命令字段放在主程序中，每加工一个零件时，由主程序通过调用子程序命令调用一次子程序，加工完成后，跳转回主程序。需要加工几个零件便调用几次子程序，十分有利于增减每次循环加工零件的数目。通过这种方式编制的加工程序也比较简洁明了，便于修改、维护。值得注意的是，由于子程序的各项参数在每次调用中都保持不变，而主轴的坐标时刻在变化，为与主程序相适应，在子程序中必须采用相对编程语句。
3. 减少刀具空行程
在BIEJING-FANUC Power Mate O数控车床中，刀具的运动是依靠步进电动机来带动的，尽管在程序命令中有快速点定位命令G00，但与普通车床的进给方式相比，依然显得效率不高。因此，要想提高机床效率，必须提高刀具的运行效率。刀具的空行程是指刀具接近工件和切削完毕后退回参考点所运行的距离。只要减少刀具空行程，就可以提高刀具的运行效率。（对于点位控制的数控车床，只要求定位精度较高，定位过程可尽可能快，而刀具相对工件的运动路线是无关紧要的。）在机床调整方面，要将刀具的初始位置安排在尽可能靠近棒料的地方。在程序方面，要根据零件的结构，使用尽可能少的刀具加工零件使刀具在安装时彼此尽可能分散，在很接近棒料时彼此就不会发生干涉；另一方面，由于刀具实际的初始位置已经与原来发生了变化，必须在程序中对刀具的参考点位置进行修改，使之与实际情况相符，与此同时再配合快速点定位命令，就可以将刀具的空行程控制在最小范围内从而提高机床加工效率。
4. 优化参数，平衡刀具负荷，减少刀具磨损
由于零件结构的千变万化，有可能导致刀具切削负荷的不平衡。而由于自身几何形状的差异导致不同刀具在刚度、强度方面存在较大差异，例如：正外圆刀与切断刀之间，正外圆刀与反外圆刀之间。如果在编程时不考虑这些差异。用强度、刚度弱的刀具承受较大的切削载荷，就会导致刀具的非正常磨损甚至损坏，而零件的加工质量达不到要求。因此编程时必须分析零件结构，用强度、刚度较高的刀具承受较大的切削载荷，用强度、刚度小的刀具承受较小的切削载荷，使不同的刀具都可以采用合理的切削用量，具有大体相近的寿命，减少磨刀及更换刀具的次数。
本文总结的一些具体结论仅适用于BIEJING- FANUC Power Mate O数控车床，但是它表现的编程思想具有普遍意义。要编制合理高效的加工程序，必须要熟悉所使用机床的程序语言并能加以灵活运用，了解机床的主参数，深入分析零件的结构特点、材料特性及加工工艺等。
BIEJING-FANUC Power Mate O数控车床指令包括G、M、S、T。其中指令为准备功能指令，M指令为辅助功能指令，S为主轴转速控制指令，T为刀具选择指令。下表列出了部分常用的指令代码及含义。
代码符号 代码含义 代码符号 代码含义
G90 绝对值输入 G31 等导程螺纹切削
G91 相对值输入 G32 跳步功能
G00 快速点定位 M02、M03 程序结束
G01 直线插补 M00 程序停机
G02、G03 顺圆和逆圆插补 M01 选择停机
G28 自动返回参考点 M98 调用子程序
G04 暂停 M99 子程序结束
--------------------------------------------------------------------以上是本人在网上搜到的，非原创，只希望对您有帮助。
㈣ C语言代码
看你的代码，应该是想通过使用12个for循环嵌套来实现，但是这种方式效率是比较低的，13的12次方有23298085122481种方案，短时间内是看不到电脑的运行结果的。
所以我采用了另一种方法，最终算得的结果是64种方案。
#include<stdio.h>
#include"LinkedList.h"
intis_unique(int*array,intvalue,intlen)
{
inti=0,j=0;
for(i=0;i<len-1;i++)
{
for(j=i+1;j<len;j++)
{
if(array[i]==array[j])
return0;
}
}
return1;
}
intmain()
{
inti=0,j=0,m=0,n=0,k=0;
intcount[4]={0};
inttmp=0;
DataTypevalue;
inta[12]={0};//用于存放临时组合的数据
intmax_num=0;//加减乘除四种运算中,符合条件的方案数量最少的个数
LinkedList_stru*list_array[4];
LinkedList_stru*list_tmp;
LinkNode_stru*p1,*p2,*p3,*p4;
intflag=0;
inttotal=0;
/*定义链表指针，用于存放创建的链表首地址*/
LinkedList_stru*list_addition=NULL,*list_subtraction=NULL;
LinkedList_stru*list_multiplication=NULL,*list_division=NULL;
printf(" 开始玩命分析......... ");
/*分析：总共有+,-,*,÷四种运算,而且运算结果需要在1~13之间。
*所以,我们可以先把这些所有符合条件的结果求出来.
**/
/*创建链表*/
list_addition=LinkedList_Create();//+
list_subtraction=LinkedList_Create();//-
list_multiplication=LinkedList_Create();//×
list_division=LinkedList_Create();//÷
/*1.求出+运算所有符合要求的方案*/
count[0]=0;
for(i=1;i<=13;i++)
{
for(j=1;j<=13;j++)
{
tmp=i+j;
if(tmp<=13)
{
if(i==j||j==tmp||i==tmp)
{
continue;
}
else
{
value.a1=i;
value.a2=j;
value.a3=tmp;
LinkedList_Add_Tail(list_addition,value);
count[0]++;
//printf("%2d+%2d=%2d ",i,j,(i+j));
}
}
}
}
//printf("计算完毕,+运算符合条件的结果总共有%d种! ",count[0]);
/*2.求出-运算所有符合要求的方案*/
count[1]=0;
for(i=1;i<=13;i++)
{
for(j=1;j<=13;j++)
{
tmp=i-j;
if(tmp>0&&tmp<=13)
{
if(i==j||j==tmp||i==tmp)
{
continue;
}
value.a1=i;
value.a2=j;
value.a3=tmp;
LinkedList_Add_Tail(list_subtraction,value);
count[1]++;
//printf("%2d-%2d=%2d ",i,j,(i-j));
}
}
}
//printf("计算完毕,-运算符合条件的结果总共有%d种! ",count[1]);
/*3.求出×运算所有符合要求的方案*/
count[2]=0;
for(i=1;i<=13;i++)
{
for(j=1;j<=13;j++)
{
tmp=i*j;
if(tmp>0&&tmp<=13)
{
if(i==j||j==tmp||i==tmp)
{
continue;
}
value.a1=i;
value.a2=j;
value.a3=tmp;
LinkedList_Add_Tail(list_multiplication,value);
count[2]++;
//printf("%2d×%2d=%2d ",i,j,(i*j));
}
}
}
//printf("计算完毕,+运算符合条件的结果总共有%d种! ",count[2]);
/*4.求出÷运算所有符合要求的方案*/
count[3]=0;
for(i=1;i<=13;i++)
{
for(j=1;j<=13;j++)
{
tmp=i%j;
if(tmp==0)
{
if(i==j||j==(i/j)||i==(i/j))
{
continue;
}
value.a1=i;
value.a2=j;
value.a3=(i/j);
LinkedList_Add_Tail(list_division,value);
count[3]++;
//printf("%2d÷%2d=%2d ",i,j,(i/j));
}
}
}
//printf("计算完毕,÷运算符合条件的结果总共有%d种! ",count[3]);
printf("list_addition:clen=%d! ",list_addition->clen);
printf("list_subtraction:clen=%d! ",list_subtraction->clen);
printf("list_multiplication:clen=%d! ",list_multiplication->clen);
printf("list_division:clen=%d! ",list_division->clen);
list_array[0]=list_addition;
list_array[1]=list_subtraction;
list_array[2]=list_multiplication;
list_array[3]=list_division;
max_num=list_array[0]->clen;
for(i=0;i<4;i++)
{
if(max_num>=list_array[i]->clen)
{
max_num=list_array[i]->clen;
//list_tmp=num[i];
}
}
//printf("最多只能有%d种方案! ",max_num);
/*从上面的计算结果我们可以知道,最多只能有10种方案,因为乘法和除法这两种运算均只有10种方案符合条件
*所以,这里我们就基于除法去做匹配.按理说不应该这么做的,应该在代码中进行判断,但是为了节省时间,只能这样了。
**/
/*遍历链表*/
p4=list_division->pHead->pNext;
for(i=0;i<list_division->clen;i++)
{
p3=list_multiplication->pHead->pNext;
for(j=0;j<list_multiplication->clen;j++)
{
p2=list_subtraction->pHead->pNext;
for(m=0;m<list_subtraction->clen;m++)
{
p1=list_addition->pHead->pNext;
for(n=0;n<list_addition->clen;n++)
{
flag=111;
a[0]=p1->data.a1;a[1]=p1->data.a2;a[2]=p1->data.a3;
a[3]=p2->data.a1;a[4]=p2->data.a2;a[5]=p2->data.a3;
a[6]=p3->data.a1;a[7]=p3->data.a2;a[8]=p3->data.a3;
a[9]=p4->data.a1;a[10]=p4->data.a2;a[11]=p4->data.a3;
for(k=0;k<sizeof(a)/sizeof(a[0]);k++)
{
if(!is_unique(a,a[k],sizeof(a)/sizeof(a[0])))
{
flag=0;
break;
}
}
if(flag==111)
{
//printf(" ");
total++;
printf("方案%d: ",total);
printf("%2d+%2d=%2d ",a[0],a[1],a[2]);
printf("%2d-%2d=%2d ",a[3],a[4],a[5]);
printf("%2d×%2d=%2d ",a[6],a[7],a[8]);
printf("%2d÷%2d=%2d ",a[9],a[10],a[11]);
printf(" ");
}
p1=p1->pNext;
}
p2=p2->pNext;
}
p3=p3->pNext;
}
p4=p4->pNext;
}
printf("计算完毕,总共有%d种方案! ",total);
return0;
}
㈤ g代码是什么
G代码是数控程序中的指令，一般都称为G指令。
G代码（G-code，又称RS-274）是最为广泛使用的数控（numerical control）编程语言，有多个版本，主要在计算机辅助制造中用于控制自动机床。
G代码有时候也称为G编程语言。使用G代码可以实现快速定位、逆圆插补、顺圆插补、中间点圆弧插补、半径编程、跳转加工。
(5)g语言代码扩展阅读
G代码及其功能——
G00------快速定位
G01------直线插补
G02------顺时针方向圆弧插补
G03------逆时针方向圆弧插补
G04------定时暂停
G05------通过中间点圆弧插补
G06------抛物线插补
G07------Z 样条曲线插补
㈥ c语言printf中%g的含义是什么代码如下
转换来说明及作为结果的打印源输出％a 浮点数、十六进制数字和p-记数法（C99）
%A 浮点数、十六进制数字和p-记法（C99）
%c 一个字符
%d 有符号十进制整数
%e 浮点数、e-记数法
%E 浮点数、E-记数法
%f 浮点数、十进制记数法
%g 根据数值不同自动选择％f或％e．
%G 根据数值不同自动选择％f或％e.
%i 有符号十进制数（与％d相同）
%o 无符号八进制整数
%p 指针
%s 字符串
%u 无符号十进制整数
%x 使用十六进制数字0f的无符号十六进制整数
%X 使用十六进制数字0f的无符号十六进制整数
%% 打印一个百分号 使用printf ()函数 printf()的基本形式： printf("格式控制字符串"，变量列表);
㈦ 数控G代码的由来 光知道用 不知道怎么来的。
这是科学家们做的事。普通人会用就行了。就像许多程序是由专C语言编出来的，你属非要问C语言是怎么来的。
这里涉及到高级语言和机器语言转换识别的问题。一般人说不清。而且大部分人知道了也没用。就算告诉你G01的机器是多少个0多个 1，你说你有用么？
㈧ c语言编程代码
两种方法我写在一起，可以独立拆开。
#include <stdio.h>
void finda1(char a[3][10]);
void finda2(char a[3][10]);
void show(char (*p)[10]);
int main()
{
char a[3][10]={{"gehajl"},{"788a987a7"},{"ccabbbabbb"}};
printf("原数组内容: ");
show(a);
printf(" 1、用数组指针的方法（函数）： ");
finda1(a);
printf("执行后: ");
show(a);
printf(" --------------------- ");
char b[3][10]={{"gehajl"},{"788a987a7"},{"ccabbbabbb"}};
printf("原数组内容: ");
show(a);
printf(" 2、用指针数组的方法（函数finda2）： ");
finda2(b);
printf("执行后: ");
show(b);
return 0;
}
void finda1(char a[3][10])
{
int i,j;
char (*p)[10]=a;
for(i=0;i<3;i++)
for(j=0;j<10;j++)
if(p[i][j]=='a')
printf("发现：第%d行第%d个元素是‘a’，已替换 ",i+1,j+1),p[i][j]='1';
}
void finda2(char a[3][10])
{
int i,j;
char *p[3]={&a[0][0],&a[1][0],&a[2][0]};
for(i=0;i<3;i++)
for(j=0;j<10;j++)
if(p[i][j]=='a')
printf("发现：第%d行第%d个元素是‘a’，已替换 ",i+1,j+1),p[i][j]='1';
}
void show(char (*p)[10])
{
int i,j;
for(i=0;i<3;i++,printf(" "))
for(j=0;j<10;j++)
printf("%c ",p[i][j]);
}