canye1984

用C#写一个机器人基础知识类

1.工业机器人

运动学

1.DH参数

2.自由度

3.坐标系

4.坐标系转换

5.正算与反算

6.雅可比矩阵

7.轨迹规划

8.Blend算法

9.速度，加速度，位置

动力学

1.负载

2.力反馈

3.柔性

4.刚性

控制理论

1.boxcar

2.反馈模型

硬件

1.马达

2.编码器

3.减速器

4.驱动

5.控制器

6.电源

7.连接部件

通讯

1.ftp

2.soap

3.socket

4.profit bus

5.can

6.tcp

7.modbus

系统

vxwork系统

    /// 
    /// 根据给的点获得数据
    /// 

    public class Val3
    {
        #region 公共变量
        /// 
        /// 产品Frame
        /// 
        public static double[] RecipeFrame = new double[6];
        /// 
        ///产品偏移
        /// 
        public static double[] RecipeOffset = new double[6];
        /// 
        /// 工具信息
        /// 
        public static double[] Tool = new double[6];

        /// 
        /// 路径FRAME
        /// 
        public static double[] TrajFrame = new double[6];
        /// 
        /// 路径偏移
        /// 
        public static double[] TrajOffset = new double[6];
        /// 
        /// 圆的直径
        /// 
        public static double TrajDiameter = 0;

        public static double Blend = 0;

        public static double RecipeSpeed = 0;

        public static double TrajSpeed = 0;


        //

        public static double[][] Point;

        public static double[][] SaftyPoint;

        public static double[][] BeforePoint;

        public static double[][] AfterPoint;

        public static double[][] BeforeSpeed;

        public static double[][] SaftySpeed;

        public static double[,] DH;
        public static double[,] DH160L = new double[,] { { 150, 825, 0,  0,   0,  0 },
                                                         { 0,    0,  0,  0,   0,  0 }, 
                                                         { 0,    0,  0,  925, 0,  110}, 
                                                         { -90,  0,  90, -90, 90, 0 }, 
                                                         { 0,    0,  0,  0,   0,  0 }, 
                                                         { 0,  -90,  90, 0,   0,  0 }
                                                       };
        //a,0,d.

        #endregion

        #region 公共函数
        public static double[] Joint2Point(double[] Joint, double[,] DH)
        {

            if (!IsJoint(Joint) || DH == null || DH.Length != 36)
            {
                return null;
            }
            double[] Trsf0 = new double[] { 0, 0, 0, 0, 0, Joint[0] + DH[5, 0] };
            double[] Trsf1 = new double[] { DH[0, 0], DH[1, 0], DH[2, 0], DH[3, 0], DH[4, 0], Joint[1] + DH[5, 1] };
            double[] Trsf2 = new double[] { DH[0, 1], DH[1, 1], DH[2, 1], DH[3, 1], DH[4, 1], Joint[2] + DH[5, 2] };
            double[] Trsf3 = new double[] { DH[0, 2], DH[1, 2], DH[2, 2], DH[3, 2], DH[4, 2], Joint[3] + DH[5, 3] };
            double[] Trsf4 = new double[] { DH[0, 3], DH[1, 3], DH[2, 3], DH[3, 3], DH[4, 3], Joint[4] + DH[5, 4] };
            double[] Trsf5 = new double[] { DH[0, 4], DH[1, 4], DH[2, 4], DH[3, 4], DH[4, 4], Joint[5] + DH[5, 5] };
            double[] Trsf6 = new double[] { DH[0, 5], DH[1, 5], DH[2, 5], DH[3, 5], DH[4, 5], 0 };

            double[] Buff = TrsfTrsf(Trsf0, Trsf1);
            Buff = TrsfTrsf(Buff, Trsf2);
            Buff = TrsfTrsf(Buff, Trsf3);
            Buff = TrsfTrsf(Buff, Trsf4);
            Buff = TrsfTrsf(Buff, Trsf5);
            return TrsfTrsf(Buff, Trsf6);

        }

        private static double[] StandardTrsf(double[] Trsf)
        {

            if (Trsf == null || Trsf.Length != 6)
                return null;
            double[] Res = new double[6];
            Res[0] = Trsf[0] / 1000.0;
            Res[1] = Trsf[1] / 1000.0;
            Res[2] = Trsf[2] / 1000.0;


            Res[3] = Trsf[3] / 180.0 * Math.PI;
            Res[4] = Trsf[4] / 180.0 * Math.PI;
            Res[5] = Trsf[5] / 180.0 * Math.PI;

            return Res;

        }
        public static double[] Point2Joint(double[] Trsf, double[,] DH, bool[] Pose)
        {

            if (!IsTrsf(Trsf) || DH == null || DH.Length != 36 || Pose == null || Pose.Length < 3)
            {
                return null;
            }
            double[] Joint = new double[6];
            double[] Trsf0 = new double[] { 0, 0, 0, 0, 0, Joint[0] + DH[5, 0] };
            double[] Trsf1 = new double[] { DH[0, 0], DH[1, 0], DH[2, 0], DH[3, 0], DH[4, 0], Joint[1] + DH[5, 1] };
            double[] Trsf2 = new double[] { DH[0, 1], DH[1, 1], DH[2, 1], DH[3, 1], DH[4, 1], Joint[2] + DH[5, 2] };
            double[] Trsf3 = new double[] { DH[0, 2], DH[1, 2], DH[2, 2], DH[3, 2], DH[4, 2], Joint[3] + DH[5, 3] };
            double[] Trsf4 = new double[] { DH[0, 3], DH[1, 3], DH[2, 3], DH[3, 3], DH[4, 3], Joint[4] + DH[5, 4] };
            double[] Trsf5 = new double[] { DH[0, 4], DH[1, 4], DH[2, 4], DH[3, 4], DH[4, 4], Joint[5] + DH[5, 5] };
            double[] Trsf6 = new double[] { DH[0, 5], DH[1, 5], DH[2, 5], DH[3, 5], DH[4, 5], 0 };

            double[] Buff = TrsfTrsf(Trsf, InverseTrsf(Trsf6));
            if (Buff == null)
            {
                return null;

            }
            if (Pose[0])
            {
                Joint[0] = Math.Atan2(Buff[1], Buff[0]) - Math.Atan2(DH[1, 0], -Math.Sqrt(Buff[0] * Buff[0] + Buff[1] * Buff[1] - DH[1, 0] * DH[1, 0]));
            }
            else
            {

                Joint[0] = Math.Atan2(Buff[1], Buff[0]) - Math.Atan2(DH[1, 0], Math.Sqrt(Buff[0] * Buff[0] + Buff[1] * Buff[1] - DH[1, 0] * DH[1, 0]));
            }
            Joint[0] = Joint[0] * 180 / Math.PI;



            return Joint;


        }

        /// 
        /// 三点求用户坐标系,rz求出来有点异常
        /// 
        /// 
        /// 
        /// 
        /// 
        public static double[] GetFrame(double[] Zero, double[] Xaxis, double[] Yaxis)
        {
            //1.参数是否合法
            if (!IsTrsf(Zero) || !IsTrsf(Yaxis) || !IsTrsf(Xaxis))
            {
                return null;
            }
            try
            {
                //2。三点不能共线
                double a = Distance(Xaxis, Yaxis);
                double b = Distance(Zero, Yaxis);
                double c = Distance(Zero, Xaxis);
                if (a == b + c || c == a + b || b == a + c)
                {
                    return null;

                }

                //3建立两个向量
                double[] OX = new double[] { -Zero[0] + Xaxis[0], -Zero[1] + Xaxis[1], -Zero[2] + Xaxis[2] };
                double[] OY = new double[] { -Zero[0] + Yaxis[0], -Zero[1] + Yaxis[1], -Zero[2] + Yaxis[2] };

                double[] Vz = GetNormalVector(OX, OY);
                //  double[] Vx = GetNormalVector(OY, Vz);
                double[] Vx = UnitVer(OX);
                double[] Vy = GetNormalVector(Vz, Vx);

                if (Vz == null || Vx == null || Vy == null)
                {

                    return null;
                }

                double[,] frame = new double[4, 4];

                frame[0, 0] = Vx[0];
                frame[1, 0] = Vx[1];
                frame[2, 0] = Vx[2];
                frame[3, 0] = 0;


                frame[0, 1] = Vy[0];
                frame[1, 1] = Vy[1];
                frame[2, 1] = Vy[2];
                frame[3, 1] = 0;


                frame[0, 2] = Vz[0];
                frame[1, 2] = Vz[1];
                frame[2, 2] = Vz[2];
                frame[3, 2] = 0;

                frame[0, 3] = Zero[0] / 1000.0;
                frame[1, 3] = Zero[1] / 1000.0;
                frame[2, 3] = Zero[2] / 1000.0;
                frame[3, 3] = 1;


                return Matrix2Trsf(frame);

            }
            catch
            {
                return null;

            }



        }


        /// 
        /// Trsf相乘
        /// 
        /// 
        /// 
        /// 
        public static double[] TrsfTrsf(double[] TrsfA, double[] TrsfB)
        {
            if (!IsTrsf(TrsfA) || !IsTrsf(TrsfB))
            {

                return null;
            }

            try
            {

                return Matrix2Trsf(MatrixMatrix(Trsf2Matrix(TrsfA), Trsf2Matrix(TrsfB)));

            }

            catch
            {
                return null;

            }


        }

        /// 
        /// 两向量获得法向量
        /// 
        /// 
        /// 
        /// 

        private static double[] GetNormalVector(double[] VectA, double[] VectB)
        {
            if (VectA == null || VectB == null || VectA.Length < 3 || VectB.Length < 3)
            {
                return null;
            }
            double[] Normal = new double[3];
            Normal[0] = VectA[1] * VectB[2] - VectA[2] * VectB[1];
            Normal[1] = VectA[2] * VectB[0] - VectA[0] * VectB[2];
            Normal[2] = VectA[0] * VectB[1] - VectA[1] * VectB[0];

            return UnitVer(Normal);
        }
        /// 
        /// 两矩阵相乘
        /// 
        /// 
        /// 
        /// 
        private static double[,] MatrixMatrix(double[,] MatrixA, double[,] MatrixB)
        {
            if (MatrixA == null || MatrixB == null || MatrixA.Length != 16 || MatrixB.Length != 16)
            {
                return null;
            }

            try
            {

                double[,] MatrixC = new double[4, 4];
                for (int i = 0; i < 4; i++)
                {
                    for (int j = 0; j < 4; j++)
                    {
                        MatrixC[i, j] = 0;

                        for (int k = 0; k < 4; k++)
                        {
                            MatrixC[i, j] = MatrixC[i, j] + MatrixA[i, k] * MatrixB[k, j];
                        }
                    }
                }
                return MatrixC;
            }
            catch
            {
                return null;
            }




        }
        /// 
        ///  计算两点间的距离
        /// 
        /// 
        /// 
        /// 
        public static double Distance(double[] TrsfA, double[] TrsfB)
        {



            if (!IsTrsf(TrsfA) || !IsTrsf(TrsfB))
            {
                return -1;
            }

            try
            {
                double x = (TrsfA[0] - TrsfB[0]) * (TrsfA[0] - TrsfB[0]);
                double y = (TrsfA[1] - TrsfB[1]) * (TrsfA[1] - TrsfB[1]);
                double z = (TrsfA[2] - TrsfB[2]) * (TrsfA[2] - TrsfB[2]);



                return Math.Sqrt(x + y + z);

            }
            catch
            {
                return -1;
            }



        }
        /// 
        /// Trsf到矩阵
        /// 
        /// 
        /// 
        private static double[,] Trsf2Matrix(double[] Trsf)
        {

            if (!IsTrsf(Trsf))
            {
                return null;
            }

            double angle = 0;
            double[,] data = new double[4, 4];
            data[0, 0] = 1;
            data[0, 1] = 0;
            data[0, 2] = 0;
            data[0, 3] = Trsf[0] / 1000.0;

            data[1, 0] = 0;
            data[1, 1] = 1;
            data[1, 2] = 0;
            data[1, 3] = Trsf[1] / 1000.0;

            data[2, 0] = 0;
            data[2, 1] = 0;
            data[2, 2] = 1;
            data[2, 3] = Trsf[2] / 1000.0;

            data[3, 0] = 0;
            data[3, 1] = 0;
            data[3, 2] = 0;
            data[3, 3] = 1;


            angle = Trsf[3] * Math.PI / 180.0;
            double[,] rx = new double[4, 4];
            rx[0, 0] = 1;
            rx[0, 1] = 0;
            rx[0, 2] = 0;
            rx[0, 3] = 0;

            rx[1, 0] = 0;
            rx[1, 1] = Math.Cos(angle);
            rx[1, 2] = Math.Sin(angle) * (-1);
            rx[1, 3] = 0;

            rx[2, 0] = 0;
            rx[2, 1] = Math.Sin(angle) * (1);
            rx[2, 2] = Math.Cos(angle);
            rx[2, 3] = 0;

            rx[3, 0] = 0;
            rx[3, 1] = 0;
            rx[3, 2] = 0;
            rx[3, 3] = 1;



            angle = Trsf[4] * Math.PI / 180.0;
            double[,] ry = new double[4, 4];
            ry[0, 0] = Math.Cos(angle);
            ry[0, 1] = 0;
            ry[0, 2] = Math.Sin(angle) * (1);
            ry[0, 3] = 0;

            ry[1, 0] = 0;
            ry[1, 1] = 1;
            ry[1, 2] = 0;
            ry[1, 3] = 0;

            ry[2, 0] = Math.Sin(angle) * (-1);
            ry[2, 1] = 0;
            ry[2, 2] = Math.Cos(angle);
            ry[2, 3] = 0;

            ry[3, 0] = 0;
            ry[3, 1] = 0;
            ry[3, 2] = 0;
            ry[3, 3] = 1;

            angle = Trsf[5] * Math.PI / 180.0;
            double[,] rz = new double[4, 4];

            rz[0, 0] = Math.Cos(angle);
            rz[0, 1] = Math.Sin(angle) * (-1);
            rz[0, 2] = 0;
            rz[0, 3] = 0;

            rz[1, 0] = Math.Sin(angle) * (1);
            rz[1, 1] = Math.Cos(angle);
            rz[1, 2] = 0;
            rz[1, 3] = 0;

            rz[2, 0] = 0;
            rz[2, 1] = 0;
            rz[2, 2] = 1;
            rz[2, 3] = 0;

            rz[3, 0] = 0;
            rz[3, 1] = 0;
            rz[3, 2] = 0;
            rz[3, 3] = 1;

            return MatrixMatrix(MatrixMatrix(MatrixMatrix(data, rx), ry), rz);


        }
        /// 
        /// 判断是否trsf
        /// 
        /// 
        /// 
        private static bool IsTrsf(double[] point)
        {

            return point != null && point.Length == 6;

        }
        /// 
        /// 判断是否Joint
        /// 
        /// 
        /// 
        public static bool IsJoint(double[] joint)
        {
            return IsTrsf(joint);
        }

        /// 
        /// 矩阵转换
        /// 
        /// 
        /// 
        private static double[] Matrix2Trsf(double[,] Matrix)
        {
            if (Matrix == null || Matrix.Length != 16 || Matrix[3, 0] != 0 || Matrix[3, 1] != 0 || Matrix[3, 2] != 0 || Matrix[3, 3] != 1)
            {

                return null;
            }

            try
            {
                double[] Res = new double[6];
                Res[0] = Matrix[0, 3] * 1000;
                Res[1] = Matrix[1, 3] * 1000;
                Res[2] = Matrix[2, 3] * 1000;



                //matrix[0,2]必须小于1大于-1
                //n 0 a
                if (Matrix[0, 2] < (-1.0 + Math.Pow(1, -5) * Math.Pow(1, -5) / 2.0))
                {
                    Res[3] = 0;
                    Res[4] = -Math.PI / 2.0;
                    Res[5] = Math.Atan2(Matrix[0, 0], Matrix[0, 1]);


                }
                else if (Matrix[0, 2] > (1.0 - Math.Pow(1, -5) * Math.Pow(1, -5) / 2.0))
                {
                    Res[3] = 0;
                    Res[4] = Math.PI / 2.0;
                    Res[5] = Math.Atan2(Matrix[0, 0], -1 * Matrix[0, 1]);

                }
                else
                {
                    double l_sign = 1.0;
                    Res[4] = Math.Asin(Matrix[0, 2]);
                    if ((Matrix[2, 2] < 0.0) && (Matrix[0, 0] < 0.0) && ((Math.Abs(Matrix[0, 2]) > Math.Pow(1, -10)) || (Math.Abs(Matrix[2, 1]) > Math.Pow(1, -10))))
                    {
                        if (Res[4] >= 0.0)
                        {
                            Res[4] = Math.PI - Res[4];
                        }
                        else
                        {
                            Res[4] = -Math.PI - Res[4];
                        }
                        l_sign = -1.0;
                    }
                    Res[3] = Math.Atan2(-l_sign * Matrix[1, 2], l_sign * Matrix[2, 2]);
                    Res[5] = Math.Atan2(-l_sign * Matrix[0, 1], l_sign * Matrix[0, 0]);



                }

                Res[3] = Res[3] * 180.0 / Math.PI;
                Res[4] = Res[4] * 180.0 / Math.PI;
                Res[5] = Res[5] * 180.0 / Math.PI;

                return Res;

            }

            catch
            {

                return null;

            }

        }

        /// 
        /// 转换求逆
        /// 
        /// 
        /// 
        public static double[] InverseTrsf(double[] Trsf)
        {
            if (!IsTrsf(Trsf))
            {
                return null;
            }

            double angle = 0;
            double[,] data = new double[4, 4];
            data[0, 0] = 1;
            data[0, 1] = 0;
            data[0, 2] = 0;
            data[0, 3] = Trsf[0] / 1000.0 * (-1);

            data[1, 0] = 0;
            data[1, 1] = 1;
            data[1, 2] = 0;
            data[1, 3] = Trsf[1] / 1000.0 * (-1);

            data[2, 0] = 0;
            data[2, 1] = 0;
            data[2, 2] = 1;
            data[2, 3] = Trsf[2] / 1000.0 * (-1);

            data[3, 0] = 0;
            data[3, 1] = 0;
            data[3, 2] = 0;
            data[3, 3] = 1;


            angle = Trsf[3] * Math.PI / 180.0;
            double[,] rx = new double[4, 4];
            rx[0, 0] = 1;
            rx[0, 1] = 0;
            rx[0, 2] = 0;
            rx[0, 3] = 0;

            rx[1, 0] = 0;
            rx[1, 1] = Math.Cos(angle);
            rx[1, 2] = Math.Sin(angle);
            rx[1, 3] = 0;

            rx[2, 0] = 0;
            rx[2, 1] = Math.Sin(angle) * (-1);
            rx[2, 2] = Math.Cos(angle);
            rx[2, 3] = 0;

            rx[3, 0] = 0;
            rx[3, 1] = 0;
            rx[3, 2] = 0;
            rx[3, 3] = 1;



            angle = Trsf[4] * Math.PI / 180;
            double[,] ry = new double[4, 4];
            ry[0, 0] = Math.Cos(angle);
            ry[0, 1] = 0;
            ry[0, 2] = Math.Sin(angle) * (-1);
            ry[0, 3] = 0;

            ry[1, 0] = 0;
            ry[1, 1] = 1;
            ry[1, 2] = 0;
            ry[1, 3] = 0;

            ry[2, 0] = Math.Sin(angle) * (1);
            ry[2, 1] = 0;
            ry[2, 2] = Math.Cos(angle);
            ry[2, 3] = 0;

            ry[3, 0] = 0;
            ry[3, 1] = 0;
            ry[3, 2] = 0;
            ry[3, 3] = 1;

            angle = Trsf[5] * Math.PI / 180;
            double[,] rz = new double[4, 4];

            rz[0, 0] = Math.Cos(angle);
            rz[0, 1] = Math.Sin(angle) * (1);
            rz[0, 2] = 0;
            rz[0, 3] = 0;

            rz[1, 0] = Math.Sin(angle) * (-1);
            rz[1, 1] = Math.Cos(angle);
            rz[1, 2] = 0;
            rz[1, 3] = 0;

            rz[2, 0] = 0;
            rz[2, 1] = 0;
            rz[2, 2] = 1;
            rz[2, 3] = 0;

            rz[3, 0] = 0;
            rz[3, 1] = 0;
            rz[3, 2] = 0;
            rz[3, 3] = 1;

            return Matrix2Trsf(MatrixMatrix(MatrixMatrix(MatrixMatrix(rz, ry), rx), data));

        }
        /// 
        /// 
        /// 
        /// 
        /// 
        private static double[] UnitVer(double[] Normal)
        {

            if (Normal == null || Normal.Length < 3)
            {
                return null;
            }
            double R = Math.Sqrt(Normal[0] * Normal[0] + Normal[1] * Normal[1] + Normal[2] * Normal[2]);
            if (R == 0)
            {
                return null;
            }
            double[] point = new double[3];
            point[0] = Normal[0] / R;
            point[1] = Normal[1] / R;
            point[2] = Normal[2] / R;
            return point;

        }

        /// 
        /// 三点求外接圆心
        /// 
        /// 
        /// 
        /// 
        /// 
        public static double[] GetCircleCenter(double[] Trsf1, double[] Trsf2, double[] Trsf3)
        {

            if (GetFrame(Trsf1, Trsf2, Trsf3) == null)
                return null;





            return null;


        }

        /// 
        /// 三点求外接圆的半径
        /// 
        /// 
        /// 
        /// 
        /// 
        public static double GetCircleRadius(double[] Trsf1, double[] Trsf2, double[] Trsf3)
        {
            double[] Center = GetCircleCenter(Trsf1, Trsf2, Trsf3);

            if (Center == null)
            {
                return 0;
            }

            double len = (Center[0] - Trsf1[0]) * (Center[0] - Trsf1[0]) + (Center[1] - Trsf1[1]) * (Center[1] - Trsf1[1]) + (Center[2] - Trsf1[2]) * (Center[2] - Trsf1[2]);
            return Math.Sqrt(len);

        }

        /// 
        /// 四点求球心
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public static double[] GetBallCenter(double[] Trsf1, double[] Trsf2, double[] Trsf3, double[] Trsf4)
        {

            if (GetFrame(Trsf1, Trsf2, Trsf3) == null)
                return null;





            return null;


        }

        /// 
        /// 四点求球的半径
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public static double GetBallRadius(double[] Trsf1, double[] Trsf2, double[] Trsf3, double[] Trsf4)
        {
            double[] Center = GetBallCenter(Trsf1, Trsf2, Trsf3, Trsf4);

            if (Center == null)
            {
                return 0;
            }

            double len = (Center[0] - Trsf1[0]) * (Center[0] - Trsf1[0]) + (Center[1] - Trsf1[1]) * (Center[1] - Trsf1[1]) + (Center[2] - Trsf1[2]) * (Center[2] - Trsf1[2]);
            return Math.Sqrt(len);

        }


        /// 
        /// 技术来源http://zh.wikipedia.org/zh-cn/%E8%B2%9D%E8%8C%B2%E6%9B%B2%E7%B7%9A
        ///         
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public static double[,] GetBlendPoints(double[] Trsf1, double[] Trsf2, double[] Trsf3, int Count)
        {
            if (!IsTrsf(Trsf1) || !IsTrsf(Trsf2) || !IsTrsf(Trsf3) || Count < 0)
            {
                return null;

            }
            double[,] Res = new double[Count, 6];
            double t = 1.0 / Count;
            for (int i = 0; i < Count; i++)
            {
                t = 1.0 / Count * i;
                for (int j = 0; j < 6; j++)
                {
                    Res[i, j] = (1 - t) * (1 - t) * Trsf1[j] + 2 * t * Trsf2[j] + t * t * Trsf3[j];

                }
            }
            return Res;


        }

        private static double[] GetStartBlend(double[] Trsf1, double[] Trsf2, double reach)
        {
            if (!IsTrsf(Trsf1) || !IsTrsf(Trsf2) || reach < 0)
            {
                return null;

            }
            double len = Distance(Trsf1, Trsf2);
            double[] Res = new double[6];
            for (int i = 0; i < 6; i++)
            {

                Res[i] = reach / len * (Trsf1[i] - Trsf2[i]) + Trsf2[i];
            }

            return Res;

        }
        private static double[] GetEndBlend(double[] Trsf1, double[] Trsf2, double leave)
        {
            if (!IsTrsf(Trsf1) || !IsTrsf(Trsf2) || leave < 0)
            {
                return null;

            }
            double len = Distance(Trsf1, Trsf2);
            double[] Res = new double[6];
            for (int i = 0; i < 6; i++)
            {

                Res[i] = leave / len * (Trsf2[i] - Trsf1[i]) + Trsf1[i];
            }

            return Res;

        }
        public static double[,] CartBlend(double[] Start, double[] Center, double[] end, double reach, double leave, int Count)
        {


            return GetBlendPoints(GetStartBlend(Start, Center, reach), Center, GetEndBlend(Start, Center, leave), Count);
        }








        public static bool[] GetPose(double[] Joint,double[,] DH)
        {
            if (!IsJoint(Joint))
            {
                return null;
            }
            bool[] Res = new bool[3];
            double[] d = new double[3];
            d[0] = DH[2, 3]+DH[2,5]+DH[0,1];
            d[1]=DH[2,3];
            d[2]=DH[0,0];


            Res[0]=((d[0]*Math.Sin(Joint[1]+d[1]*Math.Sin(Joint[1]+Joint[2]+d[2]))<0));

            Res[1] = (Joint[2] >= 0);

            Res[2] = (Joint[4] >= 0);
            return Res;
        
        }
        #endregion

    }

