从面积和角度计算三角形

时间:2010-07-20 13:22:53

标签: math trigonometry calculus

我正在尝试根据面积和角度计算三角形。如果Angle-B是90°那么公式可以工作,但在我的情况下,角度可以是0.1°到179.8°。该公式假设角度为90,所以我认为可能存在一些隐藏的东西可能非常适合角度。这是公式:

alt text http://i25.tinypic.com/jj33gx.png alt text http://i31.tinypic.com/2mmijkm.png

代码中的公式为:

Height = sqrt((2 * Area) / (tan(Angle-A)));

我正在寻找公式的后半部分。公式的下一部分是这样的:

cos(sin(AngleB))

6 个答案:

答案 0 :(得分:6)

tziki的回答是正确的,但我想详细说明它是如何得出的。

我们从角度和区域开始,因为知道。我将使用OP图中的标签进行解释。

首先,我们有一个基本事实,即三角形的面积是其基数和高度的乘积的一半:Area = base * height / 2。我们希望能够确定基数和高度之间的关系,以便我们可以将这个方程式减少到一个未知数并求解基数。

要知道的另一件重要事情是三角形的高度与Side-A成正比:height = Side-A * sin(Angle-B)。因此,了解Side-A会给我们带来高度。

现在我们需要在Side-A和Side-C(基础)之间建立关系。这里最合适的规则是正弦律:Side-A/sin(A) = Side-C/sin(C)。我们重新安排这个等式,用Side-C来找到Side-A:Side-A = Side-C * sin(A)/sin(C)

我们现在可以将此结果插入到高度方程式中,仅根据Side-C得到高度公式:height = Side-C * sin(A) * sin(B) / sin(C)

使用Side-C作为面积方程的基础,我们现在可以仅用Side-C找到该区域:Area = Side-C^2 * sin(A) * sin(B) / 2sin(C)

然后重新安排这个等式,以区域:

找到Side-C
Side-C = SQRT(2 * Area * sin(C) / (sin(B) * (sin(A)))

这给了你一面。这可以重复找到其他方面,或者您可以使用不同的方法找到知道这一方的其他方。

答案 1 :(得分:5)

好的,新尝试:如果我的计算是正确的,那么B面等于sqrt(2 *面积* sin(角度-B)/(sin(角度-A)* sin(角度-C))

由于面积= 1/2 * A * B * sin(c)= 1/2 * C * B * sin(a)= 1/2 * A * C * sin(b)我们得到:

A = 2 * area /(B * sin(c))并使用此我们得到:

C = sin(c)* B / sin(b),当我们将其放回区域方程时,我们得到:

B = sqrt(2 *面积* sin(角度-B)/(sin(角度-A)* sin(角度-C))

当您知道一侧和所有角度时,使用普通三角法计算其他边应该很容易。

答案 2 :(得分:1)

你已经有了答案,但我不得不在前一段时间为求职面试解决这种问题。这并不难,并没有花太多时间来达到以下解决方案。

阅读它,它应该是自我解释的。

  

创建一个Python模块,通过使用sin和cosin定理来解决三角形。

     

模块接收一些三角形的值作为参数,如果可能的话,返回所有角度和边长的值。

     

参数作为dict接收,并且应该可以从命令行独立调用。

from __future__ import division
import sys, logging
from math import radians, degrees, acos, cos, sin, sqrt, asin

class InconsistentDataError(TypeError):
    pass


class InsufficientDataError(TypeError):
    pass


class NonUpdatable(dict):
    """Dictionary whose items can be set only once."""
    def __setitem__(self, i, y):
        if self.get(i, None):
            raise InconsistentDataError()
        super(NonUpdatable, self).__setitem__(i, y)


def get_known_sides(**kwarg):
    """Filter from the input elements the Side elements."""
    return dict([i for i in kwarg.iteritems() if i[0].isupper()])

def get_known_angles(**kwarg):
    """Filter from the input elements the Angle elements."""
    return dict([i for i in kwarg.iteritems() if i[0].islower()])

def get_opposite_angle(C, B, A):
    """
    Get the angle corresponding to C.

    Keyword arguments:
    A -- right side of the angle (real number > 0)
    B -- left side of the angle (real number > 0)
    C -- side opposite to the angle (real number > 0)

    Returns:
    angle opposite to C
    """
    return degrees(acos((A**2 + B**2 - C**2) / (2 * A * B)))

def get_side(A, B, c):
    """
    Calculate the Side corresponding to the Angle c.

    Keyword arguments:
    A -- left side of C (real number > 0)
    B -- right side of C (real number > 0)
    c -- angle opposite to side C (real number)

    Returns:
    side C, opposite to c
    """
    return sqrt(A**2 + B**2 - 2*A*B*cos(radians(c)))

def get_overlapping_angle(known_angles, known_sides):
    """
    Calculate the Angle of a known side, knowing the angle to another known side.

    Keyword arguments:
    known_angles -- (dict of angles)
    known_sides -- (dict of sides)

    Returns:
    angle of the known side, to which there is no known angle
    """
    a = (set([i.lower() for i in known_sides.iterkeys()]) - 
            set([i.lower() for i in known_angles.iterkeys()])).pop()

    b = (set([i.lower() for i in known_sides.iterkeys()]) & 
            set([i.lower() for i in known_angles.iterkeys()])).pop()

    y = (known_sides[a.upper()]/known_sides[b.upper()]) * sin(radians(known_angles[b.lower()]))
    if y > 1: y = 1 #Rounding error fix --- y = 1.000000000001; asin(y) -> Exception
    return {a.lower(): degrees(asin(y))}

def get_angles(A, B, C):
    """
    Calculate all the angles, given the length of all the sides.

    Keyword arguments:
    A -- side A (real number > 0)
    B -- side B (real number > 0)
    C -- side C (real number > 0)

    Returns:
    dict of angles
    """
    sides = {"A":A,"B":B,"C":C}
    _sides = sides.keys()
    angles = {}

    for side in sides.keys():
        angles[side.lower()] = get_opposite_angle(
                                    sides[_sides[0]], 
                                    sides[_sides[1]], 
                                    sides[_sides[2]])
        _sides.append(_sides.pop(0))

    return angles

def get_triangle_values(**kwargs):
    """Calculate the missing values of a triangle based on the known values."""
    known_params = kwargs
    angles = NonUpdatable({
        "a":0, 
        "b":0, 
        "c":0,
    })
    sides = NonUpdatable({
        "A":0, 
        "B":0, 
        "C":0,
    })

    if len(known_params) < 3:
        raise InsufficientDataError("Three parameters are needed to calculate triangle's values.")

    if str(known_params.keys()).islower():
        raise TypeError("At least one length needed.")

    known_sides = NonUpdatable(get_known_sides(**known_params))
    sides.update(known_sides)
    known_angles = NonUpdatable(get_known_angles(**known_params))
    angles.update(known_angles)

    if len(known_angles) == 3 and sum(known_angles.itervalues()) != 180:
        raise InconsistentDataError("One of the sides is too long.")

    if len(known_sides) == 3:
        x=[side for side in known_sides.itervalues() if (sum(known_sides.itervalues()) - side) < side]
        if len(x):
            raise InconsistentDataError("One of the sides is too long.")

        for angle, value in get_angles(**known_sides).iteritems(): 
            # Done this way to force exception when overwriting a 
            # user input angle, otherwise it would be a simple assignment.
            # >>> angles = get_angles(**known_sides)
            # This means inconsistent input data.
            angles[angle] = value

    else: # There are angles given and not enough sides.
        if len(known_angles) > 1:
            #2 angles given. Get last angle and calculate missing sides
            for angle, val in angles.iteritems():
                if val == 0:
                    angles[angle] = 180. - sum(angles.itervalues())

            known_sides = known_sides.items()
            for side, length in sides.iteritems():
                if length == 0:
                    sides[side] = known_sides[0][1] / \
                        sin(radians(angles[known_sides[0][0].lower()])) * \
                        sin(radians(angles[side.lower()]))

        else:
            unknown_side = (set(sides.keys()) - set(known_sides.keys())).pop()

            chars = [ord(i.lower()) for i in known_params.iterkeys()]
            chars.sort()

            if chars[0] < chars[1] < chars[2]:
                sides[unknown_side] = get_side(known_sides.values()[0], known_sides.values()[1], known_angles[unknown_side.lower()])
                angles = get_angles(**sides)

            else:
                known_angles.update(get_overlapping_angle(known_angles, known_sides))
                angles.update(known_angles)

                for angle, val in angles.iteritems():
                    if val == 0:
                        angles[angle] = 180. - sum(angles.itervalues())

                sides[unknown_side] = get_side(known_sides.values()[0], known_sides.values()[1], angles[unknown_side.lower()])

    angles.update(sides)
    return angles

if __name__ == "__main__":
    try:
        values = get_triangle_values( **eval(sys.argv[1], {}, {}) )
    except IndexError, e:
        values = get_triangle_values(A=10,B=10,C=10)
    except InsufficientDataError, e:
        print "Not enough data!"
        exit(1)
    except InconsistentDataError, e:
        print "Data is inconsistent!"
        exit(1)

    print values

A,B和C是边长,a,b和c是角度,因此c是与C侧相反的角度。

<子> Tests

答案 3 :(得分:0)

如果我没有弄错,两个角度a和b之间的边x的长度应该如下。

         ________________
        /  2A       2A
x =    / ------ + ------
     \/  tan(a)   tan(b)

所以计算边C,但是角度A和角度B。

(现在仔细检查它 - 似乎是正确的。)

答案 4 :(得分:0)

如何计算三角形的两条边的长度,其中第三个尺寸的长度为1(在角度上使用law of sines,该边指定长度为1),然后缩放三角形直到它的区域与您所在的区域相匹配?然后你可以很容易地计算出身高。 http://en.wikipedia.org/wiki/Triangle_area#Using_trigonometry

答案 5 :(得分:0)

如果三角形是等腰,你给Side-A的公式似乎是正确的,即Angle-B = Angle-C(你使用正弦定律和该区域的正弦公式得到这个)。如果它不是等腰,你似乎需要知道其他角度;通用公式是:

Side-A = sqrt(2*Area*sin(Angle-A)/(sin(Angle-B)*sin(Angle-C)))

当然,我是在脑子里这样做的,所以检查数学;)

编辑:好的,在签入纸张后修改公式。