mathjs simple integral

อินทิกรัลง่าย ๆ สำหรับ Math.js

ห้องสมุดนี้เป็นส่วนขยายสำหรับห้องสมุด Math.js ยอดนิยม มันเพิ่มฟังก์ชั่น integral ที่สามารถค้นหาอินทิกรัลของฟังก์ชั่นทางคณิตศาสตร์ที่เรียบง่าย นอกจากนี้ยังมีความยืดหยุ่นในกฎการรวมที่ใช้เพื่อให้สามารถใช้กฎที่กำหนดเองแทนหรือนอกเหนือจากกฎมาตรฐาน

โปรดทราบว่าซอฟต์แวร์นี้ยังถือว่าเป็นเบต้าดังนั้นหากคุณเจอข้อผิดพลาดหรือขอบขรุขระโปรดส่งปัญหา!

ติดตั้ง

ในการติดตั้งแพ็คเกจให้ใช้สิ่งต่อไปนี้:

 npm install mathjs-simple-integral

ในการลงทะเบียนส่วนขยายด้วย Math.js ให้ใช้สิ่งต่อไปนี้:

 math . import ( require ( 'mathjs-simple-integral' ) ) ;

สิ่งนี้จะเพิ่มฟังก์ชัน math.integral ให้กับ Math.js

การใช้งาน

การใช้งานพื้นฐานของส่วนขยายนี้เป็นเรื่องง่ายมาก: เพียงแค่ให้ Integrand (ไม่ว่าจะเป็น Node หรือสตริง) และตัวแปรของการรวม (ไม่ว่าจะเป็น SymbolNode หรือสตริง):

 math . integral ( 'x^2' , 'x' ) ; // 'x ^ 3 / 3'
math . integral ( '1/x' , 'x' ) ; // 'log(abs(x))'
math . integral ( 'e^x' , 'x' ) ; // 'e^x'
math . integral ( 'cos(2*x+pi/6)' , 'x' ) ; // 'sin(2 * x + pi / 6) / 2'

หาก integral ไม่สามารถค้นหาอินทิกรัลของนิพจน์ที่กำหนดได้มันจะทำให้เกิดข้อผิดพลาด:

 math . integral ( 'e^(x^2)' ) ; // Error: Unable to find integral of "e ^ (x ^ 2)" with respect to "x"

การทำให้เข้าใจง่าย

โดยค่าเริ่มต้น integral เรียกใช้ math.simplify บนเอาต์พุตเนื่องจากกระบวนการรวมสามารถสร้างนิพจน์ที่ไม่มั่นคง อย่างไรก็ตามมันเป็นไปได้ที่จะได้รับเอาต์พุตดิบที่ไม่ได้รับการรับรองจาก integral โดยส่งผ่านในวัตถุ options ที่มีการตั้งค่า simplify เป็น false กับพารามิเตอร์ที่สามที่เป็นตัวเลือก:

 math . integral ( 'x^2' , 'x' , { simplify : false } ) ; // '1 / (2 + 1) * x ^ (2 + 1)'
math . integral ( '1/(2*x)' , 'x' , { simplify : false } ) ; // '2 ^ -1 * log(abs(x))'

กฎที่กำหนดเอง

ในการใช้งานนี้กฎการรวมถูกกำหนดเป็นฟังก์ชั่นที่ใช้เป็นพารามิเตอร์ (1) expr นิพจน์ที่จะรวมเข้าด้วยกัน (2) context บริบทของการรวม; และ (3) subIntegral ฟังก์ชั่นที่พยายามรวมรูปแบบการแสดงออกของ subexpression หรือรูปแบบการเขียนใหม่ของอินทิกรัล กฎการรวมจะส่งคืนอินทิกรัลที่คำนวณได้หรือ null หากไม่สามารถหาได้ นอกเหนือจากการรวมมาตรฐานจำนวนมากที่ใช้งานแล้ว (อยู่ที่ math.integral.rules ) สามารถระบุชุดของกฎการรวมที่กำหนดเองได้

