精华内容
下载资源
问答
  • 2021-03-29 08:54:52

    C语言求两个链表的相交点的算法完整源码(定义,实现,main函数测试)

    #include <iostream>
    #include <cmath>
    
    struct Node {
       
      int data;
      Node * next;
      Node( int d 
    更多相关内容
  • 怎样求两个函数关系式的交点坐标

    千次阅读 2021-05-22 08:43:00
    定义与定义表达式一般地,自变量x和因变量y之间存在如下关系:y=ax^2+bx+c(a,b,c为常数,a≠0,且a决定函数的开口方向,a>0时,开口方向向上,a<0时,开口方向向下,IaI还可以决定开口大小,IaI越大开口就越小...

    满意答案

    I.定义与定义表达式

    一般地,自变量x和因变量y之间存在如下关系:

    y=ax^2+bx+c

    (a,b,c为常数,a≠0,且a决定函数的开口方向,a>0时,开口方向向上,a<0时,开口方向向下,IaI还可以决定开口大小,IaI越大开口就越小,IaI越小开口就越大.)

    则称y为x的二次函数。

    二次函数表达式的右边通常为二次三项式。

    II.二次函数的三种表达式

    一般式:y=ax^2+bx+c(a,b,c为常数,a≠0)

    顶点式:y=a(x-h)^2+k [抛物线的顶点P(h,k)]

    交点式:y=a(x-x₁)(x-x ₂) [仅限于与x轴有交点A(x₁ ,0)和 B(x₂,0)的抛物线]

    注:在3种形式的互相转化中,有如下关系:

    ______

    h=-b/2a k=(4ac-b^2)/4a x₁,x₂=(-b±√b^2-4ac)/2a

    III.二次函数的图像

    在平面直角坐标系中作出二次函数y=x^2的图像,

    可以看出,二次函数的图像是一条抛物线。

    IV.抛物线的性质

    1.抛物线是轴对称图形。对称轴为直线

    x = -b/2a。

    对称轴与抛物线唯一的交点为抛物线的顶点P。

    特别地,当b=0时,抛物线的对称轴是y轴(即直线x=0)

    2.抛物线有一个顶点P,坐标为

    P ( -b/2a ,(4ac-b^2)/4a )

    当-b/2a=0时,P在y轴上;当Δ= b^2-4ac=0时,P在x轴上。

    3.二次项系数a决定抛物线的开口方向和大小。

    当a>0时,抛物线向上开口;当a<0时,抛物线向下开口。

    |a|越大,则抛物线的开口越小。

    4.一次项系数b和二次项系数a共同决定对称轴的位置。

    当a与b同号时(即ab>0),对称轴在y轴左;

    当a与b异号时(即ab<0),对称轴在y轴右。

    5.常数项c决定抛物线与y轴交点。

    抛物线与y轴交于(0,c)

    6.抛物线与x轴交点个数

    Δ= b^2-4ac>0时,抛物线与x轴有2个交点。

    Δ= b^2-4ac=0时,抛物线与x轴有1个交点。

    _______

    Δ= b^2-4ac<0时,抛物线与x轴没有交点。X的取值是虚数(x= -b±√b^2-4ac 的值的相反数,乘上虚数i,整个式子除以2a)

    V.二次函数与一元二次方程

    特别地,二次函数(以下称函数)y=ax^2+bx+c,

    当y=0时,二次函数为关于x的一元二次方程(以下称方程),

    即ax^2+bx+c=0

    此时,函数图像与x轴有无交点即方程有无实数根。

    函数与x轴交点的横坐标即为方程的根。

    以下是在北京四中远程教育上看到的好资料``!!

    1.二次函数y=ax^2,y=a(x-h)^2,y=a(x-h)^2 +k,y=ax^2+bx+c(各式中,a≠0)的图象形状相同,只是位置不同,它们的顶点坐标及对称轴如下表:

    解析式

    y=ax^2

    y=a(x-h)^2

    y=a(x-h)^2+k

    y=ax^2+bx+c

    顶点坐标

    (0,0)

    (h,0)

    (h,k)

    (-b/2a,[4ac-b^2]/4a)

    对 称 轴

    x=0

    x=h

    x=h

    x=-b/2a

    当h>0时,y=a(x-h)^2的图象可由抛物线y=ax^2向右平行移动h个单位得到,

    当h<0时,则向左平行移动|h|个单位得到.

    当h>0,k>0时,将抛物线y=ax^2向右平行移动h个单位,再向上移动k个单位,就可以得到y=a(x-h)^2 +k的图象;

    当h>0,k<0时,将抛物线y=ax^2向右平行移动h个单位,再向下移动|k|个单位可得到y=a(x-h)^2+k的图象;

    当h<0,k>0时,将抛物线向左平行移动|h|个单位,再向上移动k个单位可得到y=a(x-h)^2+k的图象;

    当h<0,k<0时,将抛物线向左平行移动|h|个单位,再向下移动|k|个单位可得到y=a(x-h)^2+k的图象;

    因此,研究抛物线 y=ax^2+bx+c(a≠0)的图象,通过配方,将一般式化为y=a(x-h)^2+k的形式,可确定其顶点坐标、对称轴,抛物线的大体位置就很清楚了.这给画图象提供了方便.

    2.抛物线y=ax^2+bx+c(a≠0)的图象:当a>0时,开口向上,当a<0时开口向下,对称轴是直线x=-b/2a,顶点坐标是(-b/2a,[4ac-b^2]/4a).

    3.抛物线y=ax^2+bx+c(a≠0),若a>0,当x ≤ -b/2a时,y随x的增大而减小;当x ≥ -b/2a时,y随x的增大而增大.若a<0,当x ≤ -b/2a时,y随x的增大而增大;当x ≥ -b/2a时,y随x的增大而减小.

    4.抛物线y=ax^2+bx+c的图象与坐标轴的交点:

    (1)图象与y轴一定相交,交点坐标为(0,c);

    (2)当△=b^2-4ac>0,图象与x轴交于两点A(x₁,0)和B(x₂,0),其中的x1,x2是一元二次方程ax^2+bx+c=0

    (a≠0)的两根.这两点间的距离AB=|x₂-x₁|

    当△=0.图象与x轴只有一个交点;

    当△<0.图象与x轴没有交点.当a>0时,图象落在x轴的上方,x为任何实数时,都有y>0;当a<0时,图象落在x轴的下方,x为任何实数时,都有y<0.

    5.抛物线y=ax^2+bx+c的最值:如果a>0(a<0),则当x= -b/2a时,y最小(大)值=(4ac-b^2)/4a.

    顶点的横坐标,是取得最值时的自变量值,顶点的纵坐标,是最值的取值.

    6.用待定系数法求二次函数的解析式

    (1)当题给条件为已知图象经过三个已知点或已知x、y的三对对应值时,可设解析式为一般形式:

    y=ax^2+bx+c(a≠0).

    (2)当题给条件为已知图象的顶点坐标或对称轴时,可设解析式为顶点式:y=a(x-h)^2+k(a≠0).

    (3)当题给条件为已知图象与x轴的两个交点坐标时,可设解析式为两根式:y=a(x-x₁)(x-x₂)(a≠0).

    7.二次函数知识很容易与其它知识综合应用,而形成较为复杂的综合题目。因此,以二次函数知识为主的综合性题目是中考的热点考题,往往以大题形式出现.

    010分享举报

    展开全文
  • c语言-求两交点

    千次阅读 2017-08-28 11:35:28
    已知两圆圆心坐标及半径两圆交点 (C语言|参数方程求解) 在一个二维平面上给定两个圆的圆心横纵坐标、半径共6个参数, 求交点. 这个问题无非是解二元二次方程组.普通二元二次方程联立消元求解的困难在于, 中间过程...

        在一个二维平面上给定两个圆的圆心横纵坐标、半径共6个参数, 求交点. 这个问题无非是解二元二次方程组.普通二元二次方程联立消元求解的困难在于, 中间过程里的系数会变得非常复杂, 从而导致容易出错—因为公式毕竟还是要人来推导,人的出错率比计算机要高得多得多—改用圆的参数方程求解, 可以在显著地减轻这个负担.
    现在谈谈这问题的求解过程. 选择圆的参数方程的好处是方程是一次的, 化简方便, 虽然是三角函数方程并且既有正弦也有余弦, 不过到最后可以很方便地求出来.

    (下面分析中x^y表示x的y次方)
    大家还记得圆的参数方程吧, 圆心 (x0, y0), 半径为 r 的圆的参数方程是:
        x = r * cosθ + x0
        y = r * sinθ + y0
    假设现在两圆参数x1, y1, r1, x2, y2, r2(这些分别表示, 咳, 有谁看不出来它们分别表示什么吗?), 设交点为 (x, y), 代入其中一个圆中的参数方程有
        x = r1 * cosθ + x1 且 y = r1 * sinθ + y1
    代入另一圆的标准方程, 得到
        (r1 * cosθ + x1 - x2)^2 + (r1 * sinθ + y1 - y2)^2 = r2^2
    是的, 看起来有关于正余弦二次项, 不过不要惊慌, 展开合并同类项之后, 正好这两项会合并成常数:
    左边 = (r1 * cosθ)^2 + (r1 * sinθ)^2 + 2 * r1 * (x1 - x2) * cosθ + 2 * r1 * (y1 - y2) * sinθ
          = r2^2 - (x1 - x2)^2 - (y1 - y2)^2 = 右边
    这样就好办了, 把 r1^2 转移到等式右边, 令:
       a = 2 * r1 * (x1 - x2)
        b = 2 * r1 * (y1 - y2)
        c = r2^2 - r1^2 - (x1 - x2)^2 - (y1 - y2)^2
    那么方程便成为:
        a * cosθ + b * sinθ = c
    用 (1 - (cosθ)^2)^(1 / 2) 表示sinθ, 令:
        p = a^2 + b^2
        q = -2 * a * c
        r = c^2 - b^2
    便化为一个一元二次方程, 解得:
        cosθ = (±(q^2 - 4 * p * r)^(1 / 2) - q) / (2 * p)
    

        然而到此为止还没有结束, 因为刚才将三角方程转化为二次方程时, 等式两边平方了一次, 如果直接这样求对应角的正弦值, 符号总会为正.为了将纵坐标正确解出, 必须变角. 那么如何变角?方法当然很多, 诱导公式, 或者反过头去把方程变一下, 以正弦作为未知数,但是这些方法都比较复杂. 在这里可以选择另一种方案, 那就是用验证代替求解: 验证所得的解是不是根, 如果不是, 将纵坐标反号便可以了.最后注意一下两解的横坐标相同的情况, 这样要先输出正的再输出负的.

    #include<math.h>  
    
    struct point_t {  
        double x, y;  
    };  
    
    struct circle_t {  
        struct point_t center;  
        double r;  
    };  
    
    int double_equals(double const a, double const b)  
    {  
        static const double ZERO = 1e-9;  
        return fabs(a - b) < ZERO;  
    }  
    
    double distance_sqr(struct point_t const* a, struct point_t const* b)  
    {  
        return (a->x - b->x) * (a->x - b->x) + (a->y - b->y) * (a->y - b->y);  
    }  
    
    double distance(struct point_t const* a, struct point_t const* b)  
    {  
        return sqrt(distance_sqr(a, b));  
    }  
    
    int insect(struct circle_t circles[], struct point_t points[])  
    {  
        double d, a, b, c, p, q, r;  
        double cos_value[2], sin_value[2];  
        if (double_equals(circles[0].center.x, circles[1].center.x)  
            && double_equals(circles[0].center.y, circles[1].center.y)  
            && double_equals(circles[0].r, circles[1].r)) {  
            return -1;  
        }  
    
        d = distance(&circles[0].center, &circles[1].center);  
        if (d > circles[0].r + circles[1].r  
            || d < fabs(circles[0].r - circles[1].r)) {  
            return 0;  
        }  
    
        a = 2.0 * circles[0].r * (circles[0].center.x - circles[1].center.x);  
        b = 2.0 * circles[0].r * (circles[0].center.y - circles[1].center.y);  
        c = circles[1].r * circles[1].r - circles[0].r * circles[0].r  
            - distance_sqr(&circles[0].center, &circles[1].center);  
        p = a * a + b * b;  
        q = -2.0 * a * c;  
        if (double_equals(d, circles[0].r + circles[1].r)  
            || double_equals(d, fabs(circles[0].r - circles[1].r))) {  
            cos_value[0] = -q / p / 2.0;  
            sin_value[0] = sqrt(1 - cos_value[0] * cos_value[0]);  
    
            points[0].x = circles[0].r * cos_value[0] + circles[0].center.x;  
            points[0].y = circles[0].r * sin_value[0] + circles[0].center.y;  
    
            if (!double_equals(distance_sqr(&points[0], &circles[1].center),  
                               circles[1].r * circles[1].r)) {  
                points[0].y = circles[0].center.y - circles[0].r * sin_value[0];  
            }  
            return 1;  
        }  
    
        r = c * c - b * b;  
        cos_value[0] = (sqrt(q * q - 4.0 * p * r) - q) / p / 2.0;  
        cos_value[1] = (-sqrt(q * q - 4.0 * p * r) - q) / p / 2.0;  
        sin_value[0] = sqrt(1 - cos_value[0] * cos_value[0]);  
        sin_value[1] = sqrt(1 - cos_value[1] * cos_value[1]);  
    
        points[0].x = circles[0].r * cos_value[0] + circles[0].center.x;  
        points[1].x = circles[0].r * cos_value[1] + circles[0].center.x;  
        points[0].y = circles[0].r * sin_value[0] + circles[0].center.y;  
        points[1].y = circles[0].r * sin_value[1] + circles[0].center.y;  
    
        if (!double_equals(distance_sqr(&points[0], &circles[1].center),  
                           circles[1].r * circles[1].r)) {  
            points[0].y = circles[0].center.y - circles[0].r * sin_value[0];  
        }  
        if (!double_equals(distance_sqr(&points[1], &circles[1].center),  
                           circles[1].r * circles[1].r)) {  
            points[1].y = circles[0].center.y - circles[0].r * sin_value[1];  
        }  
        if (double_equals(points[0].y, points[1].y)  
            && double_equals(points[0].x, points[1].x)) {  
            if (points[0].y > 0) {  
                points[1].y = -points[1].y;  
            } else {  
                points[0].y = -points[0].y;  
            }  
        }  
        return 2;  
    }  
    
    int main()  
    {  
        struct circle_t circles[2];  
        struct point_t points[2];  
        printf("请输入两圆x,y,半径(以逗号分开):");  
        while (EOF != scanf("%lf,%lf,%lf,%lf,%lf,%lf",  
                       &circles[0].center.x, &circles[0].center.y, &circles[0].r,  
                       &circles[1].center.x, &circles[1].center.y, &circles[1].r)) {  
            switch (insect(circles, points)) {  
                case -1:  
                    printf("THE CIRCLES ARE THE SAME/n");  
                    break;  
                case 0:  
                    printf("NO INTERSECTION/n");  
                    break;  
                case 1:  
                    printf("(%.3lf %.3lf)\n", points[0].x, points[0].y);  
                    break;  
                case 2:  
                    printf("(%.3lf %.3lf) (%.3lf %.3lf)\n",  
                           points[0].x, points[0].y,  
                           points[1].x, points[1].y);  
            }  
        }  
        return 0;  
    }  
    展开全文
  • c语言--求两交点

    千次阅读 2015-01-14 18:00:38
     在一个二维平面上给定两个圆的圆心横纵坐标、半径共6个参数, 求交点. 这个问题无非是解二元二次方程组.普通二元二次方程联立消元求解的困难在于, 中间过程里的系数会变得非常复杂, 从而导致容易出错---因为公式...

    已知两圆圆心坐标及半径求两圆交点 (C语言|参数方程求解)


       在一个二维平面上给定两个圆的圆心横纵坐标、半径共6个参数, 求交点. 这个问题无非是解二元二次方程组.普通二元二次方程联立消元求解的困难在于, 中间过程里的系数会变得非常复杂, 从而导致容易出错---因为公式毕竟还是要人来推导,人的出错率比计算机要高得多得多---改用圆的参数方程求解, 可以在显著地减轻这个负担.
      现在谈谈这问题的求解过程. 选择圆的参数方程的好处是方程是一次的, 化简方便, 虽然是三角函数方程并且既有正弦也有余弦, 不过到最后可以很方便地求出来.

        (下面分析中x^y表示x的y次方)
        大家还记得圆的参数方程吧, 圆心 (x0, y0), 半径为 r 的圆的参数方程是:
            x = r * cosθ + x0
            y = r * sinθ + y0
        假设现在两圆参数x1, y1, r1, x2, y2, r2(这些分别表示, 咳, 有谁看不出来它们分别表示什么吗?), 设交点为 (x, y), 代入其中一个圆中的参数方程有
            x = r1 * cosθ + x1 且 y = r1 * sinθ + y1
        代入另一圆的标准方程, 得到
            (r1 * cosθ + x1 - x2)^2 + (r1 * sinθ + y1 - y2)^2 = r2^2
        是的, 看起来有关于正余弦二次项, 不过不要惊慌, 展开合并同类项之后, 正好这两项会合并成常数:
        左边 = (r1 * cosθ)^2 + (r1 * sinθ)^2 + 2 * r1 * (x1 - x2) * cosθ + 2 * r1 * (y1 - y2) * sinθ
              = r2^2 - (x1 - x2)^2 - (y1 - y2)^2 = 右边
        这样就好办了, 把 r1^2 转移到等式右边, 令:
           a = 2 * r1 * (x1 - x2)
            b = 2 * r1 * (y1 - y2)
            c = r2^2 - r1^2 - (x1 - x2)^2 - (y1 - y2)^2
        那么方程便成为:
            a * cosθ + b * sinθ = c
        用 (1 - (cosθ)^2)^(1 / 2) 表示sinθ, 令:
            p = a^2 + b^2
            q = -2 * a * c
            r = c^2 - b^2
        便化为一个一元二次方程, 解得:
            cosθ = (±(q^2 - 4 * p * r)^(1 / 2) - q) / (2 * p)
       然而到此为止还没有结束, 因为刚才将三角方程转化为二次方程时, 等式两边平方了一次, 如果直接这样求对应角的正弦值, 符号总会为正.为了将纵坐标正确解出, 必须变角. 那么如何变角?方法当然很多, 诱导公式, 或者反过头去把方程变一下, 以正弦作为未知数,但是这些方法都比较复杂. 在这里可以选择另一种方案, 那就是用验证代替求解: 验证所得的解是不是根, 如果不是, 将纵坐标反号便可以了.最后注意一下两解的横坐标相同的情况, 这样要先输出正的再输出负的.

    下面上代码
    #include<math.h> // sqrt fabs

    // 点
    struct point_t {
        double x, y;
    };

    // 圆
    struct circle_t {
        struct point_t center;
        double r;
    };

    // 浮点数判同
    int double_equals(double const a, double const b)
    {
        static const double ZERO = 1e-9;
        return fabs(a - b) < ZERO;
    }

    // 两点之间距离的平方
    double distance_sqr(struct point_t const* a, struct point_t const* b)
    {
        return (a->x - b->x) * (a->x - b->x) + (a->y - b->y) * (a->y - b->y);
    }

    // 两点之间的距离
    double distance(struct point_t const* a, struct point_t const* b)
    {
        return sqrt(distance_sqr(a, b));
    }

    /*
    * 两圆相交函数
    * 参数:
    *    circles[0] 和 circles[1] 分别是两个圆.
    *    points[0] 和 points[1] 用来存放交点数值, 虽然有些情况下两个不都会用上;
    *        如果用到了两个交点, 那么返回后, 横坐标大的在前, 如果横坐标一样, 则纵坐标大的在前.
    * 返回值:
    *    -1 如果两个圆一模一样;
    *    其它整数值: 交点个数.
    */
    int insect(struct circle_t circles[], struct point_t points[])
    {
        double d, a, b, c, p, q, r; // a, b, c, p, q, r 与上面分析中的量一致
        double cos_value[2], sin_value[2]; // 交点的在 circles[0] 上对应的正余弦取值
                                           // 余弦值 cos_value 就是分析中的 cosθ
        if (double_equals(circles[0].center.x, circles[1].center.x)
            && double_equals(circles[0].center.y, circles[1].center.y)
            && double_equals(circles[0].r, circles[1].r)) {
            return -1;
        }

        d = distance(&circles[0].center, &circles[1].center); // 圆心距离
        if (d > circles[0].r + circles[1].r
            || d < fabs(circles[0].r - circles[1].r)) {
            return 0;
        }

        a = 2.0 * circles[0].r * (circles[0].center.x - circles[1].center.x);
        b = 2.0 * circles[0].r * (circles[0].center.y - circles[1].center.y);
        c = circles[1].r * circles[1].r - circles[0].r * circles[0].r
            - distance_sqr(&circles[0].center, &circles[1].center);
        p = a * a + b * b;
        q = -2.0 * a * c;

        // 如果交点仅一个
        if (double_equals(d, circles[0].r + circles[1].r)
            || double_equals(d, fabs(circles[0].r - circles[1].r))) {
            cos_value[0] = -q / p / 2.0;
            sin_value[0] = sqrt(1 - cos_value[0] * cos_value[0]);

            points[0].x = circles[0].r * cos_value[0] + circles[0].center.x;
            points[0].y = circles[0].r * sin_value[0] + circles[0].center.y;

            // 在这里验证解是否正确, 如果不正确, 则将纵坐标符号进行变换
            if(!double_equals(distance_sqr(&points[0], &circles[1].center),
                              circles[1].r * circles[1].r)) {
                points[0].y = circles[0].center.y - circles[0].r * sin_value[0];
            }
            return 1;
        }

        r = c * c - b * b;
        cos_value[0] = (sqrt(q * q - 4.0 * p * r) - q) / p / 2.0;
        cos_value[1] = (-sqrt(q * q - 4.0 * p * r) - q) / p / 2.0;
        sin_value[0] = sqrt(1 - cos_value[0] * cos_value[0]);
        sin_value[1] = sqrt(1 - cos_value[1] * cos_value[1]);

        points[0].x = circles[0].r * cos_value[0] + circles[0].center.x;
        points[1].x = circles[0].r * cos_value[1] + circles[0].center.x;
        points[0].y = circles[0].r * sin_value[0] + circles[0].center.y;
        points[1].y = circles[0].r * sin_value[1] + circles[0].center.y;

        // 验证解是否正确, 两个解都需要验证.
        if (!double_equals(distance_sqr(&points[0], &circles[1].center),
                           circles[1].r * circles[1].r)) {
            points[0].y = circles[0].center.y - circles[0].r * sin_value[0];
        }
        if (!double_equals(distance_sqr(&points[1], &circles[1].center),
                           circles[1].r * circles[1].r)) {
            points[1].y = circles[0].center.y - circles[0].r * sin_value[1];
        }
        // 如果求得的两个点坐标相同, 则必然其中一个点的纵坐标反号可以求得另一点坐标
        if (double_equals(points[0].y, points[1].y)
            && double_equals(points[0].x, points[1].x)) {
            if(points[0].y > 0) {
                points[1].y = -points[1].y;
            } else {
                points[0].y = -points[0].y;
            }
        }
        return 2;
    }

    NP 问题的启示

        NP 问题教导我们, 验证比求解要简单! 虽然这一道题, 无论怎么看, 都是一个普通的 P 问题, 但是我们还是可以贯彻这一思想, 用最简易的手法获得答案.
        一个完整的程序:

    [cpp]  view plain copy
    1. <span style="font-family:SimSun;">#include<stdio.h>  
    2. #include<math.h>  
    3.   
    4. struct point_t {  
    5.     double x, y;  
    6. };  
    7.   
    8. struct circle_t {  
    9.     struct point_t center;  
    10.     double r;  
    11. };  
    12.   
    13. int double_equals(double const a, double const b)  
    14. {  
    15.     static const double ZERO = 1e-9;  
    16.     return fabs(a - b) < ZERO;  
    17. }  
    18.   
    19. double distance_sqr(struct point_t const* a, struct point_t const* b)  
    20. {  
    21.     return (a->x - b->x) * (a->x - b->x) + (a->y - b->y) * (a->y - b->y);  
    22. }  
    23.   
    24. double distance(struct point_t const* a, struct point_t const* b)  
    25. {  
    26.     return sqrt(distance_sqr(a, b));  
    27. }  
    28.   
    29. int insect(struct circle_t circles[], struct point_t points[])  
    30. {  
    31.     double d, a, b, c, p, q, r;  
    32.     double cos_value[2], sin_value[2];  
    33.     if (double_equals(circles[0].center.x, circles[1].center.x)  
    34.         && double_equals(circles[0].center.y, circles[1].center.y)  
    35.         && double_equals(circles[0].r, circles[1].r)) {  
    36.         return -1;  
    37.     }  
    38.   
    39.     d = distance(&circles[0].center, &circles[1].center);  
    40.     if (d > circles[0].r + circles[1].r  
    41.         || d < fabs(circles[0].r - circles[1].r)) {  
    42.         return 0;  
    43.     }  
    44.   
    45.     a = 2.0 * circles[0].r * (circles[0].center.x - circles[1].center.x);  
    46.     b = 2.0 * circles[0].r * (circles[0].center.y - circles[1].center.y);  
    47.     c = circles[1].r * circles[1].r - circles[0].r * circles[0].r  
    48.         - distance_sqr(&circles[0].center, &circles[1].center);  
    49.     p = a * a + b * b;  
    50.     q = -2.0 * a * c;  
    51.     if (double_equals(d, circles[0].r + circles[1].r)  
    52.         || double_equals(d, fabs(circles[0].r - circles[1].r))) {  
    53.         cos_value[0] = -q / p / 2.0;  
    54.         sin_value[0] = sqrt(1 - cos_value[0] * cos_value[0]);  
    55.   
    56.         points[0].x = circles[0].r * cos_value[0] + circles[0].center.x;  
    57.         points[0].y = circles[0].r * sin_value[0] + circles[0].center.y;  
    58.   
    59.         if (!double_equals(distance_sqr(&points[0], &circles[1].center),  
    60.                            circles[1].r * circles[1].r)) {  
    61.             points[0].y = circles[0].center.y - circles[0].r * sin_value[0];  
    62.         }  
    63.         return 1;  
    64.     }  
    65.   
    66.     r = c * c - b * b;  
    67.     cos_value[0] = (sqrt(q * q - 4.0 * p * r) - q) / p / 2.0;  
    68.     cos_value[1] = (-sqrt(q * q - 4.0 * p * r) - q) / p / 2.0;  
    69.     sin_value[0] = sqrt(1 - cos_value[0] * cos_value[0]);  
    70.     sin_value[1] = sqrt(1 - cos_value[1] * cos_value[1]);  
    71.   
    72.     points[0].x = circles[0].r * cos_value[0] + circles[0].center.x;  
    73.     points[1].x = circles[0].r * cos_value[1] + circles[0].center.x;  
    74.     points[0].y = circles[0].r * sin_value[0] + circles[0].center.y;  
    75.     points[1].y = circles[0].r * sin_value[1] + circles[0].center.y;  
    76.   
    77.     if (!double_equals(distance_sqr(&points[0], &circles[1].center),  
    78.                        circles[1].r * circles[1].r)) {  
    79.         points[0].y = circles[0].center.y - circles[0].r * sin_value[0];  
    80.     }  
    81.     if (!double_equals(distance_sqr(&points[1], &circles[1].center),  
    82.                        circles[1].r * circles[1].r)) {  
    83.         points[1].y = circles[0].center.y - circles[0].r * sin_value[1];  
    84.     }  
    85.     if (double_equals(points[0].y, points[1].y)  
    86.         && double_equals(points[0].x, points[1].x)) {  
    87.         if (points[0].y > 0) {  
    88.             points[1].y = -points[1].y;  
    89.         } else {  
    90.             points[0].y = -points[0].y;  
    91.         }  
    92.     }  
    93.     return 2;  
    94. }  
    95.   
    96. int main()  
    97. {  
    98.     struct circle_t circles[2];  
    99.     struct point_t points[2];  
    100.     printf("请输入两圆x,y,半径(以逗号分开):");  
    101.     while (EOF != scanf("%lf,%lf,%lf,%lf,%lf,%lf",  
    102.                    &circles[0].center.x, &circles[0].center.y, &circles[0].r,  
    103.                    &circles[1].center.x, &circles[1].center.y, &circles[1].r)) {  
    104.         switch (insect(circles, points)) {  
    105.             case -1:  
    106.                 printf("THE CIRCLES ARE THE SAME/n");  
    107.                 break;  
    108.             case 0:  
    109.                 printf("NO INTERSECTION/n");  
    110.                 break;  
    111.             case 1:  
    112.                 printf("(%.3lf %.3lf)\n", points[0].x, points[0].y);  
    113.                 break;  
    114.             case 2:  
    115.                 printf("(%.3lf %.3lf) (%.3lf %.3lf)\n",  
    116.                        points[0].x, points[0].y,  
    117.                        points[1].x, points[1].y);  
    118.         }  
    119.     }  
    120.     return 0;  
    121. }  
    122.   
    展开全文
  • 下面是修正后的/// /// 计算条直线的交点/// /// L1的点1坐标/// L1的点2坐标/// L2的点1坐标/// L2的点2坐标/// public static PointF GetIntersection(PointF lineFirstStar, PointF lineFirstEnd, PointF ...
  • 两个不同点x1,x2,如果f(x1)和f(x2)符号相反,则(x1,x2)区间内必有一个根。如果f(x1)与f(x2)同符号,则应改变x1,x2,直到f(x1)、f(x2)异号为止。注意x1、x2的值不应差太大,以保证(x1,x2)区间内只有一个根。 2. 连接...
  • 已知两圆圆心坐标及半径两圆交点 (C语言|参数方程求解)在一个二维平面上给定两个圆的圆心横纵坐标、半径共6个参数, 求交点. 这个问题无非是解二元二次方程组.普通二元二次方程联立消元求解的困难在于, 中间过程里...
  • 爱上数学提高素养爱上数学提高素养二次函数的四种表达式法推导整理于2018418夜(1(1)如果二次函数的图像经过已知三点,则设表达式为 三元一次方程组a、b、c。y .= ax2 bx c,把已知三点坐标代入其中构造h, k),...
  • c语言怎么画出一元二次函数图像

    千次阅读 2021-05-20 18:24:34
    matlab 已知二次函数系数 怎么画出二次函数图像x*x不正确,你是需要计算x的平方对吧,那么需要x.*x或者x.^2,点乘如果是x*x表示矩阵相乘,那么如果x是n*1的向量,[n*1]*[n*1]维度就不正确了画出它们的二次函数图像再答:y...
  • C语言的单链表求交点

    2019-10-21 22:24:09
    使用o(1)的空间复杂度,求两个链表相交的时候的交点,这个思想就类似于使用o(1)的空间复杂度和o(n)的时间复杂度来链表的第k个节点。 过程如下: 获取两个链表的长度 将较长的链表移动和短链表长度差值的位置 移动...
  • 判断两个单链表相交 判断 2 个单链表是否相交,是一个老生常谈但又极具思考性的面试题,本节就在读者已经掌握单链表及其基本操作的基础上,就此问题给大家做深入地讲解。 首先,读者要搞清楚“相交”的含义。...
  • 个函数只考虑了二维空间的交。 GetInterBetweenTwoLines函数即为求交点函数。 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; ...
  • 二次函数在初中数学的知识体系中算得上是一重要内容, 而在高中数学中只能算得上一重要的基础知识了,因而起到了一“承上启下”的作用,所以学好二次函数的相关知识至关重要;我们常见的二次函数解析式主要...
  • 二次方程ax²+bx+c=0可以看做给定二次函数y=ax²+bx+c的函数值为0时的情况因此当函数与X轴没有交点时,二次方程也无解二次不等式可以看做是二次函数给定值域时的情况因此解解一元二次函数,a、b、c等于多少,c=-415....
  • 平面中直线的交点,当直线不平行时,必定只有一个交点。 /* 返回直线的交点 */ Point LinesIntersection(Line m, Line n, int *flag) { double d = n.A * m.B - m.A * n.B; if (d == 0) { *flag = 0; ...
  • 在一个二维平面上给定两个圆的圆心横纵坐标、半径共6个参数, 求交点. 这个问题无非是解二元二次方程组. 普通二元二次方程联立消元求解的困难在于, 中间过程里的系数会变得非常复杂, 从而导致容易出错---因为公式毕竟...
  • c语言进阶3-有参函数

    2019-09-25 10:03:57
    一、 有参函数的定义 有参函数的定义格式如下: 类型标识符 函数名(形式参数表列) { 语句; } 如 void fun(int a,int b) { printf(“a+b=%d”,a+b); } 当然类型标识符也可以是int或float或char,但那...
  • 其原理是:过各行、各列像素中心构造一组虚拟网格线,按直线从起点到终点的顺序计算直线各垂直网格线的交点,然后确定该列像素中与此交点最近的像素。Bresenham算法也是一种计算机图形学中常见的绘制直线的算法,其...
  • 在程序中,有种方法可以终止函数的执行,并返回到调用函数的位置。第一种方法是在函数体中,从第一句一直执行到最后一句,当所有语句都执行完,程序遇到结束符号”}”后返回。 例:从函数返回 #include "stdio...
  • 算法: 要计算,相当于方程: 的正实根。...牛顿迭代法有很明显的几何意义(参见右图5-12),当我们选定以后,过 作 的切线,其切线方程为:此切线方程与x轴的交点,即得:正因为牛顿法有这一明显得几何意...
  • 小论c语言递归与递推

    2021-05-23 06:47:35
    当n=2时,A2=4 当n=3时,A3=8 设当有n-1条曲线时可将平面分成A(n-1)区域,此时,加入第n条曲线,因为各曲线之间两两相交于点,所以,第n条封闭曲线与前n-1条曲线共有2*(n-1)个交点,这些交点将第n条...
  • C语言每日一练——第154天:牛顿迭代法方程根

    千次阅读 多人点赞 2022-03-18 11:02:02
    史上最强「牛顿迭代法方程根」讲解(代码详解+思路分析+动图演示+特性总结)
  • 关于圆的面积 (C语言代码)

    千次阅读 2021-05-22 10:59:11
    d为圆圆心连线的长度。相交面积为Sd=sqrt((x1-x2)^2+(y1-y2)^2)(1)如果r1+r2<=d那么圆相离,相交面积S=0(2)如果r2-r1>=d那么半径小的圆内含半径大的圆,那么相交面积为小圆的面积S=pi*r1*r1(3)既非(1...
  • 比如节点F和节点H的最低公共祖先,先出从根节点A到F的路径,再出A到H的路径,那么最后一相同的节点就是最低公共祖先。A->B->D->F和A->B->E->H,最后相同的节点事B,所以最低公共祖先是B...
  • 一次函数与一元一次不等式(洋葱数学)一、基本知识点考点:1、一次函数 y = kx+b (k ≠0 ) 与一元一次不等式的关系:y>0,则 kx + b > 0 ; y﹤0,则 kx + b < 0 。2、如图,直线y=kx+b交坐标轴于A(﹣2,0),B(0...
  • 二次函数的图像与性质文 吴文忠一、列举4组典型二次函数的图像1、y=ax2型,如:。查看:图像2、y=ax2+c型,如:。查看:图像3、y=a(x-h)2型,如:。查看:图像4、y=a(x-h)2+k型,如:。查看:图像二、y=ax2型的图像...
  • 2405: C语言习题 牛顿迭代法根时间限制:1 Sec内存限制:128 MB提交:562解决:317题目描述用牛顿迭代法根。方程为ax3+bx2+cx+d=0。系数a,b,c,d的值一次为1,2,3,4,由主函数输入。x在1附近的一实根。出根后由...
  • c语言求三次方程的根程序设计》由会员分享,可在线阅读,更多相关《c语言求三次方程的根程序设计(10页珍藏版)》请在人人文库网上搜索。1、沈阳理工大学机械工程学院计 算 机 程 序 训 练 任 务 书姓名 崔晓光班级 ...
  • 直线与椭圆交点距离公式

    千次阅读 2021-05-24 02:41:03
    题目:直线与椭圆交点距离公式马上考试了解答:(根号(k^+1))*根号(x1^2+X2^2-2x1x2)再问: 可以说清楚点吗再答: (根号(k^+1))*根号((x1+X2)^2-2x1x2)k为直线的斜率,x1+X2 x1x2用根与系数的关系即可猜你喜欢:1....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,760
精华内容 704
关键字:

c语言求两个函数交点