गणित

Question

में वेक्टर समीकरणों को हल करना मैं समझने की कोशिश कर रहा हूं कि समीकरणों के सिस्टम को हल करने के लिए गणित का उपयोग कैसे करें, जहां कुछ चर और गुणांक वैक्टर हैं। एक साधारण उदाहरण की तरह

कुछ जहाँ मैं एक पता है, वी, और पी की भयावहता होगा, और मैं टी और दिशा के लिए हल करने के लिए पी। (मूल रूप से, दो किरणें ए और बी दिया जाता है, जहां मुझे ए के बारे में सब कुछ पता है, लेकिन केवल बी की उत्पत्ति और परिमाण, यह पता लगाएं कि बी की दिशा क्या होनी चाहिए कि यह ए को छेड़छाड़ करे।

अब, मुझे पता है कि इस तरह की चीज को हाथ से कैसे हल किया जाए, लेकिन यह धीमा और त्रुटि-प्रवण है, इसलिए मैं उम्मीद कर रहा था कि मैं गणित का उपयोग चीजों को गति देने और त्रुटि-जांचने के लिए कर सकता हूं। हालांकि, मैं नहीं देख सकता कि गणित को प्रतीकात्मक रूप से इस तरह के वैक्टर से जुड़े समीकरणों को हल करने के लिए कैसे प्राप्त करें।

मैंने वेक्टर एनालिसिस पैकेज में देखा है, जो कुछ भी प्रासंगिक नहीं लगता है; इस बीच रैखिक बीजगणित पैकेज में केवल रैखिक प्रणालियों के लिए एक सॉल्वर होता है (जो यह नहीं है, क्योंकि मुझे नहीं पता है कि टी या पी, बस | पी |)।

मैं simpleminded बात कर की कोशिश की:, उनके घटकों में वैक्टर के विस्तार (नाटक वे 3 डी कर रहे हैं) और उन्हें सुलझाने के रूप में अगर मैं दो पैरामीट्रिक कार्यों समानता के लिए कोशिश कर रहे थे

Solve[ 
     { Function[t, {Bx + Vx*t, By + Vy*t, Bz + Vz*t}][t] == 
      Function[t, {Px*t, Py*t, Pz*t}][t], 
     Px^2 + Py^2 + Pz^2 == Q^2 } , 
     { t, Px, Py, Pz } 
    ] 

लेकिन "समाधान" जो बाहर निकलता है गुणांक और भीड़ की एक बड़ी गड़बड़ है। यह मुझे उन सभी आयामों को विस्तारित करने के लिए भी मजबूर करता है जिन्हें मैं खिलाता हूं।

मैं क्या चाहते डॉट उत्पादों, पार उत्पादों, और मानदंडों के मामले में एक अच्छा प्रतीकात्मक समाधान है:

लेकिन मैं नहीं देख सकते हैं कि Solve बताने के लिए कि गुणांकों के कुछ वैक्टर हैं स्केलर्स के बजाय।

क्या यह संभव है? क्या गणित मुझे वैक्टरों पर प्रतीकात्मक समाधान दे सकता है? या मुझे सिर्फ 2 पेंसिल प्रौद्योगिकी के साथ रहना चाहिए?

(बस स्पष्ट होने के लिए, मुझे शीर्ष पर विशेष समीकरण के समाधान में रूचि नहीं है - मैं पूछ रहा हूं कि क्या मैं गणित का उपयोग कम्प्यूटेशनल ज्यामिति समस्याओं को हल करने के लिए कर सकता हूं जैसे आम तौर पर मुझे सब कुछ व्यक्त करने के बिना {Ax, Ay, Az}, आदि का एक स्पष्ट मैट्रिक्स)

Answer 1

मेरे पास आपके लिए कोई सामान्य समाधान नहीं है (MathForum जाने का बेहतर तरीका हो सकता है), लेकिन कुछ सुझाव हैं जो मैं आपको दे सकता हूं। सबसे पहले अपने वैक्टरों के विस्तार को एक व्यवस्थित तरीके से घटकों में विस्तार करना है। उदाहरण के लिए, मैं आपके द्वारा लिखे गए समीकरण को हल करता हूं।

rawSol = With[{coords = {x, y, z}}, 
    Solve[ 
    Flatten[ 
    {A[#] + V[#] t == P[#] t & /@ coords, 
    Total[P[#]^2 & /@ coords] == P^2}], 
    Flatten[{t, P /@ coords}]]]; 

फिर आप rawSol चर से अधिक आसानी से काम कर सकते हैं। अगला, क्योंकि आप एक समान तरीके से वेक्टर घटकों का जिक्र कर रहे हैं (हमेशा गणित पैटर्न v_[x|y|z] से मेल खाते हैं), आप नियमों को परिभाषित कर सकते हैं जो उन्हें सरल बनाने में सहायता करेंगे।मैं निम्नलिखित नियमों के साथ आ पहले थोड़ा के आसपास खेला:

vectorRules = 
    {forms___ + vec_[x]^2 + vec_[y]^2 + vec_[z]^2 :> forms + vec^2, 
    forms___ + c_. v1_[x]*v2_[x] + c_. v1_[y]*v2_[y] + c_. v1_[z]*v2_[z] :> 
    forms + c v1\[CenterDot]v2}; 

ये नियम वेक्टर मानदंडों और डॉट उत्पादों (पार से उत्पादों पाठक के लिए एक संभावना दर्दनाक व्यायाम के रूप में छोड़ दिया जाता है) के लिए रिश्तों को सरल बनाएगा। संपादित करें: rcollyer ने बताया कि आप डॉट उत्पादों के नियम में वैकल्पिक c बना सकते हैं, इसलिए आपको केवल मानदंडों और डॉट उत्पादों के लिए दो नियमों की आवश्यकता है।

In[3] := t /. rawSol //. vectorRules // Simplify // InputForm 
    Out[3] = {(A \[CenterDot] V - Sqrt[A^2*(P^2 - V^2) + 
            (A \[CenterDot] V)^2])/(P^2 - V^2), 
      (A \[CenterDot] V + Sqrt[A^2*(P^2 - V^2) + 
            (A \[CenterDot] V)^2])/(P^2 - V^2)} 

जैसा कि मैंने कहा, यह किसी भी द्वारा समस्याओं के इन प्रकार के हल के लिए एक पूरी तरह से नहीं है:

इन नियमों के साथ

, मैं तुरंत एक रूप से मिलता-पास में t के लिए समाधान आसान बनाने के लिए कर रहा था इसका मतलब है, लेकिन यदि आप समस्या को हल करने के बारे में सावधान हैं जो पैटर्न-मिलान और नियम-प्रतिस्थापन दृष्टिकोण से काम करना आसान है, तो आप बहुत दूर जा सकते हैं।

Answer 2

---

मेथेमेटिका 7.0.1.0

साथ

Clear[A, V, P]; 
A = {1, 2, 3}; 
V = {4, 5, 6}; 
P = {P1, P2, P3}; 
Solve[A + V t == P, P] 

आउटपुट:

{{P1 -> 1 + 4 t, P2 -> 2 + 5 t, P3 -> 3 (1 + 2 t)}} 

बाहर टाइप पी = {P1, P2, पी 3} कष्टप्रद हो सकता है यदि सरणी या मैट्रिक्स बड़ी है।

Clear[A, V, PP, P]; 
A = {1, 2, 3}; 
V = {4, 5, 6}; 
PP = Array[P, 3]; 
Solve[A + V t == PP, PP] 

आउटपुट:

{{P[1] -> 1 + 4 t, P[2] -> 2 + 5 t, P[3] -> 3 (1 + 2 t)}} 

मैट्रिक्स वेक्टर आंतरिक उत्पाद:

Clear[A, xx, bb]; 
A = {{1, 5}, {6, 7}}; 
xx = Array[x, 2]; 
bb = Array[b, 2]; 
Solve[A.xx == bb, xx] 

आउटपुट:

{{x[1] -> 1/23 (-7 b[1] + 5 b[2]), x[2] -> 1/23 (6 b[1] - b[2])}} 

मैट्रिक्स गुणन:

Clear[A, BB, d]; 
A = {{1, 5}, {6, 7}}; 
BB = Array[B, {2, 2}]; 
d = {{6, 7}, {8, 9}}; 
Solve[A.BB == d] 

आउटपुट:

{{B[1, 1] -> -(2/23), B[2, 1] -> 28/23, B[1, 2] -> -(4/23), B[2, 2] -> 33/23}} 

डॉट उत्पाद एक इन्फ़िक्स संकेतन सिर्फ डॉट के लिए एक अवधि का उपयोग में बनाया गया है।

मुझे नहीं लगता कि क्रॉस उत्पाद हालांकि करता है। इस प्रकार आप एक बनाने के लिए नोटेशन पैकेज का उपयोग करते हैं। "एक्स" क्रॉस का हमारा इन्फिक्स रूप बन जाएगा। मैं नोटेशन, सिंबलनाइजेशन और इंफिक्स नॉटेशन ट्यूटोरियल से उदाहरण का मुकाबला करने का सुझाव देता हूं। नोटेशन पैलेट का भी उपयोग करें जो कुछ बॉक्स वाक्यविन्यास को दूर करने में मदद करता है।

Clear[X] 
Needs["Notation`"] 
Notation[x_ X y_\[DoubleLongLeftRightArrow]Cross[x_, y_]] 
Notation[NotationTemplateTag[ 
    RowBox[{x_, , X, , y_, }]] \[DoubleLongLeftRightArrow] 
    NotationTemplateTag[RowBox[{ , 
RowBox[{Cross, [, 
RowBox[{x_, ,, y_}], ]}]}]]] 
{a, b, c} X {x, y, z} 

आउटपुट:

{-c y + b z, c x - a z, -b x + a y} 

ऊपर भयानक लग रहा है, लेकिन यह की तरह लग रहा है जब संकेतन पैलेट का उपयोग कर:

Clear[X] 
Needs["Notation`"] 
Notation[x_ X y_\[DoubleLongLeftRightArrow]Cross[x_, y_]] 
{a, b, c} X {x, y, z} 

मैं कुछ अतीत में अंकन पैकेज का उपयोग quirks में चलाने की है गणित के संस्करण तो सावधान रहें।

Answer 3

मैंने इस मुद्दे पर कुछ अलग दृष्टिकोण लिया है। पैटर्न कि vec[_] का उपयोग कर निर्दिष्ट किया जा सकता वेक्टर मात्रा होने के लिए जाना जाता है, पैटर्न है कि एक OverVector[] या OverHat[] आवरण (एक सदिश या उन पर टोपी के साथ प्रतीकों) माना जाता है: मैं कुछ परिभाषाओं है कि इस उत्पादन लौट कर दिया है डिफ़ॉल्ट रूप से वैक्टर।

परिभाषाएं प्रयोगात्मक हैं और इन्हें इस तरह माना जाना चाहिए, लेकिन वे अच्छी तरह से काम करने लगते हैं। मैं इस समय के साथ जोड़ने की उम्मीद है।

यहां परिभाषाएं हैं। गणित नोटबुक सेल में चिपकने की आवश्यकता है और उन्हें सही ढंग से देखने के लिए मानकफॉर्म में परिवर्तित किया गया है।

Unprotect[vExpand,vExpand$,Cross,Plus,Times,CenterDot]; 

(* vec[pat] determines if pat is a vector quantity. 
vec[pat] can be used to define patterns that should be treated as vectors. 
Default: Patterns are assumed to be scalar unless otherwise defined *) 
vec[_]:=False; 

(* Symbols with a vector hat, or vector operations on vectors are assumed to be vectors *) 
vec[OverVector[_]]:=True; 
vec[OverHat[_]]:=True; 

vec[u_?vec+v_?vec]:=True; 
vec[u_?vec-v_?vec]:=True; 
vec[u_?vec\[Cross]v_?vec]:=True; 
vec[u_?VectorQ]:=True; 

(* Placeholder for matrix types *) 
mat[a_]:=False; 

(* Anything not defined as a vector or matrix is a scalar *) 
scal[x_]:=!(vec[x]\[Or]mat[x]); 
scal[x_?scal+y_?scal]:=True;scal[x_?scal y_?scal]:=True; 

(* Scalars times vectors are vectors *) 
vec[a_?scal u_?vec]:=True; 
mat[a_?scal m_?mat]:=True; 

vExpand$[u_?vec\[Cross](v_?vec+w_?vec)]:=vExpand$[u\[Cross]v]+vExpand$[u\[Cross]w]; 
vExpand$[(u_?vec+v_?vec)\[Cross]w_?vec]:=vExpand$[u\[Cross]w]+vExpand$[v\[Cross]w]; 
vExpand$[u_?vec\[CenterDot](v_?vec+w_?vec)]:=vExpand$[u\[CenterDot]v]+vExpand$[u\[CenterDot]w]; 
vExpand$[(u_?vec+v_?vec)\[CenterDot]w_?vec]:=vExpand$[u\[CenterDot]w]+vExpand$[v\[CenterDot]w]; 

vExpand$[s_?scal (u_?vec\[Cross]v_?vec)]:=Expand[s] vExpand$[u\[Cross]v]; 
vExpand$[s_?scal (u_?vec\[CenterDot]v_?vec)]:=Expand[s] vExpand$[u\[CenterDot]v]; 

vExpand$[Plus[x__]]:=vExpand$/@Plus[x]; 
vExpand$[s_?scal,Plus[x__]]:=Expand[s](vExpand$/@Plus[x]); 
vExpand$[Times[x__]]:=vExpand$/@Times[x]; 

vExpand[e_]:=e//.e:>Expand[vExpand$[e]] 

(* Some simplification rules *) 
(u_?vec\[Cross]u_?vec):=\!\(\*OverscriptBox["0", "\[RightVector]"]\); 
(u_?vec+\!\(\*OverscriptBox["0", "\[RightVector]"]\)):=u; 
0v_?vec:=\!\(\*OverscriptBox["0", "\[RightVector]"]\); 

\!\(\*OverscriptBox["0", "\[RightVector]"]\)\[CenterDot]v_?vec:=0; 
v_?vec\[CenterDot]\!\(\*OverscriptBox["0", "\[RightVector]"]\):=0; 

(a_?scal u_?vec)\[Cross]v_?vec :=a u\[Cross]v;u_?vec\[Cross](a_?scal v_?vec):=a u\[Cross]v; 
(a_?scal u_?vec)\[CenterDot]v_?vec :=a u\[CenterDot]v; 
u_?vec\[CenterDot](a_?scal v_?vec) :=a u\[CenterDot]v; 

(* Stealing behavior from Dot *) 
Attributes[CenterDot]=Attributes[Dot]; 

Protect[vExpand,vExpand$,Cross,Plus,Times,CenterDot];