C#中使用split分割字符串互联网打工人no1 c#
1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
你可能遗漏的一些C#/.NET/.NET Core知识点追逐时光者 C#.NET DotNetGuide编程指南 c#.net .netcore microsoft
前言在这个快速发展的技术世界中，时常会有一些重要的知识点、信息或细节被忽略或遗漏。《C#/.NET/.NETCore拾遗补漏》专栏我们将探讨一些可能被忽略或遗漏的重要知识点、信息或细节，以帮助大家更全面地了解这些技术栈的特性和发展方向。拾遗补漏GitHub开源地址https://github.com/YSGStudyHards/DotNetGuide/blob/main/docs/DotNet/D
C#动态加载DLL程序集及使用反射创建实例-简记不全 C#相关 Asp.net WebForm Asp.net MVC c#Assembly 反射程序集
Assembly动态加载程序集：分两种情况：1、需要加载的程序集已经在程序中被引用了，则直接从当前程序域中查找即可：Assemblyassembly=AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(x=>x.GetName().Name.Contains("theAssemblyName"));2、需要加载的程序集未被加载，则使用程序集
开发游戏的学习规划杰克逊的日记游戏学习
第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
python可以制作大型游戏_python能做游戏吗-python能开发游戏吗靖dede python可以制作大型游戏
python可以写游戏，但不适合。下面我们来分析一下具体原因。用锤子能造汽车吗？谁也没法说不能吧？历史上也确实曾经有些汽车，是用锤子造出来的。但一般来说，还是用工业机器人更合适对吗？比较大型的，使用Python的游戏有两个，一个是《EVE》，还有一个是《文明》。但这仅仅是个例，没有广泛意义。一般来说，用来做游戏的语言，有两种。一是C++。。一是C#。。Python理论上，不仅不适合做游戏，而是只要
【C#生态园】深度剖析：C#嵌入式开发工具大揭秘 friklogff C#生态园 c#开发语言
C#嵌入式开发：全面了解六大框架与库前言随着物联网和嵌入式系统的快速发展，越来越多的开发者开始关注使用C#语言进行嵌入式开发。本文将介绍几种用于C#的嵌入式开发框架和相关库，以及它们的核心功能、安装配置方法和API概览，帮助读者了解并选择适合自己项目的工具和资源。欢迎订阅专栏：C#生态园文章目录C#嵌入式开发：全面了解六大框架与库前言1.nanoFramework：一个用于C#的嵌入式开发框架1.
Lua 与 C#交互 z2014z lua c#开发语言
Lua与C#交互前提Lua是一种嵌入式脚本语言，Lua的解释器是用C编写的，因此可以方便的与C/C++进行相互调用。轻量级Lua语言的官方版本只包括一个精简的核心和最基本的库，这使得Lua体积小、启动速度快，也适合嵌入在别的程序里。交互过程C#调用Lua:由C#文件调用Lua解析器底层dll库（由C语言编写），再由dll文件执行相应的Lua文件。Lua调用C#：1、Wrap方式：首先生成C#源文件
C# 开发教程-入门基础天马3798 教程系列整理 c#开发语言
1.C#简介、环境，程序结构2.C#基本语法，变量，控制局域，数据类型，类型转换3.C#数组、循环，Linq4.C#类，封装，方法5.C#枚举、字符串6.C#面相对象，继承，封装，多态7.C#特性、属性、反射、索引器8.C#委托，事件，集合，泛型9.C#匿名方法10.C#多线程更多：JQuery开发教程入门基础Vue开发基础入门教程Vue开发高级学习教程
C# 禁止程序重复启动 wiseyao1219 c#
修改：Program.cs[STAThread]staticvoidMain(){Mutexmutex=newMutex(true,"NewGuid123456",outboolisCreatedNew);if(!isCreatedNew){MessageBox.Show(Application.ProductName+"isrunning...");return;}Application.Ena
C#中判断socket是否已断开的方法 wiseyao1219 c#
代码如下：Sockets=newSocket(..);if(s.Poll(-1,SelectMode.SelectRead)){intnRead=s.Receive();if(nRead==0){//socket连接已断开}}参考：C#中判断socket是否已断开的方法
C#文件被占用的解决方案花北城 C#项目文件占用
问题打更新包时，提示文件被占用。System.IO.IOException:文件“D:\RS\RS_CCVI20111210.exe”正由另一进程使用，因此该进程无法访问该文件。在System.IO.__Error.WinIOError(Int32errorCode,StringmaybeFullPath)在System.IO.FileStream.Init(Stringpath,FileMode
C#实现软件自动升级 BruceEditCode
winform程序相对web程序而言，功能更强大，编程更方便，但软件更新却相当麻烦，要到客户端一台一台地升级，本文结合实际情况，通过软件实现自动升级，弥补了这一缺陷，有较好的参考价值。由于程序在运行时不能用新的版本覆盖自己，因此，我们将登录窗口单独做成一个可执行文件，用户登录时，从网上检测是否有新的主程序，如果有，则从后台下载并覆盖老的版本，用户输入正确的用户名和密码后，通过参数将必要的信息（如用
C# 自动化 TineAine C#代码片段自动化 c#自动化模拟操作
实现的方法可能很笨，但是确实很好用usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Runtime.InteropServices;usingSystem.Text;usingSystem.Threading;usingSystem.Threading.Tasks;/******************
技术周总结 09.09~09.15周日(C# WinForm WPF) 打破砂锅问到底007 wpf c#WinForm
文章目录一、09.09周一1.1)问题01:Windows桌面开发中，WPF和WinForm的区别和联系？联系：区别：二、09.12周四2.1）问题01：visualstudio的相关快捷键有哪些？通用快捷键编辑导航调试窗口管理2.2）问题02：publicpartialclassChoosePLReason:CommonBaseForm2.3)问题03：介绍WindowsForms中的Syste
通过C# 裁剪PDF页面 Eiceblue C#.NET PDF c#pdf 开发语言 visual studio
在处理PDF文档时，有时需要精确地裁剪页面以适应特定需求，比如去除广告、背景信息或者仅仅是为了简化文档内容。本文将指导如何使用免费.NET控件通过C#实现裁剪PDF页面。免费库FreeSpire.PDFfor.NET支持在.NET(C#,VB.NET,ASP.NET,.NETCore)程序中实现创建、操作、转换和打印PDF文档等操作。可以从以下链接下载产品包后手动添加引用，或者直接通过NuGet安
【Unity基础】如何选择脚本编译方式Mono和IL2CPP？ tealcwu Unity基础 unity 游戏引擎
Edit->ProjectSettings->Player在Unity中，ScriptingBackend决定了项目的脚本编译方式，即如何将C#代码转换为可执行代码。Unity提供了两种主要的ScriptingBackend选项：Mono和IL2CPP。它们之间的区别影响了项目的性能、平台支持、编译时间和调试体验。以下是两者的详细对比：1.Mono简介:Mono是Unity最早使用的脚本后端，基于
C# Tuple、ValueTuple 語衣 C#知识补充 c#
栏目总目录TupleTuple是C#4.0引入的一个新特性，主要用于存储一个固定数量的元素序列，且这些元素可以具有不同的类型。Tuple是一种轻量级的数据结构，非常适合用于临时存储数据，而无需定义完整的类或结构体。优点简便性：可以快速创建一个包含多个不同类型数据的对象，而无需定义新的类或结构体。灵活性：元素数量和类型在编译时确定，但可以在不同上下文中重复使用不同元素的Tuple。缺点性能：作为引用
C# Linq语句用法大全以及Lambda表达式一个小码码 c#linq 开发语言 .net
C#Linq语句用法大全以及Lambda表达式Linq：是一种用于数据查询和操作的语言集成查询（LanguageIntegratedQuery）技术。通过Linq，我们可以使用类似于SQL查询的方式来查询、筛选和操作各种类型的数据集合，包括数组、列表、集合、XML文档、数据库表等等。常见的有：LinqtoObjects：用于操作对象集合，例如数组、列表等。LinqtoXML：用于操作XML数据，支
C#中的LInq语句 weixin_30588907 c#数据库
语言集成查询(LINQ)是一组技术的名称，这些技术建立在将查询功能直接集成到C#语言（以及VisualBasic和可能的任何其他.NET语言）的基础上。借助于LINQ，查询现在已是高级语言构造，就如同类、方法、事件等等。对于编写查询的开发人员来说，LINQ最明显的“语言集成”部分是查询表达式。查询表达式是使用C#3.0中引入的声明性查询语法编写的。通过使用查询语法，您甚至可以使用最少的代码对数据源
C#的linq语句木生火18624 C#开发
/查询表达式必须以form子句开头，以select或者group子句结束，在这两个子句之间，可以使用///where、orderby、join、let和其他的from子句本章要点用列表在对象上执行传统查询扩展方法LINQ查询操作符平行LNQ表达式树本章源代码下载地址(wrox.com)打开网页www.wrox.com/go/procsharp,单击DownloadCode选项卡即可下载本章源代码。
C# 多线程操作同一个文件，如何避免冲突 FlYFlOWERANDLEAF c#开发语言
1使用lock经测试，依然存在线程冲突privatestaticobjectlocker=newobject();……lock(locker){stringbText=File.ReadAllText(FPath);returnbText;}……lock(locker){File.WriteAllText(FPath,aContent);}2使用ReaderWriterLockSlim经测试，依然
C#LINQ常用扩展语句月落. C#c#linq solr
在C#中，LINQ提供了许多扩展方法，这些方法定义在System.Linq命名空间中。以下是一些常用的LINQ扩展方法：Where-过滤数据集合，返回满足条件的元素。varfilteredItems=collection.Where(item=>item.SomeProperty>10);Select-从数据集合中选择数据或创建新的投影。varprojectedItems=collection.S
source insight4.0中文乱码解决方法鹿屿二向箔 c语言 stm32 keil mdk
Sourceinsight是强大、顺手的代码编辑器，它几乎支持所有的语言，包括：C，C++，C#，HTML等等，能够自动创建并维护它自己高性能的符号数据库，包括函数、全局变量、结构、类和工程源文件里定义的其它类型的符号，对于大工程的源码阅读非常方便。但是因为是国外软件，对中文支持不是很好，很多电脑安装使用都会出现注释乱码问题，很让人抓狂。网上很多人遇到类似的问题，也有很多解决方式，也有很多“终极解
C#基础知识-.NET，变量，容量单位，数据类型 yi碗汤园 c#开发语言
目录1.NET简介2.变量1）定义2）声明3）赋值3.容量单位4.数据类型1）整形(整数)2）非整型(小数)3）非数值型本篇文章来分享一下C#的基础知识，主要讲述一下变量和数据类型的相关知识。1.NET简介.NETdonet是Microsoft新一代多语言的开发平台，用于构建和运行应用程序。Unity借助Mono实现跨平台，核心是.NETFramework框架。2.变量1）什么是变量变量是用来存储
C# 在WPF中实现图表生成 A_nanda WPF赏析 c#wpf 开发语言
在现代应用程序中，数据可视化是一个重要的功能，它可以帮助用户更直观地理解数据。在C#WPF（WindowsPresentationFoundation）中，有多种方式可以生成图表。以下是五种常见的方法，每种方法都有其独特的优势和局限。1.使用System.Windows.Shapes命名空间代码示例：<RectangleWidth="50"Height="50"Fill="Blue"Canva
C#中关闭窗口清除内容 Vae_Mars AI对话中的其他知识 c#开发语言
1.解释说明-窗口关闭时是可以执行函数的，可以做一部分事件处理-因为删除文件夹的方案不好做，所以改成清空文件夹内的内容2.程序示例publicMainWindow(){InitializeComponent();//检查窗口关闭this.Closing+=MainWindow_Closing;}//执行具体的方法privatevoidMainWindow_Closing(objectsender,
C#中Invoke的用法（）世界太过浮夸 .net c#
转自：http://www.cnblogs.com/lsgsanxiao/p/5523282.htmlinvoke和begininvoke区别一直对invoke和begininvoke的使用和概念比较混乱，这两天看了些资料，对这两个的用法和原理有了些新的认识和理解。首先说下，invoke和begininvoke的使用有两种情况：control中的invoke、begininvoke。delegra
.NET常见面试题汇总 .Net Core 爱好者 .net c#
首先，汇总一共分为三部分：一是关于.NET技术的面试问题，二是关于.NET项目中的实际问题，三是历年出现过一些面试题汇总一、.NET技术面试问题请简述.NET中的装箱和拆箱。什么是泛型，以及它在.NET中的用途？请解释一下C#中的委托是什么，以及它们如何工作？什么是事件，如何使用它们？请解释一下C#中的特性(Attributes)及其应用场景。.NET中的异步编程模式有哪些？什么是LINQ，它在.
c# net8调用vc写的dll wiseyao1219 c#开发语言 dll
dll程序（vc,x86)头文件extern"C"int__declspec(dllexport)WINAPIadd(inta,intb);实现intWINAPIadd(inta,intb){returna+b;}c#/net8函数声明：[DllImport("dll/Dll1.dll",CallingConvention=CallingConvention.StdCall)]publicstat
c# json使用 wiseyao1219 c#json 前端
安装包用NuGet安装包：Newtonsoft.Json对象转为Json字符串publicclassPerson{publicstringName{get;set;}publicintAge{get;set;}}Personperson=newPerson{Name="JohnDoe",Age=30};stringjson2=JsonConvert.SerializeObject(person);
rust的指针作为函数返回值是直接传递，还是先销毁后创建？ wudixiaotie 返回值
这是我自己想到的问题，结果去知呼提问，还没等别人回答，我自己就想到方法实验了。。 fn main() { let mut a = 34; println!("a's addr:{:p}", &a); let p = &mut a; println!("p's addr:{:p}", &a
java编程思想 -- 数据的初始化百合不是茶 java 数据的初始化
1.使用构造器确保数据初始化 /* *在ReckInitDemo类中创建Reck的对象 */ public class ReckInitDemo { public static void main(String[] args) { //创建Reck对象 new Reck(); } }
[航天与宇宙]为什么发射和回收航天器有档期 comsci
地球的大气层中有一个时空屏蔽层,这个层次会不定时的出现,如果该时空屏蔽层出现,那么将导致外层空间进入的任何物体被摧毁,而从地面发射到太空的飞船也将被摧毁... 所以,航天发射和飞船回收都需要等待这个时空屏蔽层消失之后,再进行 &
linux下批量替换文件内容商人shang linux 替换
1、网络上现成的资料　　格式: sed -i "s/查找字段/替换字段/g" `grep 查找字段 -rl 路径` 　　linux sed 批量替换多个文件中的字符串　　sed -i "s/oldstring/newstring/g" `grep oldstring -rl yourdir` 　　例如：替换/home下所有文件中的www.admi
网页在线天气预报 oloz 天气预报
网页在线调用天气预报 <%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transit
SpringMVC和Struts2比较杨白白 springMVC
1. 入口 spring mvc的入口是servlet，而struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这样就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。参见：http://blog.csdn.net/zs15932616453/article/details/8832343 2
refuse copy, lazy girl! 小桔子 copy
妹妹坐船头啊啊啊啊！都打算一点点琢磨呢。文字编辑也写了基本功能了。。今天查资料，结果查到了人家写得完完整整的。我清楚的认识到： 1.那是我自己觉得写不出的高度 2.如果直接拿来用，很快就能解决问题 3.然后就是抄咩~~ 4.肿么可以这样子，都不想写了今儿个，留着作参考吧！拒绝大抄特抄，慢慢一点点写！
apache与php整合 aichenglong php apache web
一 apache web服务器 1 apeche web服务器的安装 1)下载Apache web服务器 2)配置域名(如果需要使用要在DNS上注册) 3)测试安装访问http://localhost/验证是否安装成功 2 apache管理 1)service.msc进行图形化管理 2)命令管理，配
Maven常用内置变量 AILIKES maven
Built-in properties ${basedir} represents the directory containing pom.xml ${version} equivalent to ${project.version} (deprecated: ${pom.version}) Pom/Project properties Al
java的类和对象百合不是茶 JAVA面向对象类对象
java中的类： java是面向对象的语言，解决问题的核心就是将问题看成是一个类，使用类来解决 java使用 class 类名来创建类，在Java中类名要求和构造方法，Java的文件名是一样的创建一个A类： class A{ } java中的类：将某两个事物有联系的属性包装在一个类中，再通
JS控制页面输入框为只读 bijian1013 JavaScript
在WEB应用开发当中，增、删除、改、查功能必不可少，为了减少以后维护的工作量，我们一般都只做一份页面，通过传入的参数控制其是新增、修改或者查看。而修改时需将待修改的信息从后台取到并显示出来，实际上就是查看的过程，唯一的区别是修改时，页面上所有的信息能修改，而查看页面上的信息不能修改。因此完全可以将其合并，但通过前端JS将查看页面的所有信息控制为只读，在信息量非常大时，就比较麻烦。
AngularJS与服务器交互 bijian1013 JavaScript AngularJS $http
对于AJAX应用（使用XMLHttpRequests）来说，向服务器发起请求的传统方式是：获取一个XMLHttpRequest对象的引用、发起请求、读取响应、检查状态码，最后处理服务端的响应。整个过程示例如下： var xmlhttp = new XMLHttpRequest(); xmlhttp.onreadystatechange
[Maven学习笔记八]Maven常用插件应用 bit1129 maven
常用插件及其用法位于：http://maven.apache.org/plugins/ 1. Jetty server plugin 2. Dependency copy plugin 3. Surefire Test plugin 4. Uber jar plugin 1. Jetty Pl
【Hive六】Hive用户自定义函数(UDF) bit1129 自定义函数
1. 什么是Hive UDF Hive是基于Hadoop中的MapReduce，提供HQL查询的数据仓库。Hive是一个很开放的系统，很多内容都支持用户定制，包括：文件格式：Text File，Sequence File 内存中的数据格式： Java Integer/String, Hadoop IntWritable/Text 用户提供的 map/reduce 脚本：不管什么
杀掉nginx进程后丢失nginx.pid，如何重新启动nginx ronin47 nginx 重启 pid丢失
nginx进程被意外关闭，使用nginx -s reload重启时报如下错误：nginx: [error] open() “/var/run/nginx.pid” failed (2: No such file or directory)这是因为nginx进程被杀死后pid丢失了，下一次再开启nginx -s reload时无法启动解决办法：nginx -s reload 只是用来告诉运行中的ng
UI设计中我们为什么需要设计动效 brotherlamp UI ui教程 ui视频 ui资料 ui自学
随着国际大品牌苹果和谷歌的引领，最近越来越多的国内公司开始关注动效设计了，越来越多的团队已经意识到动效在产品用户体验中的重要性了，更多的UI设计师们也开始投身动效设计领域。但是说到底，我们到底为什么需要动效设计？或者说我们到底需要什么样的动效？做动效设计也有段时间了，于是尝试用一些案例，从产品本身出发来说说我所思考的动效设计。一、加强体验舒适度嗯，就是让用户更加爽更加爽的用你的产品。
Spring中JdbcDaoSupport的DataSource注入问题 bylijinnan java spring
参考以下两篇文章： http://www.mkyong.com/spring/spring-jdbctemplate-jdbcdaosupport-examples/ http://stackoverflow.com/questions/4762229/spring-ldap-invoking-setter-methods-in-beans-configuration Sprin
数据库连接池的工作原理 chicony 数据库连接池
随着信息技术的高速发展与广泛应用，数据库技术在信息技术领域中的位置越来越重要，尤其是网络应用和电子商务的迅速发展，都需要数据库技术支持动态Web站点的运行，而传统的开发模式是：首先在主程序（如Servlet、Beans）中建立数据库连接；然后进行SQL操作，对数据库中的对象进行查询、修改和删除等操作；最后断开数据库连接。使用这种开发模式，对
java 关键字 CrazyMizzz java
关键字是事先定义的，有特别意义的标识符，有时又叫保留字。对于保留字，用户只能按照系统规定的方式使用，不能自行定义。 Java中的关键字按功能主要可以分为以下几类：（1）访问修饰符 public,private,protected p
Hive中的排序语法 daizj 排序 hive order by DISTRIBUTE BY sort by
Hive中的排序语法 2014.06.22 ORDER BY hive中的ORDER BY语句和关系数据库中的sql语法相似。他会对查询结果做全局排序，这意味着所有的数据会传送到一个Reduce任务上，这样会导致在大数量的情况下，花费大量时间。与数据库中 ORDER BY 的区别在于在hive.mapred.mode = strict模式下，必须指定 limit 否则执行会报错。
单态设计模式 dcj3sjt126com 设计模式
单例模式（Singleton）用于为一个类生成一个唯一的对象。最常用的地方是数据库连接。使用单例模式生成一个对象后，该对象可以被其它众多对象所使用。 <?phpclass Example{ // 保存类实例在此属性中 private static&
svn locked dcj3sjt126com Lock
post-commit hook failed (exit code 1) with output: svn: E155004: Working copy 'D:\xx\xxx' locked svn: E200031: sqlite: attempt to write a readonly database svn: E200031: sqlite: attempt to write a
ARM寄存器学习 e200702084 数据结构 C++c C#F#
无论是学习哪一种处理器，首先需要明确的就是这种处理器的寄存器以及工作模式。 ARM有37个寄存器，其中31个通用寄存器，6个状态寄存器。 1、不分组寄存器（R0-R7）不分组也就是说说，在所有的处理器模式下指的都时同一物理寄存器。在异常中断造成处理器模式切换时，由于不同的处理器模式使用一个名字相同的物理寄存器，就是
常用编码资料 gengzg 编码
List<UserInfo> list=GetUserS.GetUserList(11); String json=JSON.toJSONString(list); HashMap<Object,Object> hs=new HashMap<Object, Object>(); for(int i=0;i<10;i++) {
进程 vs. 线程 hongtoushizi 线程 linux 进程
我们介绍了多进程和多线程，这是实现多任务最常用的两种方式。现在，我们来讨论一下这两种方式的优缺点。首先，要实现多任务，通常我们会设计Master-Worker模式，Master负责分配任务，Worker负责执行任务，因此，多任务环境下，通常是一个Master，多个Worker。如果用多进程实现Master-Worker，主进程就是Master，其他进程就是Worker。如果用多线程实现
Linux定时Job：crontab -e 与 /etc/crontab 的区别 Josh_Persistence linux crontab
一、linux中的crotab中的指定的时间只有5个部分：* * * * * 分别表示：分钟，小时，日，月，星期，具体说来：第一段代表分钟 0—59 第二段代表小时 0—23 第三段代表日期 1—31 第四段代表月份 1—12 第五段代表星期几，0代表星期日 0—6 如： */1 * * * * 每分钟执行一次。 *
KMP算法详解 hm4123660 数据结构 C++算法字符串 KMP
字符串模式匹配我们相信大家都有遇过，然而我们也习惯用简单匹配法（即Brute-Force算法)，其基本思路就是一个个逐一对比下去，这也是我们大家熟知的方法，然而这种算法的效率并不高，但利于理解。假设主串s="ababcabcacbab",模式串为t="
枚举类型的单例模式 zhb8015 单例模式
E.编写一个包含单个元素的枚举类型[极推荐]。代码如下： public enum MaYun {himself; //定义一个枚举的元素，就代表MaYun的一个实例private String anotherField;MaYun() {//MaYun诞生要做的事情//这个方法也可以去掉。将构造时候需要做的事情放在instance赋值的时候：/** himself = MaYun() {*
Kafka+Storm+HDFS ssydxa219 storm
cd /myhome/usr/stormbin/storm nimbus &bin/storm supervisor &bin/storm ui &Kafka+Storm+HDFS整合实践kafka_2.9.2-0.8.1.1.tgzapache-storm-0.9.2-incubating.tar.gzKafka安装配置我们使用3台机器搭建Kafk
Java获取本地服务器的IP 中华好儿孙 java Web 获取服务器ip地址
System.out.println("getRequestURL:"+request.getRequestURL()); System.out.println("getLocalAddr:"+request.getLocalAddr()); System.out.println("getLocalPort:&quo

用C#写一个机器人基础知识类

你可能感兴趣的:(C#)