ตัวอย่างเช่นสมมติว่าเราได้เพิ่มฟังก์ชั่นที่กำหนดเอง myUpperGamma ซึ่งเป็นตัวแทนของฟังก์ชั่นแกมม่าที่ไม่สมบูรณ์ตอนบนและตอนนี้เราต้องการเพิ่มการสนับสนุนสำหรับการรวมมันโดยเฉพาะอย่างยิ่งเราต้องการใช้กฎนี้: integral("myUpperGamma(s,x)", "x") = x*myUpperGamma(s,x) - myUpperGamma(s+1, x) (ตรวจสอบที่นี่) ก่อนอื่นให้เราเขียนกฎนี้เป็นฟังก์ชั่น:

 var myUpperGammaRule = function ( expr , context , subIntegral ) {
  // Ensure we are trying to integrate a FunctionNode
  if ( expr . type === "FunctionNode" ) {
    // Ensure we are trying to integrate 'myUpperGamma' and that it has 2 arguments
    if ( expr . name === "myUpperGamma" && expr . args . length === 2 ) {
      // Ensure that the first argument is constant and the second one is
      // the variable of integration
      if ( context . isConstant ( expr . args [ 0 ] ) && expr . args [ 1 ] . equals ( context . variable ) ) {
        // Yay, we matched 'myUpperGamma(s,x)', so we know the integral!
        return new OperatorNode ( '-' , 'subtract' , [
          new OperatorNode ( '*' , 'multiply' , [
            context . variable ,
            new FunctionNode ( 'myUpperGamma' , [
              expr . args [ 0 ] ,
              context . variable
            ] )
          ] ) ,
          new FunctionNode ( 'myUpperGamma' , [
            new OperatorNode ( '+' , 'add' , [
              expr . args [ 0 ] ,
              new ConstantNode ( 1 )
            ] ) ,
            context . variable
          ] )
        ] ) ;
      }
    }
  }
  // Our rule, didn't apply :(
  // return undefined
}

ตอนนี้เรามีกฎการรวมที่กำหนดเองของเราเราสามารถเพิ่มลงในรายการกฎมาตรฐานและใช้รายการรวมนี้เพื่อค้นหาอินทิกรัลที่เกี่ยวข้องกับ myUpperGamma !

 // Define our integration rules to include our custom rule
var options = { rules : math . integral . rules . concat ( [ myUpperGammaRule ] ) } ;

// Compute integrals of our function!
math . integral ( 'myUpperGamma(a,x)' , 'x' , options ) ;
// 'x*myUpperGamma(a,x) - myUpperGamma(a+1,x)'

math . integral ( 'myUpperGamma(a^2,x) + 13' , 'x' , options ) ;
// 'x*myUpperGamma(a^2,x) - myUpperGamma(a^2+1,x) + 13*x'

math . integral ( 'myUpperGamma(a,5*x+99)' , 'x' , options ) ;
// '((5*x+99) * myUpperGamma(a, 5*x+99) - myUpperGamma(a+1, 5*x+99)) / 5'

math . integral ( 'sqrt(myUpperGamma(a,x)) * sqrt(myUpperGamma(a,x))' , 'x' , options ) ;
// 'x*myUpperGamma(a,x) - myUpperGamma(a+1,x)'

ตอนนี้สมมติว่านอกเหนือจาก myUpperGamma แล้วเรายังมีฟังก์ชั่นที่กำหนดเองอื่น ๆ mySum : เช่นเดียวกับ add มันจะยอมรับจำนวนตัวแปรของอาร์กิวเมนต์และเพิ่มอาร์กิวเมนต์เข้าด้วยกัน แต่มันก็ทำหน้าที่อื่น ๆ ที่ไม่ใช่คณิตศาสตร์อื่น ๆ (เช่นการบันทึกแต่ละอาร์กิวเมนต์ก่อนการประเมินผล หรือการตรวจสอบเพื่อให้แน่ใจว่าไม่มีข้อโต้แย้ง NaN ) ตอนนี้เราสามารถเพิ่มกฎให้กับผู้รวมที่แสดงถึงความเป็นเส้นตรงของอินทิกรัลเหนือ mySum :

 // integral(mySum(f(x), g(x), ...), x) = mySum(integral(f(x), x), integral(g(x), x), ...)
function mySumRule ( expr , context , subIntegral ) {
  // Ensure we are trying to integrate a FunctionNode
  if ( expr . type === "FunctionNode" ) {
    // Ensure we are trying to integrate 'mySum'
    if ( expr . name === "mySum" ) {
      // Try to find integrals of all the terms in the sum
      var termIntegrals = expr . args . map ( function ( term ) {
        return subIntegral ( term , context , 'sum rule (mySum)' ) ;
      } ) ;

      // Only if all terms had integrals did we actually find an integral
      if ( termIntegrals . every ( function ( termInt ) { return ! ! termInt ; } ) ) {
        // Yay, we found the integral!
        return new FunctionNode ( 'mySum' , termIntegrals ) ;
      }
    }
  }
  // return undefined
}

โปรดทราบว่าเราใช้การเรียกกลับ subIntegral เพื่อค้นหาอินทิกรัลของคำทั้งหมดในผลรวมแล้วส่งคืนอินทิกรัลสำหรับนิพจน์ mySum ทั้งหมดเฉพาะในกรณีที่แต่ละคำทั้งหมดสามารถรวมเข้าด้วยกัน ตอนนี้ถ้าเราใช้กฎที่กำหนดเองทั้งสองของเราเราสามารถรวมการแสดงออกกับทั้ง mySum และ myUpperGamma :

 var options = { rules : math . integral . rules . concat ( [ myUpperGammaRule , mySumRule ] ) } ;

math . integral ( "mySum(3*x^2, x, 1/x, 1)" , "x" , options ) ;
// 'mySum(x^3, x^2/2, log(abs(x)), x)'

math . integral ( "mySum(2*x, myUpperGamma(a,x))" , "x" , options ) ;
// 'mySum(x^2, x*myUpperGamma(a,x) - myUpperGamma(a+1,x))'

เอาต์พุตดีบัก

วัตถุตัวเลือกสามารถมี debugPrint อสังหาริมทรัพย์ว่าหากตั้งค่าเป็น true จะสั่งให้ผู้รวบรวม "แสดงผลงาน": นั่นคือมันจะพิมพ์ลงในคอนโซลทุกขั้นตอนที่ใช้และกฎทั้งหมดที่ใช้ในการรวมเฉพาะ ตัวอย่างเช่น integral("x^2 + sin(pi*x)", "x", {debugPrint: true}) สร้างผลลัพธ์ต่อไปนี้บนคอนโซล:

 find integral of (x ^ 2) + (sin(pi * x))  dx
  sum rule: find integral of x ^ 2  dx
    Computed: (1 / (2 + 1)) * (x ^ (2 + 1))
  sum rule: find integral of sin(pi * x)  dx
    linear substitution: find integral of sin(x)  dx
      Computed: -(cos(x))
    Computed: (-(cos(pi * x))) / (pi * 1)
  Computed: ((1 / (2 + 1)) * (x ^ (2 + 1))) + ((-(cos(pi * x))) / (pi * 1))

การใช้ debugPrint เป็นวิธีที่ดีในการเรียนรู้วิธีการรวมกฎการรวมและรวมกันเพื่อค้นหาอินทิกรัลและมีประโยชน์อย่างยิ่งเมื่อพัฒนากฎการรวมที่กำหนดเอง

อัลกอริทึม

อัลกอริทึมการรวมที่ใช้โดยการใช้งานนี้จะขึ้นอยู่กับการจับคู่รูปแบบการค้นหาที่ลึกซึ้งครั้งแรก แต่ละรูปแบบจะถูกระบุเป็นฟังก์ชั่นที่พยายามคำนวณอินทิกรัลโดยตรงหรือเขียนใหม่หรือแยกการรวมเข้าด้วยกันเป็นนิพจน์ที่ง่ายต่อการรวมเข้าด้วยกันและคำนวณอินทิกรัลของสิ่งนั้น แกนกลางของผู้รวมเป็นกฎ Agnostic: โดยค่าเริ่มต้นจะใช้ชุดของกฎการรวมมาตรฐานที่เก็บไว้ที่ integral.rules แม้ว่าการใช้กฎที่กำหนดเองได้รับการสนับสนุน (ดูส่วนกฎที่กำหนดเอง)

การบันทึกความทรงจำของ Integrands ไม่เพียง แต่เพิ่มความเร็วสำหรับอินทิกรัลทั่วไปของการแสดงออกย่อยเท่านั้น แต่ยังป้องกันไม่ให้ลูปไม่มีที่สิ้นสุดหากกฎสองข้อยกเลิกซึ่งกันและกัน (เช่นถ้าหนึ่งทวีคูณออกมา อย่างไรก็ตามอัลกอริทึมนี้ยังคงมีความอ่อนไหวต่อกฎ (หรือกฎการโต้ตอบหลายประการ) ที่สามารถใช้จำนวนครั้งที่ไม่มีที่สิ้นสุดที่สร้างการรวมใหม่ที่ไม่ซ้ำกันและทุกแอปพลิเคชัน กฎดังกล่าวจะทำให้ผู้รวมกลุ่มกลับมาอีกครั้ง (หรือจนกว่าจะมีการใช้พื้นที่สแต็กหรือหน่วยความจำทั้งหมด)

ข้อ จำกัด

เนื่องจากความเรียบง่ายของวิธีการนี้ (และระยะแรกของการพัฒนาของแพ็คเกจนี้) มีข้อ จำกัด มากมายในการใช้งานปัจจุบันนี้ ในการให้รายการที่ไม่สมบูรณ์ขณะนี้ไม่มีกฎให้สนับสนุนสิ่งต่อไปนี้:

• การรวมโดยส่วนหรือ U-substitution (ยกเว้นการแทนการใช้งานของฟังก์ชั่นเชิงเส้นเมื่อตัวแปรของการรวมเป็นเอกลักษณ์ในการรวม) ซึ่งหมายความว่าเราไม่สามารถรวมนิพจน์ต่อไปนี้:
  • 2 * x * cos(x^2)
  • 3 * x^2 * e^(x^3)
  • x * ln(x)
  • x^3 * e^x
• การสลายตัวของเศษส่วนบางส่วนเพื่อรวมฟังก์ชั่นเหตุผล
• ฟังก์ชั่นตรีโกณมิติผกผัน
• การทำให้เข้าใจง่ายของตรีโกณมิติตามที่จำเป็นสำหรับการแสดงออกเช่น cos(x) * tan(x)
• การรวม e ^ -(x^2) และชอบใช้ erf

หากใช้กฎเพื่อจัดการกรณีเหล่านี้ (หรือกรณีที่ไม่ได้รับการสนับสนุนอื่น ๆ ) โปรดส่งคำขอดึง!

ใบอนุญาต

ลิขสิทธิ์ (c) 2018 Joel Hoover ([email protected])

ได้รับใบอนุญาตภายใต้ใบอนุญาต Apache เวอร์ชัน 2.0 ("ใบอนุญาต"); คุณไม่สามารถใช้ไฟล์นี้ยกเว้นตามใบอนุญาต คุณอาจได้รับสำเนาใบอนุญาตที่

http://www.apache.org/licenses/license-2.0

เว้นแต่ว่ากฎหมายที่บังคับใช้หรือตกลงเป็นลายลักษณ์อักษรซอฟต์แวร์ที่แจกจ่ายภายใต้ใบอนุญาตจะถูกแจกจ่ายตาม "ตามพื้นฐาน" โดยไม่มีการรับประกันหรือเงื่อนไขใด ๆ ไม่ว่าจะโดยชัดแจ้งหรือโดยนัย ดูใบอนุญาตสำหรับภาษาเฉพาะที่ควบคุมการอนุญาตและข้อ จำกัด ภายใต้ใบอนุญาต